Merge branch android-msm-pixel-4.19 into android-msm-barbet-4.19

Bug: 184813985
Change-Id: I36d914a7d645766899f2cbeb3de1ce209d9b51fc

4 files changed, 138 insertions, 245 deletions

diff --git a/sec_ts.c b/sec_ts.c
index 3d0b884..b652480 100644
--- a/sec_ts.c
+++ b/sec_ts.c
@@ -1836,6 +1836,37 @@ static void sec_ts_handle_coord_event(struct sec_ts_data *ts,
 		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
@@ -2205,7 +2236,6 @@ static void sec_ts_offload_set_running(struct sec_ts_data *ts, bool running)
 static void sec_ts_read_event(struct sec_ts_data *ts)
 {
 	int ret;
-	u8 t_id;
 	u8 event_id;
 	u8 left_event_count;
 	u8 read_event_buff[MAX_EVENT_COUNT][SEC_TS_EVENT_BUFF_SIZE] = { { 0 } };
@@ -2247,7 +2277,7 @@ static void sec_ts_read_event(struct sec_ts_data *ts)
 		/* run lpm interrupt handler */
 	}
 
-	ret = t_id = event_id = curr_pos = remain_event_count = 0;
+	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);
@@ -2303,8 +2333,6 @@ static void sec_ts_read_event(struct sec_ts_data *ts)
 	}
 
 	do {
-		s16 max_force_p = 0;
-
 		event_buff = read_event_buff[curr_pos];
 		event_id = event_buff[0] & 0x3;
 
@@ -2483,44 +2511,6 @@ static void sec_ts_read_event(struct sec_ts_data *ts)
 				event_buff[3], event_buff[4], event_buff[5]);
 			break;
 		}
-
-		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 f:%d v:%02X%02X cal:%02X(%02X) id(%d,%d) p:%d P%02XT%04X\n",
-					ts->dex_name,
-					t_id, ts->coord[t_id].mcount,
-					ts->touch_count,
-					ts->coord[t_id].x, ts->coord[t_id].y,
-					max_force_p,
-					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->cal_count, ts->tune_fix_ver);
-
-				ts->coord[t_id].action =
-						SEC_TS_COORDINATE_ACTION_NONE;
-				ts->coord[t_id].mcount = 0;
-				ts->coord[t_id].palm_count = 0;
-				max_force_p = 0;
-			}
-		}
-
 		curr_pos++;
 		remain_event_count--;
 	} while (remain_event_count >= 0);
@@ -3014,7 +3004,7 @@ static int sec_ts_parse_dt(struct spi_device *client)
 			return -EINVAL;
 		}
 	} else {
-		input_err(true, dev,
+		input_dbg(true, dev,
 			  "%s: Failed to get tsp-icid gpio\n", __func__);
 	}
 
@@ -3043,8 +3033,9 @@ static int sec_ts_parse_dt(struct spi_device *client)
 	client->irq = gpio_to_irq(pdata->irq_gpio);
 
 	if (of_property_read_u32(np, "sec,irq_type", &pdata->irq_type)) {
-		input_err(true, dev,
-			  "%s: Failed to get irq_type property\n", __func__);
+		input_dbg(true, dev,
+			"%s: no irq_type property, set to default!\n",
+			__func__);
 		pdata->irq_type = IRQF_TRIGGER_LOW | IRQF_ONESHOT;
 	}
 
@@ -3090,7 +3081,7 @@ static int sec_ts_parse_dt(struct spi_device *client)
 		input_info(true, dev, "%s: TSP_ID : %d\n", __func__,
 			   gpio_get_value(pdata->tsp_id));
 	else
-		input_err(true, dev,
+		input_dbg(true, dev,
 			  "%s: Failed to get tsp-id gpio\n", __func__);
 
 	pdata->switch_gpio = of_get_named_gpio(np,
@@ -3156,11 +3147,11 @@ static int sec_ts_parse_dt(struct spi_device *client)
 
 	if (of_property_read_string_index(np, "sec,project_name", 0,
 					  &pdata->project_name))
-		input_err(true, &client->dev,
+		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_err(true, &client->dev,
+		input_dbg(true, &client->dev,
 			  "%s: skipped to get model_name property\n", __func__);
 
 #if defined(CONFIG_FB_MSM_MDSS_SAMSUNG)
@@ -3204,13 +3195,13 @@ static int sec_ts_parse_dt(struct spi_device *client)
 
 	if (of_property_read_string(np,
 		"sec,regulator_dvdd", &pdata->regulator_dvdd))
-		input_err(true, dev,
+		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_err(true, dev,
+		input_dbg(true, dev,
 			"%s: Failed to get regulator_avdd name property\n",
 			__func__);
 
@@ -3240,14 +3231,14 @@ static int sec_ts_parse_dt(struct spi_device *client)
 	pdata->support_mt_pressure = true;
 
 #ifdef PAT_CONTROL
-	input_err(true, &client->dev,
+	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_err(true, &client->dev,
+	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,
@@ -3986,7 +3977,7 @@ static int sec_ts_probe(struct spi_device *client)
 	if (ret < 0)
 		input_err(true, &ts->client->dev, "psy notifier register failed\n");
 
-	input_err(true, &ts->client->dev, "%s: done\n", __func__);
+	input_info(true, &ts->client->dev, "%s: done\n", __func__);
 	input_log_fix();
 
 	return 0;
@@ -4150,81 +4141,9 @@ void sec_ts_unlocked_release_all_finger(struct sec_ts_data *ts)
 
 void sec_ts_locked_release_all_finger(struct sec_ts_data *ts)
 {
-	int i;
-
 	mutex_lock(&ts->eventlock);
-
-	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:%X(%X|%X), 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->cal_count,
-				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);
-
+	sec_ts_unlocked_release_all_finger(ts);
 	mutex_unlock(&ts->eventlock);
-
 }
 
 #ifdef USE_POWER_RESET_WORK
@@ -4698,7 +4617,7 @@ int sec_ts_start_device(struct sec_ts_data *ts)
 	mutex_lock(&ts->device_mutex);
 
 	if (ts->power_status == SEC_TS_STATE_POWER_ON) {
-		input_err(true, &ts->client->dev,
+		input_info(true, &ts->client->dev,
 			  "%s: already power on\n", __func__);
 		goto out;
 	}
@@ -5329,7 +5248,6 @@ static int __init sec_ts_init(void)
 		return -ENODEV;
 	}
 #endif
-	pr_err("%s %s\n", SECLOG, __func__);
 
 #ifdef I2C_INTERFACE
 	return i2c_add_driver(&sec_ts_driver);
diff --git a/sec_ts.h b/sec_ts.h
index da8b820..9901d63 100644
--- a/sec_ts.h
+++ b/sec_ts.h
@@ -1129,6 +1129,7 @@ int execute_selftest(struct sec_ts_data *ts, u32 option);
 int execute_p2ptest(struct sec_ts_data *ts);
 int sec_ts_read_raw_data(struct sec_ts_data *ts,
 		struct sec_cmd_data *sec, struct sec_ts_test_mode *mode);
+u8 sec_ts_run_cal_check(struct sec_ts_data *ts);
 
 #if (1)//!defined(CONFIG_SAMSUNG_PRODUCT_SHIP)
 int sec_ts_raw_device_init(struct sec_ts_data *ts);
diff --git a/sec_ts_fn.c b/sec_ts_fn.c
index bc5f2d2..ad9ba71 100644
--- a/sec_ts_fn.c
+++ b/sec_ts_fn.c
@@ -113,6 +113,7 @@ static void set_noise_mode_enable(void *device_data);
 static void set_continuous_report_enable(void *device_data);
 static void set_charger_nb_enable(void *device_data);
 static void set_print_format(void *device_data);
+static void run_cal_check(void *device_data);
 
 static struct sec_cmd sec_cmds[] = {
 	{SEC_CMD("fw_update", fw_update),},
@@ -222,6 +223,7 @@ static struct sec_cmd sec_cmds[] = {
 		set_continuous_report_enable),},
 	{SEC_CMD("set_charger_nb_enable", set_charger_nb_enable),},
 	{SEC_CMD("set_print_format", set_print_format),},
+	{SEC_CMD("run_cal_check", run_cal_check),},
 	{SEC_CMD("not_support_cmd", not_support_cmd),},
 };
 
@@ -1269,10 +1271,18 @@ int sec_ts_fix_tmode(struct sec_ts_data *ts, u8 mode, u8 state)
 		__func__, mode, state);
 
 	ret = ts->sec_ts_write(ts, SEC_TS_CMD_STATEMANAGE_ON, onoff, 1);
+	if (ret < 0)
+		input_err(true, &ts->client->dev,
+			  "%s: write reg %#x failed, return %i\n",
+			  __func__, SEC_TS_CMD_STATEMANAGE_ON, ret);
 	sec_ts_delay(20);
 
 	ret = ts->sec_ts_write(ts, SEC_TS_CMD_CHG_SYSMODE, tBuff,
 			       sizeof(tBuff));
+	if (ret < 0)
+		input_err(true, &ts->client->dev,
+			  "%s: write reg %#x failed, return %i\n",
+			  __func__, SEC_TS_CMD_CHG_SYSMODE, ret);
 	sec_ts_delay(20);
 
 	return ret;
@@ -1286,6 +1296,10 @@ int sec_ts_release_tmode(struct sec_ts_data *ts)
 	input_info(true, &ts->client->dev, "%s\n", __func__);
 
 	ret = ts->sec_ts_write(ts, SEC_TS_CMD_STATEMANAGE_ON, onoff, 1);
+	if (ret < 0)
+		input_err(true, &ts->client->dev,
+			  "%s: write reg %#x failed, return %i\n",
+			  __func__, SEC_TS_CMD_STATEMANAGE_ON, ret);
 	sec_ts_delay(20);
 
 	return ret;
@@ -5229,7 +5243,6 @@ static void run_force_calibration(void *device_data)
 	u8 img_ver[4];
 #endif
 	struct sec_ts_test_mode mode;
-	char mis_cal_data = 0xF0;
 
 	sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_SYSFS, true);
 
@@ -5268,72 +5281,19 @@ static void run_force_calibration(void *device_data)
 				"%s: fail to write PRESSURE CAL!\n", __func__);
 #endif
 
-		if (ts->plat_data->mis_cal_check) {
-			buff[0] = 0;
-			rc = ts->sec_ts_write(ts, SEC_TS_CMD_STATEMANAGE_ON,
-					      buff, 1);
-			if (rc < 0) {
-				input_err(true, &ts->client->dev,
-					"%s: mis_cal_check error[1] ret: %d\n",
-					__func__, rc);
-			}
-
-			buff[0] = 0x2;
-			buff[1] = 0x2;
-			rc = ts->sec_ts_write(ts, SEC_TS_CMD_CHG_SYSMODE,
-					      buff, 2);
-			if (rc < 0) {
-				input_err(true, &ts->client->dev,
-					"%s: mis_cal_check error[2] ret: %d\n",
-					__func__, rc);
-			}
-
-			input_err(true, &ts->client->dev,
-				  "%s: try mis Cal. check\n", __func__);
-			rc = ts->sec_ts_write(ts, SEC_TS_CMD_MIS_CAL_CHECK,
-					      NULL, 0);
-			if (rc < 0) {
-				input_err(true, &ts->client->dev,
-					"%s: mis_cal_check error[3] ret: %d\n",
-					__func__, rc);
-			}
-			sec_ts_delay(200);
-
-			rc = ts->sec_ts_read(ts, SEC_TS_CMD_MIS_CAL_READ,
-					     &mis_cal_data, 1);
-			if (rc < 0) {
-				input_err(true, &ts->client->dev,
-					  "%s: fail!, %d\n", __func__, rc);
-				mis_cal_data = 0xF3;
-			} else {
-				input_info(true, &ts->client->dev,
-					"%s: miss cal data : %d\n",
-					__func__, mis_cal_data);
-			}
-
-			buff[0] = 1;
-			rc = ts->sec_ts_write(ts, SEC_TS_CMD_STATEMANAGE_ON,
-					      buff, 1);
-			if (rc < 0) {
-				input_err(true, &ts->client->dev,
-					"%s: mis_cal_check error[4] ret: %d\n",
-					__func__, rc);
-			}
-
-			if (mis_cal_data) {
-				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);
-				snprintf(buff, sizeof(buff), "%s", "MIS CAL");
-				sec->cmd_state = SEC_CMD_STATUS_FAIL;
+		if (ts->plat_data->mis_cal_check &&
+		    sec_ts_run_cal_check(ts)) {
+			memset(&mode, 0x00,
+			       sizeof(struct sec_ts_test_mode));
+			mode.type = TYPE_AMBIENT_DATA;
+			mode.allnode = TEST_MODE_ALL_NODE;
 
-				enable_irq(ts->client->irq);
+			sec_ts_read_raw_data(ts, NULL, &mode);
+			snprintf(buff, sizeof(buff), "%s", "MIS CAL");
+			sec->cmd_state = SEC_CMD_STATUS_FAIL;
 
-				goto out_force_cal;
-			}
+			enable_irq(ts->client->irq);
+			goto out_force_cal;
 		}
 
 #ifdef PAT_CONTROL
@@ -7431,6 +7391,71 @@ static void set_print_format(void *device_data)
 	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
 }
 
+u8 sec_ts_run_cal_check(struct sec_ts_data *ts)
+{
+	int rc = 0;
+	u8 mis_cal_data = 0xF0;
+
+	if (ts->plat_data->mis_cal_check) {
+		rc = sec_ts_fix_tmode(ts, TOUCH_SYSTEM_MODE_TOUCH,
+				      TOUCH_MODE_STATE_TOUCH);
+		if (rc < 0)
+			input_err(true, &ts->client->dev,
+				  "%s: failed#1 ret: %d\n", __func__, rc);
+
+		rc = ts->sec_ts_write(ts, SEC_TS_CMD_MIS_CAL_CHECK,
+				      NULL, 0);
+		if (rc < 0)
+			input_err(true, &ts->client->dev,
+				  "%s: failed#2 ret: %d\n", __func__, rc);
+		sec_ts_delay(200);
+
+		rc = ts->sec_ts_read(ts, SEC_TS_CMD_MIS_CAL_READ,
+				     &mis_cal_data, 1);
+		if (rc < 0) {
+			input_err(true, &ts->client->dev,
+				  "%s: failed#3 ret: %d\n", __func__, rc);
+			mis_cal_data = 0xF3;
+		} else {
+			input_info(true, &ts->client->dev,
+				   "%s: mis cal data : %d\n",
+				   __func__, mis_cal_data);
+		}
+
+		rc = sec_ts_release_tmode(ts);
+		if (rc < 0)
+			input_err(true, &ts->client->dev,
+				  "%s: failed#4 ret: %d\n", __func__, rc);
+	} else {
+		input_info(true, &ts->client->dev,
+			  "%s: not support!\n", __func__);
+		mis_cal_data = 0xF1;
+	}
+
+	return mis_cal_data;
+}
+
+static void run_cal_check(void *device_data)
+{
+	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;
+	struct sec_ts_data *ts = container_of(sec, struct sec_ts_data, sec);
+	char buff[SEC_CMD_STR_LEN] = { 0 };
+	u8 ret;
+
+	sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_SYSFS, true);
+	sec_cmd_set_default_result(sec);
+
+	ret = sec_ts_run_cal_check(ts);
+	if (ret)
+		scnprintf(buff, sizeof(buff), "FAIL(%#x)\n", ret);
+	else
+		scnprintf(buff, sizeof(buff), "OK\n");
+
+	sec->cmd_state = SEC_CMD_STATUS_OK;
+	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
+	sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_SYSFS, false);
+}
+
 static void not_support_cmd(void *device_data)
 {
 	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;
diff --git a/sec_ts_fw.c b/sec_ts_fw.c
index 8db5b58..b02ab38 100644
--- a/sec_ts_fw.c
+++ b/sec_ts_fw.c
@@ -1005,58 +1005,7 @@ static int sec_ts_firmware_update(struct sec_ts_data *ts, const u8 *data,
 #endif
 
 			/* check mis-cal */
-			if (ts->plat_data->mis_cal_check) {
-				u8 buff[2];
-				u8 mis_cal_data;
-
-				buff[0] = STATE_MANAGE_OFF;
-				ret = ts->sec_ts_write(ts,
-					SEC_TS_CMD_STATEMANAGE_ON, buff, 1);
-				if (ret < 0)
-					input_err(true, &ts->client->dev,
-						"%s: mis_cal_check error[1] ret: %d\n",
-						__func__, ret);
-
-				buff[0] = TOUCH_SYSTEM_MODE_TOUCH;
-				buff[1] = TOUCH_MODE_STATE_TOUCH;
-				ret = ts->sec_ts_write(ts,
-					SEC_TS_CMD_CHG_SYSMODE, buff, 2);
-				if (ret < 0)
-					input_err(true, &ts->client->dev,
-						"%s: mis_cal_check error[2] ret: %d\n",
-						__func__, ret);
-
-				input_info(true, &ts->client->dev,
-					"%s: mis_cal check\n", __func__);
-				ret = ts->sec_ts_write(ts,
-					SEC_TS_CMD_MIS_CAL_CHECK, NULL, 0);
-				if (ret < 0)
-					input_err(true, &ts->client->dev,
-						"%s: mis_cal_check error[3] ret: %d\n",
-						__func__, ret);
-				sec_ts_delay(200);
-
-				ret = ts->sec_ts_read(ts,
-					SEC_TS_CMD_MIS_CAL_READ,
-					&mis_cal_data, 1);
-				if (ret < 0)
-					input_err(true, &ts->client->dev,
-						"%s: fail!, %d\n",
-						__func__, ret);
-				else
-					input_info(true, &ts->client->dev,
-						"%s: mis_cal data : %d\n",
-						__func__, mis_cal_data);
-
-				buff[0] = STATE_MANAGE_ON;
-				ret = ts->sec_ts_write(ts,
-					SEC_TS_CMD_STATEMANAGE_ON, buff, 1);
-				if (ret < 0)
-					input_err(true, &ts->client->dev,
-						"%s: mis_cal_check error[4] ret: %d\n",
-						__func__, ret);
-			}
-
+			sec_ts_run_cal_check(ts);
 			/* Update calibration report */
 			sec_ts_read_calibration_report(ts);
 		} else