1742 lines
49 KiB
C
1742 lines
49 KiB
C
/*
|
|
* Goodix Touchscreen Driver
|
|
* Copyright (C) 2020 - 2021 Goodix, Inc.
|
|
*
|
|
* 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 a reference
|
|
* to you, when you are integrating the GOODiX's CTP IC into your system,
|
|
* 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 "goodix_ts_core.h"
|
|
#include <linux/rtc.h>
|
|
#include <linux/timer.h>
|
|
#include <linux/version.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/seq_file.h>
|
|
#include <asm/uaccess.h>
|
|
|
|
#define PROC_NODE_NAME "goodix_ts/get_rawdata"
|
|
|
|
#define JITTER1_TEST_ITEM "jitter100-test"
|
|
#define JITTER2_TEST_ITEM "jitter1000-test"
|
|
#define SRAM_TEST_ITEM "sram-test"
|
|
#define SHORT_TEST_ITEM "short-test"
|
|
#define OPEN_TEST_ITEM "open-test"
|
|
|
|
#define SEC_TEST_OK 0
|
|
#define SEC_TEST_NG 1
|
|
|
|
#define MAX_TEST_TIME_MS 15000
|
|
#define DEFAULT_TEST_TIME_MS 7000
|
|
|
|
#define CHN_VDD 0xFF
|
|
#define CHN_GND 0x7F
|
|
#define DRV_CHANNEL_FLAG 0x80
|
|
|
|
extern struct goodix_module goodix_modules;
|
|
static bool module_initialized;
|
|
|
|
static u32 short_parms[] = {10, 800, 800, 800, 800, 800, 30};
|
|
|
|
typedef struct __attribute__((packed)) {
|
|
u8 result;
|
|
u8 drv_drv_num;
|
|
u8 sen_sen_num;
|
|
u8 drv_sen_num;
|
|
u8 drv_gnd_avdd_num;
|
|
u8 sen_gnd_avdd_num;
|
|
u16 checksum;
|
|
} test_result_t;
|
|
|
|
struct goodix_jitter_data {
|
|
short mutualDiffMax;
|
|
short mutualDiffMin;
|
|
short selfDiffMax;
|
|
short selfDiffMin;
|
|
/* 1000 frames */
|
|
short min_of_min_matrix;
|
|
short max_of_min_matrix;
|
|
short min_of_max_matrix;
|
|
short max_of_max_matrix;
|
|
short min_of_avg_matrix;
|
|
short max_of_avg_matrix;
|
|
};
|
|
|
|
static int ts_test_read(struct goodix_ts_core *cd, unsigned int addr,
|
|
unsigned char *data, unsigned int len)
|
|
{
|
|
return cd->bus->read(cd->bus->dev, addr, data, len);
|
|
}
|
|
|
|
static int ts_test_write(struct goodix_ts_core *cd, unsigned int addr,
|
|
unsigned char *data, unsigned int len)
|
|
{
|
|
return cd->bus->write(cd->bus->dev, addr, data, len);
|
|
}
|
|
|
|
static void goodix_data_statistics(s16 *data, int data_size,
|
|
int *max, int *min)
|
|
{
|
|
int i;
|
|
|
|
*min = data[0];
|
|
*max = data[0];
|
|
for (i = 0; i < data_size; i++) {
|
|
*max = *max < data[i] ? data[i] : *max;
|
|
*min = *min > data[i] ? data[i] : *min;
|
|
}
|
|
}
|
|
|
|
static int cal_cha_to_cha_res(struct goodix_ts_core *cd, int v1, int v2)
|
|
{
|
|
if (cd->bus->ic_type == IC_TYPE_BERLIN_B)
|
|
return (v1 - v2) * 74 / v2 + 20;
|
|
else if (cd->bus->ic_type == IC_TYPE_BERLIN_D)
|
|
return (v1 / v2 - 1) * 55 + 45;
|
|
else {
|
|
ts_err("abnormal tsp ic type(%d)", cd->bus->ic_type);
|
|
return (v1 - v2) * 74 / v2 + 20;
|
|
}
|
|
}
|
|
|
|
static int cal_cha_to_avdd_res(struct goodix_ts_core *cd, int v1, int v2)
|
|
{
|
|
if (cd->bus->ic_type == IC_TYPE_BERLIN_B)
|
|
return 64 * (2 * v2 - 25) * 99 / v1 - 60;
|
|
else if (cd->bus->ic_type == IC_TYPE_BERLIN_D)
|
|
return 64 * (2 * v2 - 25) * 93 / v1 - 20;
|
|
else {
|
|
ts_err("abnormal tsp ic type(%d)", cd->bus->ic_type);
|
|
return 64 * (2 * v2 - 25) * 99 / v1 - 60;
|
|
}
|
|
}
|
|
|
|
static int cal_cha_to_gnd_res(struct goodix_ts_core *cd, int v)
|
|
{
|
|
if (cd->bus->ic_type == IC_TYPE_BERLIN_B)
|
|
return 150500 / v - 60;
|
|
else if (cd->bus->ic_type == IC_TYPE_BERLIN_D)
|
|
return 120000 / v - 16;
|
|
else {
|
|
ts_err("abnormal tsp ic type(%d)", cd->bus->ic_type);
|
|
return 150500 / v - 60;
|
|
}
|
|
}
|
|
|
|
static u32 map_die2pin(struct goodix_ts_core *cd, u32 chn_num)
|
|
{
|
|
int i = 0;
|
|
u32 res = 255;
|
|
int max_drv_num = cd->max_drv_num;
|
|
int max_sen_num = cd->max_sen_num;
|
|
|
|
if (chn_num & DRV_CHANNEL_FLAG)
|
|
chn_num = (chn_num & ~DRV_CHANNEL_FLAG) + max_sen_num;
|
|
|
|
for (i = 0; i < max_sen_num; i++) {
|
|
if ((u8)cd->sen_map[i] == chn_num) {
|
|
res = i;
|
|
break;
|
|
}
|
|
}
|
|
/* res != 255 mean found the corresponding channel num */
|
|
if (res != 255)
|
|
return res;
|
|
/* if cannot find in SenMap try find in DrvMap */
|
|
for (i = 0; i < max_drv_num; i++) {
|
|
if ((u8)cd->drv_map[i] == chn_num) {
|
|
res = i;
|
|
break;
|
|
}
|
|
}
|
|
if (i >= max_drv_num)
|
|
ts_err("Faild found corrresponding channel num:%d", chn_num);
|
|
else
|
|
res |= DRV_CHANNEL_FLAG;
|
|
|
|
return res;
|
|
}
|
|
|
|
#define SHORT_TEST_RUN_REG 0x10400
|
|
#define SHORT_TEST_RUN_FLAG 0xAA
|
|
#define INSPECT_FW_SWITCH_CMD 0x85
|
|
static int goodix_brl_short_test_prepare(struct goodix_ts_core *cd)
|
|
{
|
|
struct goodix_ts_cmd tmp_cmd;
|
|
int ret;
|
|
int retry = 5;
|
|
u8 status;
|
|
|
|
ts_info("short test prepare IN");
|
|
tmp_cmd.len = 4;
|
|
tmp_cmd.cmd = INSPECT_FW_SWITCH_CMD;
|
|
ret = cd->hw_ops->send_cmd(cd, &tmp_cmd);
|
|
if (ret < 0) {
|
|
ts_err("send test mode failed");
|
|
return ret;
|
|
}
|
|
|
|
while (retry--) {
|
|
sec_delay(40);
|
|
ret = cd->hw_ops->read(cd, SHORT_TEST_RUN_REG, &status, 1);
|
|
if (!ret && status == SHORT_TEST_RUN_FLAG)
|
|
return 0;
|
|
ts_info("short_mode_status=0x%02x ret=%d", status, ret);
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int gdix_check_tx_tx_shortcircut(struct goodix_ts_core *cd,
|
|
u8 short_ch_num)
|
|
{
|
|
int ret = 0, err = 0;
|
|
u32 r_threshold = 0, short_r = 0;
|
|
int size = 0, i = 0, j = 0;
|
|
u16 adc_signal = 0;
|
|
u8 master_pin_num, slave_pin_num;
|
|
u8 *data_buf;
|
|
u32 data_reg = cd->drv_drv_reg;
|
|
int max_drv_num = cd->max_drv_num;
|
|
int max_sen_num = cd->max_sen_num;
|
|
u16 self_capdata, short_die_num = 0;
|
|
|
|
size = 4 + max_drv_num * 2 + 2;
|
|
data_buf = kzalloc(size, GFP_KERNEL);
|
|
if (!data_buf) {
|
|
ts_err("Failed to alloc memory");
|
|
return -ENOMEM;
|
|
}
|
|
/* drv&drv shortcircut check */
|
|
for (i = 0; i < short_ch_num; i++) {
|
|
ret = ts_test_read(cd, data_reg, data_buf, size);
|
|
if (ret < 0) {
|
|
ts_err("Failed read Drv-to-Drv short rawdata");
|
|
err = -EINVAL;
|
|
break;
|
|
}
|
|
|
|
if (checksum_cmp(data_buf, size, CHECKSUM_MODE_U8_LE)) {
|
|
ts_err("Drv-to-Drv adc data checksum error");
|
|
err = -EINVAL;
|
|
break;
|
|
}
|
|
|
|
r_threshold = short_parms[1];
|
|
short_die_num = le16_to_cpup((__le16 *)&data_buf[0]);
|
|
short_die_num -= max_sen_num;
|
|
if (short_die_num >= max_drv_num) {
|
|
ts_info("invalid short pad num:%d",
|
|
short_die_num + max_sen_num);
|
|
continue;
|
|
}
|
|
|
|
/* TODO: j start position need recheck */
|
|
self_capdata = le16_to_cpup((__le16 *)&data_buf[2]);
|
|
if (self_capdata == 0xffff || self_capdata == 0) {
|
|
ts_info("invalid self_capdata:0x%x", self_capdata);
|
|
continue;
|
|
}
|
|
|
|
for (j = short_die_num + 1; j < max_drv_num; j++) {
|
|
adc_signal = le16_to_cpup((__le16 *)&data_buf[4 + j * 2]);
|
|
|
|
if (adc_signal < short_parms[0])
|
|
continue;
|
|
|
|
short_r = (u32)cal_cha_to_cha_res(cd, self_capdata, adc_signal);
|
|
if (short_r < r_threshold) {
|
|
master_pin_num =
|
|
map_die2pin(cd, short_die_num + max_sen_num);
|
|
slave_pin_num =
|
|
map_die2pin(cd, j + max_sen_num);
|
|
if (master_pin_num == 0xFF || slave_pin_num == 0xFF) {
|
|
ts_info("WARNNING invalid pin");
|
|
continue;
|
|
}
|
|
ts_err("short circut:R=%dK,R_Threshold=%dK",
|
|
short_r, r_threshold);
|
|
ts_err("%s%d--%s%d shortcircut",
|
|
(master_pin_num & DRV_CHANNEL_FLAG) ? "DRV" : "SEN",
|
|
(master_pin_num & ~DRV_CHANNEL_FLAG),
|
|
(slave_pin_num & DRV_CHANNEL_FLAG) ? "DRV" : "SEN",
|
|
(slave_pin_num & ~DRV_CHANNEL_FLAG));
|
|
|
|
/* save fail ch on cd->test_data.open_short_test_trx_result[] */
|
|
{
|
|
int offset, num;
|
|
offset = (master_pin_num & DRV_CHANNEL_FLAG) ? 0 : DRV_CHAN_BYTES;
|
|
offset += (master_pin_num & ~DRV_CHANNEL_FLAG) / 8;
|
|
num = (master_pin_num & ~DRV_CHANNEL_FLAG) % 8;
|
|
cd->test_data.open_short_test_trx_result[offset] |= (1 << num);
|
|
ts_err("master_pin_num=%d, offset=%d, num=%d", master_pin_num, offset, num);
|
|
|
|
offset = (slave_pin_num & DRV_CHANNEL_FLAG) ? 0 : DRV_CHAN_BYTES;
|
|
offset += (slave_pin_num & ~DRV_CHANNEL_FLAG) / 8;
|
|
num = (slave_pin_num & ~DRV_CHANNEL_FLAG) % 8;
|
|
cd->test_data.open_short_test_trx_result[offset] |= (1 << num);
|
|
ts_err("slave_pin_num=%d, offset=%d, num=%d", master_pin_num, offset, num);
|
|
}
|
|
|
|
err = -EINVAL;
|
|
}
|
|
}
|
|
data_reg += size;
|
|
}
|
|
|
|
kfree(data_buf);
|
|
return err;
|
|
}
|
|
|
|
static int gdix_check_rx_rx_shortcircut(struct goodix_ts_core *cd,
|
|
u8 short_ch_num)
|
|
{
|
|
int ret = 0, err = 0;
|
|
u32 r_threshold = 0, short_r = 0;
|
|
int size = 0, i = 0, j = 0;
|
|
u16 adc_signal = 0;
|
|
u8 master_pin_num, slave_pin_num;
|
|
u8 *data_buf;
|
|
u32 data_reg = cd->sen_sen_reg;
|
|
int max_sen_num = cd->max_sen_num;
|
|
u16 self_capdata, short_die_num = 0;
|
|
|
|
size = 4 + max_sen_num * 2 + 2;
|
|
data_buf = kzalloc(size, GFP_KERNEL);
|
|
if (!data_buf) {
|
|
ts_err("Failed to alloc memory");
|
|
return -ENOMEM;
|
|
}
|
|
/* drv&drv shortcircut check */
|
|
for (i = 0; i < short_ch_num; i++) {
|
|
ret = ts_test_read(cd, data_reg, data_buf, size);
|
|
if (ret) {
|
|
ts_err("Failed read Sen-to-Sen short rawdata");
|
|
err = -EINVAL;
|
|
break;
|
|
}
|
|
|
|
if (checksum_cmp(data_buf, size, CHECKSUM_MODE_U8_LE)) {
|
|
ts_err("Sen-to-Sen adc data checksum error");
|
|
err = -EINVAL;
|
|
break;
|
|
}
|
|
|
|
r_threshold = short_parms[3];
|
|
short_die_num = le16_to_cpup((__le16 *)&data_buf[0]);
|
|
if (short_die_num >= max_sen_num) {
|
|
ts_info("invalid short pad num:%d", short_die_num);
|
|
continue;
|
|
}
|
|
|
|
/* TODO: j start position need recheck */
|
|
self_capdata = le16_to_cpup((__le16 *)&data_buf[2]);
|
|
if (self_capdata == 0xffff || self_capdata == 0) {
|
|
ts_info("invalid self_capdata:0x%x", self_capdata);
|
|
continue;
|
|
}
|
|
|
|
for (j = short_die_num + 1; j < max_sen_num; j++) {
|
|
adc_signal = le16_to_cpup((__le16 *)&data_buf[4 + j * 2]);
|
|
|
|
if (adc_signal < short_parms[0])
|
|
continue;
|
|
|
|
short_r = (u32)cal_cha_to_cha_res(cd, self_capdata, adc_signal);
|
|
if (short_r < r_threshold) {
|
|
master_pin_num = map_die2pin(cd, short_die_num);
|
|
slave_pin_num = map_die2pin(cd, j);
|
|
if (master_pin_num == 0xFF || slave_pin_num == 0xFF) {
|
|
ts_info("WARNNING invalid pin");
|
|
continue;
|
|
}
|
|
ts_err("short circut:R=%dK,R_Threshold=%dK",
|
|
short_r, r_threshold);
|
|
ts_err("%s%d--%s%d shortcircut",
|
|
(master_pin_num & DRV_CHANNEL_FLAG) ? "DRV" : "SEN",
|
|
(master_pin_num & ~DRV_CHANNEL_FLAG),
|
|
(slave_pin_num & DRV_CHANNEL_FLAG) ? "DRV" : "SEN",
|
|
(slave_pin_num & ~DRV_CHANNEL_FLAG));
|
|
|
|
/* save fail ch on cd->test_data.open_short_test_trx_result[] */
|
|
{
|
|
int offset, num;
|
|
offset = (master_pin_num & DRV_CHANNEL_FLAG) ? 0 : DRV_CHAN_BYTES;
|
|
offset += (master_pin_num & ~DRV_CHANNEL_FLAG) / 8;
|
|
num = (master_pin_num & ~DRV_CHANNEL_FLAG) % 8;
|
|
cd->test_data.open_short_test_trx_result[offset] |= (1 << num);
|
|
ts_err("master_pin_num=%d, offset=%d, num=%d", master_pin_num, offset, num);
|
|
|
|
offset = (slave_pin_num & DRV_CHANNEL_FLAG) ? 0 : DRV_CHAN_BYTES;
|
|
offset += (slave_pin_num & ~DRV_CHANNEL_FLAG) / 8;
|
|
num = (slave_pin_num & ~DRV_CHANNEL_FLAG) % 8;
|
|
cd->test_data.open_short_test_trx_result[offset] |= (1 << num);
|
|
ts_err("slave_pin_num=%d, offset=%d, num=%d", master_pin_num, offset, num);
|
|
}
|
|
|
|
err = -EINVAL;
|
|
}
|
|
}
|
|
data_reg += size;
|
|
}
|
|
|
|
kfree(data_buf);
|
|
return err;
|
|
}
|
|
|
|
static int gdix_check_tx_rx_shortcircut(struct goodix_ts_core *cd,
|
|
u8 short_ch_num)
|
|
{
|
|
int ret = 0, err = 0;
|
|
u32 r_threshold = 0, short_r = 0;
|
|
int size = 0, i = 0, j = 0;
|
|
u16 adc_signal = 0;
|
|
u8 master_pin_num, slave_pin_num;
|
|
u8 *data_buf = NULL;
|
|
u32 data_reg = cd->drv_sen_reg;
|
|
int max_drv_num = cd->max_drv_num;
|
|
int max_sen_num = cd->max_sen_num;
|
|
u16 self_capdata, short_die_num = 0;
|
|
|
|
size = 4 + max_drv_num * 2 + 2;
|
|
data_buf = kzalloc(size, GFP_KERNEL);
|
|
if (!data_buf) {
|
|
ts_err("Failed to alloc memory");
|
|
return -ENOMEM;
|
|
}
|
|
/* drv&sen shortcircut check */
|
|
for (i = 0; i < short_ch_num; i++) {
|
|
ret = ts_test_read(cd, data_reg, data_buf, size);
|
|
if (ret) {
|
|
ts_err("Failed read Drv-to-Sen short rawdata");
|
|
err = -EINVAL;
|
|
break;
|
|
}
|
|
|
|
if (checksum_cmp(data_buf, size, CHECKSUM_MODE_U8_LE)) {
|
|
ts_err("Drv-to-Sen adc data checksum error");
|
|
err = -EINVAL;
|
|
break;
|
|
}
|
|
|
|
r_threshold = short_parms[2];
|
|
short_die_num = le16_to_cpup((__le16 *)&data_buf[0]);
|
|
if (short_die_num >= max_sen_num) {
|
|
ts_info("invalid short pad num:%d", short_die_num);
|
|
continue;
|
|
}
|
|
|
|
/* TODO: j start position need recheck */
|
|
self_capdata = le16_to_cpup((__le16 *)&data_buf[2]);
|
|
if (self_capdata == 0xffff || self_capdata == 0) {
|
|
ts_info("invalid self_capdata:0x%x", self_capdata);
|
|
continue;
|
|
}
|
|
|
|
for (j = 0; j < max_drv_num; j++) {
|
|
adc_signal = le16_to_cpup((__le16 *)&data_buf[4 + j * 2]);
|
|
|
|
if (adc_signal < short_parms[0])
|
|
continue;
|
|
|
|
short_r = (u32)cal_cha_to_cha_res(cd, self_capdata, adc_signal);
|
|
if (short_r < r_threshold) {
|
|
master_pin_num = map_die2pin(cd, short_die_num);
|
|
slave_pin_num = map_die2pin(cd, j + max_sen_num);
|
|
if (master_pin_num == 0xFF || slave_pin_num == 0xFF) {
|
|
ts_info("WARNNING invalid pin");
|
|
continue;
|
|
}
|
|
ts_err("short circut:R=%dK,R_Threshold=%dK",
|
|
short_r, r_threshold);
|
|
ts_err("%s%d--%s%d shortcircut",
|
|
(master_pin_num & DRV_CHANNEL_FLAG) ? "DRV" : "SEN",
|
|
(master_pin_num & ~DRV_CHANNEL_FLAG),
|
|
(slave_pin_num & DRV_CHANNEL_FLAG) ? "DRV" : "SEN",
|
|
(slave_pin_num & ~DRV_CHANNEL_FLAG));
|
|
|
|
/* save fail ch on cd->test_data.open_short_test_trx_result[] */
|
|
{
|
|
int offset, num;
|
|
offset = (master_pin_num & DRV_CHANNEL_FLAG) ? 0 : DRV_CHAN_BYTES;
|
|
offset += (master_pin_num & ~DRV_CHANNEL_FLAG) / 8;
|
|
num = (master_pin_num & ~DRV_CHANNEL_FLAG) % 8;
|
|
cd->test_data.open_short_test_trx_result[offset] |= (1 << num);
|
|
ts_err("master_pin_num=%d, offset=%d, num=%d", master_pin_num, offset, num);
|
|
|
|
offset = (slave_pin_num & DRV_CHANNEL_FLAG) ? 0 : DRV_CHAN_BYTES;
|
|
offset += (slave_pin_num & ~DRV_CHANNEL_FLAG) / 8;
|
|
num = (slave_pin_num & ~DRV_CHANNEL_FLAG) % 8;
|
|
cd->test_data.open_short_test_trx_result[offset] |= (1 << num);
|
|
ts_err("slave_pin_num=%d, offset=%d, num=%d", master_pin_num, offset, num);
|
|
}
|
|
|
|
err = -EINVAL;
|
|
}
|
|
}
|
|
data_reg += size;
|
|
}
|
|
|
|
kfree(data_buf);
|
|
return err;
|
|
}
|
|
|
|
static int gdix_check_resistance_to_gnd(struct goodix_ts_core *cd,
|
|
u16 adc_signal, u32 pos)
|
|
{
|
|
long r = 0;
|
|
u16 r_th = 0, avdd_value = 0;
|
|
u16 chn_id_tmp = 0;
|
|
u8 pin_num = 0;
|
|
unsigned short short_type;
|
|
int max_drv_num = cd->max_drv_num;
|
|
int max_sen_num = cd->max_sen_num;
|
|
|
|
avdd_value = short_parms[6];
|
|
short_type = adc_signal & 0x8000;
|
|
adc_signal &= ~0x8000;
|
|
if (adc_signal == 0)
|
|
adc_signal = 1;
|
|
|
|
if (short_type == 0) {
|
|
/* short to GND */
|
|
r = cal_cha_to_gnd_res(cd, adc_signal);
|
|
} else {
|
|
/* short to VDD */
|
|
r = cal_cha_to_avdd_res(cd, adc_signal, avdd_value);
|
|
}
|
|
|
|
if (pos < max_drv_num)
|
|
r_th = short_parms[4];
|
|
else
|
|
r_th = short_parms[5];
|
|
|
|
chn_id_tmp = pos;
|
|
if (chn_id_tmp < max_drv_num)
|
|
chn_id_tmp += max_sen_num;
|
|
else
|
|
chn_id_tmp -= max_drv_num;
|
|
|
|
if (r < r_th) {
|
|
pin_num = map_die2pin(cd, chn_id_tmp);
|
|
ts_err("%s%d shortcircut to %s,R=%ldK,R_Threshold=%dK",
|
|
(pin_num & DRV_CHANNEL_FLAG) ? "DRV" : "SEN",
|
|
(pin_num & ~DRV_CHANNEL_FLAG),
|
|
short_type ? "VDD" : "GND",
|
|
r, r_th);
|
|
|
|
/* save fail ch on cd->test_data.open_short_test_trx_result[] */
|
|
{
|
|
int offset, num;
|
|
offset = (pin_num & DRV_CHANNEL_FLAG) ? 0 : DRV_CHAN_BYTES;
|
|
offset += (pin_num & ~DRV_CHANNEL_FLAG) / 8;
|
|
num = (pin_num & ~DRV_CHANNEL_FLAG) % 8;
|
|
cd->test_data.open_short_test_trx_result[offset] |= (1 << num);
|
|
ts_err("pin_num=%d, offset=%d, num=%d", pin_num, offset, num);
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int gdix_check_gndvdd_shortcircut(struct goodix_ts_core *cd)
|
|
{
|
|
int ret = 0, err = 0;
|
|
int size = 0, i = 0;
|
|
u16 adc_signal = 0;
|
|
u32 data_reg = cd->diff_code_reg;
|
|
u8 *data_buf = NULL;
|
|
int max_drv_num = cd->max_drv_num;
|
|
int max_sen_num = cd->max_sen_num;
|
|
|
|
size = (max_drv_num + max_sen_num) * 2 + 2;
|
|
data_buf = kzalloc(size, GFP_KERNEL);
|
|
if (!data_buf) {
|
|
ts_err("Failed to alloc memory");
|
|
return -ENOMEM;
|
|
}
|
|
/* read diff code, diff code will be used to calculate
|
|
* resistance between channel and GND */
|
|
ret = ts_test_read(cd, data_reg, data_buf, size);
|
|
if (ret < 0) {
|
|
ts_err("Failed read to-gnd rawdata");
|
|
err = -EINVAL;
|
|
goto err_out;
|
|
}
|
|
|
|
if (checksum_cmp(data_buf, size, CHECKSUM_MODE_U8_LE)) {
|
|
ts_err("diff code checksum error");
|
|
err = -EINVAL;
|
|
goto err_out;
|
|
}
|
|
|
|
for (i = 0; i < max_drv_num + max_sen_num; i++) {
|
|
adc_signal = le16_to_cpup((__le16 *)&data_buf[i * 2]);
|
|
ret = gdix_check_resistance_to_gnd(cd, adc_signal, i);
|
|
if (ret != 0) {
|
|
ts_err("Resistance to-gnd/vdd short");
|
|
err = ret;
|
|
}
|
|
}
|
|
|
|
err_out:
|
|
kfree(data_buf);
|
|
return err;
|
|
}
|
|
|
|
static int goodix_short_analysis(struct goodix_ts_core *cd)
|
|
{
|
|
int ret;
|
|
int err = 0;
|
|
test_result_t test_result;
|
|
unsigned int result_reg = cd->short_test_result_reg;
|
|
|
|
ret = cd->hw_ops->read(cd, result_reg,
|
|
(u8 *)&test_result, sizeof(test_result));
|
|
if (ret < 0) {
|
|
ts_err("Read TEST_RESULT_REG failed");
|
|
return ret;
|
|
}
|
|
|
|
if (checksum_cmp((u8 *)&test_result, sizeof(test_result),
|
|
CHECKSUM_MODE_U8_LE)) {
|
|
ts_err("shrot result checksum err");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!(test_result.result & 0x0F)) {
|
|
ts_raw_info(">>>>> No shortcircut");
|
|
cd->test_data.info[SEC_SHORT_TEST].data[0] = SEC_TEST_OK;
|
|
} else {
|
|
ts_raw_info("short flag 0x%02x, drv&drv:%d, sen&sen:%d, drv&sen:%d, drv/GNDVDD:%d, sen/GNDVDD:%d",
|
|
test_result.result, test_result.drv_drv_num, test_result.sen_sen_num,
|
|
test_result.drv_sen_num, test_result.drv_gnd_avdd_num, test_result.sen_gnd_avdd_num);
|
|
/* get short channel and resistance */
|
|
if (test_result.drv_drv_num)
|
|
err |= gdix_check_tx_tx_shortcircut(cd, test_result.drv_drv_num);
|
|
if (test_result.sen_sen_num)
|
|
err |= gdix_check_rx_rx_shortcircut(cd, test_result.sen_sen_num);
|
|
if (test_result.drv_sen_num)
|
|
err |= gdix_check_tx_rx_shortcircut(cd, test_result.drv_sen_num);
|
|
if (test_result.drv_gnd_avdd_num || test_result.sen_gnd_avdd_num)
|
|
err |= gdix_check_gndvdd_shortcircut(cd);
|
|
if (err)
|
|
cd->test_data.info[SEC_SHORT_TEST].data[0] = SEC_TEST_NG;
|
|
else
|
|
cd->test_data.info[SEC_SHORT_TEST].data[0] = SEC_TEST_OK;
|
|
}
|
|
cd->test_data.info[SEC_SHORT_TEST].isFinished = true;
|
|
|
|
if (err)
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#define JITTER_LEN 24
|
|
static int goodix_brl_jitter_test(struct goodix_ts_core *cd, u8 type)
|
|
{
|
|
int ret;
|
|
int retry;
|
|
struct goodix_ts_cmd cmd;
|
|
struct goodix_jitter_data raw_data;
|
|
unsigned int jitter_addr = cd->production_test_addr;
|
|
u8 buf[JITTER_LEN];
|
|
|
|
/* switch test config */
|
|
cmd.len = 5;
|
|
cmd.cmd = cd->switch_cfg_cmd;
|
|
cmd.data[0] = 1;
|
|
ret = cd->hw_ops->send_cmd(cd, &cmd);
|
|
if (ret < 0) {
|
|
ts_err("switch test config failed");
|
|
return ret;
|
|
}
|
|
|
|
sec_delay(20);
|
|
|
|
cmd.cmd = 0x88;
|
|
cmd.data[0] = type;
|
|
cmd.len = 5;
|
|
ret = cd->hw_ops->send_cmd(cd, &cmd);
|
|
if (ret < 0) {
|
|
ts_err("send jitter test cmd failed");
|
|
return ret;
|
|
}
|
|
if (type == JITTER_100_FRAMES)
|
|
sec_delay(100);
|
|
else
|
|
sec_delay(8000);
|
|
|
|
retry = 20;
|
|
while (retry--) {
|
|
ret = cd->hw_ops->read(cd, jitter_addr, buf, (int)sizeof(buf));
|
|
if (ret < 0) {
|
|
ts_err("read raw data failed");
|
|
return ret;
|
|
}
|
|
if (type == JITTER_100_FRAMES) {
|
|
if (buf[0] == 0xAA && buf[1] == 0xAA)
|
|
break;
|
|
} else {
|
|
if (buf[0] == 0xBB && buf[1] == 0xBB)
|
|
break;
|
|
}
|
|
sec_delay(50);
|
|
}
|
|
if (retry < 0) {
|
|
ts_err("raw data not ready, status = %x%x", buf[0], buf[1]);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (type == JITTER_100_FRAMES) {
|
|
raw_data.mutualDiffMax = le16_to_cpup((__le16 *)&buf[2]);
|
|
raw_data.mutualDiffMin = le16_to_cpup((__le16 *)&buf[4]);
|
|
raw_data.selfDiffMax = le16_to_cpup((__le16 *)&buf[6]);
|
|
raw_data.selfDiffMin = le16_to_cpup((__le16 *)&buf[8]);
|
|
cd->test_data.info[SEC_JITTER1_TEST].data[0] = raw_data.mutualDiffMax;
|
|
cd->test_data.info[SEC_JITTER1_TEST].data[1] = raw_data.mutualDiffMin;
|
|
cd->test_data.info[SEC_JITTER1_TEST].data[2] = raw_data.selfDiffMax;
|
|
cd->test_data.info[SEC_JITTER1_TEST].data[3] = raw_data.selfDiffMin;
|
|
cd->test_data.info[SEC_JITTER1_TEST].isFinished = true;
|
|
ts_raw_info("mutualdiff[%d, %d] selfdiff[%d, %d]",
|
|
raw_data.mutualDiffMin, raw_data.mutualDiffMax,
|
|
raw_data.selfDiffMin, raw_data.selfDiffMax);
|
|
} else {
|
|
if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
|
|
raw_data.min_of_min_matrix = le16_to_cpup((__le16 *)&buf[10]);
|
|
raw_data.max_of_min_matrix = le16_to_cpup((__le16 *)&buf[12]);
|
|
raw_data.min_of_max_matrix = le16_to_cpup((__le16 *)&buf[14]);
|
|
raw_data.max_of_max_matrix = le16_to_cpup((__le16 *)&buf[16]);
|
|
raw_data.min_of_avg_matrix = le16_to_cpup((__le16 *)&buf[18]);
|
|
raw_data.max_of_avg_matrix = le16_to_cpup((__le16 *)&buf[20]);
|
|
} else if (cd->bus->ic_type == IC_TYPE_BERLIN_D) {
|
|
raw_data.min_of_min_matrix = le16_to_cpup((__le16 *)&buf[2]);
|
|
raw_data.max_of_min_matrix = le16_to_cpup((__le16 *)&buf[4]);
|
|
raw_data.min_of_max_matrix = le16_to_cpup((__le16 *)&buf[6]);
|
|
raw_data.max_of_max_matrix = le16_to_cpup((__le16 *)&buf[8]);
|
|
raw_data.min_of_avg_matrix = le16_to_cpup((__le16 *)&buf[10]);
|
|
raw_data.max_of_avg_matrix = le16_to_cpup((__le16 *)&buf[12]);
|
|
} else {
|
|
raw_data.min_of_min_matrix = le16_to_cpup((__le16 *)&buf[10]);
|
|
raw_data.max_of_min_matrix = le16_to_cpup((__le16 *)&buf[12]);
|
|
raw_data.min_of_max_matrix = le16_to_cpup((__le16 *)&buf[14]);
|
|
raw_data.max_of_max_matrix = le16_to_cpup((__le16 *)&buf[16]);
|
|
raw_data.min_of_avg_matrix = le16_to_cpup((__le16 *)&buf[18]);
|
|
raw_data.max_of_avg_matrix = le16_to_cpup((__le16 *)&buf[20]);
|
|
ts_err("abnormal tsp ic type(%d)", cd->bus->ic_type);
|
|
}
|
|
|
|
cd->test_data.info[SEC_JITTER2_TEST].data[0] = raw_data.min_of_min_matrix;
|
|
cd->test_data.info[SEC_JITTER2_TEST].data[1] = raw_data.max_of_min_matrix;
|
|
cd->test_data.info[SEC_JITTER2_TEST].data[2] = raw_data.min_of_max_matrix;
|
|
cd->test_data.info[SEC_JITTER2_TEST].data[3] = raw_data.max_of_max_matrix;
|
|
cd->test_data.info[SEC_JITTER2_TEST].data[4] = raw_data.min_of_avg_matrix;
|
|
cd->test_data.info[SEC_JITTER2_TEST].data[5] = raw_data.max_of_avg_matrix;
|
|
cd->test_data.info[SEC_JITTER2_TEST].isFinished = true;
|
|
ts_raw_info("min_matrix[%d, %d] max_matrix[%d, %d] avg_matrix[%d, %d]",
|
|
raw_data.min_of_min_matrix, raw_data.max_of_min_matrix,
|
|
raw_data.min_of_max_matrix, raw_data.max_of_max_matrix,
|
|
raw_data.min_of_avg_matrix, raw_data.max_of_avg_matrix);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int goodix_jitter_test(struct goodix_ts_core *cd, u8 type)
|
|
{
|
|
int ret;
|
|
|
|
if (type == JITTER_100_FRAMES)
|
|
cd->test_data.info[SEC_JITTER1_TEST].item_name = JITTER1_TEST_ITEM;
|
|
else
|
|
cd->test_data.info[SEC_JITTER2_TEST].item_name = JITTER2_TEST_ITEM;
|
|
|
|
ret = goodix_brl_jitter_test(cd, type);
|
|
if (ret < 0)
|
|
ts_err("jitter test process failed");
|
|
return ret;
|
|
}
|
|
|
|
static int goodix_brl_open_test(struct goodix_ts_core *cd)
|
|
{
|
|
int ret;
|
|
int retry = 20;
|
|
int i;
|
|
struct goodix_ts_cmd cmd;
|
|
unsigned char buf[OPEN_TEST_RESULT_LEN];
|
|
|
|
cmd.cmd = 0x89;
|
|
cmd.len = 4;
|
|
ret = cd->hw_ops->send_cmd(cd, &cmd);
|
|
if (ret < 0) {
|
|
ts_err("send open test cmd failed");
|
|
return ret;
|
|
}
|
|
sec_delay(400);
|
|
while (retry--) {
|
|
ret = cd->hw_ops->read(cd, OPEN_TEST_RESULT, buf, (int)sizeof(buf));
|
|
if (ret < 0) {
|
|
ts_err("read open test result failed");
|
|
return ret;
|
|
}
|
|
if (buf[0] == 0xAA && buf[1] == 0xAA)
|
|
break;
|
|
sec_delay(50);
|
|
}
|
|
if (retry < 0) {
|
|
ts_err("open test not ready, status = %x%x", buf[0], buf[1]);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = checksum_cmp(buf + 2, OPEN_TEST_RESULT_LEN - 2, CHECKSUM_MODE_U8_LE);
|
|
if (ret) {
|
|
ts_err("open test result checksum error %*ph", OPEN_TEST_RESULT_LEN, buf);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (buf[2] == 0) {
|
|
ts_raw_info("open test pass");
|
|
ret = 0;
|
|
cd->test_data.info[SEC_OPEN_TEST].data[0] = SEC_TEST_OK;
|
|
} else {
|
|
ts_raw_info("open test failed");
|
|
|
|
/* save result data */
|
|
for (i = 0; i < OPEN_SHORT_TEST_RESULT_LEN ; i++) {
|
|
cd->test_data.open_short_test_trx_result[i] = buf[3 + i];
|
|
}
|
|
|
|
cd->test_data.info[SEC_OPEN_TEST].data[0] = SEC_TEST_NG;
|
|
/* DRV[0~55] total 7 bytes */
|
|
for (i = 0; i < DRV_CHAN_BYTES; i++) {
|
|
if (buf[i + 3])
|
|
ts_raw_info("DRV[%d~%d] open circuit, ret=0x%X", i * 8, i * 8 + 7, buf[i + 3]);
|
|
}
|
|
/* SEN[0~79] total 10 bytes */
|
|
for (i = 0; i < SEN_CHAN_BYTES; i++) {
|
|
if (buf[i + 10])
|
|
ts_raw_info("SEN[%d~%d] open circuit, ret=0x%X", i * 8, i * 8 + 7, buf[i + 10]);
|
|
}
|
|
ret = -EINVAL;
|
|
}
|
|
cd->test_data.info[SEC_OPEN_TEST].isFinished = true;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int goodix_brld_open_test(struct goodix_ts_core *cd)
|
|
{
|
|
int ret;
|
|
int retry = 20;
|
|
int i;
|
|
struct goodix_ts_cmd cmd;
|
|
unsigned char buf[24];
|
|
unsigned int result_addr = cd->production_test_addr;
|
|
|
|
cmd.cmd = 0x63;
|
|
cmd.len = 4;
|
|
ret = cd->hw_ops->send_cmd(cd, &cmd);
|
|
if (ret < 0) {
|
|
ts_err("send open test cmd failed");
|
|
return ret;
|
|
}
|
|
sec_delay(200);
|
|
|
|
while (retry--) {
|
|
ret = cd->hw_ops->read(cd, result_addr, buf, (int)sizeof(buf));
|
|
if (ret < 0) {
|
|
ts_err("read open test result failed");
|
|
return ret;
|
|
}
|
|
if (buf[0] == 0xCC && buf[1] == 0xCC)
|
|
break;
|
|
sec_delay(50);
|
|
}
|
|
if (retry < 0) {
|
|
ts_err("open test not ready, status = %x%x", buf[0], buf[1]);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = checksum_cmp(buf, sizeof(buf), CHECKSUM_MODE_U8_LE);
|
|
if (ret) {
|
|
ts_err("open test result checksum error");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (buf[2] == 0) {
|
|
ts_raw_info("open test pass");
|
|
ret = 0;
|
|
cd->test_data.info[SEC_OPEN_TEST].data[0] = SEC_TEST_OK;
|
|
} else {
|
|
ts_raw_info("open test failed");
|
|
|
|
/* save result data */
|
|
for (i = 0; i < OPEN_SHORT_TEST_RESULT_LEN ; i++) {
|
|
cd->test_data.open_short_test_trx_result[i] = buf[3 + i];
|
|
}
|
|
|
|
cd->test_data.info[SEC_OPEN_TEST].data[0] = SEC_TEST_NG;
|
|
/* DRV[0~55] total 7 bytes */
|
|
for (i = 0; i < DRV_CHAN_BYTES; i++) {
|
|
if (buf[i + 3])
|
|
ts_raw_info("DRV[%d~%d] open circuit, ret=0x%X", i * 8, i * 8 + 7, buf[i + 3]);
|
|
}
|
|
/* SEN[0~79] total 10 bytes */
|
|
for (i = 0; i < SEN_CHAN_BYTES; i++) {
|
|
if (buf[i + 10])
|
|
ts_raw_info("SEN[%d~%d] open circuit, ret=0x%X", i * 8, i * 8 + 7, buf[i + 10]);
|
|
}
|
|
ret = -EINVAL;
|
|
}
|
|
|
|
cd->test_data.info[SEC_OPEN_TEST].isFinished = true;
|
|
|
|
return ret;
|
|
}
|
|
|
|
int goodix_open_test(struct goodix_ts_core *cd)
|
|
{
|
|
int ret = 0;
|
|
int retry = 2;
|
|
struct goodix_ts_cmd temp_cmd;
|
|
|
|
cd->test_data.info[SEC_OPEN_TEST].item_name = OPEN_TEST_ITEM;
|
|
|
|
restart:
|
|
/* switch test config */
|
|
temp_cmd.len = 5;
|
|
temp_cmd.cmd = cd->switch_cfg_cmd;
|
|
temp_cmd.data[0] = 1;
|
|
ret = cd->hw_ops->send_cmd(cd, &temp_cmd);
|
|
if (ret < 0) {
|
|
ts_err("switch test cfg failed, exit");
|
|
return ret;
|
|
}
|
|
sec_delay(20);
|
|
|
|
if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
|
|
ret = goodix_brl_open_test(cd);
|
|
} else if (cd->bus->ic_type == IC_TYPE_BERLIN_D) {
|
|
ret = goodix_brld_open_test(cd);
|
|
} else {
|
|
ret = goodix_brl_open_test(cd);
|
|
ts_err("abnormal tsp ic type(%d)", cd->bus->ic_type);
|
|
}
|
|
|
|
if (ret && retry--) {
|
|
ts_info("open test failed, retry[%d]", 2 - retry);
|
|
cd->hw_ops->reset(cd, 200);
|
|
goto restart;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
static int goodix_brl_sram_test(struct goodix_ts_core *cd)
|
|
{
|
|
int ret;
|
|
int retry;
|
|
struct goodix_ts_cmd cmd;
|
|
u8 buf[2];
|
|
|
|
cmd.cmd = 0x87;
|
|
cmd.len = 4;
|
|
ret = cd->hw_ops->send_cmd(cd, &cmd);
|
|
if (ret < 0) {
|
|
ts_err("send SRAM test cmd failed");
|
|
return ret;
|
|
}
|
|
sec_delay(50);
|
|
|
|
/* FW 1 test */
|
|
ret = cd->hw_ops->read(cd, 0xD8D0, buf, 1);
|
|
if (ret < 0 || buf[0] != 0xAA) {
|
|
ts_err("FW1 status[0x%02x] != 0xAA", buf[0]);
|
|
return -EINVAL;
|
|
}
|
|
|
|
buf[0] = 0;
|
|
cd->hw_ops->write(cd, 0xD8D0, buf, 1);
|
|
|
|
retry = 20;
|
|
while (retry--) {
|
|
sec_delay(50);
|
|
ret = cd->hw_ops->read(cd, 0xD8D0, buf, 1);
|
|
if (!ret && buf[0] == 0xBB)
|
|
break;
|
|
}
|
|
if (retry < 0) {
|
|
ts_err("FW1 test not ready, status = 0x%02x", buf[0]);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* FW 2 test */
|
|
buf[0] = 0;
|
|
cd->hw_ops->write(cd, 0xD8D0, buf, 1);
|
|
|
|
sec_delay(50);
|
|
ret = cd->hw_ops->read(cd, 0xD8D0, buf, 1);
|
|
if (ret < 0 || buf[0] != 0xAA) {
|
|
ts_err("FW2 status[0x%02x] != 0xAA", buf[0]);
|
|
return -EINVAL;
|
|
}
|
|
|
|
buf[0] = 0;
|
|
cd->hw_ops->write(cd, 0xD8D0, buf, 1);
|
|
|
|
retry = 20;
|
|
while (retry--) {
|
|
sec_delay(50);
|
|
ret = cd->hw_ops->read(cd, 0xD8D0, buf, 2);
|
|
if (!ret && buf[0] == 0x66)
|
|
break;
|
|
}
|
|
if (retry < 0) {
|
|
ts_err("FW2 test not ready, status = 0x%02x", buf[0]);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (buf[1] == 0) {
|
|
ts_raw_info("SRAM test OK");
|
|
ret = 0;
|
|
cd->test_data.info[SEC_SRAM_TEST].data[0] = SEC_TEST_OK;
|
|
} else {
|
|
ts_raw_info("SRAM test NG");
|
|
ret = -EINVAL;
|
|
cd->test_data.info[SEC_SRAM_TEST].data[0] = SEC_TEST_NG;
|
|
}
|
|
cd->test_data.info[SEC_SRAM_TEST].isFinished = true;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int goodix_brld_sram_test(struct goodix_ts_core *cd)
|
|
{
|
|
int ret;
|
|
int retry = 20;
|
|
struct goodix_ts_cmd cmd;
|
|
u8 buf[2];
|
|
|
|
cmd.cmd = 0x61;
|
|
cmd.len = 4;
|
|
ret = cd->hw_ops->send_cmd(cd, &cmd);
|
|
if (ret < 0) {
|
|
ts_err("send SRAM test cmd failed");
|
|
return ret;
|
|
}
|
|
sec_delay(50);
|
|
|
|
while (retry--) {
|
|
ret = cd->hw_ops->read(cd, 0xD8D0, buf, 2);
|
|
if (buf[0] == 0xAA)
|
|
break;
|
|
sec_delay(40);
|
|
}
|
|
|
|
if (retry < 0) {
|
|
ts_err("sram test not ready, status = 0x%02x", buf[0]);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (buf[1] == 0) {
|
|
ts_raw_info("SRAM test OK");
|
|
ret = 0;
|
|
cd->test_data.info[SEC_SRAM_TEST].data[0] = SEC_TEST_OK;
|
|
} else {
|
|
ts_raw_info("SRAM test NG");
|
|
ret = -EINVAL;
|
|
cd->test_data.info[SEC_SRAM_TEST].data[0] = SEC_TEST_NG;
|
|
}
|
|
cd->test_data.info[SEC_SRAM_TEST].isFinished = true;
|
|
|
|
return ret;
|
|
}
|
|
|
|
int goodix_sram_test(struct goodix_ts_core *cd)
|
|
{
|
|
int ret;
|
|
int retry = 2;
|
|
|
|
cd->test_data.info[SEC_SRAM_TEST].item_name = SRAM_TEST_ITEM;
|
|
|
|
restart:
|
|
if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
|
|
ret = goodix_brl_sram_test(cd);
|
|
} else if (cd->bus->ic_type == IC_TYPE_BERLIN_D) {
|
|
ret = goodix_brld_sram_test(cd);
|
|
} else {
|
|
ret = goodix_brl_sram_test(cd);
|
|
ts_err("abnormal tsp ic type(%d)", cd->bus->ic_type);
|
|
}
|
|
|
|
if (ret && retry--) {
|
|
ts_info("sram test failed, retry[%d]", 2 - retry);
|
|
cd->hw_ops->reset(cd, 200);
|
|
goto restart;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
#define SHORT_TEST_FINISH_FLAG 0x88
|
|
static int goodix_brl_short_test(struct goodix_ts_core *cd)
|
|
{
|
|
int ret = 0;
|
|
int retry;
|
|
u16 test_time;
|
|
u8 status;
|
|
unsigned int time_reg = cd->short_test_time_reg;
|
|
unsigned int result_reg = cd->short_test_status_reg;
|
|
|
|
ret = goodix_brl_short_test_prepare(cd);
|
|
if (ret < 0) {
|
|
ts_err("Failed enter short test mode");
|
|
return ret;
|
|
}
|
|
|
|
sec_delay(300);
|
|
|
|
/* get short test time */
|
|
ret = cd->hw_ops->read(cd, time_reg, (u8 *)&test_time, 2);
|
|
if (ret < 0) {
|
|
ts_err("Failed to get test_time, default %dms", DEFAULT_TEST_TIME_MS);
|
|
test_time = DEFAULT_TEST_TIME_MS;
|
|
} else {
|
|
if (test_time > MAX_TEST_TIME_MS) {
|
|
ts_info("test time too long %d > %d",
|
|
test_time, MAX_TEST_TIME_MS);
|
|
test_time = MAX_TEST_TIME_MS;
|
|
}
|
|
/* if predict time is 0, means fast test pass */
|
|
ts_info("get test time %dms", test_time);
|
|
}
|
|
|
|
status = 0;
|
|
cd->hw_ops->write(cd, SHORT_TEST_RUN_REG, &status, 1);
|
|
|
|
/* wait short test finish */
|
|
if (test_time > 0)
|
|
sec_delay(test_time);
|
|
|
|
retry = 50;
|
|
while (retry--) {
|
|
ret = cd->hw_ops->read(cd, result_reg, &status, 1);
|
|
if (!ret && status == SHORT_TEST_FINISH_FLAG)
|
|
break;
|
|
sec_delay(50);
|
|
}
|
|
if (retry < 0) {
|
|
ts_err("short test failed, status:0x%02x", status);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* start analysis short result */
|
|
ts_info("short_test finished, start analysis");
|
|
ret = goodix_short_analysis(cd);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int goodix_short_test(struct goodix_ts_core *cd)
|
|
{
|
|
int ret;
|
|
int retry = 2;
|
|
|
|
cd->test_data.info[SEC_SHORT_TEST].item_name = SHORT_TEST_ITEM;
|
|
|
|
restart:
|
|
ret = goodix_brl_short_test(cd);
|
|
if (ret && retry--) {
|
|
ts_info("short test failed, retry[%d]", 2 - retry);
|
|
cd->hw_ops->reset(cd, 200);
|
|
goto restart;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
#define GOODIX_TOUCH_EVENT 0x80
|
|
#define DISCARD_FRAMES_NUM 3
|
|
int goodix_cache_rawdata(struct goodix_ts_core *cd, int test_type, u8 freq)
|
|
{
|
|
int ret;
|
|
int retry = 20;
|
|
struct goodix_ts_cmd temp_cmd;
|
|
unsigned int freq_cmd = cd->switch_freq_cmd;
|
|
uint32_t flag_addr;
|
|
uint32_t raw_addr;
|
|
uint32_t diff_addr;
|
|
uint32_t selfraw_addr;
|
|
uint32_t selfdiff_addr;
|
|
int tx = 0;
|
|
int rx = 0;
|
|
u8 val;
|
|
int i;
|
|
|
|
if (test_type == RAWDATA_TEST_TYPE_MUTUAL_RAW || test_type == RAWDATA_TEST_TYPE_MUTUAL_DIFF) {
|
|
memset(&temp_cmd, 0x00, sizeof(struct goodix_ts_cmd));
|
|
/* switch test config */
|
|
temp_cmd.len = 5;
|
|
temp_cmd.cmd = cd->switch_cfg_cmd;
|
|
temp_cmd.data[0] = 1;
|
|
ret = cd->hw_ops->send_cmd(cd, &temp_cmd);
|
|
if (ret < 0) {
|
|
ts_err("switch test config failed");
|
|
return ret;
|
|
}
|
|
sec_delay(20);
|
|
}
|
|
|
|
memset(&temp_cmd, 0x00, sizeof(struct goodix_ts_cmd));
|
|
|
|
tx = cd->ic_info.parm.drv_num;
|
|
rx = cd->ic_info.parm.sen_num;
|
|
if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
|
|
flag_addr = cd->ic_info.misc.touch_data_addr;
|
|
raw_addr = cd->ic_info.misc.mutual_rawdata_addr;
|
|
diff_addr = cd->ic_info.misc.mutual_diffdata_addr;
|
|
selfraw_addr = cd->ic_info.misc.self_rawdata_addr;
|
|
selfdiff_addr = cd->ic_info.misc.self_diffdata_addr;
|
|
temp_cmd.cmd = 0x90;
|
|
temp_cmd.data[0] = 0x84;
|
|
temp_cmd.len = 5;
|
|
} else if (cd->bus->ic_type == IC_TYPE_BERLIN_D) {
|
|
flag_addr = cd->ic_info.misc.frame_data_addr;
|
|
raw_addr = 0x104B2;
|
|
selfraw_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;
|
|
diff_addr = raw_addr;
|
|
selfdiff_addr = selfraw_addr;
|
|
if (test_type == RAWDATA_TEST_TYPE_SELF_RAW || test_type == RAWDATA_TEST_TYPE_MUTUAL_RAW) {
|
|
temp_cmd.cmd = 0x90;
|
|
temp_cmd.data[0] = 0x84;
|
|
temp_cmd.len = 5;
|
|
} else {
|
|
temp_cmd.cmd = 0x90;
|
|
temp_cmd.data[0] = 0x82;
|
|
temp_cmd.len = 5;
|
|
}
|
|
} else {
|
|
ts_err("abnormal tsp ic type(%d)", cd->bus->ic_type);
|
|
flag_addr = cd->ic_info.misc.touch_data_addr;
|
|
raw_addr = cd->ic_info.misc.mutual_rawdata_addr;
|
|
diff_addr = cd->ic_info.misc.mutual_diffdata_addr;
|
|
selfraw_addr = cd->ic_info.misc.self_rawdata_addr;
|
|
selfdiff_addr = cd->ic_info.misc.self_diffdata_addr;
|
|
temp_cmd.cmd = 0x90;
|
|
temp_cmd.data[0] = 0x84;
|
|
temp_cmd.len = 5;
|
|
}
|
|
|
|
|
|
ret = cd->hw_ops->send_cmd(cd, &temp_cmd);
|
|
if (ret < 0) {
|
|
ts_err("switch rawdata mode failed, exit!");
|
|
return ret;
|
|
}
|
|
|
|
if (freq == FREQ_HIGH) {
|
|
temp_cmd.len = 6;
|
|
temp_cmd.cmd = freq_cmd;
|
|
temp_cmd.data[0] = 0x36;
|
|
temp_cmd.data[1] = 0x13;
|
|
cd->hw_ops->send_cmd(cd, &temp_cmd);
|
|
sec_delay(50);
|
|
} else if (freq == FREQ_LOW) {
|
|
temp_cmd.len = 6;
|
|
temp_cmd.cmd = freq_cmd;
|
|
temp_cmd.data[0] = 0x67;
|
|
temp_cmd.data[1] = 0x06;
|
|
cd->hw_ops->send_cmd(cd, &temp_cmd);
|
|
sec_delay(50);
|
|
}
|
|
|
|
/* discard the first few frames */
|
|
for (i = 0; i < DISCARD_FRAMES_NUM; i++) {
|
|
sec_delay(20);
|
|
val = 0;
|
|
ret = ts_test_write(cd, flag_addr, &val, 1);
|
|
if (ret < 0) {
|
|
ts_err("clean touch event failed, exit!");
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
while (retry--) {
|
|
sec_delay(5);
|
|
ret = ts_test_read(cd, flag_addr, &val, 1);
|
|
if (!ret && (val & GOODIX_TOUCH_EVENT))
|
|
break;
|
|
}
|
|
if (retry < 0) {
|
|
ts_err("rawdata is not ready val:0x%02x, exit!", val);
|
|
ret = -EIO;
|
|
return ret;
|
|
}
|
|
|
|
if (test_type == RAWDATA_TEST_TYPE_MUTUAL_RAW) {
|
|
if (freq == FREQ_HIGH) {
|
|
cd->test_data.high_freq_rawdata.size = tx * rx;
|
|
ret = ts_test_read(cd, raw_addr, (u8 *)cd->test_data.high_freq_rawdata.data,
|
|
cd->test_data.high_freq_rawdata.size * 2);
|
|
goodix_rotate_abcd2cbad(tx, rx, cd->test_data.high_freq_rawdata.data);
|
|
goodix_data_statistics(cd->test_data.high_freq_rawdata.data, cd->test_data.high_freq_rawdata.size,
|
|
&cd->test_data.high_freq_rawdata.max, &cd->test_data.high_freq_rawdata.min);
|
|
cd->test_data.high_freq_rawdata.delta = cd->test_data.high_freq_rawdata.max - cd->test_data.high_freq_rawdata.min;
|
|
} else if (freq == FREQ_LOW) {
|
|
cd->test_data.low_freq_rawdata.size = tx * rx;
|
|
ret = ts_test_read(cd, raw_addr, (u8 *)cd->test_data.low_freq_rawdata.data,
|
|
cd->test_data.low_freq_rawdata.size * 2);
|
|
goodix_rotate_abcd2cbad(tx, rx, cd->test_data.low_freq_rawdata.data);
|
|
goodix_data_statistics(cd->test_data.low_freq_rawdata.data, cd->test_data.low_freq_rawdata.size,
|
|
&cd->test_data.low_freq_rawdata.max, &cd->test_data.low_freq_rawdata.min);
|
|
cd->test_data.low_freq_rawdata.delta = cd->test_data.low_freq_rawdata.max - cd->test_data.low_freq_rawdata.min;
|
|
} else {
|
|
/* read raw data */
|
|
cd->test_data.rawdata.size = tx * rx;
|
|
ret = ts_test_read(cd, raw_addr, (u8 *)cd->test_data.rawdata.data,
|
|
cd->test_data.rawdata.size * 2);
|
|
if (ret < 0) {
|
|
ts_err("obtian rawdata failed, exit!");
|
|
return ret;
|
|
}
|
|
goodix_rotate_abcd2cbad(tx, rx, cd->test_data.rawdata.data);
|
|
goodix_data_statistics(cd->test_data.rawdata.data, cd->test_data.rawdata.size,
|
|
&cd->test_data.rawdata.max, &cd->test_data.rawdata.min);
|
|
cd->test_data.rawdata.delta = cd->test_data.rawdata.max - cd->test_data.rawdata.min;
|
|
}
|
|
} else if (test_type == RAWDATA_TEST_TYPE_MUTUAL_DIFF) {
|
|
/* read diff data */
|
|
cd->test_data.diffdata.size = tx * rx;
|
|
ret = ts_test_read(cd, diff_addr, (u8 *)cd->test_data.diffdata.data,
|
|
cd->test_data.diffdata.size * 2);
|
|
if (ret < 0) {
|
|
ts_err("obtian diffdata failed, exit!");
|
|
return ret;
|
|
}
|
|
goodix_rotate_abcd2cbad(tx, rx, cd->test_data.diffdata.data);
|
|
goodix_data_statistics(cd->test_data.diffdata.data, cd->test_data.diffdata.size,
|
|
&cd->test_data.diffdata.max, &cd->test_data.diffdata.min);
|
|
} else if (test_type == RAWDATA_TEST_TYPE_SELF_RAW) {
|
|
/* read selfraw */
|
|
cd->test_data.selfraw.size = tx + rx;
|
|
ret = ts_test_read(cd, selfraw_addr, (u8 *)cd->test_data.selfraw.data,
|
|
cd->test_data.selfraw.size * 2);
|
|
if (ret < 0) {
|
|
ts_err("obtian selfraw data failed, exit!");
|
|
return ret;
|
|
}
|
|
goodix_data_statistics(cd->test_data.selfraw.data, tx,
|
|
&cd->test_data.selfraw.tx_max, &cd->test_data.selfraw.tx_min);
|
|
goodix_data_statistics(cd->test_data.selfraw.data + tx, rx,
|
|
&cd->test_data.selfraw.rx_max, &cd->test_data.selfraw.rx_min);
|
|
} else if (test_type == RAWDATA_TEST_TYPE_SELF_DIFF) {
|
|
/* read selfdiff */
|
|
cd->test_data.selfdiff.size = tx + rx;
|
|
ret = ts_test_read(cd, selfdiff_addr, (u8 *)cd->test_data.selfdiff.data,
|
|
cd->test_data.selfdiff.size * 2);
|
|
if (ret < 0) {
|
|
ts_err("obtian selfdiff data failed, exit!");
|
|
return ret;
|
|
}
|
|
goodix_data_statistics(cd->test_data.selfdiff.data, cd->test_data.selfdiff.size,
|
|
&cd->test_data.selfdiff.tx_max, &cd->test_data.selfdiff.tx_min);
|
|
} else {
|
|
ts_err("invalid test_type %d", test_type);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ts_raw_info("test_type:%d, done", test_type);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int goodix_read_realtime(struct goodix_ts_core *cd, int test_type)
|
|
{
|
|
int ret;
|
|
int retry = 20;
|
|
struct goodix_ts_cmd temp_cmd;
|
|
uint32_t flag_addr;
|
|
uint32_t raw_addr;
|
|
uint32_t diff_addr;
|
|
int tx = cd->ic_info.parm.drv_num;
|
|
int rx = cd->ic_info.parm.sen_num;
|
|
u8 val;
|
|
|
|
if (test_type == RAWDATA_TEST_TYPE_MUTUAL_RAW) {
|
|
/* switch test config */
|
|
temp_cmd.len = 5;
|
|
temp_cmd.cmd = cd->switch_cfg_cmd;
|
|
temp_cmd.data[0] = 1;
|
|
ret = cd->hw_ops->send_cmd(cd, &temp_cmd);
|
|
if (ret < 0) {
|
|
ts_err("switch test config failed");
|
|
return ret;
|
|
}
|
|
sec_delay(20);
|
|
}
|
|
|
|
if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
|
|
flag_addr = cd->ic_info.misc.touch_data_addr;
|
|
raw_addr = cd->ic_info.misc.mutual_rawdata_addr;
|
|
diff_addr = cd->ic_info.misc.mutual_diffdata_addr;
|
|
temp_cmd.cmd = 0x01;
|
|
temp_cmd.len = 4;
|
|
} else {
|
|
flag_addr = cd->ic_info.misc.frame_data_addr;
|
|
raw_addr = 0x104B2;
|
|
diff_addr = raw_addr;
|
|
if (test_type == RAWDATA_TEST_TYPE_MUTUAL_RAW) {
|
|
temp_cmd.cmd = 0x90;
|
|
temp_cmd.data[0] = 0x81;
|
|
temp_cmd.len = 5;
|
|
} else {
|
|
temp_cmd.cmd = 0x90;
|
|
temp_cmd.data[0] = 0x82;
|
|
temp_cmd.len = 5;
|
|
}
|
|
}
|
|
ret = cd->hw_ops->send_cmd(cd, &temp_cmd);
|
|
if (ret < 0) {
|
|
ts_err("switch rawdata mode failed, exit!");
|
|
goto exit;
|
|
}
|
|
|
|
val = 0;
|
|
ts_test_write(cd, flag_addr, &val, 1);
|
|
|
|
while (retry--) {
|
|
sec_delay(5);
|
|
ret = ts_test_read(cd, flag_addr, &val, 1);
|
|
if (!ret && (val & GOODIX_TOUCH_EVENT))
|
|
break;
|
|
}
|
|
if (retry < 0) {
|
|
ts_err("rawdata is not ready val:0x%02x, exit!", val);
|
|
ret = -EIO;
|
|
goto exit;
|
|
}
|
|
|
|
if (test_type == RAWDATA_TEST_TYPE_MUTUAL_RAW) {
|
|
memset(cd->test_data.rawdata.data, 0, sizeof(cd->test_data.rawdata.data));
|
|
cd->test_data.rawdata.size = tx * rx;
|
|
ts_test_read(cd, raw_addr, (u8 *)cd->test_data.rawdata.data,
|
|
cd->test_data.rawdata.size * 2);
|
|
goodix_rotate_abcd2cbad(tx, rx, cd->test_data.rawdata.data);
|
|
} else if (test_type == RAWDATA_TEST_TYPE_MUTUAL_DIFF) {
|
|
memset(cd->test_data.diffdata.data, 0, sizeof(cd->test_data.diffdata.data));
|
|
cd->test_data.diffdata.size = tx * rx;
|
|
ts_test_read(cd, diff_addr, (u8 *)cd->test_data.diffdata.data,
|
|
cd->test_data.diffdata.size * 2);
|
|
goodix_rotate_abcd2cbad(tx, rx, cd->test_data.diffdata.data);
|
|
} else {
|
|
ts_err("invalid test_type %d", test_type);
|
|
ret = -EINVAL;
|
|
}
|
|
|
|
val = 0;
|
|
ts_test_write(cd, flag_addr, &val, 1);
|
|
|
|
exit:
|
|
if (cd->bus->ic_type == IC_TYPE_BERLIN_B) {
|
|
temp_cmd.len = 4;
|
|
temp_cmd.cmd = 0x00;
|
|
} else {
|
|
temp_cmd.len = 5;
|
|
temp_cmd.cmd = 0x90;
|
|
temp_cmd.data[0] = 0;
|
|
}
|
|
cd->hw_ops->send_cmd(cd, &temp_cmd);
|
|
|
|
if (test_type == RAWDATA_TEST_TYPE_MUTUAL_RAW) {
|
|
temp_cmd.len = 5;
|
|
temp_cmd.cmd = cd->switch_cfg_cmd;
|
|
temp_cmd.data[0] = 0;
|
|
cd->hw_ops->send_cmd(cd, &temp_cmd);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int goodix_snr_test(struct goodix_ts_core *cd, int type, int frames)
|
|
{
|
|
int ret;
|
|
int retry = 50;
|
|
struct goodix_ts_cmd temp_cmd;
|
|
unsigned char temp_buf[58];
|
|
int i;
|
|
unsigned char snr_cmd = cd->snr_cmd;
|
|
unsigned int snr_addr = cd->production_test_addr;
|
|
|
|
if (type == SNR_TEST_NON_TOUCH) {
|
|
ts_info("run_snr_non_touched, %d", frames);
|
|
temp_cmd.len = 7;
|
|
temp_cmd.cmd = snr_cmd;
|
|
temp_cmd.data[0] = 0x01;
|
|
temp_cmd.data[1] = (u8)frames;
|
|
temp_cmd.data[2] = (u8)(frames >> 8);
|
|
memset(cd->test_data.snr_result, 0, sizeof(cd->test_data.snr_result));
|
|
} else if (type == SNR_TEST_TOUCH) {
|
|
ts_info("run_snr_touched, %d", frames);
|
|
temp_cmd.len = 7;
|
|
temp_cmd.cmd = snr_cmd;
|
|
temp_cmd.data[0] = 0x02;
|
|
temp_cmd.data[1] = (u8)frames;
|
|
temp_cmd.data[2] = (u8)(frames >> 8);
|
|
} else {
|
|
ts_err("abnormal type(%d)", type);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = cd->hw_ops->send_cmd(cd, &temp_cmd);
|
|
if (ret < 0) {
|
|
ts_err("send snr_test cmd failed");
|
|
return ret;
|
|
}
|
|
|
|
sec_delay(frames * 10);
|
|
|
|
while (retry--) {
|
|
sec_delay(100);
|
|
ret = cd->hw_ops->read(cd, snr_addr, temp_buf, 2);
|
|
if (ret < 0) {
|
|
ts_err("read snr status failed");
|
|
return ret;
|
|
}
|
|
if (type == SNR_TEST_NON_TOUCH) {
|
|
if (temp_buf[0] == 0xAA && temp_buf[1] == 0xAA)
|
|
break;
|
|
} else if (type == SNR_TEST_TOUCH) {
|
|
if (temp_buf[0] == 0xBB && temp_buf[1] == 0xBB)
|
|
break;
|
|
}
|
|
}
|
|
if (retry < 0) {
|
|
ts_err("can't read valid snr status:%x%x", temp_buf[0], temp_buf[1]);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (type == SNR_TEST_NON_TOUCH) {
|
|
ts_info("run_snr_non_touched, frames(%d): OK", frames);
|
|
return 0;
|
|
|
|
} else if (type == SNR_TEST_TOUCH) {
|
|
|
|
ret = cd->hw_ops->read(cd, snr_addr, temp_buf, sizeof(temp_buf));
|
|
if (ret < 0) {
|
|
ts_err("read snr touched data failed");
|
|
return ret;
|
|
}
|
|
|
|
if (checksum_cmp(temp_buf + 2, sizeof(temp_buf) - 2, CHECKSUM_MODE_U8_LE)) {
|
|
ts_err("snr touched data checksum error");
|
|
ts_err("data:%*ph", (int)sizeof(temp_buf) - 2, temp_buf + 2);
|
|
return -EINVAL;
|
|
}
|
|
|
|
for (i = 0; i < 9; i++) {
|
|
cd->test_data.snr_result[i * 3] = (s16)le16_to_cpup((__le16 *)&temp_buf[2 + i * 6]);
|
|
cd->test_data.snr_result[i * 3 + 1] = (s16)le16_to_cpup((__le16 *)&temp_buf[4 + i * 6]);
|
|
cd->test_data.snr_result[i * 3 + 2] = (s16)le16_to_cpup((__le16 *)&temp_buf[6 + i * 6]);
|
|
ts_raw_info("run_snr_touched, frame(%d) #%d: avg:%d snr1:%d snr2:%d",
|
|
frames, i, cd->test_data.snr_result[i * 3],
|
|
cd->test_data.snr_result[i * 3 + 1], cd->test_data.snr_result[i * 3 + 2]);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
ts_err("abnormal type(%d)", type);
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int goodix_auto_test(struct goodix_ts_core *cd)
|
|
{
|
|
int i = 0;
|
|
|
|
/* disable irq */
|
|
cd->hw_ops->irq_enable(cd, false);
|
|
|
|
memset(&cd->test_data, 0, sizeof(cd->test_data));
|
|
|
|
for (i = RAWDATA_TEST_TYPE_MUTUAL_RAW; i <= RAWDATA_TEST_TYPE_SELF_DIFF; i++) {
|
|
/* cache rawdata */
|
|
goodix_cache_rawdata(cd, i, FREQ_NORMAL);
|
|
}
|
|
cd->hw_ops->reset(cd, 100);
|
|
/* jitter test */
|
|
goodix_jitter_test(cd, JITTER_100_FRAMES);
|
|
goodix_jitter_test(cd, JITTER_1000_FRAMES);
|
|
/* open test */
|
|
goodix_open_test(cd);
|
|
/* SRAM test */
|
|
goodix_sram_test(cd);
|
|
cd->hw_ops->reset(cd, 100);
|
|
/* short test */
|
|
goodix_short_test(cd);
|
|
|
|
/* reset IC */
|
|
cd->hw_ops->reset(cd, 100);
|
|
cd->hw_ops->irq_enable(cd, true);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int rawdata_proc_show(struct seq_file *m, void *v)
|
|
{
|
|
struct goodix_ts_core *cd;
|
|
int tx = 0;
|
|
int rx = 0;
|
|
int i;
|
|
|
|
if (!m || !v) {
|
|
ts_err("rawdata_proc_show, input null ptr");
|
|
return -EIO;
|
|
}
|
|
|
|
cd = m->private;
|
|
if (!cd) {
|
|
ts_err("can't get core data");
|
|
return -EIO;
|
|
}
|
|
|
|
goodix_auto_test(cd);
|
|
|
|
tx = cd->ic_info.parm.drv_num;
|
|
rx = cd->ic_info.parm.sen_num;
|
|
|
|
seq_printf(m, "TX:%d RX:%d\n", tx, rx);
|
|
seq_printf(m, "mutual_rawdata[%d, %d, %d]:\n",
|
|
cd->test_data.rawdata.max, cd->test_data.rawdata.min, cd->test_data.rawdata.delta);
|
|
for (i = 0; i < cd->test_data.rawdata.size; i++) {
|
|
seq_printf(m, "%d,", cd->test_data.rawdata.data[i]);
|
|
if ((i + 1) % tx == 0)
|
|
seq_printf(m, "\n");
|
|
}
|
|
|
|
/* print high freq rawdata */
|
|
seq_printf(m, "high_freq_rawdata[%d, %d, %d]:\n",
|
|
cd->test_data.high_freq_rawdata.max, cd->test_data.high_freq_rawdata.min, cd->test_data.high_freq_rawdata.delta);
|
|
for (i = 0; i < cd->test_data.high_freq_rawdata.size; i++) {
|
|
seq_printf(m, "%d,", cd->test_data.high_freq_rawdata.data[i]);
|
|
if ((i + 1) % tx == 0)
|
|
seq_printf(m, "\n");
|
|
}
|
|
|
|
/* print low freq rawdata */
|
|
seq_printf(m, "low_freq_rawdata[%d, %d, %d]:\n",
|
|
cd->test_data.low_freq_rawdata.max, cd->test_data.low_freq_rawdata.min, cd->test_data.low_freq_rawdata.delta);
|
|
for (i = 0; i < cd->test_data.low_freq_rawdata.size; i++) {
|
|
seq_printf(m, "%d,", cd->test_data.low_freq_rawdata.data[i]);
|
|
if ((i + 1) % tx == 0)
|
|
seq_printf(m, "\n");
|
|
}
|
|
|
|
seq_printf(m, "mutual_diffdata[%d, %d]:\n",
|
|
cd->test_data.diffdata.max, cd->test_data.diffdata.min);
|
|
for (i = 0; i < cd->test_data.diffdata.size; i++) {
|
|
seq_printf(m, "%3d,", cd->test_data.diffdata.data[i]);
|
|
if ((i + 1) % tx == 0)
|
|
seq_printf(m, "\n");
|
|
}
|
|
|
|
seq_printf(m, "self_rawdata_tx[%d, %d]:\n",
|
|
cd->test_data.selfraw.tx_max, cd->test_data.selfraw.tx_min);
|
|
for (i = 0; i < tx; i++)
|
|
seq_printf(m, "%d,", cd->test_data.selfraw.data[i]);
|
|
seq_printf(m, "\nself_rawdata_rx[%d, %d]:\n",
|
|
cd->test_data.selfraw.rx_max, cd->test_data.selfraw.rx_min);
|
|
for (i = tx; i < cd->test_data.selfraw.size; i++)
|
|
seq_printf(m, "%d,", cd->test_data.selfraw.data[i]);
|
|
seq_printf(m, "\n");
|
|
|
|
seq_printf(m, "self_diffdata[%d, %d]:\n",
|
|
cd->test_data.selfdiff.tx_max, cd->test_data.selfdiff.tx_min);
|
|
for (i = 0; i < cd->test_data.selfdiff.size; i++)
|
|
seq_printf(m, "%d,", cd->test_data.selfdiff.data[i]);
|
|
seq_printf(m, "\n");
|
|
|
|
for (i = 0; i < SEC_TEST_MAX_ITEM; i++) {
|
|
if (!cd->test_data.info[i].isFinished)
|
|
continue;
|
|
seq_printf(m, "[%d]%s: ", i, cd->test_data.info[i].item_name);
|
|
if (i == SEC_JITTER1_TEST) {
|
|
seq_printf(m, "mutualDiff[%d %d] ",
|
|
cd->test_data.info[i].data[1], cd->test_data.info[i].data[0]);
|
|
seq_printf(m, "selfDiff[%d %d]\n",
|
|
cd->test_data.info[i].data[3], cd->test_data.info[i].data[2]);
|
|
} else if (i == SEC_JITTER2_TEST) {
|
|
seq_printf(m, "min_matrix[%d %d] ",
|
|
cd->test_data.info[i].data[0], cd->test_data.info[i].data[1]);
|
|
seq_printf(m, "max_matrix[%d %d] ",
|
|
cd->test_data.info[i].data[2], cd->test_data.info[i].data[3]);
|
|
seq_printf(m, "avg_matrix[%d %d]\n",
|
|
cd->test_data.info[i].data[4], cd->test_data.info[i].data[5]);
|
|
} else {
|
|
seq_printf(m, "%s\n",
|
|
cd->test_data.info[i].data[0] == SEC_TEST_OK ? "OK" : "NG");
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int rawdata_proc_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open_size(file, rawdata_proc_show, PDE_DATA(inode), PAGE_SIZE * 10);
|
|
}
|
|
|
|
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 6, 0))
|
|
static const struct proc_ops rawdata_proc_fops = {
|
|
.proc_open = rawdata_proc_open,
|
|
.proc_read = seq_read,
|
|
.proc_lseek = seq_lseek,
|
|
.proc_release = single_release,
|
|
};
|
|
#else
|
|
static const struct file_operations rawdata_proc_fops = {
|
|
.open = rawdata_proc_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
#endif
|
|
|
|
int inspect_module_init(void)
|
|
{
|
|
struct proc_dir_entry *proc_entry;
|
|
|
|
proc_entry = proc_create_data(PROC_NODE_NAME, 0664, NULL,
|
|
&rawdata_proc_fops, goodix_modules.core_data);
|
|
if (!proc_entry)
|
|
ts_err("failed to create proc entry: %s", PROC_NODE_NAME);
|
|
|
|
module_initialized = true;
|
|
ts_info("inspect module init success");
|
|
return 0;
|
|
}
|
|
|
|
void inspect_module_exit(void)
|
|
{
|
|
ts_info("inspect module exit");
|
|
if (!module_initialized)
|
|
return;
|
|
|
|
remove_proc_entry(PROC_NODE_NAME, NULL);
|
|
module_initialized = false;
|
|
}
|
|
|