Initial file dump from open source releaseHEADmaster

1 files changed, 1474 insertions, 0 deletions

diff --git a/drivers/input/touchscreen/ist30xxc/ist30xxc_update.c b/drivers/input/touchscreen/ist30xxc/ist30xxc_update.c
new file mode 100755
index 00000000..92073196
--- /dev/null
+++ b/drivers/input/touchscreen/ist30xxc/ist30xxc_update.c
@@ -0,0 +1,1474 @@
+/*
+ *  Copyright (C) 2010,Imagis Technology Co. Ltd. All Rights Reserved.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ */
+
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/firmware.h>
+#include <linux/stat.h>
+#include <asm/unaligned.h>
+#include <linux/uaccess.h>
+#include <linux/fcntl.h>
+#include <linux/file.h>
+#include <linux/fs.h>
+#include <linux/err.h>
+
+#include "ist30xxc.h"
+#include "ist30xxc_update.h"
+#include "ist30xxc_tracking.h"
+
+#if IST30XX_INTERNAL_BIN
+#if defined(CONFIG_MACH_SS_SHARKLT8) || defined(CONFIG_MACH_SS_SHARKLT8LIGHTSLEEP)
+#include "./firmware/ss_sharklt8_fw.h"
+#else
+#include "./firmware/coreprimeve3g_fw.h"
+#endif
+#if (IMAGIS_TSP_IC < IMAGIS_IST3038C)
+#if IST30XX_MULTIPLE_TSP
+//#include "./firmware/ist30xxc_fw_tsp_Ver0000_porting.h"
+#endif
+#endif
+#endif  // IST30XX_INTERNAL_BIN
+
+#define TAGS_PARSE_OK		(0)
+
+// ISP burst r/w
+int ist30xx_isp_read_burst(struct i2c_client *client, u32 addr,
+			u32 *buf32, u16 len)
+{
+	int ret = 0;
+	int i;
+	u16 max_len = I2C_MAX_READ_SIZE / IST30XX_DATA_LEN;
+	u16 remain_len = len;
+
+	for (i = 0; i < len; i += max_len) {
+		if (remain_len < max_len) max_len = remain_len;
+		ret = ist30xx_read_buf(client, addr, buf32, max_len);
+		if (unlikely(ret)) {
+			tsp_err("Burst fail, addr: %x\n", __func__, addr);
+			return ret;
+		}
+
+		buf32 += max_len;
+		remain_len -= max_len;
+	}
+
+	return 0;
+}
+
+int ist30xx_isp_write_burst(struct i2c_client *client, u32 addr,
+			u32 *buf32, u16 len)
+{
+	int ret = 0;
+	int i;
+	u16 max_len = I2C_MAX_WRITE_SIZE / IST30XX_DATA_LEN;
+	u16 remain_len = len;
+
+	for (i = 0; i < len; i += max_len) {
+		if (remain_len < max_len) max_len = remain_len;
+		ret = ist30xx_write_buf(client, addr, buf32, max_len);
+		if (unlikely(ret)) {
+			tsp_err("Burst fail, addr: %x\n", addr);
+			return ret;
+		}
+
+		buf32 += max_len;
+		remain_len -= max_len;
+	}
+
+	return 0;
+}
+
+#define IST30XX_ISP_READ_TOTAL_S		(0x01)
+#define IST30XX_ISP_READ_TOTAL_B		(0x11)
+#define IST30XX_ISP_READ_MAIN_S		(0x02)
+#define IST30XX_ISP_READ_MAIN_B		(0x12)
+#define IST30XX_ISP_READ_INFO_S		(0x03)
+#define IST30XX_ISP_READ_INFO_B		(0x13)
+#define IST30XX_ISP_PROG_TOTAL_S		(0x04)
+#define IST30XX_ISP_PROG_TOTAL_B		(0x14)
+#define IST30XX_ISP_PROG_MAIN_S		(0x05)
+#define IST30XX_ISP_PROG_MAIN_B		(0x15)
+#define IST30XX_ISP_PROG_INFO_S		(0x06)
+#define IST30XX_ISP_PROG_INFO_B		(0x16)
+#define IST30XX_ISP_ERASE_BLOCK		(0x07)
+#define IST30XX_ISP_ERASE_SECTOR		(0x08)
+#define IST30XX_ISP_ERASE_PAGE		(0x09)
+#define IST30XX_ISP_ERASE_INFO		(0x0A)
+#define IST30XX_ISP_READ_TOTAL_CRC	(0x1B)
+#define IST30XX_ISP_READ_MAIN_CRC		(0x1C)
+#define IST30XX_ISP_READ_INFO_CRC		(0x1D)
+int ist30xxc_isp_enable(struct i2c_client *client, bool enable)
+{
+	int ret = 0;
+
+	if (enable) {
+		ret = ist30xx_write_cmd(client, IST30XX_FLASH_ISPEN, 0xDE01);
+		if (unlikely(ret))
+			return ret;
+
+#if (IMAGIS_TSP_IC < IMAGIS_IST3038C)
+		ret = ist30xx_write_cmd(client, IST30XX_FLASH_MODE, 0x4100);
+		if (unlikely(ret))
+			return ret;
+
+		ret = ist30xx_write_cmd(client, IST30XX_FLASH_TEST_MODE1, 0x38);
+		if (unlikely(ret))
+			return ret;
+#endif
+	} else {
+		ret = ist30xx_write_cmd(client, IST30XX_FLASH_ISPEN, 0x2);
+		if (unlikely(ret))
+			return ret;
+	}
+
+	msleep(1);
+
+	return ret;
+}
+
+int ist30xxc_isp_mode(struct i2c_client *client, int mode)
+{
+	int ret = 0;
+	u32 val = 0;
+
+	switch (mode) {
+	case IST30XX_ISP_READ_TOTAL_S:
+		val = 0x8090;
+		break;
+	case IST30XX_ISP_READ_TOTAL_B:
+	case IST30XX_ISP_READ_TOTAL_CRC:
+		val = 0x8190;
+		break;
+	case IST30XX_ISP_READ_MAIN_S:
+		val = 0x0090;
+		break;
+	case IST30XX_ISP_READ_MAIN_B:
+	case IST30XX_ISP_READ_MAIN_CRC:
+		val = 0x0190;
+		break;
+	case IST30XX_ISP_READ_INFO_S:
+		val = 0x0098;
+		break;
+	case IST30XX_ISP_READ_INFO_B:
+	case IST30XX_ISP_READ_INFO_CRC:
+		val = 0x0198;
+		break;
+	case IST30XX_ISP_PROG_TOTAL_S:
+		val = 0x8050;
+		break;
+	case IST30XX_ISP_PROG_TOTAL_B:
+		val = 0x8150;
+		break;
+	case IST30XX_ISP_PROG_MAIN_S:
+		val = 0x0050;
+		break;
+	case IST30XX_ISP_PROG_MAIN_B:
+		val = 0x0150;
+		break;
+	case IST30XX_ISP_PROG_INFO_S:
+		val = 0x0058;
+		break;
+	case IST30XX_ISP_PROG_INFO_B:
+		val = 0x0158;
+		break;
+	case IST30XX_ISP_ERASE_BLOCK:
+		val = 0x0031;
+		break;
+	case IST30XX_ISP_ERASE_SECTOR:
+		val = 0x0032;
+		break;
+	case IST30XX_ISP_ERASE_PAGE:
+		val = 0x0030;
+		break;
+	case IST30XX_ISP_ERASE_INFO:
+		val = 0x0038;
+		break;
+	default:
+		tsp_err("ISP fail, unknown mode\n");
+		return -EINVAL;
+	}
+
+#if (IMAGIS_TSP_IC > IMAGIS_IST3032C)
+	val &= ~(0x8000);
+#endif
+
+	ret = ist30xx_write_cmd(client, IST30XX_FLASH_MODE, val);
+	if (unlikely(ret)) {
+		tsp_err("ISP fail, IST30XX_FLASH_MODE\n");
+		return ret;
+	}
+
+	return 0;
+}
+
+int ist30xxc_isp_erase(struct i2c_client *client, int mode, u32 index)
+{
+	int ret = 0;
+
+	ret = ist30xxc_isp_mode(client, mode);
+	if (unlikely(ret))
+		return ret;
+
+	ret = ist30xx_write_cmd(client, IST30XX_FLASH_DIN, index);
+	if (unlikely(ret)) {
+		tsp_err("ISP fail, IST30XX_FLASH_DIN\n");
+		return ret;
+	}
+
+	msleep(50); // Flash erase time : Mininum 40msec
+
+	return ret;
+}
+
+
+int ist30xxc_isp_program(struct i2c_client *client, u32 addr, int mode,
+		       const u32 *buf32, int len)
+{
+	int ret = 0;
+
+	ret = ist30xxc_isp_mode(client, mode);
+	if (unlikely(ret))
+		return ret;
+
+	ret = ist30xx_write_cmd(client, IST30XX_FLASH_ADDR, addr);
+	if (unlikely(ret)) {
+		tsp_err("ISP fail, IST30XX_FLASH_ADDR\n");
+		return ret;
+	}
+
+	if (mode & 0x10)
+		ret = ist30xx_isp_write_burst(client,
+				IST30XX_FLASH_DIN, (u32 *)buf32, len);
+	else
+		ret = ist30xx_write_buf(client, IST30XX_FLASH_DIN, (u32 *)buf32, len);
+
+	if (unlikely(ret)) {
+		tsp_err("ISP fail, IST30XX_FLASH_DIN\n");
+		return ret;
+	}
+
+	return ret;
+}
+
+int ist30xxc_isp_read(struct i2c_client *client, u32 addr, int mode,
+		      u32 *buf32, int len)
+{
+	int ret = 0;
+
+	/* IST30xxB ISP read mode */
+	ret = ist30xxc_isp_mode(client, mode);
+	if (unlikely(ret))
+		return ret;
+
+	ret = ist30xx_write_cmd(client, IST30XX_FLASH_ADDR, addr);
+	if (unlikely(ret)) {
+		tsp_err("ISP fail, IST30XX_FLASH_ADDR\n");
+		return ret;
+	}
+
+	if (mode & 0x10)
+		ret = ist30xx_isp_read_burst(client, IST30XX_FLASH_DOUT, buf32, len);
+	else
+		ret = ist30xx_read_buf(client, IST30XX_FLASH_DOUT, buf32, len);
+
+	if (unlikely(ret)) {
+		tsp_err("ISP fail, IST30XX_FLASH_DOUT\n");
+		return ret;
+	}
+
+	return 0;
+}
+
+int ist30xxc_cmd_read_chksum(struct i2c_client *client, int mode,
+			     u32 start_addr, u32 end_addr, u32 *chksum)
+{
+	int ret = 0;
+	u32 val = (1 << 28) | (1 << 25) | (1 << 24) | (1 << 20) | (1 << 16);
+
+	val |= (end_addr / IST30XX_ADDR_LEN) - 1;
+
+	ret = ist30xxc_isp_mode(client, mode);
+	if (unlikely(ret))
+		return ret;
+
+	ret = ist30xx_write_cmd(client, IST30XX_FLASH_ADDR, start_addr);
+	if (unlikely(ret)) {
+		tsp_err("ISP fail, IST30XX_FLASH_ADDR (%x)\n", val);
+		return ret;
+	}
+
+	ret = ist30xx_write_cmd(client, IST30XX_FLASH_AUTO_READ, val);
+	if (unlikely(ret)) {
+		tsp_err("ISP fail, IST30XX_FLASH_AUTO_READ (%x)\n", val);
+		return ret;
+	}
+
+	msleep(100);
+
+	ret = ist30xx_read_reg(client, IST30XX_FLASH_CRC, chksum);
+	if (unlikely(ret)) {
+		tsp_err("ISP fail, IST30XX_FLASH_CRC (%x)\n", chksum);
+		return ret;
+	}
+
+	return 0;
+}
+
+int ist30xxc_read_chksum(struct ist30xx_data *data, u32 *chksum)
+{
+	int ret = 0;
+	u32 start_addr, end_addr;
+
+	start_addr = data->tags.fw_addr;
+	end_addr = data->tags.sensor_addr + data->tags.sensor_size;
+	ret = ist30xxc_cmd_read_chksum(data->client,
+			IST30XX_ISP_READ_TOTAL_CRC, start_addr, end_addr, chksum);
+	if (unlikely(ret))
+		return ret;
+
+	tsp_info("chksum: %x(%x~%x)\n", *chksum, start_addr, end_addr);
+
+	return 0;
+}
+
+int ist30xxc_read_chksum_all(struct i2c_client *client, u32 *chksum)
+{
+	int ret = 0;
+	u32 start_addr, end_addr;
+
+	start_addr = IST30XX_FLASH_BASE_ADDR;
+	end_addr = IST30XX_FLASH_BASE_ADDR + IST30XX_FLASH_TOTAL_SIZE;
+	ret = ist30xxc_cmd_read_chksum(client,
+			IST30XX_ISP_READ_TOTAL_CRC, start_addr, end_addr, chksum);
+	if (unlikely(ret))
+		return ret;
+
+	tsp_info("chksum: %x(%x~%x)\n", *chksum, start_addr, end_addr);
+
+	return 0;
+}
+
+int ist30xxc_isp_fw_read(struct ist30xx_data *data, u32 *buf32)
+{
+	int ret = 0;
+	int i;
+	int len;
+	u32 addr = IST30XX_FLASH_BASE_ADDR;
+
+	ist30xx_reset(data, true);
+
+	/* IST30xxB ISP enable */
+	ret = ist30xxc_isp_enable(data->client, true);
+	if (unlikely(ret))
+		return ret;
+
+#if I2C_BURST_MODE
+	for (i = 0; i < IST30XX_FLASH_TOTAL_SIZE; i += I2C_MAX_READ_SIZE) {
+		len = I2C_MAX_READ_SIZE / IST30XX_DATA_LEN;
+		if ((IST30XX_FLASH_TOTAL_SIZE - i) < I2C_MAX_READ_SIZE)
+			len = (IST30XX_FLASH_TOTAL_SIZE - i) / IST30XX_DATA_LEN;
+
+		ret = ist30xxc_isp_read(data->client, addr, IST30XX_ISP_READ_TOTAL_B,
+				buf32, len);
+		if (unlikely(ret))
+			goto isp_fw_read_end;
+
+		addr += len;
+		buf32 += len;
+	}
+#else
+	for (i = 0; i < IST30XX_FLASH_MAIN_SIZE; i += IST30XX_DATA_LEN) {
+		ret = ist30xxc_isp_read(data->client, addr, IST30XX_ISP_READ_TOTAL_S,
+				buf32, 1);
+		if (unlikely(ret))
+			goto isp_fw_read_end;
+
+		addr++;
+		buf32++;
+	}
+#endif
+isp_fw_read_end:
+	/* IST30xxC ISP disable */
+	ist30xxc_isp_enable(data->client, false);
+	ist30xx_reset(data, false);
+	return ret;
+}
+
+int ist30xxc_isp_fw_update(struct ist30xx_data *data, const u8 *buf)
+{
+#if !(I2C_BURST_MODE)
+	int i;
+#endif
+	int ret = 0;
+	u32 addr = IST30XX_FLASH_BASE_ADDR;
+
+	ist30xx_reset(data, true);
+
+	/* IST30xxC ISP enable */
+	ret = ist30xxc_isp_enable(data->client, true);
+	if (unlikely(ret))
+		goto isp_fw_update_end;
+
+	/* IST30xxC ISP erase */
+	ret = ist30xxc_isp_erase(data->client, IST30XX_ISP_ERASE_BLOCK, 0);
+	if (unlikely(ret))
+		goto isp_fw_update_end;
+
+#if (IST30XX_FLASH_INFO_SIZE > 0)
+	ret = ist30xxc_isp_erase(data->client, IST30XX_ISP_ERASE_INFO, 0);
+	if (unlikely(ret))
+		goto isp_fw_update_end;
+#endif
+
+	ist30xx_reset(data, true);
+
+	/* IST30xxC ISP enable */
+	ret = ist30xxc_isp_enable(data->client, true);
+	if (unlikely(ret))
+		goto isp_fw_update_end;
+
+#if I2C_BURST_MODE
+	/* IST30xxC ISP write burst */
+#if 0
+	for (i = 0; i < IST30XX_FLASH_TOTAL_SIZE / IST30XX_FLASH_PAGE_SIZE; i++) {
+		ret = ist30xxc_isp_program(data->client, addr,
+		IST30XX_ISP_PROG_TOTAL_B, (u32 *)buf,
+		IST30XX_FLASH_PAGE_SIZE / IST30XX_DATA_LEN);
+		if (unlikely(ret))
+			goto isp_fw_update_end;
+
+		addr += IST30XX_FLASH_PAGE_SIZE / IST30XX_DATA_LEN;
+		buf += IST30XX_FLASH_PAGE_SIZE;
+	}
+#else
+	ret = ist30xxc_isp_program(data->client, addr, IST30XX_ISP_PROG_TOTAL_B,
+			(u32 *)buf, IST30XX_FLASH_TOTAL_SIZE / IST30XX_DATA_LEN);
+	if (unlikely(ret))
+		goto isp_fw_update_end;
+#endif
+#else
+	/* IST30xxC ISP write single */
+	for (i = 0; i < IST30XX_FLASH_TOTAL_SIZE; i += IST30XX_DATA_LEN) {
+		ret = ist30xxc_isp_program(data->client, addr,
+		IST30XX_ISP_PROG_TOTAL_S, (u32 *)buf, 1);
+		if (unlikely(ret))
+			goto isp_fw_update_end;
+
+		addr++;
+		buf += IST30XX_DATA_LEN;
+	}
+#endif
+
+isp_fw_update_end:
+	/* IST30xxC ISP disable */
+	ist30xxc_isp_enable(data->client, false);
+	ist30xx_reset(data, false);
+	return ret;
+}
+
+u32 ist30xx_parse_ver(struct ist30xx_data *data, int flag, const u8 *buf)
+{
+	u32 ver = 0;
+	u32 *buf32 = (u32 *)buf;
+
+	if (flag == FLAG_MAIN)
+		ver = (u32)buf32[(data->tags.flag_addr + 0x1FC) >> 2];
+	else if (flag == FLAG_TEST)
+		ver = (u32)buf32[(data->tags.flag_addr + 0x1F4) >> 2];
+	else if (flag == FLAG_FW)
+		ver = (u32)(buf32[(data->tags.cfg_addr + 0x4) >> 2] & 0xFFFF);
+	else if (flag == FLAG_CORE)
+		ver = (u32)buf32[(data->tags.flag_addr + 0x1F0) >> 2];
+	else
+		tsp_warn("Parsing ver's flag is not corrent!\n");
+
+	return ver;
+}
+
+int calib_ms_delay = CALIB_WAIT_TIME;
+int ist30xx_calib_wait(struct ist30xx_data *data)
+{
+	int cnt = calib_ms_delay;
+
+	data->status.calib_msg = 0;
+	while (cnt-- > 0) {
+		msleep(100);
+
+		if (data->status.calib_msg) {
+			tsp_info("Calibration status : %d, Max raw gap : %d - (%08x)\n",
+				 CALIB_TO_STATUS(data->status.calib_msg),
+				 CALIB_TO_GAP(data->status.calib_msg),
+				 data->status.calib_msg);
+			if (CALIB_TO_STATUS(data->status.calib_msg) == 0)
+				return 0;  // Calibrate success
+			else
+				return -EAGAIN;
+		}
+	}
+	tsp_warn("Calibration time out\n");
+
+	return -EPERM;
+}
+
+int ist30xx_calibrate(struct ist30xx_data *data, int wait_cnt)
+{
+	int ret = -ENOEXEC;
+
+	tsp_info("*** Calibrate %ds ***\n", calib_ms_delay / 10);
+
+	data->status.update = 1;
+	ist30xx_disable_irq(data);
+	while (1) {
+		ret = ist30xx_cmd_calibrate(data->client);
+		if (unlikely(ret))
+			continue;
+
+		ist30xx_enable_irq(data);
+		ret = ist30xx_calib_wait(data);
+		if (likely(!ret))
+			break;
+
+		ist30xx_disable_irq(data);
+
+		if (--wait_cnt == 0)
+			break;
+
+		ist30xx_reset(data, false);
+	}
+
+	ist30xx_disable_irq(data);
+	ist30xx_reset(data, false);
+	data->status.update = 2;
+	ist30xx_enable_irq(data);
+
+	return ret;
+}
+
+
+int ist30xx_parse_tags(struct ist30xx_data *data, const u8 *buf, const u32 size)
+{
+	int ret = -EPERM;
+	struct ist30xx_tags *tags;
+
+	tags = (struct ist30xx_tags *)(&buf[size - sizeof(struct ist30xx_tags)]);
+
+	if (!strncmp(tags->magic1, IST30XX_TAG_MAGIC, sizeof(tags->magic1))
+		&& !strncmp(tags->magic2, IST30XX_TAG_MAGIC, sizeof(tags->magic2))
+		) {
+		data->tags = *tags;
+
+		data->tags.fw_addr -= data->tags.rom_base;
+		data->tags.cfg_addr -= data->tags.rom_base;
+		data->tags.sensor_addr -= data->tags.rom_base;
+		data->tags.cp_addr -= data->tags.rom_base;
+		data->tags.flag_addr -= data->tags.rom_base;
+
+		data->fw.index = data->tags.fw_addr;
+		data->fw.size = tags->flag_addr - tags->fw_addr +
+				tags->flag_size;
+		data->fw.chksum = tags->chksum;
+
+		tsp_verb("Tagts magic1: %s, magic2: %s\n",
+				data->tags.magic1, data->tags.magic2);
+				tsp_verb(" rom: %x\n", data->tags.rom_base);
+				tsp_verb(" ram: %x\n", data->tags.ram_base);
+				tsp_verb(" fw: %x(%x)\n", data->tags.fw_addr, data->tags.fw_size);
+				tsp_verb(" cfg: %x(%x)\n", data->tags.cfg_addr, data->tags.cfg_size);
+				tsp_verb(" sensor: %x(%x)\n",
+				data->tags.sensor_addr, data->tags.sensor_size);
+				tsp_verb(" cp: %x(%x)\n", data->tags.cp_addr, data->tags.cp_size);
+				tsp_verb(" flag: %x(%x)\n", data->tags.flag_addr, data->tags.flag_size);
+				tsp_verb(" zvalue: %x\n", data->tags.zvalue_base);
+				tsp_verb(" algo: %x\n", data->tags.algo_base);
+				tsp_verb(" raw: %x\n", data->tags.raw_base);
+				tsp_verb(" filter: %x\n", data->tags.filter_base);
+				tsp_verb(" chksum: %x\n", data->tags.chksum);
+				tsp_verb(" chksum_all: %x\n", data->tags.chksum_all);
+				tsp_verb(" build time: %04d/%02d/%02d (%02d:%02d:%02d)\n",
+				data->tags.year, data->tags.month, data->tags.day,
+				data->tags.hour, data->tags.min, data->tags.sec);
+
+		ret = 0;
+	}
+
+	return ret;
+}
+
+int ist30xx_get_update_info(struct ist30xx_data *data, const u8 *buf,
+			     const u32 size)
+{
+	int ret;
+
+	ret = ist30xx_parse_tags(data, buf, size);
+	if (unlikely(ret != TAGS_PARSE_OK))
+		tsp_warn("Cannot find tags of F/W, make a tags by 'tagts.exe'\n");
+
+    return ret;
+}
+
+#define TSP_INFO_SWAP_XY    (1 << 0)
+#define TSP_INFO_FLIP_X     (1 << 1)
+#define TSP_INFO_FLIP_Y     (1 << 2)
+u32 ist30xx_info_cal_crc(u32 *buf)
+{
+	int i;
+	u32 chksum32 = 0;
+
+	for (i = 0; i < IST30XX_MAX_CMD_SIZE - 1; i++) {
+		chksum32 += *buf++;
+	}
+
+    return chksum32;
+}
+
+int ist30xx_tsp_update_info(struct ist30xx_data *data)
+{
+	int ret = 0;
+	u32 chksum;
+	u32 info[IST30XX_MAX_CMD_SIZE];
+	u32 tsp_lcd, tsp_swap, tsp_scr, tsp_gtx, tsp_ch;
+	u32 tkey_info0, tkey_info1, tkey_info2;
+	u32 finger_info, baseline, threshold;
+	TSP_INFO *tsp = &data->tsp_info;
+#if IST30XX_USE_KEY
+	TKEY_INFO *tkey = &data->tkey_info;
+#endif
+
+	ret = ist30xx_cmd_hold(data->client, 1);
+	if (unlikely(ret))
+		return ret;
+
+	ret = ist30xx_burst_read(data->client,
+			IST30XX_DA_ADDR(eHCOM_GET_CHIP_ID), &info[0],
+			IST30XX_MAX_CMD_SIZE, true);
+	if (unlikely(ret))
+		return ret;
+
+	ist30xx_cmd_hold(data->client, 0);
+	if (unlikely(ret)) {
+		ist30xx_reset(data, false);
+		return ret;
+	}
+
+	ret = ist30xx_read_cmd(data, IST30XX_REG_CHIPID, &data->chip_id);
+	if (unlikely(ret))
+		return ret;
+
+	if ((info[IST30XX_CMD_VALUE(eHCOM_GET_CHIP_ID)] != data->chip_id) ||
+		(info[IST30XX_CMD_VALUE(eHCOM_GET_CHIP_ID)] == 0) ||
+		(info[IST30XX_CMD_VALUE(eHCOM_GET_CHIP_ID)] == 0xFFFF))
+		return -EINVAL;
+
+	chksum = ist30xx_info_cal_crc((u32*)info);
+	if (chksum != info[IST30XX_MAX_CMD_SIZE - 1]) {
+		tsp_err("info checksum : %08X, %08X\n",
+			chksum, info[IST30XX_MAX_CMD_SIZE - 1]);
+		return -EINVAL;
+	}
+	tsp_info("info read success\n");
+
+	tsp_lcd = info[IST30XX_CMD_VALUE(eHCOM_GET_LCD_INFO)];
+	tsp_ch = info[IST30XX_CMD_VALUE(eHCOM_GET_TSP_INFO)];
+	tkey_info0 = info[IST30XX_CMD_VALUE(eHCOM_GET_KEY_INFO_0)];
+	tkey_info1 = info[IST30XX_CMD_VALUE(eHCOM_GET_KEY_INFO_1)];
+	tkey_info2 = info[IST30XX_CMD_VALUE(eHCOM_GET_KEY_INFO_2)];
+	tsp_scr = info[IST30XX_CMD_VALUE(eHCOM_GET_SCR_INFO)];
+	tsp_gtx = info[IST30XX_CMD_VALUE(eHCOM_GET_GTX_INFO)];
+	tsp_swap = info[IST30XX_CMD_VALUE(eHCOM_GET_SWAP_INFO)];
+	finger_info = info[IST30XX_CMD_VALUE(eHCOM_GET_FINGER_INFO)];
+	baseline = info[IST30XX_CMD_VALUE(eHCOM_GET_BASELINE)];
+	threshold = info[IST30XX_CMD_VALUE(eHCOM_GET_TOUCH_TH)];
+
+	tsp->ch_num.rx = (tsp_ch >> 16) & 0xFFFF;
+	tsp->ch_num.tx = tsp_ch & 0xFFFF;
+
+	tsp->node.len = tsp->ch_num.tx * tsp->ch_num.rx;
+
+	tsp->gtx.num = (tsp_gtx >> 24) & 0xFF;
+	tsp->gtx.ch_num[0] = (tsp_gtx >> 16) & 0xFF;
+	tsp->gtx.ch_num[1] = (tsp_gtx >> 8) & 0xFF;
+	tsp->gtx.ch_num[2] = 0xFF;
+	tsp->gtx.ch_num[3] = 0xFF;
+
+	tsp->finger_num = finger_info;
+	tsp->dir.swap_xy = (tsp_swap & TSP_INFO_SWAP_XY ? true : false);
+	tsp->dir.flip_x = (tsp_swap & TSP_INFO_FLIP_X ? true : false);
+	tsp->dir.flip_y = (tsp_swap & TSP_INFO_FLIP_Y ? true : false);
+
+	tsp->baseline = baseline & 0xFFFF;
+
+	tsp->screen.rx = (tsp_scr >> 16) & 0xFFFF;
+	tsp->screen.tx = tsp_scr & 0xFFFF;
+
+	if (tsp->dir.swap_xy) {
+		tsp->width = tsp_lcd & 0xFFFF;
+		tsp->height = (tsp_lcd >> 16) & 0xFFFF;
+	} else {
+		tsp->width = (tsp_lcd >> 16) & 0xFFFF;
+		tsp->height = tsp_lcd & 0xFFFF;
+	}
+
+#if IST30XX_USE_KEY
+	tkey->enable = (((tkey_info0 >> 24) & 0xFF) ? true : false);
+	tkey->key_num = (tkey_info0 >> 16) & 0xFF;
+	tkey->ch_num[0].tx = tkey_info0 & 0xFF;
+	tkey->ch_num[0].rx = (tkey_info0 >> 8) & 0xFF;
+	tkey->ch_num[1].tx = (tkey_info1 >> 16) & 0xFF;
+	tkey->ch_num[1].rx = (tkey_info1 >> 24) & 0xFF;
+	tkey->ch_num[2].tx = tkey_info1 & 0xFF;
+	tkey->ch_num[2].rx = (tkey_info1 >> 8) & 0xFF;
+	tkey->ch_num[3].tx = (tkey_info2 >> 16) & 0xFF;
+	tkey->ch_num[3].rx = (tkey_info2 >> 24) & 0xFF;
+	tkey->ch_num[4].tx = tkey_info2 & 0xFF;
+	tkey->ch_num[4].rx = (tkey_info2 >> 8) & 0xFF;
+
+	tkey->baseline = (baseline >> 16) & 0xFFFF;
+#endif
+
+	return ret;
+}
+
+int ist30xx_get_tsp_info(struct ist30xx_data *data)
+{
+	int ret = 0;
+	int retry = 3;
+#if IST30XX_INTERNAL_BIN
+	TSP_INFO *tsp = &data->tsp_info;
+#if IST30XX_USE_KEY
+	TKEY_INFO *tkey = &data->tkey_info;
+#endif
+	u8 *cfg_buf;
+#endif
+
+	while (retry--) {
+		ret = ist30xx_tsp_update_info(data);
+		if (ret == 0) {
+			tsp_info("tsp update info success!\n");
+			return ret;
+		}
+	}
+
+#if IST30XX_INTERNAL_BIN
+	cfg_buf = (u8 *)&data->fw.buf[data->tags.cfg_addr];
+
+	tsp->ch_num.rx = (u8)cfg_buf[0x0C];
+	tsp->ch_num.tx = (u8)cfg_buf[0x0D];
+	tsp->node.len = tsp->ch_num.tx * tsp->ch_num.rx;
+
+	tsp->gtx.num = (u8)cfg_buf[0x10];
+	tsp->gtx.ch_num[0] = (u8)cfg_buf[0x11];
+	tsp->gtx.ch_num[1] = (u8)cfg_buf[0x12];
+	tsp->gtx.ch_num[2] = (u8)cfg_buf[0x13];
+	tsp->gtx.ch_num[3] = (u8)cfg_buf[0x14];
+
+	tsp->finger_num = (u8)cfg_buf[0x1A];
+	tsp->dir.swap_xy = (bool)(cfg_buf[0x1B] & TSP_INFO_SWAP_XY ? true : false);
+	tsp->dir.flip_x = (bool)(cfg_buf[0x1B] & TSP_INFO_FLIP_X ? true : false);
+	tsp->dir.flip_y = (bool)(cfg_buf[0x1B] & TSP_INFO_FLIP_Y ? true : false);
+
+	tsp->baseline = (u16)((cfg_buf[0x31] << 8) | cfg_buf[0x30]);
+
+	tsp->screen.rx = (u8)cfg_buf[0x0E];
+	tsp->screen.tx = (u8)cfg_buf[0x0F];
+
+	if (tsp->dir.swap_xy) {
+		tsp->width = (u16)((cfg_buf[0x19] << 8) | cfg_buf[0x18]);
+		tsp->height = (u16)((cfg_buf[0x17] << 8) | cfg_buf[0x16]);
+	} else {
+		tsp->width = (u16)((cfg_buf[0x17] << 8) | cfg_buf[0x16]);
+		tsp->height = (u16)((cfg_buf[0x19] << 8) | cfg_buf[0x18]);
+	}
+
+#if IST30XX_USE_KEY
+	tkey->enable = (bool)(cfg_buf[0x3A] & 1);
+	tkey->key_num = (u8)cfg_buf[0x3B];
+	tkey->ch_num[0].tx = (u8)cfg_buf[0x3E];
+	tkey->ch_num[0].rx = (u8)cfg_buf[0x43];
+	tkey->ch_num[1].tx = (u8)cfg_buf[0x3F];
+	tkey->ch_num[1].rx = (u8)cfg_buf[0x44];
+	tkey->ch_num[2].tx = (u8)cfg_buf[0x40];
+	tkey->ch_num[2].rx = (u8)cfg_buf[0x45];
+	tkey->ch_num[3].tx = (u8)cfg_buf[0x41];
+	tkey->ch_num[3].rx = (u8)cfg_buf[0x46];
+	tkey->ch_num[4].tx = (u8)cfg_buf[0x42];
+	tkey->ch_num[4].rx = (u8)cfg_buf[0x47];
+
+	tkey->baseline = (u16)((cfg_buf[0x3D] << 8) | cfg_buf[0x3C]);
+#endif
+#endif
+
+	return ret;
+}
+
+void ist30xx_print_info(struct ist30xx_data *data)
+{
+	TSP_INFO *tsp = &data->tsp_info;
+	TKEY_INFO *tkey = &data->tkey_info;
+
+	tsp_info("*** TSP/TKEY info ***\n");
+	tsp_info("TSP info: \n");
+	tsp_info(" finger num: %d\n", tsp->finger_num);
+	tsp_info(" dir swap: %d, flip x: %d, y: %d\n",
+			tsp->dir.swap_xy, tsp->dir.flip_x, tsp->dir.flip_y);
+	tsp_info(" baseline: %d\n", tsp->baseline);
+	tsp_info(" ch_num tx: %d, rx: %d\n", tsp->ch_num.tx, tsp->ch_num.rx);
+	tsp_info(" screen tx: %d, rx: %d\n", tsp->screen.tx, tsp->screen.rx);
+	tsp_info(" width: %d, height: %d\n", tsp->width, tsp->height);
+	tsp_info(" gtx num: %d, ch [1]: %d, [2]: %d, [3]: %d, [4]: %d\n",
+			tsp->gtx.num, tsp->gtx.ch_num[0], tsp->gtx.ch_num[1],
+			tsp->gtx.ch_num[2], tsp->gtx.ch_num[3]);
+	tsp_info(" node len: %d\n", tsp->node.len);
+	tsp_info("TKEY info: \n");
+	tsp_info(" enable: %d, key num: %d\n", tkey->enable, tkey->key_num);
+	tsp_info(" ch [0]: %d,%d [1]: %d,%d [2]: %d,%d [3]: %d,%d [4]: %d,%d\n",
+			tkey->ch_num[0].tx, tkey->ch_num[0].rx, tkey->ch_num[1].tx,
+			tkey->ch_num[1].rx, tkey->ch_num[2].tx, tkey->ch_num[2].rx,
+			tkey->ch_num[3].tx, tkey->ch_num[3].rx, tkey->ch_num[4].tx,
+			tkey->ch_num[4].rx);
+	tsp_info(" baseline : %d\n", tkey->baseline);
+}
+
+#define update_next_step(ret)   { if (unlikely(ret)) goto end; }
+int ist30xx_fw_update(struct ist30xx_data *data, const u8 *buf, int size)
+{
+	int ret = 0;
+	u32 chksum = 0;
+	struct ist30xx_fw *fw = &data->fw;
+
+	tsp_info("*** Firmware update ***\n");
+	tsp_info(" main: %x, fw: %x, test: %x, core: %x(addr: 0x%x ~ 0x%x)\n",
+			fw->bin.main_ver, fw->bin.fw_ver, fw->bin.test_ver, fw->bin.core_ver,
+			fw->index, (fw->index + fw->size));
+
+	data->status.update = 1;
+	data->status.update_result = 0;
+
+	ist30xx_disable_irq(data);
+
+	ret = ist30xxc_isp_fw_update(data, buf);
+	update_next_step(ret);
+
+	ret = ist30xx_read_cmd(data, eHCOM_GET_CRC32, &chksum);
+	if (unlikely((ret) || (chksum != fw->chksum))) {
+		if (unlikely(ret))
+			ist30xx_reset(data, false);
+
+		goto end;
+	}
+
+	ret = ist30xx_get_ver_info(data);
+	update_next_step(ret);
+
+end:
+	if (unlikely(ret)) {
+		data->status.update_result = 1;
+		tsp_warn("Firmware update Fail!, ret=%d\n", ret);
+	} else if (unlikely(chksum != fw->chksum)) {
+		data->status.update_result = 1;
+		tsp_warn("Error CheckSum: %x(%x)\n", chksum, fw->chksum);
+		ret = -ENOEXEC;
+	}
+
+	ist30xx_enable_irq(data);
+
+	data->status.update = 2;
+
+	return ret;
+}
+
+int ist30xx_fw_recovery(struct ist30xx_data *data)
+{
+	int ret = -EPERM;
+	u8 *fw = data->fw.buf;
+	int fw_size = data->fw.buf_size;
+
+	ret = ist30xx_get_update_info(data, fw, fw_size);
+	if (ret)
+		return ret;
+
+	data->fw.bin.main_ver = ist30xx_parse_ver(data, FLAG_MAIN, fw);
+	data->fw.bin.fw_ver = ist30xx_parse_ver(data, FLAG_FW, fw);
+	data->fw.bin.test_ver = ist30xx_parse_ver(data, FLAG_TEST, fw);
+	data->fw.bin.core_ver = ist30xx_parse_ver(data, FLAG_CORE, fw);
+
+	mutex_lock(&ist30xx_mutex);
+	ret = ist30xx_fw_update(data, fw, fw_size);
+	if (ret == 0)
+		ist30xx_calibrate(data, 1);
+	mutex_unlock(&ist30xx_mutex);
+
+	ist30xx_start(data);
+
+	return ret;
+}
+
+#if IST30XX_INTERNAL_BIN
+int ist30xx_check_fw(struct ist30xx_data *data, const u8 *buf)
+{
+	int ret;
+	u32 chksum;
+
+	ret = ist30xx_read_cmd(data, eHCOM_GET_CRC32, &chksum);
+	if (unlikely(ret)) {
+		ist30xx_reset(data, false);
+		return ret;
+	}
+
+	if (unlikely(chksum != data->fw.chksum)) {
+		tsp_warn("Checksum compare error, (IC: %08x, Bin: %08x)\n",
+			 chksum, data->fw.chksum);
+		return -EPERM;
+	}
+
+	return 0;
+}
+
+bool ist30xx_check_valid_vendor(u32 tsp_vendor)
+{
+#if (IMAGIS_TSP_IC < IMAGIS_IST3038C)
+	switch (tsp_vendor) {
+	case TSP_TYPE_ALPS:
+	case TSP_TYPE_EELY:
+	case TSP_TYPE_TOP:
+	case TSP_TYPE_MELFAS:
+	case TSP_TYPE_ILJIN:
+	case TSP_TYPE_SYNOPEX:
+	case TSP_TYPE_SMAC:
+	case TSP_TYPE_TAEYANG:
+	case TSP_TYPE_TOVIS:
+	case TSP_TYPE_ELK:
+	case TSP_TYPE_OTHERS:
+		return true;
+	default:
+		return false;
+	}
+#else
+	if (tsp_vendor < TSP_TYPE_NO)
+		return true;
+#endif
+
+    return false;
+}
+
+#if (IMAGIS_TSP_IC < IMAGIS_IST3038C)
+#if IST30XX_MULTIPLE_TSP
+void ist30xx_set_tsp_fw(struct ist30xx_data *data)
+{
+	char *str;
+	struct ist30xx_fw *fw = &data->fw;
+
+	switch (data->tsp_type) {
+	case TSP_TYPE_ILJIN:
+		str = "ALPS/ILJIN";
+		fw->buf = (u8 *)ist30xxc_fw;
+		fw->buf_size = sizeof(ist30xxc_fw);
+		break;
+	case TSP_TYPE_EELY:
+		str = "EELY";
+		fw->buf = (u8 *)ist30xxc_fw2;
+		fw->buf_size = sizeof(ist30xxc_fw2);
+		break;
+
+	case TSP_TYPE_UNKNOWN:
+	default:
+		str = "Unknown";
+		tsp_warn("Unknown TSP vendor(0x%x)\n", data->tsp_type);
+		break;
+	}
+	tsp_info("TSP vendor : %s(%x)\n", str, data->tsp_type);
+}
+#endif  // IST30XX_MULTIPLE_TSP
+#endif  // (IMAGIS_TSP_IC < IMAGIS_IST3038C)
+
+int ist30xx_check_auto_update(struct ist30xx_data *data)
+{
+	int ret = 0;
+	int retry = IST30XX_MAX_RETRY_CNT;
+	u32 tsp_type = TSP_TYPE_UNKNOWN;
+	bool tsp_check = false;
+	u32 chksum;
+	struct ist30xx_fw *fw = &data->fw;
+
+	while (retry--) {
+		ret = ist30xx_read_cmd(data, eHCOM_GET_TSP_VENDOR, &tsp_type);
+		if (likely(ret == 0)) {
+			if (likely(ist30xx_check_valid_vendor(tsp_type) == true))
+				tsp_check = true;
+			break;
+		}
+
+		ist30xx_reset(data, false);
+	}
+#if (IMAGIS_TSP_IC < IMAGIS_IST3038C)
+	tsp_info("TSP vendor: %x\n", tsp_type);
+#endif
+
+	if (unlikely(!tsp_check))
+		goto fw_check_end;
+
+	ist30xx_get_ver_info(data);
+
+	if (likely((fw->cur.fw_ver > 0) && (fw->cur.fw_ver < 0xFFFFFFFF))) {
+		tsp_info("Version compare IC: %x(%x), BIN: %x(%x)\n", fw->cur.fw_ver,
+		fw->cur.main_ver, fw->bin.fw_ver, fw->bin.main_ver);
+
+		/* If FW version is same, check FW checksum */
+		if (likely((fw->cur.main_ver == fw->bin.main_ver) &&
+			(fw->cur.fw_ver == fw->bin.fw_ver) &&
+			(fw->cur.test_ver == 0))) {
+			ret = ist30xx_read_cmd(data, eHCOM_GET_CRC32, &chksum);
+			if (unlikely((ret) || (chksum != fw->chksum))) {
+				tsp_warn("Checksum error, IC: %x, Bin: %x (ret: %d)\n",
+					 chksum, fw->chksum, ret);
+				goto fw_check_end;
+			}
+		}
+
+		/*
+		 *  fw->cur.main_ver : Main version in TSP IC
+		 *  fw->cur.fw_ver : FW version if TSP IC
+		 *  fw->bin.main_ver : Main version in FW Binary
+		 *  fw->bin.fw_ver : FW version in FW Binary
+		 */
+		/* If the ver of binary is higher than ver of IC, FW update operate. */
+
+		if (likely((fw->cur.main_ver >= fw->bin.main_ver) &&
+			(fw->cur.fw_ver >= fw->bin.fw_ver)))
+			return 0;
+	}
+
+fw_check_end:
+	return -EAGAIN;
+}
+
+int ist30xx_auto_bin_update(struct ist30xx_data *data)
+{
+	int ret = 0;
+	int retry = IST30XX_MAX_RETRY_CNT;
+	struct ist30xx_fw *fw = &data->fw;
+
+	fw->buf = (u8 *)ist30xxc_fw;
+	fw->buf_size = sizeof(ist30xxc_fw);
+
+#if (IMAGIS_TSP_IC < IMAGIS_IST3038C)
+#if IST30XX_MULTIPLE_TSP
+	ist30xx_set_tsp_fw(data);
+#endif
+#endif
+
+	ret = ist30xx_get_update_info(data, fw->buf, fw->buf_size);
+	if (unlikely(ret))
+		return 1;
+	fw->bin.main_ver = ist30xx_parse_ver(data, FLAG_MAIN, fw->buf);
+	fw->bin.fw_ver = ist30xx_parse_ver(data, FLAG_FW, fw->buf);
+	fw->bin.test_ver = ist30xx_parse_ver(data, FLAG_TEST, fw->buf);
+	fw->bin.core_ver = ist30xx_parse_ver(data, FLAG_CORE, fw->buf);
+
+	tsp_info("IC: %x, Binary ver main: %x, fw: %x, test: %x, core: %x\n",
+			data->chip_id, fw->bin.main_ver, fw->bin.fw_ver, fw->bin.test_ver,
+			fw->bin.core_ver);
+
+	mutex_lock(&ist30xx_mutex);
+	ret = ist30xx_check_auto_update(data);
+	mutex_unlock(&ist30xx_mutex);
+
+	if (likely(ret >= 0))
+		return ret;
+
+update_bin:   // TSP is not ready / FW update
+	tsp_info("Update version. fw(main, test, core): %x(%x, %x, %x) -> %x(%x, %x, %x)\n",
+			fw->cur.fw_ver, fw->cur.main_ver, fw->cur.test_ver, fw->cur.core_ver,
+			fw->bin.fw_ver, fw->bin.main_ver, fw->bin.test_ver, fw->bin.core_ver);
+
+	mutex_lock(&ist30xx_mutex);
+	while (retry--) {
+		ret = ist30xx_fw_update(data, fw->buf, fw->buf_size);
+		if (unlikely(!ret))
+			break;
+	}
+	mutex_unlock(&ist30xx_mutex);
+
+	if (unlikely(ret))
+		return ret;
+
+	if (unlikely(retry > 0 && ist30xx_check_fw(data, fw->buf)))
+		goto update_bin;
+
+	mutex_lock(&ist30xx_mutex);
+	ist30xx_calibrate(data, IST30XX_MAX_RETRY_CNT);
+	mutex_unlock(&ist30xx_mutex);
+
+	return ret;
+}
+#endif // IST30XX_INTERNAL_BIN
+
+#define MAX_FILE_PATH   255
+/* sysfs: /sys/class/touch/firmware/firmware */
+ssize_t ist30xx_fw_store(struct device *dev, struct device_attribute *attr,
+			 const char *buf, size_t size)
+{
+	int ret;
+	int fw_size = 0;
+	u8 *fw = NULL;
+	const u8 *buff = 0;
+	mm_segment_t old_fs = { 0 };
+	struct file *fp = NULL;
+	long fsize = 0, nread = 0;
+	char fw_path[MAX_FILE_PATH];
+	const struct firmware *request_fw = NULL;
+	int mode = 0;
+	int calib = 1;
+	struct ist30xx_data *data = dev_get_drvdata(dev);
+
+	sscanf(buf, "%d %d", &mode, &calib);
+
+	switch (mode) {
+	case MASK_UPDATE_INTERNAL:
+#if IST30XX_INTERNAL_BIN
+		fw = data->fw.buf;
+		fw_size = data->fw.buf_size;
+#else
+		tsp_warn("Not support internal bin!!\n");
+		return size;
+#endif
+		break;
+
+	case MASK_UPDATE_FW:
+		ret = request_firmware(&request_fw, IST30XX_FW_NAME,
+				       &data->client->dev);
+		if (ret) {
+			tsp_warn("File not found, %s\n", IST30XX_FW_NAME);
+			return size;
+		}
+
+		fw = (u8 *)request_fw->data;
+		fw_size = (u32)request_fw->size;
+		tsp_info("firmware is loaded!!\n");
+		break;
+
+        case MASK_UPDATE_SDCARD:
+		old_fs = get_fs();
+		set_fs(get_ds());
+
+		snprintf(fw_path, MAX_FILE_PATH, "/sdcard/%s",
+			 IST30XX_FW_NAME);
+		fp = filp_open(fw_path, O_RDONLY, 0);
+		if (IS_ERR(fp)) {
+			tsp_info("file %s open error:%d\n", fw_path, (s32)fp);
+			goto err_file_open;
+		}
+
+		fsize = fp->f_path.dentry->d_inode->i_size;
+
+		buff = kzalloc((size_t)fsize, GFP_KERNEL);
+		if (!buff) {
+			tsp_info("fail to alloc buffer\n");
+			goto err_alloc;
+		}
+
+		nread = vfs_read(fp, (char __user *)buff, fsize, &fp->f_pos);
+		if (nread != fsize) {
+			tsp_info("mismatch fw size\n");
+			goto err_fw_size;
+		}
+
+		fw = (u8 *)buff;
+		fw_size = (u32)fsize;
+
+		filp_close(fp, current->files);
+		tsp_info("firmware is loaded!!\n");
+		break;
+
+	case MASK_UPDATE_ERASE:
+		tsp_info("EEPROM all erase!!\n");
+
+		mutex_lock(&ist30xx_mutex);
+		ist30xx_disable_irq(data);
+		ist30xx_reset(data, true);
+		ist30xxc_isp_enable(data->client, true);
+		ist30xxc_isp_erase(data->client, IST30XX_ISP_ERASE_BLOCK, 0);
+#if (IST30XX_FLASH_INFO_SIZE > 0)
+		ist30xxc_isp_erase(data->client, IST30XX_ISP_ERASE_INFO, 0);
+#endif
+		ist30xxc_isp_enable(data->client, false);
+		ist30xx_reset(data, false);
+		ist30xx_start(data);
+		ist30xx_enable_irq(data);
+		mutex_unlock(&ist30xx_mutex);
+
+	default:
+		return size;
+	}
+
+	ret = ist30xx_get_update_info(data, fw, fw_size);
+	if (ret)
+		goto err_get_info;
+
+	data->fw.bin.main_ver = ist30xx_parse_ver(data, FLAG_MAIN, fw);
+	data->fw.bin.fw_ver = ist30xx_parse_ver(data, FLAG_FW, fw);
+	data->fw.bin.test_ver = ist30xx_parse_ver(data, FLAG_TEST, fw);
+	data->fw.bin.core_ver = ist30xx_parse_ver(data, FLAG_CORE, fw);
+
+	mutex_lock(&ist30xx_mutex);
+	ist30xx_fw_update(data, fw, fw_size);
+
+	if (calib)
+		ist30xx_calibrate(data, 1);
+	mutex_unlock(&ist30xx_mutex);
+
+	ist30xx_start(data);
+
+err_get_info:
+	if (request_fw != NULL)
+		release_firmware(request_fw);
+
+	if (fp != NULL) {
+err_fw_size:
+		kfree(buff);
+err_alloc:
+		filp_close(fp, NULL);
+err_file_open:
+		set_fs(old_fs);
+	}
+
+	return size;
+}
+
+/* sysfs: /sys/class/touch/firmware/fw_sdcard */
+ssize_t ist30xx_fw_sdcard_show(struct device *dev,
+			       struct device_attribute *attr, char *buf)
+{
+	int ret = 0;
+	int fw_size = 0;
+	u8 *fw = NULL;
+	const u8 *buff = 0;
+	mm_segment_t old_fs = { 0 };
+	struct file *fp = NULL;
+	long fsize = 0, nread = 0;
+	char fw_path[MAX_FILE_PATH];
+	struct ist30xx_data *data = dev_get_drvdata(dev);
+
+	old_fs = get_fs();
+	set_fs(get_ds());
+
+	snprintf(fw_path, MAX_FILE_PATH, "/sdcard/%s",
+		 IST30XX_FW_NAME);
+	fp = filp_open(fw_path, O_RDONLY, 0);
+	if (IS_ERR(fp)) {
+		tsp_info("file %s open error:%d\n", fw_path, (s32)fp);
+		goto err_file_open;
+	}
+
+	fsize = fp->f_path.dentry->d_inode->i_size;
+
+	buff = kzalloc((size_t)fsize, GFP_KERNEL);
+	if (!buff) {
+		tsp_info("fail to alloc buffer\n");
+		goto err_alloc;
+	}
+
+	nread = vfs_read(fp, (char __user *)buff, fsize, &fp->f_pos);
+	if (nread != fsize) {
+		tsp_info("mismatch fw size\n");
+		goto err_fw_size;
+	}
+
+	fw = (u8 *)buff;
+	fw_size = (u32)fsize;
+
+	filp_close(fp, current->files);
+	tsp_info("firmware is loaded!!\n");
+
+	ret = ist30xx_get_update_info(data, fw, fw_size);
+	if (ret)
+		goto err_get_info;
+	data->fw.bin.main_ver = ist30xx_parse_ver(data, FLAG_MAIN, fw);
+	data->fw.bin.fw_ver = ist30xx_parse_ver(data, FLAG_FW, fw);
+	data->fw.bin.test_ver = ist30xx_parse_ver(data, FLAG_TEST, fw);
+	data->fw.bin.core_ver = ist30xx_parse_ver(data, FLAG_CORE, fw);
+
+	mutex_lock(&ist30xx_mutex);
+	ist30xx_fw_update(data, fw, fw_size);
+	mutex_unlock(&ist30xx_mutex);
+
+	ist30xx_start(data);
+
+err_get_info:
+err_fw_size:
+	if (buff)
+		kfree(buff);
+err_alloc:
+	if (fp)
+		filp_close(fp, NULL);
+err_file_open:
+	set_fs(old_fs);
+
+	return 0;
+}
+
+/* sysfs: /sys/class/touch/firmware/firmware */
+ssize_t ist30xx_fw_status_show(struct device *dev,
+			       struct device_attribute *attr, char *buf)
+{
+	int count;
+	struct ist30xx_data *data = dev_get_drvdata(dev);
+
+	switch (data->status.update) {
+	case 1:
+		count = sprintf(buf, "Downloading\n");
+		break;
+	case 2:
+		if (data->status.update_result) {
+			count = sprintf(buf, "Update fail\n");
+		} else {
+			count = sprintf(buf, "Update success, ver %x(%x, %x, %x)-> %x(%x, %x, %x), "
+					"status : %d, gap : %d\n",
+					data->fw.prev.fw_ver, data->fw.prev.main_ver,
+					data->fw.prev.test_ver, data->fw.prev.core_ver,
+					data->fw.cur.fw_ver, data->fw.cur.main_ver,
+					data->fw.cur.test_ver, data->fw.cur.core_ver,
+					CALIB_TO_STATUS(data->status.calib_msg),
+					CALIB_TO_GAP(data->status.calib_msg));
+		}
+		break;
+	default:
+		count = sprintf(buf, "Pass\n");
+	}
+
+	return count;
+}
+
+/* sysfs: /sys/class/touch/firmware/fw_read */
+u32 buf32_flash[IST30XX_FLASH_TOTAL_SIZE / IST30XX_DATA_LEN];
+ssize_t ist30xx_fw_read_show(struct device *dev, struct device_attribute *attr,
+			     char *buf)
+{
+	int i;
+	mm_segment_t old_fs = { 0 };
+	struct file *fp = NULL;
+	char fw_path[MAX_FILE_PATH];
+	u8 *buf8 = (u8 *)buf32_flash;
+	struct ist30xx_data *data = dev_get_drvdata(dev);
+
+	mutex_lock(&ist30xx_mutex);
+	ist30xx_disable_irq(data);
+
+	ist30xxc_isp_fw_read(data, buf32_flash);
+	for (i = 0; i < IST30XX_FLASH_TOTAL_SIZE; i += 16) {
+		tsp_debug("%07x: %02x%02x %02x%02x %02x%02x %02x%02x "
+				"%02x%02x %02x%02x %02x%02x %02x%02x\n", i,
+				buf8[i], buf8[i + 1], buf8[i + 2], buf8[i + 3],
+				buf8[i + 4], buf8[i + 5], buf8[i + 6], buf8[i + 7],
+				buf8[i + 8], buf8[i + 9], buf8[i + 10], buf8[i + 11],
+				buf8[i + 12], buf8[i + 13], buf8[i + 14], buf8[i + 15]);
+	}
+
+	old_fs = get_fs();
+	set_fs(get_ds());
+
+	snprintf(fw_path, MAX_FILE_PATH, "/sdcard/%s", IST30XX_BIN_NAME);
+	fp = filp_open(fw_path, O_CREAT|O_WRONLY|O_TRUNC, 0);
+	if (IS_ERR(fp)) {
+		tsp_info("file %s open error:%d\n", fw_path, (s32)fp);
+		goto err_file_open;
+	}
+
+	fp->f_op->write(fp, buf8, IST30XX_FLASH_TOTAL_SIZE, &fp->f_pos);
+	fput(fp);
+
+	filp_close(fp, NULL);
+	set_fs(old_fs);
+
+err_file_open:
+	ist30xx_enable_irq(data);
+	mutex_unlock(&ist30xx_mutex);
+
+	ist30xx_start(data);
+
+	return 0;
+}
+
+/* sysfs: /sys/class/touch/firmware/version */
+ssize_t ist30xx_fw_version_show(struct device *dev,
+				struct device_attribute *attr, char *buf)
+{
+	int count;
+	struct ist30xx_data *data = dev_get_drvdata(dev);
+
+	count = sprintf(buf, "ID: %x, main: %x, fw: %x, test: %x, core: %x\n",
+			data->chip_id, data->fw.cur.main_ver, data->fw.cur.fw_ver,
+			data->fw.cur.test_ver, data->fw.cur.core_ver);
+
+#if IST30XX_INTERNAL_BIN
+	{
+		char msg[128];
+
+		ist30xx_get_update_info(data, data->fw.buf, data->fw.buf_size);
+
+		count += snprintf(msg, sizeof(msg),
+				 " Header - main: %x, fw: %x, test: %x, core: %x\n",
+				ist30xx_parse_ver(data, FLAG_MAIN, data->fw.buf),
+				ist30xx_parse_ver(data, FLAG_FW, data->fw.buf),
+				ist30xx_parse_ver(data, FLAG_TEST, data->fw.buf),
+				ist30xx_parse_ver(data, FLAG_CORE, data->fw.buf));
+		strncat(buf, msg, sizeof(msg));
+	}
+#endif
+
+	return count;
+}
+
+
+/* sysfs  */
+static DEVICE_ATTR(fw_read, S_IRWXUGO, ist30xx_fw_read_show, NULL);
+static DEVICE_ATTR(firmware, S_IRWXUGO, ist30xx_fw_status_show,
+		   ist30xx_fw_store);
+static DEVICE_ATTR(fw_sdcard, S_IRWXUGO, ist30xx_fw_sdcard_show, NULL);
+static DEVICE_ATTR(version, S_IRWXUGO, ist30xx_fw_version_show, NULL);
+
+struct class *ist30xx_class;
+struct device *ist30xx_fw_dev;
+
+static struct attribute *fw_attributes[] = {
+	&dev_attr_fw_read.attr,
+	&dev_attr_firmware.attr,
+	&dev_attr_fw_sdcard.attr,
+	&dev_attr_version.attr,
+	NULL,
+};
+
+static struct attribute_group fw_attr_group = {
+	.attrs	= fw_attributes,
+};
+
+int ist30xx_init_update_sysfs(struct ist30xx_data *data)
+{
+	/* /sys/class/touch */
+	ist30xx_class = class_create(THIS_MODULE, "touch");
+
+	/* /sys/class/touch/firmware */
+	ist30xx_fw_dev = device_create(ist30xx_class, NULL, 0, data, "firmware");
+
+	/* /sys/class/touch/firmware/... */
+	if (unlikely(sysfs_create_group(&ist30xx_fw_dev->kobj, &fw_attr_group)))
+		tsp_err("Failed to create sysfs group(%s)!\n", "firmware");
+
+	data->status.update = 0;
+	data->status.calib = 0;
+	data->status.update_result = 0;
+
+	return 0;
+}