drivers/input/touchscreen/st/fts_gui.c - kernel/msm - Git at Google

 /*
  * FTS Capacitive touch screen controller (FingerTipS)
  *
  * Copyright (C) 2016-2018, STMicroelectronics Limited.
  * Authors: AMG(Analog Mems Group) <marco.cali@st.com>
  *
  *
  * 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.
  *
  * This program is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  * more details.
  *
  * You should have received a copy of the GNU General Public License along with
  * this program.  If not, see <http://www.gnu.org/licenses/>.
  */


 #include <linux/device.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/input.h>
 #include <linux/input/mt.h>
 #include <linux/interrupt.h>
 #include <linux/hrtimer.h>
 #include <linux/delay.h>
 #include <linux/firmware.h>
 #include <linux/i2c.h>
 #include <linux/i2c-dev.h>
 #include <linux/completion.h>
 //#include <linux/wakelock.h>
 #include <linux/pm_wakeup.h>
 #include <linux/gpio.h>
 #include <linux/of_gpio.h>
 #include <linux/regulator/consumer.h>
 #include "fts.h"
 #include "fts_lib/ftsIO.h"

 #ifdef SCRIPTLESS

 unsigned int data[CMD_RESULT_STR_LEN] = {0};
 unsigned char pAddress_i2c[CMD_RESULT_STR_LEN] = {0};
 int byte_count_read;
 char Out_buff[TSP_BUF_SIZE];


 /*I2C CMd functions: functions to interface with GUI without script */

 ssize_t fts_i2c_wr_show(struct device *dev, struct device_attribute *attr,
 	char *buf)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct fts_ts_info *info = i2c_get_clientdata(client);
 	int i;
 	char buff[16];

 	memset(Out_buff, 0x00, ARRAY_SIZE(Out_buff));
 	if (byte_count_read == 0) {
 		snprintf(Out_buff, sizeof(Out_buff), "{FAILED}");
 		return snprintf(buf, TSP_BUF_SIZE, "%s\n", Out_buff);
 	}
 #ifdef SCRIPTLESS_DEBUG
 	pr_err("%s:DATA READ {", __func__);
 	for (i = 0; i < byte_count_read; i++) {
 		pr_err(" %02X", (unsigned int)info->cmd_wr_result[i]);
 		if (i < (byte_count_read - 1))
 			pr_err(" ");
 	}
 	pr_err("}\n");
 #endif
 	snprintf(buff, sizeof(buff), "{");
 	strlcat(Out_buff, buff, ARRAY_SIZE(Out_buff));
 	for (i = 0; i < (byte_count_read + 2); i++) {
 		char temp_byte_count_read;

 		if (i == 0) {
 			temp_byte_count_read = (byte_count_read >> 8) & 0xFF;

 			snprintf(buff, sizeof(buff), "%02X",
 				temp_byte_count_read);
 		} else if (i == 1) {
 			temp_byte_count_read = (byte_count_read) & 0xFF;

 			snprintf(buff, sizeof(buff), "%02X",
 				temp_byte_count_read);

 		} else {
 			snprintf(buff, sizeof(buff), "%02X",
 				info->cmd_wr_result[i-2]);
 		}
 		//snprintf(buff, sizeof(buff), "%02X", info->cmd_wr_result[i]);
 		strlcat(Out_buff, buff,  ARRAY_SIZE(Out_buff));
 		if (i < (byte_count_read + 1)) {
 			snprintf(buff, sizeof(buff), " ");
 			strlcat(Out_buff, buff, ARRAY_SIZE(Out_buff));
 		}
 	}
 	snprintf(buff, sizeof(buff), "}");
 	strlcat(Out_buff, buff, ARRAY_SIZE(Out_buff));
 	return snprintf(buf, TSP_BUF_SIZE, "%s\n", Out_buff);
 }

 ssize_t fts_i2c_wr_store(struct device *dev, struct device_attribute *attr,
 	const char *buf, size_t count)
 {
 	int ret;
 	struct i2c_client *client = to_i2c_client(dev);
 	struct fts_ts_info *info = i2c_get_clientdata(client);
 	unsigned char pAddress[9] = {0};
 	unsigned int byte_count = 0;
 	int i;
 	unsigned int data[9] = {0};

 	memset(data, 0x00, ARRAY_SIZE(data));
 	memset(info->cmd_wr_result, 0x00, ARRAY_SIZE(info->cmd_wr_result));
 	ret = sscanf(buf, "%x %x %x %x %x %x %x %x %x ",
 		(data + 8), (data), (data + 1), (data + 2), (data + 3),
 		(data + 4), (data + 5), (data + 6), (data + 7));
 	if (ret != 9)
 		return -EINVAL;
 	byte_count = data[8];

 	/**
 	 * if(sizeof(buf) != byte_count )
 	 * {
 	 * printk("%s : Byte count is wrong\n",__func__);
 	 * return count;
 	 * }
 	 */
 #ifdef SCRIPTLESS_DEBUG
 	pr_err("\n");
 	pr_err("%s: Input Data 1:", __func__);

 	for (i = 0 ; i < byte_count; i++) {
 		pr_err(" %02X", data[i]);
 		pAddress[i] = (unsigned char)data[i];
 	}
 	pr_err("\n");
 #else
 	for (i = 0 ; i < byte_count; i++)
 		pAddress[i] = (unsigned char)data[i];
 #endif
 	byte_count_read = (((unsigned int)data[byte_count - 2]) << 8)
 				| data[byte_count - 1];
 	ret = fts_writeCmd(pAddress, 3);
 	msleep(20);
 	ret = fts_readCmd(&pAddress[3], (byte_count - 5),
 			info->cmd_wr_result, byte_count_read);
 #ifdef SCRIPTLESS_DEBUG
 	 pr_err("%s:DATA READ\n{", __func__);
 	for (i = 0; i < (2 + byte_count_read); i++) {
 		char temp_byte_count_read;

 		if (i == 0) {
 			temp_byte_count_read = (byte_count_read >> 8) & 0xFF;
 			pr_err("%02X", (unsigned int)temp_byte_count_read);
 		} else if (i == 1) {
 			temp_byte_count_read = (byte_count_read) & 0xFF;
 			pr_err("%02X", (unsigned int)temp_byte_count_read);

 		} else {
 			pr_err("%02X",
 				(unsigned int)info->cmd_read_result[i - 2]);
 		}

 		if (i < (byte_count_read + 1))
 			pr_err(" ");

 	}
 	pr_err("}\n");
 #endif
 	if (ret)
 		dev_err(dev, "Unable to read register\n");
 	return count;
 }

 ssize_t fts_i2c_read_show(struct device *dev, struct device_attribute *attr,
 	char *buf)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct fts_ts_info *info = i2c_get_clientdata(client);
 	int i;
 	char buff[16];

 	memset(Out_buff, 0x00, ARRAY_SIZE(Out_buff));
 	if (byte_count_read == 0) {
 		snprintf(Out_buff, sizeof(Out_buff), "{FAILED}");
 		return snprintf(buf, TSP_BUF_SIZE, "%s\n", Out_buff);
 	}
 #ifdef SCRIPTLESS_DEBUG
 	pr_err("%s:DATA READ {", __func__);
 	for (i = 0; i < byte_count_read; i++) {
 		pr_err("%02X", (unsigned int)info->cmd_read_result[i]);
 		if (i < (byte_count_read - 1))
 			pr_err(" ");
 	}
 	pr_err("}\n");
 #endif
 	snprintf(buff, sizeof(buff), "{");
 	strlcat(Out_buff, buff, ARRAY_SIZE(Out_buff));
 	for (i = 0; i < (byte_count_read + 2); i++) {
 		char temp_byte_count_read;

 		if (i == 0) {
 			temp_byte_count_read = (byte_count_read >> 8) & 0xFF;
 			snprintf(buff, sizeof(buff), "%02X",
 				temp_byte_count_read);
 		} else if (i == 1) {
 			temp_byte_count_read = (byte_count_read) & 0xFF;
 			snprintf(buff, sizeof(buff), "%02X",
 				temp_byte_count_read);
 		} else {
 			snprintf(buff, sizeof(buff), "%02X",
 				info->cmd_read_result[i - 2]);
 		}
 		strlcat(Out_buff, buff, ARRAY_SIZE(Out_buff));
 		if (i < (byte_count_read + 1)) {
 			snprintf(buff, sizeof(buff), " ");
 			strlcat(Out_buff, buff, ARRAY_SIZE(Out_buff));
 		}
 	}
 	snprintf(buff, sizeof(buff), "}");
 	strlcat(Out_buff, buff, ARRAY_SIZE(Out_buff));

 	return snprintf(buf, TSP_BUF_SIZE, "%s\n", Out_buff);
 }

 ssize_t fts_i2c_read_store(struct device *dev, struct device_attribute *attr,
 	const char *buf, size_t count)
 {
 	int ret;
 	struct i2c_client *client = to_i2c_client(dev);
 	struct fts_ts_info *info = i2c_get_clientdata(client);
 	unsigned char pAddress[9] = {0};
 	unsigned int byte_count = 0;
 	int i;
 	unsigned int data[9] = {0};

 	byte_count_read = 0;
 	memset(data, 0x00, ARRAY_SIZE(data));
 	memset(info->cmd_read_result, 0x00, ARRAY_SIZE(info->cmd_read_result));
 	ret = sscanf(buf, "%x %x %x %x %x %x %x %x %x ",
 		(data + 8), (data), (data + 1), (data + 2), (data + 3),
 		(data + 4), (data + 5), (data + 6), (data + 7));
 	if (ret != 9)
 		return -EINVAL;
 	byte_count = data[8];

 	if (byte_count > 8) {
 #ifdef SCRIPTLESS_DEBUG
 		pr_err("%s:Byte count is more than 8\n", __func__);
 #endif
 		return count;
 	}
 	/*if(sizeof(buf) != byte_count )*/
 	/*{*/
 	/*	printk("%s : Byte count is wrong\n",__func__);*/
 	/*	return count;*/
 	/*}*/
 #ifdef SCRIPTLESS_DEBUG
 	pr_err("\n");
 	pr_err("%s: Input Data 1:", __func__);
 	for (i = 0 ; i < byte_count; i++) {
 		pr_err("%02X", data[i]);
 		pAddress[i] = (unsigned char)data[i];
 	}
 	pr_err("\n");
 #else
 	for (i = 0 ; i < byte_count; i++)
 		pAddress[i] = (unsigned char)data[i];
 #endif
 	byte_count_read = (((unsigned int)data[byte_count - 2]) << 8)
 				| data[byte_count - 1];
 	ret = fts_readCmd(pAddress, (byte_count - 2), info->cmd_read_result,
 		byte_count_read);
 #ifdef SCRIPTLESS_DEBUG
 	pr_err("%s:DATA READ\n{", __func__);
 	for (i = 0; i < (byte_count_read + 2); i++) {
 		char temp_byte_count_read;

 		if (i == 0) {
 			temp_byte_count_read = (byte_count_read >> 8) & 0xFF;

 			pr_err("%02X", (unsigned int)temp_byte_count_read);
 		} else if (i == 1) {
 			temp_byte_count_read = (byte_count_read) & 0xFF;

 			pr_err("%02X", (unsigned int)temp_byte_count_read);

 		} else {
 			pr_err("%02X",
 				(unsigned int)info->cmd_read_result[i - 2]);
 		}
 		if (i < (byte_count_read + 1))
 			pr_err(" ");
 	}
 	pr_err("}\n");
 #endif
 	if (ret)
 		dev_err(dev, "Unable to read register\n");
 	return count;
 }


 ssize_t fts_i2c_write_show(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct fts_ts_info *info = i2c_get_clientdata(client);

 	return snprintf(buf, TSP_BUF_SIZE, "%s", info->cmd_write_result);

 }

 ssize_t fts_i2c_write_store(struct device *dev, struct device_attribute *attr,
 		const char *buf, size_t count)
 {
 	int ret;
 	struct i2c_client *client = to_i2c_client(dev);
 	struct fts_ts_info *info = i2c_get_clientdata(client);
 	unsigned int byte_count = 0;
 	int i;

 	memset(data, 0x00, ARRAY_SIZE(data));
 	memset(pAddress_i2c, 0x00, ARRAY_SIZE(pAddress_i2c));
 	memset(info->cmd_write_result, 0x00,
 			ARRAY_SIZE(info->cmd_write_result));
 	ret = sscanf(buf, "%x %x", data, (data + 1));
 	if (ret != 2)
 		return -EINVAL;
 	byte_count = data[0] << 8 | data[1];

 	if (byte_count <= ARRAY_SIZE(pAddress_i2c)) {
 		for (i = 0; i < (byte_count); i++) {
 			ret = sscanf(&buf[3 * (i + 2)], "%x ", (data + i));
 			if (ret != 1)
 				return -EINVAL;
 		}
 	} else {
 #ifdef SCRIPTLESS_DEBUG
 		pr_err("%s:message size is > allowed limit of 512 bytes\n",
 			__func__);
 #endif
 		snprintf(info->cmd_write_result, sizeof(info->cmd_write_result),
 			"{Write NOT OK}\n");
 	}
 #ifdef SCRIPTLESS_DEBUG
 	pr_err("\n");
 	pr_err("%s:Byte_count = %02d|Count = %02d |size of buf:%02d\n",
 		__func__, byte_count, (int)count, (int)sizeof(buf));
 	pr_err("%s: Input Data 1:", __func__);
 	for (i = 0 ; i < byte_count; i++) {
 		pr_err(" %02X", data[i]);
 		pAddress_i2c[i] = (unsigned char)data[i];
 	}
 	pr_err("\n");
 #else
 	for (i = 0 ; i < byte_count; i++)
 		pAddress_i2c[i] = (unsigned char)data[i];
 #endif
 	if ((pAddress_i2c[0] == 0xb3) && (pAddress_i2c[3] == 0xb1)) {
 		ret = fts_writeCmd(pAddress_i2c, 3);
 		msleep(20);
 		ret = fts_writeCmd(&pAddress_i2c[3], byte_count-3);
 	} else {
 		ret = fts_writeCmd(pAddress_i2c, byte_count);
 	}

 #ifdef SCRIPTLESS_DEBUG
 	pr_err("%s:DATA :", __func__);
 	for (i = 0; i < byte_count; i++)
 		pr_err(" %02X", (unsigned int)pAddress_i2c[i]);
 	pr_err(" byte_count: %02X\n", byte_count);
 #endif
 	if (ret < 0) {
 		dev_err(dev, "{Write NOT OK}\n");
 		snprintf(info->cmd_write_result, sizeof(info->cmd_write_result),
 			"{Write NOT OK}\n");
 	} else {
 		snprintf(info->cmd_write_result, sizeof(info->cmd_write_result),
 			"{Write OK}\n");
 #ifdef SCRIPTLESS_DEBUG
 		pr_err("%s : {Write OK}\n", __func__);
 #endif
 	}
 	return count;
 }

 static DEVICE_ATTR(iread, 0664, NULL, fts_i2c_read_store);
 static DEVICE_ATTR(iread_result, 0664, fts_i2c_read_show, NULL);
 static DEVICE_ATTR(iwr, 0664, NULL, fts_i2c_wr_store);
 static DEVICE_ATTR(iwr_result, 0664, fts_i2c_wr_show, NULL);
 static DEVICE_ATTR(iwrite, 0664, NULL, fts_i2c_write_store);
 static DEVICE_ATTR(iwrite_result, 0664, fts_i2c_write_show, NULL);

 static struct attribute *i2c_cmd_attributes[] = {
 	&dev_attr_iread.attr,
 	&dev_attr_iread_result.attr,
 	&dev_attr_iwr.attr,
 	&dev_attr_iwr_result.attr,
 	&dev_attr_iwrite.attr,
 	&dev_attr_iwrite_result.attr,
 	NULL,
 };

 struct attribute_group i2c_cmd_attr_group = {
 	.attrs = i2c_cmd_attributes,
 };

  #endif
	/*
	* FTS Capacitive touch screen controller (FingerTipS)
	*
	* Copyright (C) 2016-2018, STMicroelectronics Limited.
	* Authors: AMG(Analog Mems Group) <marco.cali@st.com>
	*
	*
	* 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.
	*
	* This program is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	* more details.
	*
	* You should have received a copy of the GNU General Public License along with
	* this program. If not, see <http://www.gnu.org/licenses/>.
	*/


	#include <linux/device.h>
	#include <linux/init.h>
	#include <linux/kernel.h>
	#include <linux/module.h>
	#include <linux/slab.h>
	#include <linux/input.h>
	#include <linux/input/mt.h>
	#include <linux/interrupt.h>
	#include <linux/hrtimer.h>
	#include <linux/delay.h>
	#include <linux/firmware.h>
	#include <linux/i2c.h>
	#include <linux/i2c-dev.h>
	#include <linux/completion.h>
	//#include <linux/wakelock.h>
	#include <linux/pm_wakeup.h>
	#include <linux/gpio.h>
	#include <linux/of_gpio.h>
	#include <linux/regulator/consumer.h>
	#include "fts.h"
	#include "fts_lib/ftsIO.h"

	#ifdef SCRIPTLESS

	unsigned int data[CMD_RESULT_STR_LEN] = {0};
	unsigned char pAddress_i2c[CMD_RESULT_STR_LEN] = {0};
	int byte_count_read;
	char Out_buff[TSP_BUF_SIZE];


	/I2C CMd functions: functions to interface with GUI without script /

	ssize_t fts_i2c_wr_show(struct device dev, struct device_attribute attr,
	char *buf)
	{
	struct i2c_client *client = to_i2c_client(dev);
	struct fts_ts_info *info = i2c_get_clientdata(client);
	int i;
	char buff[16];

	memset(Out_buff, 0x00, ARRAY_SIZE(Out_buff));
	if (byte_count_read == 0) {
	snprintf(Out_buff, sizeof(Out_buff), "{FAILED}");
	return snprintf(buf, TSP_BUF_SIZE, "%s\n", Out_buff);
	}
	#ifdef SCRIPTLESS_DEBUG
	pr_err("%s:DATA READ {", __func__);
	for (i = 0; i < byte_count_read; i++) {
	pr_err(" %02X", (unsigned int)info->cmd_wr_result[i]);
	if (i < (byte_count_read - 1))
	pr_err(" ");
	}
	pr_err("}\n");
	#endif
	snprintf(buff, sizeof(buff), "{");
	strlcat(Out_buff, buff, ARRAY_SIZE(Out_buff));
	for (i = 0; i < (byte_count_read + 2); i++) {
	char temp_byte_count_read;

	if (i == 0) {
	temp_byte_count_read = (byte_count_read >> 8) & 0xFF;

	snprintf(buff, sizeof(buff), "%02X",
	temp_byte_count_read);
	} else if (i == 1) {
	temp_byte_count_read = (byte_count_read) & 0xFF;

	snprintf(buff, sizeof(buff), "%02X",
	temp_byte_count_read);

	} else {
	snprintf(buff, sizeof(buff), "%02X",
	info->cmd_wr_result[i-2]);
	}
	//snprintf(buff, sizeof(buff), "%02X", info->cmd_wr_result[i]);
	strlcat(Out_buff, buff, ARRAY_SIZE(Out_buff));
	if (i < (byte_count_read + 1)) {
	snprintf(buff, sizeof(buff), " ");
	strlcat(Out_buff, buff, ARRAY_SIZE(Out_buff));
	}
	}
	snprintf(buff, sizeof(buff), "}");
	strlcat(Out_buff, buff, ARRAY_SIZE(Out_buff));
	return snprintf(buf, TSP_BUF_SIZE, "%s\n", Out_buff);
	}

	ssize_t fts_i2c_wr_store(struct device dev, struct device_attribute attr,
	const char *buf, size_t count)
	{
	int ret;
	struct i2c_client *client = to_i2c_client(dev);
	struct fts_ts_info *info = i2c_get_clientdata(client);
	unsigned char pAddress[9] = {0};
	unsigned int byte_count = 0;
	int i;
	unsigned int data[9] = {0};

	memset(data, 0x00, ARRAY_SIZE(data));
	memset(info->cmd_wr_result, 0x00, ARRAY_SIZE(info->cmd_wr_result));
	ret = sscanf(buf, "%x %x %x %x %x %x %x %x %x ",
	(data + 8), (data), (data + 1), (data + 2), (data + 3),
	(data + 4), (data + 5), (data + 6), (data + 7));
	if (ret != 9)
	return -EINVAL;
	byte_count = data[8];

	/**
	* if(sizeof(buf) != byte_count )
	* {
	* printk("%s : Byte count is wrong\n",__func__);
	* return count;
	* }
	*/
	#ifdef SCRIPTLESS_DEBUG
	pr_err("\n");
	pr_err("%s: Input Data 1:", __func__);

	for (i = 0 ; i < byte_count; i++) {
	pr_err(" %02X", data[i]);
	pAddress[i] = (unsigned char)data[i];
	}
	pr_err("\n");
	#else
	for (i = 0 ; i < byte_count; i++)
	pAddress[i] = (unsigned char)data[i];
	#endif
	byte_count_read = (((unsigned int)data[byte_count - 2]) << 8)
	\| data[byte_count - 1];
	ret = fts_writeCmd(pAddress, 3);
	msleep(20);
	ret = fts_readCmd(&pAddress[3], (byte_count - 5),
	info->cmd_wr_result, byte_count_read);
	#ifdef SCRIPTLESS_DEBUG
	pr_err("%s:DATA READ\n{", __func__);
	for (i = 0; i < (2 + byte_count_read); i++) {
	char temp_byte_count_read;

	if (i == 0) {
	temp_byte_count_read = (byte_count_read >> 8) & 0xFF;
	pr_err("%02X", (unsigned int)temp_byte_count_read);
	} else if (i == 1) {
	temp_byte_count_read = (byte_count_read) & 0xFF;
	pr_err("%02X", (unsigned int)temp_byte_count_read);

	} else {
	pr_err("%02X",
	(unsigned int)info->cmd_read_result[i - 2]);
	}

	if (i < (byte_count_read + 1))
	pr_err(" ");

	}
	pr_err("}\n");
	#endif
	if (ret)
	dev_err(dev, "Unable to read register\n");
	return count;
	}

	ssize_t fts_i2c_read_show(struct device dev, struct device_attribute attr,
	char *buf)
	{
	struct i2c_client *client = to_i2c_client(dev);
	struct fts_ts_info *info = i2c_get_clientdata(client);
	int i;
	char buff[16];

	memset(Out_buff, 0x00, ARRAY_SIZE(Out_buff));
	if (byte_count_read == 0) {
	snprintf(Out_buff, sizeof(Out_buff), "{FAILED}");
	return snprintf(buf, TSP_BUF_SIZE, "%s\n", Out_buff);
	}
	#ifdef SCRIPTLESS_DEBUG
	pr_err("%s:DATA READ {", __func__);
	for (i = 0; i < byte_count_read; i++) {
	pr_err("%02X", (unsigned int)info->cmd_read_result[i]);
	if (i < (byte_count_read - 1))
	pr_err(" ");
	}
	pr_err("}\n");
	#endif
	snprintf(buff, sizeof(buff), "{");
	strlcat(Out_buff, buff, ARRAY_SIZE(Out_buff));
	for (i = 0; i < (byte_count_read + 2); i++) {
	char temp_byte_count_read;

	if (i == 0) {
	temp_byte_count_read = (byte_count_read >> 8) & 0xFF;
	snprintf(buff, sizeof(buff), "%02X",
	temp_byte_count_read);
	} else if (i == 1) {
	temp_byte_count_read = (byte_count_read) & 0xFF;
	snprintf(buff, sizeof(buff), "%02X",
	temp_byte_count_read);
	} else {
	snprintf(buff, sizeof(buff), "%02X",
	info->cmd_read_result[i - 2]);
	}
	strlcat(Out_buff, buff, ARRAY_SIZE(Out_buff));
	if (i < (byte_count_read + 1)) {
	snprintf(buff, sizeof(buff), " ");
	strlcat(Out_buff, buff, ARRAY_SIZE(Out_buff));
	}
	}
	snprintf(buff, sizeof(buff), "}");
	strlcat(Out_buff, buff, ARRAY_SIZE(Out_buff));

	return snprintf(buf, TSP_BUF_SIZE, "%s\n", Out_buff);
	}

	ssize_t fts_i2c_read_store(struct device dev, struct device_attribute attr,
	const char *buf, size_t count)
	{
	int ret;
	struct i2c_client *client = to_i2c_client(dev);
	struct fts_ts_info *info = i2c_get_clientdata(client);
	unsigned char pAddress[9] = {0};
	unsigned int byte_count = 0;
	int i;
	unsigned int data[9] = {0};

	byte_count_read = 0;
	memset(data, 0x00, ARRAY_SIZE(data));
	memset(info->cmd_read_result, 0x00, ARRAY_SIZE(info->cmd_read_result));
	ret = sscanf(buf, "%x %x %x %x %x %x %x %x %x ",
	(data + 8), (data), (data + 1), (data + 2), (data + 3),
	(data + 4), (data + 5), (data + 6), (data + 7));
	if (ret != 9)
	return -EINVAL;
	byte_count = data[8];

	if (byte_count > 8) {
	#ifdef SCRIPTLESS_DEBUG
	pr_err("%s:Byte count is more than 8\n", __func__);
	#endif
	return count;
	}
	/if(sizeof(buf) != byte_count )/
	/{/
	/* printk("%s : Byte count is wrong\n",__func__);*/
	/* return count;*/
	/}/
	#ifdef SCRIPTLESS_DEBUG
	pr_err("\n");
	pr_err("%s: Input Data 1:", __func__);
	for (i = 0 ; i < byte_count; i++) {
	pr_err("%02X", data[i]);
	pAddress[i] = (unsigned char)data[i];
	}
	pr_err("\n");
	#else
	for (i = 0 ; i < byte_count; i++)
	pAddress[i] = (unsigned char)data[i];
	#endif
	byte_count_read = (((unsigned int)data[byte_count - 2]) << 8)
	\| data[byte_count - 1];
	ret = fts_readCmd(pAddress, (byte_count - 2), info->cmd_read_result,
	byte_count_read);
	#ifdef SCRIPTLESS_DEBUG
	pr_err("%s:DATA READ\n{", __func__);
	for (i = 0; i < (byte_count_read + 2); i++) {
	char temp_byte_count_read;

	if (i == 0) {
	temp_byte_count_read = (byte_count_read >> 8) & 0xFF;

	pr_err("%02X", (unsigned int)temp_byte_count_read);
	} else if (i == 1) {
	temp_byte_count_read = (byte_count_read) & 0xFF;

	pr_err("%02X", (unsigned int)temp_byte_count_read);

	} else {
	pr_err("%02X",
	(unsigned int)info->cmd_read_result[i - 2]);
	}
	if (i < (byte_count_read + 1))
	pr_err(" ");
	}
	pr_err("}\n");
	#endif
	if (ret)
	dev_err(dev, "Unable to read register\n");
	return count;
	}


	ssize_t fts_i2c_write_show(struct device *dev,
	struct device_attribute attr, char buf)
	{
	struct i2c_client *client = to_i2c_client(dev);
	struct fts_ts_info *info = i2c_get_clientdata(client);

	return snprintf(buf, TSP_BUF_SIZE, "%s", info->cmd_write_result);

	}

	ssize_t fts_i2c_write_store(struct device dev, struct device_attribute attr,
	const char *buf, size_t count)
	{
	int ret;
	struct i2c_client *client = to_i2c_client(dev);
	struct fts_ts_info *info = i2c_get_clientdata(client);
	unsigned int byte_count = 0;
	int i;

	memset(data, 0x00, ARRAY_SIZE(data));
	memset(pAddress_i2c, 0x00, ARRAY_SIZE(pAddress_i2c));
	memset(info->cmd_write_result, 0x00,
	ARRAY_SIZE(info->cmd_write_result));
	ret = sscanf(buf, "%x %x", data, (data + 1));
	if (ret != 2)
	return -EINVAL;
	byte_count = data[0] << 8 \| data[1];

	if (byte_count <= ARRAY_SIZE(pAddress_i2c)) {
	for (i = 0; i < (byte_count); i++) {
	ret = sscanf(&buf[3 * (i + 2)], "%x ", (data + i));
	if (ret != 1)
	return -EINVAL;
	}
	} else {
	#ifdef SCRIPTLESS_DEBUG
	pr_err("%s:message size is > allowed limit of 512 bytes\n",
	__func__);
	#endif
	snprintf(info->cmd_write_result, sizeof(info->cmd_write_result),
	"{Write NOT OK}\n");
	}
	#ifdef SCRIPTLESS_DEBUG
	pr_err("\n");
	pr_err("%s:Byte_count = %02d\|Count = %02d \|size of buf:%02d\n",
	__func__, byte_count, (int)count, (int)sizeof(buf));
	pr_err("%s: Input Data 1:", __func__);
	for (i = 0 ; i < byte_count; i++) {
	pr_err(" %02X", data[i]);
	pAddress_i2c[i] = (unsigned char)data[i];
	}
	pr_err("\n");
	#else
	for (i = 0 ; i < byte_count; i++)
	pAddress_i2c[i] = (unsigned char)data[i];
	#endif
	if ((pAddress_i2c[0] == 0xb3) && (pAddress_i2c[3] == 0xb1)) {
	ret = fts_writeCmd(pAddress_i2c, 3);
	msleep(20);
	ret = fts_writeCmd(&pAddress_i2c[3], byte_count-3);
	} else {
	ret = fts_writeCmd(pAddress_i2c, byte_count);
	}

	#ifdef SCRIPTLESS_DEBUG
	pr_err("%s:DATA :", __func__);
	for (i = 0; i < byte_count; i++)
	pr_err(" %02X", (unsigned int)pAddress_i2c[i]);
	pr_err(" byte_count: %02X\n", byte_count);
	#endif
	if (ret < 0) {
	dev_err(dev, "{Write NOT OK}\n");
	snprintf(info->cmd_write_result, sizeof(info->cmd_write_result),
	"{Write NOT OK}\n");
	} else {
	snprintf(info->cmd_write_result, sizeof(info->cmd_write_result),
	"{Write OK}\n");
	#ifdef SCRIPTLESS_DEBUG
	pr_err("%s : {Write OK}\n", __func__);
	#endif
	}
	return count;
	}

	static DEVICE_ATTR(iread, 0664, NULL, fts_i2c_read_store);
	static DEVICE_ATTR(iread_result, 0664, fts_i2c_read_show, NULL);
	static DEVICE_ATTR(iwr, 0664, NULL, fts_i2c_wr_store);
	static DEVICE_ATTR(iwr_result, 0664, fts_i2c_wr_show, NULL);
	static DEVICE_ATTR(iwrite, 0664, NULL, fts_i2c_write_store);
	static DEVICE_ATTR(iwrite_result, 0664, fts_i2c_write_show, NULL);

	static struct attribute *i2c_cmd_attributes[] = {
	&dev_attr_iread.attr,
	&dev_attr_iread_result.attr,
	&dev_attr_iwr.attr,
	&dev_attr_iwr_result.attr,
	&dev_attr_iwrite.attr,
	&dev_attr_iwrite_result.attr,
	NULL,
	};

	struct attribute_group i2c_cmd_attr_group = {
	.attrs = i2c_cmd_attributes,
	};

	#endif