int ist30xx_tsp_update_info(struct ist30xx_data *data) { int ret = 0; u32 tsp_ch_num, tsp_swap, tsp_dir; TSP_INFO *tsp = &data->tsp_info; ret = ist30xx_read_cmd(data->client, CMD_GET_TSP_SWAP_INFO, &tsp_swap); if (unlikely(ret)) return ret; ret = ist30xx_read_cmd(data->client, CMD_GET_TSP_DIRECTION, &tsp_dir); if (unlikely(ret)) return ret; ret = ist30xx_read_cmd(data->client, CMD_GET_TSP_CHNUM1, &tsp_ch_num); if (unlikely(ret || !tsp_ch_num)) return ret; tsp->finger_num = IST30XX_MAX_MT_FINGERS; tsp->ch_num.rx = tsp_ch_num >> 16; tsp->ch_num.tx = tsp_ch_num & 0xFFFF; 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->node.len = tsp->ch_num.tx * tsp->ch_num.rx; tsp->height = (tsp->dir.swap_xy ? tsp->ch_num.rx : tsp->ch_num.tx); tsp->width = (tsp->dir.swap_xy ? tsp->ch_num.tx : tsp->ch_num.rx); return ret; }
int ist30xx_get_ver_info(struct ist30xx_data *data) { int ret; data->fw.pre_ver = data->fw.ver; data->fw.ver = 0; ret = ist30xx_read_cmd(data->client, CMD_GET_CHIP_ID, &data->chip_id); if (ret) return ret; ret = ist30xx_read_cmd(data->client, CMD_GET_FW_VER, &data->fw.ver); if (ret) return ret; ret = ist30xx_read_cmd(data->client, CMD_GET_PARAM_VER, &data->param_ver); if (ret) return ret; tsp_info("Chip ID : %x F/W: %x Param: %x\n", data->chip_id, data->fw.ver, data->param_ver); if ((data->chip_id != IST30XX_CHIP_ID) && (data->chip_id != IST30XXA_CHIP_ID)) return -EPERM; return 0; }
/* /sys/class/factory/tsp/fw_ver */ ssize_t factory_tsp_fw_ver_show(struct device *dev, struct device_attribute *attr, char *buf) { int ret; ist30xx_disable_irq(ts_data); ret = ist30xx_cmd_run_device(ts_data->client); if (ret) return sprintf(buf, "NULL"); ret = ist30xx_read_cmd(ts_data->client, CMD_GET_FW_VER, &ts_data->fw.ver); if (ret) return sprintf(buf, "NULL"); ret = ist30xx_read_cmd(ts_data->client, CMD_GET_PARAM_VER, &ts_data->param_ver); if (ret) return sprintf(buf, "NULL"); ist30xx_enable_irq(ts_data); tsp_info("tsp version: %d.%d(%d.%d.%d)\n", (ts_data->param_ver >> 8) & 0xFF, ts_data->param_ver & 0xFF, (ts_data->fw.ver >> 16) & 0xFF, (ts_data->fw.ver >> 8) & 0xFF, ts_data->fw.ver & 0xFF); return sprintf(buf, "%d.%d(%d.%d.%d)\n", (ts_data->param_ver >> 8) & 0xFF, ts_data->param_ver & 0xFF, (ts_data->fw.ver >> 16) & 0xFF, (ts_data->fw.ver >> 8) & 0xFF, ts_data->fw.ver & 0xFF); }
/* /sys/class/factory/tsp/panel_vendor */ ssize_t factory_tsp_panel_vendor_show(struct device *dev, struct device_attribute *attr, char *buf) { int ret; u32 panel_vendor; ist30xx_disable_irq(ts_data); ret = ist30xx_cmd_run_device(ts_data->client); if (ret) return sprintf(buf, "NULL"); ret = ist30xx_read_cmd(ts_data->client, CMD_GET_TSP_VENDOR, &panel_vendor); if (ret) return sprintf(buf, "NULL"); /* * TSP panel_vendor * - ALPS 1 * - SUNTEL 2 * - TOVIS 3 * - ILJIN 4 * - SYNOPEX 5 * - TAEYANG 6 */ ist30xx_enable_irq(ts_data); tsp_info("tsp panel vendor: %d\n", panel_vendor); return sprintf(buf, "%d\n", panel_vendor); }
/* /sys/class/factory/tsp/chip_name */ ssize_t factory_tsp_chip_name_show(struct device *dev, struct device_attribute *attr, char *buf) { int ret; ist30xx_disable_irq(ts_data); ret = ist30xx_cmd_run_device(ts_data->client); if (ret) return sprintf(buf, "NULL"); ret = ist30xx_read_cmd(ts_data->client, CMD_GET_CHIP_ID, &ts_data->chip_id); if (ret) return sprintf(buf, "NULL"); ist30xx_enable_irq(ts_data); if ((ts_data->chip_id != IST30XX_CHIP_ID) && (ts_data->chip_id != IST30XXA_CHIP_ID)) return sprintf(buf, "NULL"); tsp_info("tsp chip name: %s\n", IST30XX_CHIP_NAME); return sprintf(buf, "%s\n", IST30XX_CHIP_NAME); }
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_tkey_update_info(struct ist30xx_data *data) { int ret = 0; u32 tkey_info1, tkey_info2, tkey_info3; TKEY_INFO *tkey = &data->tkey_info; ret = ist30xx_read_cmd(data->client, CMD_GET_KEY_INFO1, &tkey_info1); if (unlikely(ret)) return ret; ret = ist30xx_read_cmd(data->client, CMD_GET_KEY_INFO2, &tkey_info2); if (unlikely(ret)) return ret; ret = ist30xx_read_cmd(data->client, CMD_GET_KEY_INFO3, &tkey_info3); if (unlikely(ret)) return ret; tkey->enable = ((tkey_info1 & (0xFF << 24)) ? true : false); tkey->key_num = (tkey_info1 >> 16) & 0xFF; tkey->ch_num[0] = (tkey_info2 >> 24) & 0xFF; tkey->ch_num[1] = (tkey_info2 >> 16) & 0xFF; tkey->ch_num[2] = (tkey_info2 >> 8) & 0xFF; tkey->ch_num[3] = tkey_info2 & 0xFF; tkey->ch_num[4] = (tkey_info3 >> 24) & 0xFF; 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; }
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; }