int ist30xx_set_cmcs_cmd(struct i2c_client *client, CMCS_INFO *cmcs)
{
int ret;
u32 val;
val = (u32)(cmcs->cmd.base_screen | (cmcs->cmd.mode << 16));
ret = ist30xx_write_cmd(client, cmcs->addr.base_screen, val);
if (ret) return ret;
tsp_verb("Baseline screen(0x%08x): 0x%08x\n", cmcs->addr.base_screen, val);
val = (u32)cmcs->cmd.base_key;
ret = ist30xx_write_cmd(client, cmcs->addr.base_key, val);
if (ret) return ret;
tsp_verb("Baseline key(0x%08x): 0x%08x\n", cmcs->addr.base_key, val);
val = cmcs->cmd.start_cp_cm | (cmcs->cmd.start_cp_cs << 16);
ret = ist30xx_write_cmd(client, cmcs->addr.start_cp, val);
if (ret) return ret;
tsp_verb("StartCP(0x%08x): 0x%08x\n", cmcs->addr.start_cp, val);
val = cmcs->cmd.vcmp_cm | (cmcs->cmd.vcmp_cs << 16);
ret = ist30xx_write_cmd(client, cmcs->addr.vcmp, val);
if (ret) return ret;
tsp_verb("VCMP(0x%08x): 0x%08x\n", cmcs->addr.vcmp, val);
return 0;
}
int ist30xx_cmd_run_device(struct i2c_client *client)
{
int ret = -EIO;
u32 val = 0x00C80001;
ist30xx_reset();
ret = ist30xx_write_cmd(client, CMD_RUN_DEVICE, 0);
msleep(10);
ret = ist30xx_write_cmd(client, CMD_ZVALUE_MODE, val);
msleep(10);
return ret;
}
int ist30xx_set_cmcs_sensor(struct i2c_client *client, CMCS_INFO *cmcs,
u32 *buf32)
{
int i, ret;
int len;
u32 waddr;
u32 *tmp32;
tsp_verb("%08x %08x %08x %08x\n", buf32[0], buf32[1], buf32[2], buf32[3]);
waddr = cmcs->addr.sensor1;
len = cmcs->sensor1_size / IST30XX_DATA_LEN;
for (i = 0; i < len; i++) {
ret = ist30xx_write_cmd(client, waddr, *buf32++);
if (ret)
return ret;
waddr += IST30XX_DATA_LEN;
}
tmp32 = buf32;
tsp_verb("%08x %08x %08x %08x\n", tmp32[0], tmp32[1], tmp32[2], tmp32[3]);
waddr = cmcs->addr.sensor2;
len = (cmcs->sensor2_size - 0x10) / IST30XX_DATA_LEN;
for (i = 0; i < len; i++) {
ret = ist30xx_write_cmd(client, waddr, *buf32++);
if (ret)
return ret;
waddr += IST30XX_DATA_LEN;
}
buf32 += (0x10 / IST30XX_DATA_LEN);
tmp32 = buf32;
tsp_verb("%08x %08x %08x %08x\n", tmp32[0], tmp32[1], tmp32[2], tmp32[3]);
waddr = cmcs->addr.sensor3;
len = cmcs->sensor3_size / IST30XX_DATA_LEN;
for (i = 0; i < len; i++) {
ret = ist30xx_write_cmd(client, waddr, *buf32++);
if (ret)
return ret;
waddr += IST30XX_DATA_LEN;
}
return 0;
}
int ist30xx_cmd_start_scan(struct i2c_client *client)
{
int ret;
u32 val = 0x00C80001;
ret = ist30xx_write_cmd(client, CMD_ZVALUE_MODE, 0x00C80001);
if (ret)
return ret;
get_zvalue_mode = true;
ret = ist30xx_write_cmd(client, CMD_START_SCAN, 0);
msleep(100);
return ret;
}
ssize_t factory_tkey_zvalue_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int ret;
int cmd = 0;
u32 val = 0;
sscanf(buf, "%d", &cmd);
DMSG("[TSP] tkey zvalue cmd(%d)\n", cmd);
val = (cmd > 0 ? 0x00C80001 : 0);
if (cmd) {
ist30xx_disable_irq(ts_data);
ist30xx_cmd_run_device(ts_data->client);
ist30xx_enable_irq(ts_data);
}
ret = ist30xx_write_cmd(ts_data->client, CMD_ZVALUE_MODE, val);
if (ret) {
pr_err("[ TSP ] fail, zvalue mode enter(%d)\n", ret);
return size;
}
get_zvalue_mode = (cmd > 0 ? true : false);
DMSG("[TSP] tkey zvalue val: %x, cmd: %d\n", val, cmd);
return size;
}
int ist30xx_cmd_update(struct i2c_client *client, int cmd)
{
int ret = ist30xx_write_cmd(client, cmd, 0);
msleep(10);
return ret;
}
int ist30xx_cmd_calibrate(struct i2c_client *client)
{
int ret = ist30xx_write_cmd(client, CMD_CALIBRATE, 0);
msleep(100);
return ret;
}
int ist30xx_cmd_reg(struct i2c_client *client, int cmd)
{
int ret = ist30xx_write_cmd(client, cmd, 0);
if (cmd == CMD_ENTER_REG_ACCESS)
msleep(50);
return ret;
}
int ist30xx_cmd_update(struct i2c_client *client, int cmd)
{
u32 val = (cmd == CMD_ENTER_FW_UPDATE ? CMD_FW_UPDATE_MAGIC : 0);
int ret = ist30xx_write_cmd(client, cmd, val);
msleep(10);
return ret;
}
int ist30xx_cmd_calibrate(struct i2c_client *client)
{
int ret = ist30xx_write_cmd(client, CMD_CALIBRATE, 0);
DMSG("[ TSP ] %s\n", __func__);
msleep(100);
return ret;
}
int ist30xx_cmd_check_calib(struct i2c_client *client)
{
int ret = ist30xx_write_cmd(client, CMD_CHECK_CALIB, 0);
DMSG("[ TSP ] %s\n", __func__);
msleep(20);
return ret;
}
int ist30xx_cmd_run_device(struct i2c_client *client)
{
int ret = -EIO;
ist30xx_reset();
ret = ist30xx_write_cmd(client, CMD_RUN_DEVICE, 0);
if (ret) return ret;
msleep(10);
ret = ist30xx_write_cmd(client, CMD_ZVALUE_MODE, 0x00C80001); // remove after 15mode test
get_zvalue_mode = true;
#if IST30XX_NOISE_MODE
get_event_mode = true;
#endif
msleep(10); // remove after 15mode test
return ret;
}
int ist30xx_cmd_run_device(struct i2c_client *client)
{
int ret = -EIO;
ist30xx_reset();
ret = ist30xx_write_cmd(client, CMD_RUN_DEVICE, 0);
msleep(10);
return ret;
}
int ist30xx_cmd_check_calib(struct i2c_client *client)
{
int ret = ist30xx_write_cmd(client, CMD_CHECK_CALIB, 0);
DMSG("[ TSP ] *** Check Calibration cmd ***\n");
msleep(20);
return ret;
}
int ist30xx_get_info(struct ist30xx_data *data)
{
int ret;
u32 calib_msg;
int retry = 0;
ist30xx_tsp_info.finger_num = IST30XX_MAX_MT_FINGERS;
mutex_lock(&ist30xx_mutex);
ist30xx_disable_irq(data);
RETRY :
ret = ist30xx_write_cmd(data->client, CMD_RUN_DEVICE, 0);
msleep(50);
ret = ist30xx_get_ver_info(data);
if(ret != 0) {
if(retry++ < 10) {
tsp_debug("ist30xx_get_info retry : %d \n", retry);
ist30xx_ts_reset();
goto RETRY;
}
}
ret = ist30xx_tsp_update_info();
ret = ist30xx_tkey_update_info();
ist30xx_print_info();
ret = ist30xx_read_cmd(ts_data->client, CMD_GET_CALIB_RESULT, &calib_msg);
if (ret == 0) {
tsp_info("calib status: 0x%08x\n", calib_msg);
if ((calib_msg & CALIB_MSG_MASK) != CALIB_MSG_VALID ||
CALIB_TO_STATUS(calib_msg) > 0) {
ist30xx_calibrate(IST30XX_FW_UPDATE_RETRY);
ist30xx_cmd_run_device(data->client);
}
}
ist30xx_start(ts_data);
#if IST30XX_EVENT_MODE
ktime_get_ts(&t_event);
#endif
data->status.calib = 0;
ist30xx_enable_irq(data);
mutex_unlock(&ist30xx_mutex);
return ret;
}
int ist30xx_cmd_start_scan(struct i2c_client *client)
{
int ret;
ret = ist30xx_write_cmd(client, CMD_ZVALUE_MODE, 0x00C80001); // remove after 15mode test
if (ret) return ret; // remove after 15mode
msleep(10); // remove after 15mode test
get_zvalue_mode = true;
#if IST30XX_NOISE_MODE
get_event_mode = true;
#endif
ret = ist30xx_write_cmd(client, CMD_START_SCAN, 0);
msleep(200);
return ret;
}
int ist30xx_cmd_check_calib(struct i2c_client *client)
{
int ret = ist30xx_write_cmd(client, CMD_CHECK_CALIB, 0);
ist30xx_tracking(TRACK_CMD_CHECK_CALIB);
tsp_info("*** Check Calibration cmd ***\n");
msleep(20);
return ret;
}
int ist30xx_cmd_start_scan(struct i2c_client *client)
{
int ret;
#if IST30XX_USE_ZVALUE
ret = ist30xx_write_cmd(client, CMD_ZVALUE_MODE, 0x00C80001);
if (ret) return ret;
msleep(10);
get_zvalue_mode = true;
#endif
#if IST30XX_NOISE_MODE
get_event_mode = true;
#endif
ret = ist30xx_write_cmd(client, CMD_START_SCAN, 0);
msleep(100);
return ret;
}
int ist30xx_cmd_calibrate(struct i2c_client *client)
{
int ret = ist30xx_write_cmd(client, CMD_CALIBRATE, 0);
ist30xx_tracking(TRACK_CMD_CALIB);
tsp_info("%s\n", __func__);
msleep(100);
return ret;
}
int ist30xx_cmd_run_device(struct i2c_client *client, bool is_reset)
{
int ret = -EIO;
if (is_reset == true) ist30xx_reset();
ret = ist30xx_write_cmd(client, CMD_RUN_DEVICE, 0);
ist30xx_tracking(TRACK_CMD_RUN_DEVICE);
msleep(10);
return ret;
}
int ist30xx_cmd_gesture(struct i2c_client *client, int gesture)
{
int ret = -EIO;
if (gesture > 3)
return ret;
ret = ist30xx_write_cmd(client, CMD_SET_GESTURE_MODE, gesture);
msleep(10);
return ret;
}
int ist30xx_cmd_start_scan(struct i2c_client *client)
{
int ret;
ret = ist30xx_write_cmd(client, CMD_START_SCAN, 0);
msleep(100);
#if IST30XX_NOISE_MODE
ts_data->status.noise_mode = true;
#endif
return ret;
}
int ist30xx_cmd_start_scan(struct i2c_client *client)
{
int ret;
ret = ist30xx_write_cmd(client, CMD_START_SCAN, 0);
ist30xx_tracking(TRACK_CMD_SCAN);
msleep(100);
ts_data->status.noise_mode = true;
return ret;
}
int ist30xx_cmd_reg(struct i2c_client *client, int cmd)
{
int ret = ist30xx_write_cmd(client, cmd, 0);
if (cmd == CMD_ENTER_REG_ACCESS) {
ist30xx_tracking(TRACK_CMD_ENTER_REG);
msleep(100);
} else if (cmd == CMD_EXIT_REG_ACCESS) {
ist30xx_tracking(TRACK_CMD_EXIT_REG);
msleep(10);
}
return ret;
}
void ist30xx_start(struct ist30xx_data *data)
{
#if IST30XX_DETECT_TA
if (ist30xx_ta_status > -1) {
ist30xx_write_cmd(data->client, CMD_SET_TA_MODE, ist30xx_ta_status);
tsp_info("%s(), ta_mode : %d\n", __func__, ist30xx_ta_status);
}
#endif
ist30xx_cmd_start_scan(data->client);
#if IST30XX_EVENT_MODE
if ((data->status.update != 1) && (data->status.calib != 1))
ktime_get_ts(&t_event);
#endif
}
int ist30xx_cmd_reg(struct i2c_client *client, int cmd)
{
int ret = ist30xx_write_cmd(client, cmd, 0);
if (cmd == CMD_ENTER_REG_ACCESS) {
#if IST30XX_NOISE_MODE
get_event_mode = false;
#endif
msleep(50);
}
#if IST30XX_NOISE_MODE
else if (cmd == CMD_EXIT_REG_ACCESS) {
get_event_mode = true;
}
#endif
return ret;
}
int ist30xx_get_info(struct ist30xx_data *data)
{
int ret;
u32 calib_msg;
ist30xx_tsp_info.finger_num = IST30XX_MAX_MT_FINGERS;
mutex_lock(&ist30xx_mutex);
ist30xx_disable_irq(data);
#if !(IST30XX_INTERNAL_BIN)
ret = ist30xx_write_cmd(data->client, CMD_RUN_DEVICE, 0);
if (ret)
goto get_info_end;
msleep(10);
ret = ist30xx_get_ver_info(data);
if (ret) goto get_info_end;
#endif // !(IST30XX_INTERNAL_BIN)
#if IST30XX_DEBUG
# if IST30XX_INTERNAL_BIN
ist30xx_get_tsp_info();
ist30xx_get_tkey_info();
# else
ret = ist30xx_tsp_update_info();
if (ret) goto get_info_end;
ret = ist30xx_tkey_update_info();
if (ret) goto get_info_end;
# endif
ist30xx_print_info();
#endif // IST30XX_DEBUG
ret = ist30xx_read_cmd(ts_data->client, CMD_GET_CALIB_RESULT, &calib_msg);
if (ret == 0) {
tsp_info("calib status: 0x%08x\n", calib_msg);
if ((calib_msg & CALIB_MSG_MASK) != CALIB_MSG_VALID ||
CALIB_TO_STATUS(calib_msg) > 0) {
ist30xx_calibrate(IST30XX_FW_UPDATE_RETRY);
ist30xx_cmd_run_device(data->client);
}
}
ist30xx_start(ts_data);
#if IST30XX_EVENT_MODE
ktime_get_ts(&t_event);
#endif
data->status.calib = 0;
#if !(IST30XX_INTERNAL_BIN)
get_info_end:
#endif
if (ret == 0)
ist30xx_enable_irq(data);
else
printk("[ TSP ] ist30xx_get_info return value : %d\n", ret);
mutex_unlock(&ist30xx_mutex);
return ret;
}
int ist30xx_cmcs_test(const u8 *buf, int size)
{
int ret;
int len;
u32 chksum = 0;
u32 *buf32;
struct i2c_client *client = (struct i2c_client *)ts_data->client;
CMCS_INFO *cmcs = (CMCS_INFO *)&ts_cmcs->cmcs;
tsp_info("*** CM/CS test ***\n");
tsp_info(" mode: 0x%x, baseline(screen: %d, key: %d)\n",
cmcs->cmd.mode, cmcs->cmd.base_screen, cmcs->cmd.base_key);
tsp_info(" start_cp (cm: %d, cs: %d), vcmp (cm: %d, cs: %d)\n",
cmcs->cmd.start_cp_cm, cmcs->cmd.start_cp_cs,
cmcs->cmd.vcmp_cm, cmcs->cmd.vcmp_cs);
ist30xx_disable_irq(ts_data);
ist30xx_reset(false);
ret = ist30xx_cmd_reg(client, CMD_ENTER_REG_ACCESS);
cmcs_next_step(ret);
/* Set sensor register */
buf32 = ts_cmcs->buf_sensor;
ret = ist30xx_set_cmcs_sensor(client, cmcs, buf32);
cmcs_next_step(ret);
/* Set command */
ret = ist30xx_set_cmcs_cmd(client, cmcs);
cmcs_next_step(ret);
ret = ist30xx_cmd_reg(client, CMD_EXIT_REG_ACCESS);
cmcs_next_step(ret);
/* Load cmcs test code */
ret = ist30xx_write_cmd(client, CMD_EXEC_MEM_CODE, 0);
cmcs_next_step(ret);
buf32 = (u32 *)ts_cmcs->buf_cmcs;
len = cmcs->cmd.cmcs_size / IST30XX_DATA_LEN;
tsp_verb("%08x %08x %08x %08x\n", buf32[0], buf32[1], buf32[2], buf32[3]);
ret = ist30xx_write_buf(client, len, buf32, len);
cmcs_next_step(ret);
/* Check checksum */
ret = ist30xx_read_cmd(client, CMD_DEFAULT, &chksum);
cmcs_next_step(ret);
if (chksum != IST30XX_CMCS_LOAD_END)
goto end;
tsp_info("CM/CS code ready!!\n");
/* Check checksum */
ret = ist30xx_read_cmd(client, CMD_DEFAULT, &chksum);
cmcs_next_step(ret);
tsp_info("CM/CS code chksum: %08x, %08x\n", chksum, cmcs->cmcs_chksum);
ist30xx_enable_irq(ts_data);
/* Wait CMCS test result */
if (ist30xx_calib_wait() == 1)
tsp_info("CM/CS test OK.\n");
else
tsp_info("CM/CS test fail.\n");
ist30xx_disable_irq(ts_data);
/* Read CM/CS data*/
if (ENABLE_CM_MODE(cmcs->cmd.mode)) {
/* Read CM data */
memset(ts_cmcs_buf->cm, 0, sizeof(ts_cmcs_buf->cm));
ret = ist30xx_get_cmcs_buf(client, cmcs, ts_cmcs_buf->cm);
cmcs_next_step(ret);
ret = ist30xx_apply_cmcs_slope(cmcs, ts_cmcs_buf);
}
if (ENABLE_CS_MODE(cmcs->cmd.mode)) {
/* Read CS0 data */
memset(ts_cmcs_buf->cs0, 0, sizeof(ts_cmcs_buf->cs0));
memset(ts_cmcs_buf->cs1, 0, sizeof(ts_cmcs_buf->cs1));
ret = ist30xx_get_cmcs_buf(client, cmcs, ts_cmcs_buf->cs0);
cmcs_next_step(ret);
/* Read CS1 data */
ret = ist30xx_get_cmcs_buf(client, cmcs, ts_cmcs_buf->cs1);
cmcs_next_step(ret);
}
ist30xx_reset(false);
ist30xx_start(ts_data);
cmcs_ready = CMCS_READY;
end:
if (unlikely(ret)) {
tsp_warn("CM/CS test Fail!, ret=%d\n", ret);
} else if (unlikely(chksum != cmcs->cmcs_chksum)) {
tsp_warn("Error CheckSum: %x(%x)\n", chksum, cmcs->cmcs_chksum);
ret = -ENOEXEC;
}
ist30xx_enable_irq(ts_data);
return ret;
}
