touch/goodix: Import driver v1.2.7 and v1.2.8

Release note:
v1.2.8:
1. Based on GT9916R or GT9916P to update FW respectively.
2. Support heatmap function for GT9966.
3. Support FATP test items for GT9966.
4. Modify the expression of CFG version.

v1.2.7:
1. minor change for goodix_set_highsense_mode()

Bug: 273167792
Change-Id: I74dc8f620174908fd74545fac328f6ea08edf844
Signed-off-by: Super Liu <supercjliu@google.com>

4 files changed, 325 insertions, 155 deletions

diff --git a/goodix_brl_fwupdate.c b/goodix_brl_fwupdate.c
index f7136fa..b277743 100644
--- a/goodix_brl_fwupdate.c
+++ b/goodix_brl_fwupdate.c
@@ -248,22 +248,22 @@ static int goodix_parse_firmware(struct goodix_ts_core *cd,
 	}
 
 	ts_info("Firmware package protocol: V%u", fw_summary->protocol_ver);
-	ts_info("Firmware PID:GT%s", fw_summary->fw_pid);
-	ts_info("Firmware VID:%*ph", 4, fw_summary->fw_vid);
-	ts_info("Firmware chip type:0x%02X", fw_summary->chip_type);
-	ts_info("Firmware bus type:%s",
+	ts_info("Firmware PID: GT%s", fw_summary->fw_pid);
+	ts_info("Firmware VID: %*ph", 4, fw_summary->fw_vid);
+	ts_info("Firmware chip type: 0x%02X", fw_summary->chip_type);
+	ts_info("Firmware bus type: %s",
 		(fw_summary->bus_type & BUS_TYPE_SPI) ? "SPI" : "I2C");
-	ts_info("Firmware size:%u", fw_summary->size);
-	ts_info("Firmware subsystem num:%u", fw_summary->subsys_num);
+	ts_info("Firmware size: %u", fw_summary->size);
+	ts_info("Firmware subsystem num: %u", fw_summary->subsys_num);
 
 	for (i = 0; i < fw_summary->subsys_num; i++) {
 		ts_debug("------------------------------------------");
-		ts_debug("Index:%d", i);
-		ts_debug("Subsystem type:%02X", fw_summary->subsys[i].type);
-		ts_debug("Subsystem size:%u", fw_summary->subsys[i].size);
-		ts_debug("Subsystem flash_addr:%08X",
+		ts_debug("Index: %d", i);
+		ts_debug("Subsystem type: %02X", fw_summary->subsys[i].type);
+		ts_debug("Subsystem size: %u", fw_summary->subsys[i].size);
+		ts_debug("Subsystem flash_addr: %08X",
 			fw_summary->subsys[i].flash_addr);
-		ts_debug("Subsystem Ptr:%p", fw_summary->subsys[i].data);
+		ts_debug("Subsystem Ptr: %p", fw_summary->subsys[i].data);
 
 		if (fw_summary->subsys[i].type == CONFIG_DATA_TYPE) {
 			one_binary_cfg->len = fw_summary->subsys[i].size;
@@ -1135,9 +1135,32 @@ int goodix_do_fw_update(struct goodix_ts_core *cd, int mode)
 	return 0;
 }
 
+/*
+ * [GOOG]
+ * Read PID from flash.
+ * This is only available for IC_TYPE_BERLIN_D.
+ */
+static int goodix_read_pid_from_flash(struct goodix_ts_core *cd)
+{
+	u8 *buf = cd->flash_pid;
+	int ret;
+
+	if (cd->bus && cd->bus->ic_type != IC_TYPE_BERLIN_D)
+		return -EOPNOTSUPP;
+
+	ret = cd->hw_ops->read_flash(cd, 0x1F020 + 17, buf, sizeof(buf));
+	if (ret < 0) {
+		ts_err("read flash 0x%04x failed", 0x1F020 + 17);
+		return ret;
+	}
+	ts_info("pid from flash is %s", buf);
+	return 0;
+}
+
 int goodix_fw_update_init(struct goodix_ts_core *core_data)
 {
 	int ret;
+	struct goodix_ts_board_data *bdata;
 
 	if (!core_data || !core_data->hw_ops) {
 		ts_err("core_data && hw_ops cann't be null");
@@ -1148,6 +1171,38 @@ int goodix_fw_update_init(struct goodix_ts_core *core_data)
 	core_data->update_ctrl.core_data = core_data;
 	core_data->update_ctrl.mode = 0;
 
+/*
+ * [GOOG]
+ * Suffix 'flash_pid' to firmware name that used by request_firmware()
+ * when 'goodix,pid-suffix-fw-map' property matched.
+ * e.g.:
+ *   goodix,pid-suffix-fw-map = "9916P";
+ *   'flash_pid' = 9916P
+ *   'fw_name' -> goodix_firmware.bin.9916P
+ *   'cfg_bin_name' -> goodix_cfg_group.bin.9916P
+ *   'test_limits_name' -> goodix_test_limits_255.csv.9916P
+ */
+	bdata = &core_data->board_data;
+	ret = goodix_read_pid_from_flash(core_data);
+	if (ret == 0 && core_data->bus && core_data->bus->dev) {
+		ret = of_property_match_string(core_data->bus->dev->of_node,
+			"goodix,pid-suffix-fw-map", core_data->flash_pid);
+		if (ret >= 0) {
+			u8 suffix[sizeof(core_data->flash_pid) + 1] = {0};
+
+			scnprintf(suffix, sizeof(suffix), ".%s", core_data->flash_pid);
+			strlcat(bdata->fw_name, suffix, sizeof(bdata->fw_name));
+			ts_info("Update fw_name to %s", bdata->fw_name);
+			if (!bdata->use_one_binary) {
+				strlcat(bdata->cfg_bin_name, suffix, sizeof(bdata->cfg_bin_name));
+				ts_info("Update cfg_bin_name to %s", bdata->cfg_bin_name);
+			}
+			strlcat(bdata->test_limits_name, suffix, sizeof(bdata->test_limits_name));
+			ts_info("Update test_limits_name to %s", bdata->test_limits_name);
+		}
+	}
+/*~[GOOG] */
+
 	strlcpy(core_data->update_ctrl.fw_name, core_data->board_data.fw_name,
 		sizeof(core_data->update_ctrl.fw_name));
 
diff --git a/goodix_brl_hw.c b/goodix_brl_hw.c
index 7fc0d20..3564412 100644
--- a/goodix_brl_hw.c
+++ b/goodix_brl_hw.c
@@ -1684,14 +1684,16 @@ int brl_get_mutual_data(struct goodix_ts_core *cd, enum frame_data_type type)
 	int retry = 20;
 	struct goodix_ts_cmd cmd = { 0 };
 
-	mutual_addr = cd->ic_info.misc.frame_data_addr +
-		      cd->ic_info.misc.frame_data_head_len +
-		      cd->ic_info.misc.fw_attr_len +
-		      cd->ic_info.misc.fw_log_len + 8;
-
-	cmd.cmd = GOODIX_CMD_SET_FRAMEDATA_ENABLED;
-	cmd.len = 5;
-	cmd.data[0] = type;
+	mutual_addr = cd->hw_ops->get_ms_data_addr(cd, type);
+	if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
+		flag_addr = cd->ic_info.misc.touch_data_addr;
+		cmd.cmd = 0x01;
+		cmd.len = 4;
+	} else {
+		cmd.cmd = GOODIX_CMD_SET_FRAMEDATA_ENABLED;
+		cmd.len = 5;
+		cmd.data[0] = type;
+	}
 	ret = cd->hw_ops->send_cmd(cd, &cmd);
 	if (ret < 0) {
 		ts_err("report rawdata failed, exit!");
@@ -1750,14 +1752,16 @@ int brl_get_self_sensing_data(struct goodix_ts_core *cd, enum frame_data_type ty
 	int retry = 20;
 	struct goodix_ts_cmd cmd = { 0 };
 
-	self_addr = cd->ic_info.misc.frame_data_addr +
-		    cd->ic_info.misc.frame_data_head_len +
-		    cd->ic_info.misc.fw_attr_len + cd->ic_info.misc.fw_log_len +
-		    cd->ic_info.misc.mutual_struct_len + 10;
-
-	cmd.cmd = GOODIX_CMD_SET_FRAMEDATA_ENABLED;
-	cmd.len = 5;
-	cmd.data[0] = type;
+	self_addr = cd->hw_ops->get_ss_data_addr(cd, type);
+	if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
+		flag_addr = cd->ic_info.misc.touch_data_addr;
+		cmd.cmd = 0x01;
+		cmd.len = 4;
+	} else {
+		cmd.cmd = GOODIX_CMD_SET_FRAMEDATA_ENABLED;
+		cmd.len = 5;
+		cmd.data[0] = type;
+	}
 	ret = cd->hw_ops->send_cmd(cd, &cmd);
 	if (ret < 0) {
 		ts_err("report rawdata failed, exit!");
@@ -1864,6 +1868,165 @@ static int brl_set_report_rate(
 	return ret;
 }
 
+typedef struct __attribute__((packed)) {
+	uint32_t checksum;
+	uint32_t address;
+	uint32_t length;
+} flash_head_info_t;
+
+#define FLASH_CMD_R_START 0x09
+#define FLASH_CMD_W_START 0x0A
+#define FLASH_CMD_RW_FINISH 0x0B
+#define FLASH_CMD_STATE_READY 0x04
+#define FLASH_CMD_STATE_CHECKERR 0x05
+#define FLASH_CMD_STATE_DENY 0x06
+#define FLASH_CMD_STATE_OKAY 0x07
+static int goodix_flash_cmd(
+	struct goodix_ts_core *cd, uint8_t cmd, uint8_t status, int retry_count)
+{
+	u8 cmd_buf[] = { 0x00, 0x00, 0x04, 0x00, 0x00, 0x00 };
+	int ret;
+	int i;
+	u8 r_sta;
+
+	cmd_buf[3] = cmd;
+	goodix_append_checksum(&cmd_buf[2], 2, CHECKSUM_MODE_U8_LE);
+	ret = cd->hw_ops->write(
+		cd, cd->ic_info.misc.cmd_addr, cmd_buf, sizeof(cmd_buf));
+	if (ret < 0)
+		return ret;
+
+	if (retry_count == 0)
+		return 0;
+
+	for (i = 0; i < retry_count; i++) {
+		mdelay(2);
+		ret = cd->hw_ops->read(
+			cd, cd->ic_info.misc.cmd_addr, &r_sta, 1);
+		if (ret == 0 && r_sta == status)
+			return 0;
+	}
+
+	ts_err("r_sta[0x%x] != status[0x%x]", r_sta, status);
+	return -EINVAL;
+}
+
+static int brl_flash_read(struct goodix_ts_core *cd, u32 addr, u8 *buf, int len)
+{
+	int i;
+	int ret;
+	u8 *tmp_buf;
+	u32 buffer_addr = cd->ic_info.misc.fw_buffer_addr;
+	uint32_t checksum = 0;
+	flash_head_info_t head_info;
+	u8 *p = (u8 *)&head_info.address;
+
+	tmp_buf = kzalloc(len + sizeof(flash_head_info_t), GFP_KERNEL);
+	if (!tmp_buf)
+		return -ENOMEM;
+
+	head_info.address = cpu_to_le32(addr);
+	head_info.length = cpu_to_le32(len);
+	for (i = 0; i < 8; i += 2)
+		checksum += p[i] | (p[i + 1] << 8);
+	head_info.checksum = checksum;
+
+	ret = goodix_flash_cmd(
+		cd, FLASH_CMD_R_START, FLASH_CMD_STATE_READY, 15);
+	if (ret < 0) {
+		ts_err("failed enter flash read state");
+		goto read_end;
+	}
+
+	ret = cd->hw_ops->write(
+		cd, buffer_addr, (u8 *)&head_info, sizeof(head_info));
+	if (ret < 0) {
+		ts_err("failed write flash head info");
+		goto read_end;
+	}
+
+	ret = goodix_flash_cmd(
+		cd, FLASH_CMD_RW_FINISH, FLASH_CMD_STATE_OKAY, 50);
+	if (ret) {
+		ts_err("failed read flash ready state");
+		goto read_end;
+	}
+
+	ret = cd->hw_ops->read(
+		cd, buffer_addr, tmp_buf, len + sizeof(flash_head_info_t));
+	if (ret < 0) {
+		ts_err("failed read data len %lu",
+			len + sizeof(flash_head_info_t));
+		goto read_end;
+	}
+
+	checksum = 0;
+	for (i = 0; i < len + sizeof(flash_head_info_t) - 4; i += 2)
+		checksum += tmp_buf[4 + i] | (tmp_buf[5 + i] << 8);
+
+	if (checksum != le32_to_cpup((__le32 *)tmp_buf)) {
+		ts_err("read back data checksum error");
+		ret = -EINVAL;
+		goto read_end;
+	}
+
+	memcpy(buf, tmp_buf + sizeof(flash_head_info_t), len);
+	ret = 0;
+read_end:
+	goodix_flash_cmd(cd, 0x0C, 0, 0);
+	return ret;
+}
+
+static u32 brl_get_ms_data_addr(struct goodix_ts_core *cd, enum frame_data_type type)
+{
+	u32 addr = cd->ic_info.misc.frame_data_addr +
+			cd->ic_info.misc.frame_data_head_len +
+			cd->ic_info.misc.fw_attr_len +
+			cd->ic_info.misc.fw_log_len + 8;
+
+	if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
+		switch (type) {
+		case FRAME_DATA_TYPE_RAW:
+			addr = cd->ic_info.misc.mutual_rawdata_addr;
+			break;
+		case FRAME_DATA_TYPE_BASE:
+			addr = cd->ic_info.misc.mutual_refdata_addr;
+			break;
+		case FRAME_DATA_TYPE_DIFF:
+		default:
+			addr = cd->ic_info.misc.mutual_diffdata_addr;
+			break;
+		}
+	}
+
+	return addr;
+}
+
+static u32 brl_get_ss_data_addr(struct goodix_ts_core *cd, enum frame_data_type type)
+{
+	u32 addr = cd->ic_info.misc.frame_data_addr +
+			cd->ic_info.misc.frame_data_head_len +
+			cd->ic_info.misc.fw_attr_len + cd->ic_info.misc.fw_log_len +
+			cd->ic_info.misc.mutual_struct_len + 10;
+
+	if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
+		switch (type) {
+		case FRAME_DATA_TYPE_RAW:
+			addr = cd->ic_info.misc.self_rawdata_addr;
+			break;
+		case FRAME_DATA_TYPE_BASE:
+			addr = cd->ic_info.misc.self_refdata_addr;
+			break;
+		case FRAME_DATA_TYPE_DIFF:
+		default:
+			addr = cd->ic_info.misc.self_diffdata_addr;
+			break;
+		}
+	}
+
+	return addr;
+}
+
 static struct goodix_ts_hw_ops brl_hw_ops = {
 	.power_on = brl_power_on,
 	.resume = brl_resume,
@@ -1884,6 +2047,8 @@ static struct goodix_ts_hw_ops brl_hw_ops = {
 	.event_handler = brl_event_handler,
 	.after_event_handler = brl_after_event_handler,
 	.get_capacitance_data = brl_get_capacitance_data,
+	.read_flash = brl_flash_read,
+/* [GOOG] */
 	.ping = brl_dev_confirm,
 	.get_scan_mode = brl_get_scan_mode,
 	.set_scan_mode = brl_set_scan_mode,
@@ -1902,6 +2067,9 @@ static struct goodix_ts_hw_ops brl_hw_ops = {
 	.set_coord_filter_enabled = brl_set_coord_filter_enabled,
 	.get_coord_filter_enabled = brl_get_coord_filter_enabled,
 	.set_report_rate = brl_set_report_rate,
+	.get_ms_data_addr = brl_get_ms_data_addr,
+	.get_ss_data_addr = brl_get_ss_data_addr,
+/*~[GOOG] */
 };
 
 struct goodix_ts_hw_ops *goodix_get_hw_ops(void)
diff --git a/goodix_ts_core.h b/goodix_ts_core.h
index 4caa88d..e171287 100644
--- a/goodix_ts_core.h
+++ b/goodix_ts_core.h
@@ -57,14 +57,14 @@
 
 #define GOODIX_CORE_DRIVER_NAME "goodix_ts"
 #define GOODIX_PEN_DRIVER_NAME "goodix_ts,pen"
-#define GOODIX_DRIVER_VERSION "v1.2.6"
+#define GOODIX_DRIVER_VERSION "v1.2.8"
 #define GOODIX_MAX_TOUCH 10
 #define GOODIX_PEN_MAX_PRESSURE 4096
 #define GOODIX_MAX_PEN_KEY 2
 #define GOODIX_PEN_MAX_TILT 90
 #define GOODIX_CFG_MAX_SIZE 4096
 #define GOODIX_FW_MAX_SIEZE (300 * 1024)
-#define GOODIX_MAX_STR_LABEL_LEN 32
+#define GOODIX_MAX_STR_LABEL_LEN 36
 #define GOODIX_MAX_FRAMEDATA_LEN (3 * 1024)
 #define GOODIX_GESTURE_DATA_LEN 16
 #define GOODIX_REQUEST_DATA_LEN 16
@@ -761,6 +761,9 @@ struct goodix_ts_hw_ops {
 	int (*after_event_handler)(struct goodix_ts_core *cd);
 	int (*get_capacitance_data)(
 		struct goodix_ts_core *cd, struct ts_rawdata_info *info);
+	int (*read_flash)(
+		struct goodix_ts_core *cd, u32 addr, u8 *buf, int len);
+/* [GOOG] */
 	int (*ping)(struct goodix_ts_core *cd);
 	int (*get_scan_mode)(struct goodix_ts_core *cd, enum raw_scan_mode* mode);
 	int (*set_scan_mode)(struct goodix_ts_core *cd, enum raw_scan_mode mode);
@@ -784,6 +787,9 @@ struct goodix_ts_hw_ops {
 	int (*get_coord_filter_enabled)(
 		struct goodix_ts_core *cd, bool* enabled);
 	int (*set_report_rate)(struct goodix_ts_core *cd, u32 rate);
+	u32 (*get_ms_data_addr)(struct goodix_ts_core *cd, enum frame_data_type type);
+	u32 (*get_ss_data_addr)(struct goodix_ts_core *cd, enum frame_data_type type);
+/*~[GOOG] */
 };
 
 /*
@@ -883,6 +889,7 @@ struct goodix_ts_core {
 	uint16_t *self_sensing_data;
 	uint16_t *mutual_data_manual;
 	uint16_t *self_sensing_data_manual;
+	u8 flash_pid[8]; /* optional: only available for IC_TYPE_BERLIN_D */
 	/*~[GOOG] */
 
 	int power_on;
diff --git a/goodix_ts_proc.c b/goodix_ts_proc.c
index f300280..354702b 100644
--- a/goodix_ts_proc.c
+++ b/goodix_ts_proc.c
@@ -94,7 +94,7 @@ const static char *cmd_list[] = { CMD_FW_UPDATE, CMD_AUTO_TEST, CMD_OPEN_TEST,
 #define GRIP_FUNC 3
 
 #define SHORT_SIZE 150
-#define LARGE_SIZE 5 * 1024
+#define LARGE_SIZE (10 * 1024)
 #define MAX_FRAME_CNT 50
 #define HUGE_SIZE MAX_FRAME_CNT * 20 * 1024
 static char wbuf[SHORT_SIZE];
@@ -1098,113 +1098,6 @@ static int goodix_shortcircut_test(struct goodix_ts_core *cd)
 	return ret;
 }
 
-typedef struct __attribute__((packed)) {
-	uint32_t checksum;
-	uint32_t address;
-	uint32_t length;
-} flash_head_info_t;
-
-#define FLASH_CMD_R_START 0x09
-#define FLASH_CMD_W_START 0x0A
-#define FLASH_CMD_RW_FINISH 0x0B
-#define FLASH_CMD_STATE_READY 0x04
-#define FLASH_CMD_STATE_CHECKERR 0x05
-#define FLASH_CMD_STATE_DENY 0x06
-#define FLASH_CMD_STATE_OKAY 0x07
-static int goodix_flash_cmd(struct goodix_ts_core *cd,
-		uint8_t cmd, uint8_t status, int retry_count)
-{
-	u8 cmd_buf[] = { 0x00, 0x00, 0x04, 0x00, 0x00, 0x00 };
-	int ret;
-	int i;
-	u8 r_sta;
-
-	cmd_buf[3] = cmd;
-	goodix_append_checksum(&cmd_buf[2], 2, CHECKSUM_MODE_U8_LE);
-	ret = cd->hw_ops->write(
-		cd, cd->ic_info.misc.cmd_addr, cmd_buf, sizeof(cmd_buf));
-	if (ret < 0)
-		return ret;
-
-	if (retry_count == 0)
-		return 0;
-
-	for (i = 0; i < retry_count; i++) {
-		usleep_range(2000, 2100);
-		ret = cd->hw_ops->read(
-			cd, cd->ic_info.misc.cmd_addr, &r_sta, 1);
-		if (ret == 0 && r_sta == status)
-			return 0;
-	}
-
-	ts_err("r_sta[0x%x] != status[0x%x]", r_sta, status);
-	return -EINVAL;
-}
-
-static int goodix_flash_read(struct goodix_ts_core *cd, u32 addr, u8 *buf, int len)
-{
-	int i;
-	int ret;
-	u8 *tmp_buf;
-	u32 buffer_addr = cd->ic_info.misc.fw_buffer_addr;
-	uint32_t checksum = 0;
-	flash_head_info_t head_info;
-	u8 *p = (u8 *)&head_info.address;
-
-	tmp_buf = kzalloc(len + sizeof(flash_head_info_t), GFP_KERNEL);
-	if (!tmp_buf)
-		return -ENOMEM;
-
-	head_info.address = cpu_to_le32(addr);
-	head_info.length = cpu_to_le32(len);
-	for (i = 0; i < 8; i += 2)
-		checksum += p[i] | (p[i + 1] << 8);
-	head_info.checksum = checksum;
-
-	ret = goodix_flash_cmd(cd, FLASH_CMD_R_START, FLASH_CMD_STATE_READY, 15);
-	if (ret < 0) {
-		ts_err("failed enter flash read state");
-		goto read_end;
-	}
-
-	ret = cd->hw_ops->write(
-		cd, buffer_addr, (u8 *)&head_info, sizeof(head_info));
-	if (ret < 0) {
-		ts_err("failed write flash head info");
-		goto read_end;
-	}
-
-	ret = goodix_flash_cmd(cd, FLASH_CMD_RW_FINISH, FLASH_CMD_STATE_OKAY, 50);
-	if (ret) {
-		ts_err("faild read flash ready state");
-		goto read_end;
-	}
-
-	ret = cd->hw_ops->read(
-		cd, buffer_addr, tmp_buf, len + sizeof(flash_head_info_t));
-	if (ret < 0) {
-		ts_err("failed read data len %lu",
-			len + sizeof(flash_head_info_t));
-		goto read_end;
-	}
-
-	checksum = len % 2 ? tmp_buf[len + sizeof(flash_head_info_t) - 1] : 0;
-	for (i = 0; i < len + sizeof(flash_head_info_t) - 6; i += 2)
-		checksum += tmp_buf[4 + i] | (tmp_buf[5 + i] << 8);
-
-	if (checksum != le32_to_cpup((__le32 *)tmp_buf)) {
-		ts_err("read back data checksum error");
-		ret = -EINVAL;
-		goto read_end;
-	}
-
-	memcpy(buf, tmp_buf + sizeof(flash_head_info_t), len);
-	ret = 0;
-read_end:
-	goodix_flash_cmd(cd, 0x0C, 0, 0);
-	return ret;
-}
-
 static void *seq_start(struct seq_file *s, loff_t *pos)
 {
 	if (*pos >= index)
@@ -2013,6 +1906,12 @@ static int goodix_open_test(struct goodix_ts_core *cd)
 	temp_cmd.cmd = 0x90;
 	temp_cmd.data[0] = 0x84;
 	temp_cmd.len = 5;
+	if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
+		sync_addr = cd->ic_info.misc.touch_data_addr;
+		raw_addr = cd->ic_info.misc.mutual_rawdata_addr;
+		temp_cmd.cmd = 0x1;
+		temp_cmd.len = 4;
+	}
 	ret = cd->hw_ops->send_cmd(cd, &temp_cmd);
 	if (ret < 0) {
 		ts_err("send rawdata cmd failed");
@@ -2119,6 +2018,12 @@ static int goodix_self_open_test(struct goodix_ts_core *cd)
 	temp_cmd.cmd = 0x90;
 	temp_cmd.data[0] = 0x84;
 	temp_cmd.len = 5;
+	if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
+		sync_addr = cd->ic_info.misc.touch_data_addr;
+		raw_addr = cd->ic_info.misc.self_rawdata_addr;
+		temp_cmd.cmd = 0x1;
+		temp_cmd.len = 4;
+	}
 	ret = cd->hw_ops->send_cmd(cd, &temp_cmd);
 	if (ret < 0) {
 		ts_err("send rawdata cmd failed");
@@ -2197,6 +2102,12 @@ static int goodix_noise_test(struct goodix_ts_core *cd)
 	temp_cmd.cmd = 0x90;
 	temp_cmd.data[0] = 0x82;
 	temp_cmd.len = 5;
+	if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
+		sync_addr = cd->ic_info.misc.touch_data_addr;
+		raw_addr = cd->ic_info.misc.mutual_diffdata_addr;
+		temp_cmd.cmd = 0x1;
+		temp_cmd.len = 4;
+	}
 	ret = cd->hw_ops->send_cmd(cd, &temp_cmd);
 	if (ret < 0) {
 		ts_err("send rawdata cmd failed");
@@ -2519,7 +2430,6 @@ static int goodix_auto_test(struct goodix_ts_core *cd, bool is_brief)
 static void goodix_auto_noise_test(struct goodix_ts_core *cd, u16 cnt, int threshold)
 {
 	struct goodix_ts_cmd temp_cmd;
-	struct goodix_ts_cmd rb_cmd;
 	u32 sync_addr = cd->ic_info.misc.frame_data_addr;
 	u32 raw_addr;
 	int tx = cd->ic_info.parm.drv_num;
@@ -2529,7 +2439,7 @@ static void goodix_auto_noise_test(struct goodix_ts_core *cd, u16 cnt, int thres
 	u8 status;
 	int test_try = 2;
 	int ret = 0;
-	int retry = 10;
+	int retry = 20;
 	int err_cnt = 0;
 	int i;
 
@@ -2551,12 +2461,14 @@ restart:
 	temp_cmd.data[0] = 0x86;
 	temp_cmd.data[1] = cnt & 0xFF;
 	temp_cmd.data[2] = (cnt >> 8) & 0xFF;
+	if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
+		temp_cmd.data[0] = 0x87;
+		sync_addr = cd->ic_info.misc.touch_data_addr;
+		raw_addr = cd->ic_info.misc.mutual_diffdata_addr;
+	}
 	cd->hw_ops->send_cmd(cd, &temp_cmd);
-	cd->hw_ops->read(
-		cd, cd->ic_info.misc.cmd_addr, rb_cmd.buf, sizeof(rb_cmd));
-	ts_info("rb_cmd:%*ph", (int)sizeof(rb_cmd), rb_cmd.buf);
 
-	msleep(cnt * 20);
+	msleep(cnt * 8);
 
 	while (retry--) {
 		cd->hw_ops->read(cd, sync_addr, &status, 1);
@@ -2675,6 +2587,25 @@ static int get_cap_data(struct goodix_ts_core *cd, uint8_t *type)
 
 	temp_cmd.cmd = 0x90;
 	temp_cmd.len = 5;
+
+	if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
+		flag_addr = cd->ic_info.misc.touch_data_addr;
+		if (strstr(type, CMD_GET_BASEDATA))
+			mutual_addr = cd->ic_info.misc.mutual_refdata_addr;
+		else if (strstr(type, CMD_GET_RAWDATA))
+			mutual_addr = cd->ic_info.misc.mutual_rawdata_addr;
+		else if (strstr(type, CMD_GET_DIFFDATA))
+			mutual_addr = cd->ic_info.misc.mutual_diffdata_addr;
+		else if (strstr(type, CMD_GET_SELF_BASEDATA))
+			self_addr = cd->ic_info.misc.self_refdata_addr;
+		else if (strstr(type, CMD_GET_SELF_RAWDATA))
+			self_addr = cd->ic_info.misc.self_rawdata_addr;
+		else if (strstr(type, CMD_GET_SELF_DIFFDATA))
+			self_addr = cd->ic_info.misc.self_diffdata_addr;
+		temp_cmd.cmd = 0x01;
+		temp_cmd.len = 4;
+	}
+
 	ret = cd->hw_ops->send_cmd(cd, &temp_cmd);
 	if (ret < 0) {
 		ts_err("report rawdata failed, exit!");
@@ -2748,7 +2679,14 @@ exit:
 	temp_cmd.cmd = 0x90;
 	temp_cmd.data[0] = 0;
 	temp_cmd.len = 5;
+	if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
+		temp_cmd.cmd = 0x00;
+		temp_cmd.len = 4;
+	}
 	cd->hw_ops->send_cmd(cd, &temp_cmd);
+	/* clean touch event flag */
+	val = 0;
+	cd->hw_ops->write(cd, flag_addr, &val, 1);
 	/* enable irq & esd */
 	cd->hw_ops->irq_enable(cd, true);
 	goodix_ts_esd_on(cd);
@@ -2927,19 +2865,13 @@ static void goodix_get_fw_status(struct goodix_ts_core *cd)
 static void goodix_set_highsense_mode(struct goodix_ts_core *cd, u8 val)
 {
 	struct goodix_ts_cmd temp_cmd;
-	static bool flag = false;
 
-	if (val == 0 && flag) {
-		flag = false;
+	if (val == 0) {
 		ts_info("exit highsense mode");
 		index = sprintf(rbuf, "exit highsense mode\n");
-	} else if (val == 1 && !flag) {
-		flag = true;
+	} else {
 		ts_info("enter highsense mode");
 		index = sprintf(rbuf, "enter highsense mode\n");
-	} else {
-		ts_info("have already %s", val ? "ON" : "OFF");
-		return;
 	}
 
 	temp_cmd.len = 5;
@@ -3201,6 +3133,10 @@ static void goodix_set_heatmap(struct goodix_ts_core *cd, int val)
 		temp_cmd.len = 5;
 		temp_cmd.cmd = 0xC9;
 		temp_cmd.data[0] = 0;
+		if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
+			temp_cmd.len = 4;
+			temp_cmd.cmd = 0x0;
+		}
 	} else {
 		index = sprintf(rbuf, "enable heatmap\n");
 /*
@@ -3211,6 +3147,10 @@ static void goodix_set_heatmap(struct goodix_ts_core *cd, int val)
 		temp_cmd.len = 5;
 		temp_cmd.cmd = 0xC9;
 		temp_cmd.data[0] = 1;
+		if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
+			temp_cmd.len = 4;
+			temp_cmd.cmd = 0x1;
+		}
 	}
 	cd->hw_ops->send_cmd(cd, &temp_cmd);
 	cd->hw_ops->irq_enable(cd, true);
@@ -3888,7 +3828,7 @@ static ssize_t driver_test_write(struct file *file, const char __user *buf,
 			goto exit;
 		}
 		noise_data_cnt = cmd_val;
-		rbuf = vzalloc(noise_data_cnt * 2000 + 5000);
+		rbuf = vzalloc(noise_data_cnt * 13000);
 		if (!rbuf) {
 			ts_err("failed to alloc rbuf");
 			goto exit;
@@ -3939,7 +3879,7 @@ static ssize_t driver_test_write(struct file *file, const char __user *buf,
 		}
 		mutex_lock(&cd->cmd_lock);
 		usleep_range(6000, 6100);
-		ret = goodix_flash_read(cd, 0x1F301, &id, 1);
+		ret = cd->hw_ops->read_flash(cd, 0x1F301, &id, 1);
 		mutex_unlock(&cd->cmd_lock);
 		if (ret < 0)
 			index = sprintf(rbuf, "%s: NG\n", CMD_GET_PACKAGE_ID);
@@ -3957,7 +3897,7 @@ static ssize_t driver_test_write(struct file *file, const char __user *buf,
 		}
 		mutex_lock(&cd->cmd_lock);
 		usleep_range(6000, 6100);
-		ret = goodix_flash_read(cd, 0x1F314, &id, 1);
+		ret = cd->hw_ops->read_flash(cd, 0x1F314, &id, 1);
 		mutex_unlock(&cd->cmd_lock);
 		if (ret < 0)
 			index = sprintf(rbuf, "%s: NG\n", CMD_GET_MCU_ID);
@@ -4049,7 +3989,7 @@ static ssize_t driver_test_write(struct file *file, const char __user *buf,
 			goto exit;
 		}
 		raw_data_cnt = cmd_val;
-		rbuf = vzalloc(raw_data_cnt * 5000 + 10000);
+		rbuf = vzalloc(raw_data_cnt * 13000);
 		if (!rbuf) {
 			ts_err("failed to alloc rbuf");
 			goto exit;