/*
 *
 * FocalTech TouchScreen driver.
 *
 * Copyright (c) 2012-2018, FocalTech Systems, Ltd., all rights reserved.
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * 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.
 *
 */

/*******************************************************************************
* Included header files
*******************************************************************************/
#include "../focaltech_test.h"

/*******************************************************************************
* Private constant and macro definitions using #define
*******************************************************************************/
#define REG_MS_SELECT           0x26
#define REG_CH_X_MASTER         0x50
#define REG_CH_Y_MASTER         0x51
#define REG_CH_X_SLAVE          0x52
#define REG_CH_Y_SLAVE          0x53
#define REG_FW_INFO_CNT         0x17
#define I2C_ADDR_M              0
#define I2C_ADDR_S              12
#define REG_FW_INFO_ADDR        0x81
#define REG_FW_INFO_LEN         32
#define MAX_ADC_VALUE                   4015
#define FACTORY_NOISE_MODE_REG          0x5E

/*******************************************************************************
* Private enumerations, structures and unions using typedef
*******************************************************************************/
enum M_S_TYPE {
    CHIP_AS_SLAVE = 0,
    CHIP_AS_MASTER = 1,
    SINGLE_CHIP = 3,
};

enum CASCADE_DIRECTION {
    CASCADE_LEFT_RIGHT = 0,
    CASCADE_UP_DOWN    = 1,
};

/*
 * m_s_sel    - master/slave information
 * m_i2c_addr - master ic I2C address
 * s_i2c_addr - slave ic I2C address
 * m_tx       - master IC tx number
 * m_rx       - master IC rx number
 * s_tx       - slave IC tx number
 * s_rx       - slave IC rx number
 */
struct ft8201_info {
    union m_s_sel {
        struct bits {
            u8 type         : 6;
            u8 direction    : 1;
            u8 s0_as_slave  : 1;
        } bits;
        u8 byte_val;
    } m_s_sel;
    u8 m_i2c_addr;
    u8 s_i2c_addr;
    u8 m_tx;
    u8 m_rx;
    u8 s_tx;
    u8 s_rx;
    u8  current_slave_addr;
};

/*******************************************************************************
* Static function prototypes
*******************************************************************************/
static void fts_array_copy(int *dest, const int *src, int len)
{
    int i = 0;

    for (i = 0; i < len; i++) {
        dest[i] = src[i];
    }
}

static void work_as_master(struct ft8201_info *info)
{
    if (fts_data->client->addr != info->m_i2c_addr) {
        FTS_TEST_DBG("change i2c addr to master(0x%x)\n", info->m_i2c_addr);
        fts_data->client->addr = info->m_i2c_addr;
    }
}

static void work_as_slave(struct ft8201_info *info)
{
    if (fts_data->client->addr != info->s_i2c_addr) {
        FTS_TEST_DBG("change i2c addr to slave(0x%x)\n", info->s_i2c_addr);
        fts_data->client->addr = info->s_i2c_addr;
    }
}

static int ft8201_write_reg(struct ft8201_info *info, u8 reg_addr, u8 reg_val)
{
    int ret = 0;

    /* write master reg */
    work_as_master(info);
    ret = fts_test_write_reg(reg_addr, reg_val);
    if (ret) {
        FTS_TEST_SAVE_ERR("write master reg fail\n");
        return ret;
    }

    /* write slave reg */
    work_as_slave(info);
    ret = fts_test_write_reg(reg_addr, reg_val);
    if (ret) {
        FTS_TEST_SAVE_ERR("write slave reg fail\n");
        work_as_master(info);
        return ret;
    }
    work_as_master(info);

    return 0;
}

static void integrate_data(struct ft8201_info *info, int *m_buf, int *s_buf, int *data)
{
    int i = 0;
    int *s0_buf;
    int *s1_buf;
    int s0_ch = 0;
    int s0_tx = 0;
    int s0_rx = 0;
    int s1_ch = 0;
    int s1_rx = 0;
    int row = 0;
    int s0_row = 0;
    int s1_row = 0;

    FTS_TEST_FUNC_ENTER();

    if (false == info->m_s_sel.bits.s0_as_slave) {
        s0_buf = m_buf;
        s0_tx = info->m_tx;
        s0_rx = info->m_rx;
        s0_ch = info->m_tx * info->m_rx;
        s1_buf = s_buf;
        s1_rx = info->s_rx;
        s1_ch = info->s_tx * info->s_rx;
    } else {
        s0_buf = s_buf;
        s0_tx = info->s_tx;
        s0_rx = info->s_rx;
        s0_ch = info->s_tx * info->s_rx;
        s1_buf = m_buf;
        s1_rx = info->m_rx;
        s1_ch = info->m_tx * info->m_rx;
    }

    FTS_TEST_DBG("%d %d %d %d %d", s0_tx, s0_rx, s0_ch, s1_rx, s1_ch);
    if (CASCADE_LEFT_RIGHT == info->m_s_sel.bits.direction) {
        /* cascade direction : left to right */
        for (i = 0; i < s0_tx; i++) {
            row = i * (s0_rx + s1_rx);
            s0_row = i * s0_rx;
            s1_row = i * s1_rx;

            fts_array_copy(data + row, s0_buf + s0_row, s0_rx);
            fts_array_copy(data + row + s0_rx, s1_buf + s1_row, s1_rx);
        }

    } else {
        /* cascade direction : up to down */
        fts_array_copy(data, s0_buf, s0_ch);
        fts_array_copy(data + s0_ch, s1_buf, s1_ch);
    }

    /* key */
    fts_array_copy(data + s0_ch + s1_ch, s0_buf + s0_ch, 6);
    fts_array_copy(data + s0_ch + s1_ch + 6, s1_buf + s1_ch, 6);

    FTS_TEST_FUNC_EXIT();
}

static int check_ic_info_validity(struct ft8201_info *info)
{
    /* IC type */
    if ((info->m_s_sel.bits.type != CHIP_AS_SLAVE)
        && (info->m_s_sel.bits.type != CHIP_AS_MASTER)) {
        FTS_TEST_SAVE_ERR("IC cascade type(%d) fail\n", info->m_s_sel.bits.type);
        return -EINVAL;
    }

    /* I2C addr */
    if ((0 == info->m_i2c_addr) || (0 == info->s_i2c_addr)) {
        FTS_TEST_SAVE_ERR("i2c addr of master(0x%x)/slave(0x%x) fail\n",
                          info->m_i2c_addr, info->s_i2c_addr);
        return -EINVAL;
    }

    /* tx/rx */
    if ((0 == info->m_tx) || (info->m_tx > TX_NUM_MAX)) {
        FTS_TEST_SAVE_ERR("master tx(%d) fail\n", info->m_tx);
        return -EINVAL;
    }

    if ((0 == info->m_rx) || (info->m_rx > TX_NUM_MAX)) {
        FTS_TEST_SAVE_ERR("master rx(%d) fail\n", info->m_rx);
        return -EINVAL;
    }

    if ((0 == info->s_tx) || (info->s_tx > TX_NUM_MAX)) {
        FTS_TEST_SAVE_ERR("slave tx(%d) fail\n", info->s_tx);
        return -EINVAL;
    }

    if ((0 == info->s_rx) || (info->s_rx > TX_NUM_MAX)) {
        FTS_TEST_SAVE_ERR("slave rx(%d) fail\n", info->s_rx);
        return -EINVAL;
    }

    return 0;
}

static int get_chip_information(struct ft8201_info *info)
{
    int ret = 0;
    u8 value[REG_FW_INFO_LEN] = { 0 };
    u8 cmd = 0;

    ret = fts_test_read_reg(REG_MS_SELECT, &value[0]);
    if (ret) {
        FTS_TEST_SAVE_ERR("read m/s select info fail\n");
        return ret;
    }
    info->m_s_sel.byte_val = value[0];

    ret = fts_test_read_reg(REG_CH_X_MASTER, &value[0]);
    if (ret) {
        FTS_TEST_SAVE_ERR("read ch_x_m fail\n");
        return ret;
    }
    info->m_tx = value[0];

    ret = fts_test_read_reg(REG_CH_Y_MASTER, &value[0]);
    if (ret) {
        FTS_TEST_SAVE_ERR("read ch_y_m fail\n");
        return ret;
    }
    info->m_rx = value[0];

    ret = fts_test_read_reg(REG_CH_X_SLAVE, &value[0]);
    if (ret) {
        FTS_TEST_SAVE_ERR("read ch_x_s fail\n");
        return ret;
    }
    info->s_tx = value[0];

    ret = fts_test_read_reg(REG_CH_Y_SLAVE, &value[0]);
    if (ret) {
        FTS_TEST_SAVE_ERR("read ch_y_s fail\n");
        return ret;
    }
    info->s_rx = value[0];

    ret = fts_test_write_reg(REG_FW_INFO_CNT, 0);
    if (ret) {
        FTS_TEST_SAVE_ERR("write fw into cnt fail\n");
        return ret;
    }
    cmd = REG_FW_INFO_ADDR;
    ret = fts_test_read(cmd, &value[0], REG_FW_INFO_LEN);
    if (ret) {
        FTS_TEST_SAVE_ERR("read fw info fail\n");
        return ret;
    }

    if ((value[I2C_ADDR_M] + value[I2C_ADDR_M + 1]) == 0xFF) {
        info->m_i2c_addr = value[I2C_ADDR_M] >> 1;
    }

    if ((value[I2C_ADDR_S] + value[I2C_ADDR_S + 1]) == 0xFF) {
        info->s_i2c_addr = value[I2C_ADDR_S] >> 1;
    }

    FTS_TEST_DBG("%s=%d,%s=%d,%s=%d,%s=0x%x,%s=0x%x,%s=%d,%s=%d,%s=%d,%s=%d\n",
                 "type", info->m_s_sel.bits.type,
                 "direction", info->m_s_sel.bits.direction,
                 "s0_as_slave", info->m_s_sel.bits.s0_as_slave,
                 "m_i2c_addr", info->m_i2c_addr,
                 "s_i2c_addr", info->s_i2c_addr,
                 "m_tx", info->m_tx,
                 "m_rx", info->m_rx,
                 "s_tx", info->s_tx,
                 "s_rx", info->s_rx
                );

    ret = check_ic_info_validity(info);
    if (ret) {
        FTS_TEST_SAVE_ERR("ic information invalid\n");
        return ret;
    }

    return 0;
}

static int ft8201_test_init(struct ft8201_info *info)
{
    int ret = 0;

    /* initialize info */
    memset(info, 0, sizeof(struct ft8201_info));

    /* enter factory mode */
    ret = enter_factory_mode();
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("enter factory mode fail, can't get tx/rx num\n");
        return ret;
    }

    /* get chip info */
    ret = get_chip_information(info);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("get chip information fail\n");
        return ret;
    }

    return 0;
}

static u8 ft8201_chip_clb(struct ft8201_info *info)
{
    int ret = 0;

    FTS_TEST_FUNC_ENTER();
    /* master clb */
    work_as_master(info);
    ret = chip_clb();
    if (ret) {
        FTS_TEST_SAVE_ERR("master clb fail\n");
        return ret;
    }

    /* slave clb */
    work_as_slave(info);
    ret = chip_clb();
    if (ret) {
        FTS_TEST_SAVE_ERR("master clb fail\n");
        work_as_master(info);
        return ret;
    }
    work_as_master(info);

    FTS_TEST_FUNC_EXIT();
    return 0;
}

static int ft8201_get_tx_rx_cb(struct ft8201_info *info, u8 start_node, int read_num, int *read_buffer)
{
    int ret = 0;
    int *buffer_master = NULL;
    int *buffer_slave = NULL;
    int master_tx = info->m_tx;
    int master_rx = info->m_rx;
    int slave_tx = info->s_tx;
    int slave_rx = info->s_rx;

    FTS_TEST_FUNC_ENTER();

    buffer_master = fts_malloc((master_tx + 1) * master_rx * sizeof(int));
    if (NULL == buffer_master) {
        FTS_TEST_SAVE_ERR("%s:master buf malloc fail\n", __func__);
        ret = -ENOMEM;
        goto GET_CB_ERR;
    }

    buffer_slave = fts_malloc((slave_tx + 1) * slave_rx * sizeof(int));
    if (NULL == buffer_slave) {
        FTS_TEST_SAVE_ERR("%s:slave buf malloc fail\n", __func__);
        ret = -ENOMEM;
        goto GET_CB_ERR;
    }

    /* master cb */
    work_as_master(info);
    ret = get_cb_incell(0, master_tx * master_rx  + 6, buffer_master);
    if (ret ) {
        FTS_TEST_SAVE_ERR("master clb fail\n");
        goto GET_CB_ERR;
    }

    /* slave cb */
    work_as_slave(info);
    ret = get_cb_incell(0, slave_tx * slave_rx + 6, buffer_slave);
    if (ret ) {
        FTS_TEST_SAVE_ERR("slave clb fail\n");
        work_as_master(info);
        goto GET_CB_ERR;
    }
    work_as_master(info);

    integrate_data(info, buffer_master, buffer_slave, read_buffer);

GET_CB_ERR:
    fts_free(buffer_master);
    fts_free(buffer_slave);

    FTS_TEST_FUNC_EXIT();
    return ret;
}

static int read_adc_data(u8 retval, int byte_num, int *adc_buf)
{
    int ret = 0;
    int times = 0;
    u8 short_state = 0;

    FTS_TEST_FUNC_ENTER();

    for (times = 0; times < FACTORY_TEST_RETRY; times++) {
        ret = fts_test_read_reg(FACTORY_REG_SHORT_TEST_STATE, &short_state);
        if ((0 == ret) && (retval == short_state))
            break;
        else
            FTS_TEST_DBG("reg%x=%x,retry:%d",
                         FACTORY_REG_SHORT_TEST_STATE, short_state, times);

        sys_delay(FACTORY_TEST_RETRY_DELAY);
    }
    if (times >= FACTORY_TEST_RETRY) {
        FTS_TEST_SAVE_ERR("short test timeout, ADC data not OK\n");
        ret = -EIO;
        goto ADC_ERROR;
    }

    ret = read_mass_data(FACTORY_REG_SHORT_ADDR, byte_num, adc_buf);
    if (ret) {
        FTS_TEST_SAVE_ERR("get short(adc) data fail\n");
    }

ADC_ERROR:
    FTS_TEST_FUNC_EXIT();
    return ret;
}

static u8 ft8201_weakshort_get_adcdata(struct ft8201_info *info, int *rbuf)
{
    int ret = 0;
    int master_adc_num = 0;
    int slave_adc_num = 0;
    int *buffer_master = NULL;
    int *buffer_slave = NULL;
    int master_tx = info->m_tx;
    int master_rx = info->m_rx;
    int slave_tx = info->s_tx;
    int slave_rx = info->s_rx;
    int ch_num = 0;

    FTS_TEST_FUNC_ENTER();

    buffer_master = fts_malloc((master_tx + 1) * master_rx * sizeof(int));
    if (NULL == buffer_master) {
        FTS_TEST_SAVE_ERR("%s:master buf malloc fail\n", __func__);
        ret = -ENOMEM;
        goto ADC_ERROR;
    }

    buffer_slave = fts_malloc((slave_tx + 1) * slave_rx * sizeof(int));
    if (NULL == buffer_slave) {
        FTS_TEST_SAVE_ERR("%s:slave buf malloc fail\n", __func__);
        ret = -ENOMEM;
        goto ADC_ERROR;
    }

    /* Start ADC sample */
    ch_num = master_tx + master_rx;
    ret = fts_test_write_reg(FACTORY_REG_SHORT_TEST_EN, 0x01);
    if (ret) {
        FTS_TEST_SAVE_ERR("start short test fail\n");
        goto ADC_ERROR;
    }
    sys_delay(ch_num * FACTORY_TEST_DELAY);

    /* read master adc data */
    master_adc_num = (master_tx * master_rx + 6) * 2;
    work_as_master(info);
    ret = read_adc_data(TEST_RETVAL_00, master_adc_num, buffer_master);
    if (ret) {
        FTS_TEST_SAVE_ERR("read master adc data fail\n");
        goto ADC_ERROR;
    }

    /* read slave adc data */
    slave_adc_num = (slave_tx * slave_rx + 6) * 2;
    work_as_slave(info);
    ret = read_adc_data(TEST_RETVAL_00, slave_adc_num, buffer_slave);
    if (ret) {
        FTS_TEST_SAVE_ERR("read master adc data fail\n");
        work_as_master(info);
        goto ADC_ERROR;
    }
    work_as_master(info);

    /* data integration */
    integrate_data(info, buffer_master, buffer_slave, rbuf);

ADC_ERROR:
    fts_free(buffer_master);
    fts_free(buffer_slave);

    FTS_TEST_FUNC_EXIT();
    return ret;
}

static int ft8201_short_test(struct ft8201_info *info, struct fts_test *tdata, bool *test_result)
{
    int ret = 0;
    bool tmp_result = true;
    int *adcdata = NULL;
    int tmp_adc = 0;
    int i = 0;
    struct incell_threshold *thr = &tdata->ic.incell.thr;

    FTS_TEST_FUNC_ENTER();
    FTS_TEST_SAVE_INFO("\n============ Test Item: short test\n");
    memset(tdata->buffer, 0, tdata->buffer_length);
    adcdata = tdata->buffer;

    ret = enter_factory_mode();
    if (ret) {
        FTS_TEST_SAVE_ERR("//Failed to Enter factory mode.ret=%d\n", ret);
        goto test_err;
    }

    ret = ft8201_weakshort_get_adcdata(info, adcdata);
    if (ret) {
        FTS_TEST_SAVE_ERR("//Failed to get AdcData. ret=%d\n", ret);
        goto test_err;
    }

    /* change adc to resistance */
    for (i = 0; i < tdata->node.node_num; ++i) {
        tmp_adc = adcdata[i];
        /* avoid calculating the value of the resistance is too large, limiting the size of the ADC value */
        if (tmp_adc > MAX_ADC_VALUE)
            tmp_adc = MAX_ADC_VALUE;
        adcdata[i] = (tmp_adc * 100) / (4095 - tmp_adc);
    }

    /* save */
    show_data(adcdata, true);
    save_data_csv(adcdata, "Short Circuit Test", \
                  CODE_SHORT_TEST, false, true);

    /* compare */
    tmp_result = compare_data(adcdata, thr->basic.short_res_min, TEST_SHORT_RES_MAX, thr->basic.short_res_vk_min, TEST_SHORT_RES_MAX, true);

    ret = 0;
test_err:
    if (tmp_result) {
        *test_result = true;
        FTS_TEST_SAVE_INFO("\n------ Short Circuit Test PASS\n");
    } else {
        *test_result = false;
        FTS_TEST_SAVE_INFO("\n------ Short Circuit Test NG\n");
    }
    FTS_TEST_FUNC_EXIT();
    return ret;
}

static int ft8201_open_test(struct ft8201_info *info, struct fts_test *tdata, bool *test_result)
{
    int ret = 0;
    bool tmp_result = false;
    u8 reg20_val = 0;
    u8 reg86_val = 0;
    u8 tmp_val = 0;
    int min = 0;
    int max = 0;
    int *opendata = NULL;
    int byte_num = 0;
    struct incell_threshold *thr = &tdata->ic.incell.thr;


    FTS_TEST_FUNC_ENTER();
    FTS_TEST_SAVE_INFO("\n============ Test Item: Open Test\n");
    memset(tdata->buffer, 0, tdata->buffer_length);
    opendata = tdata->buffer;

    ret = enter_factory_mode();
    if (ret) {
        FTS_TEST_SAVE_ERR("Enter Factory Failed\n");
        goto test_err;
    }

    ret = fts_test_read_reg(FACTORY_REG_OPEN_REG86, &reg86_val);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("read 0x86 fail\n");
        goto test_err;
    }

    ret = fts_test_read_reg(FACTORY_REG_OPEN_REG20, &reg20_val);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("read 0x20 fail\n");
        goto test_err;
    }


    /* set open mode */
    ret = ft8201_write_reg(info, FACTORY_REG_OPEN_REG86, 0x01);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("write 0x86 fail\n");
        goto restore_reg;
    }

    /* set Bit4~Bit5 of reg0x20 is set to 2b'10 (Source to GND) */
    tmp_val = reg20_val | (1 << 5);
    tmp_val &= ~(1 << 4);
    ret = ft8201_write_reg(info, FACTORY_REG_OPEN_REG20, tmp_val);
    if (ret) {
        FTS_TEST_SAVE_ERR("Failed to Read or Write Reg\n");
        goto restore_reg;
    }

    /* wait fw state update before clb */
    ret = wait_state_update(TEST_RETVAL_00);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("wait state update fail\n");
        goto restore_reg;
    }

    ret = ft8201_chip_clb(info);
    if (ret) {
        FTS_TEST_SAVE_ERR("auto clb fail\n");
        goto restore_reg;
    }

    /* get cb data */
    byte_num = tdata->node.tx_num * tdata->node.rx_num;
    ret = ft8201_get_tx_rx_cb(info, 0, byte_num, opendata);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("get cb fail\n");
        goto restore_reg;
    }

    /* show open data */
    show_data(opendata, false);
    /* save data */
    save_data_csv(opendata, "Open Test", \
                  CODE_OPEN_TEST, false, false);

    /* compare */
    min = thr->basic.open_cb_min;
    max = 256;
    FTS_TEST_DBG("open %d %d\n", min, opendata[0]);
    tmp_result = compare_data(opendata, min, max, 0, 0, false);

    //ret = 0;

restore_reg:
    /* restore */
    ret = ft8201_write_reg(info, FACTORY_REG_OPEN_REG86, reg86_val);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("restore reg86 fail\n");
    }

    ret = ft8201_write_reg(info, FACTORY_REG_OPEN_REG20, reg20_val);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("restore reg20 fail\n");
    }

    ret = wait_state_update(TEST_RETVAL_00);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("wait state update fail\n");
    }

    ret = ft8201_chip_clb(info);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("auto clb fail\n");
    }

test_err:
    if (tmp_result) {
        *test_result = true;
        FTS_TEST_SAVE_INFO("\n------ Open Test PASS\n");
    } else {
        *test_result = false;
        FTS_TEST_SAVE_INFO("\n------ Open Test NG\n");
    }
    FTS_TEST_FUNC_EXIT();
    return ret;
}


static int ft8201_cb_test(struct ft8201_info *info, struct fts_test *tdata, bool *test_result)
{
    bool tmp_result = false;
    int ret = 0;
    bool key_check = false;
    int byte_num = 0;
    int *cbdata = NULL;
    struct incell_threshold *thr = &tdata->ic.incell.thr;

    FTS_TEST_FUNC_ENTER();
    FTS_TEST_SAVE_INFO("\n============ Test Item: CB Test\n");
    memset(tdata->buffer, 0, tdata->buffer_length);
    cbdata = tdata->buffer;

    if (!thr->cb_min || !thr->cb_max) {
        FTS_TEST_SAVE_ERR("cb_min/max is null\n");
        ret = -EINVAL;
        goto test_err;
    }

    ret = enter_factory_mode();
    if (ret) {
        FTS_TEST_SAVE_ERR("// Failed to Enter factory mode.ret:%d\n", ret);
        goto test_err;
    }

    ret = ft8201_chip_clb(info);
    if (ret) {
        FTS_TEST_SAVE_ERR("//========= auto clb Failed\n");
        goto test_err;
    }

    byte_num = tdata->node.node_num;
    ret = ft8201_get_tx_rx_cb(info, 0, byte_num, cbdata);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("get cb fail\n");
        goto test_err;
    }

    key_check = thr->basic.cb_vkey_check;

    show_data(cbdata, key_check);
    save_data_csv(cbdata, "CB Test", \
                  CODE_CB_TEST, false, key_check);
    /* compare */
    tmp_result = compare_array(cbdata, thr->cb_min, thr->cb_max, key_check);

    ret = 0;

test_err:
    if (tmp_result) {
        *test_result = true;
        FTS_TEST_SAVE_INFO("\n------ CB Test PASS\n");
    } else {
        *test_result = false;
        FTS_TEST_SAVE_INFO("\n------ CB Test NG\n");
    }
    FTS_TEST_FUNC_EXIT();
    return ret;

}

static int ft8201_rawdata_test(struct ft8201_info *info, struct fts_test *tdata, bool *test_result)
{
    int ret = 0;
    bool tmp_result = false;
    int i = 0;
    bool key_check = true;
    int *rawdata = NULL;
    struct incell_threshold *thr = &tdata->ic.incell.thr;

    FTS_TEST_FUNC_ENTER();
    FTS_TEST_SAVE_INFO("\n============ Test Item: RawData Test\n");
    memset(tdata->buffer, 0, tdata->buffer_length);
    rawdata = tdata->buffer;

    if (!thr->rawdata_min || !thr->rawdata_max) {
        FTS_TEST_SAVE_ERR("rawdata_min/max is null\n");
        ret = -EINVAL;
        goto test_err;
    }

    ret = enter_factory_mode();
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("enter factory mode fail,ret=%d\n", ret);
        goto test_err;
    }

    /* read rawdata */
    for (i = 0 ; i < 3; i++) {
        ret = get_rawdata(rawdata);
    }
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("get RawData fail,ret=%d\n", ret);
        goto test_err;
    }

    /* save */
    show_data(rawdata, key_check);
    save_data_csv(rawdata, "RawData Test", \
                  CODE_RAWDATA_TEST, false, key_check);
    /* compare */
    tmp_result = compare_array(rawdata,
                               thr->rawdata_min,
                               thr->rawdata_max,
                               key_check);


test_err:
    if (tmp_result) {
        *test_result = true;
        FTS_TEST_SAVE_INFO("\n------ RawData Test PASS\n");
    } else {
        *test_result = false;
        FTS_TEST_SAVE_INFO("\n------ RawData Test NG\n");
    }
    FTS_TEST_FUNC_EXIT();
    return ret;

}

static int ft8201_lcdnoise_test(struct ft8201_info *info, struct fts_test *tdata, bool *test_result)
{
    int ret = 0;
    bool tmp_result = false;
    int frame_num = 0;
    int i = 0;
    int max = 0;
    int max_vk = 0;
    int byte_num  = 0;
    u8 old_mode = 0;
    u8 reg_value = 0;
    u8 status = 0;
    int *lcdnoise = NULL;
    struct incell_threshold *thr = &tdata->ic.incell.thr;

    FTS_TEST_FUNC_ENTER();
    FTS_TEST_SAVE_INFO("\n============ Test Item: LCD Noise Test\n");
    memset(tdata->buffer, 0, tdata->buffer_length);
    lcdnoise = tdata->buffer;

    ret = enter_factory_mode();
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("enter factory mode fail,ret=%d\n", ret);
        goto test_err;
    }


    ret = fts_test_read_reg(FACTORY_REG_DATA_SELECT, &old_mode);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("read reg06 fail\n");
        goto test_err;
    }

    ret = fts_test_read_reg(FACTORY_NOISE_MODE_REG, &reg_value);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("read reg5e fail\n");
        goto test_err;
    }

    ret = ft8201_write_reg(info, FACTORY_REG_DATA_SELECT, 0x64);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("write 0x64 to reg5e fail\n");
        goto restore_reg;
    }

    ret = ft8201_write_reg(info, FACTORY_REG_DATA_SELECT, 0x01);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("write 1 to reg06 fail\n");
        goto restore_reg;
    }

    frame_num = thr->basic.lcdnoise_frame;
    ret = ft8201_write_reg(info, FACTORY_REG_LCD_NOISE_FRAME, frame_num & 0xff);
    if (ret < 0) {
        FTS_TEST_SAVE_INFO("write frame num fail\n");
        goto restore_reg;
    }
    ret = ft8201_write_reg(info, FACTORY_REG_LCD_NOISE_FRAME + 1, (frame_num >> 8) & 0xff);
    if (ret < 0) {
        FTS_TEST_SAVE_INFO("write frame num fail\n");
        goto restore_reg;
    }

    /* read noise data */
    ret = fts_test_write_reg(FACTORY_REG_LINE_ADDR, 0xAD);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("write 0xAD to reg01 fail\n");
        goto restore_reg;
    }

    /* start test */
    ret = ft8201_write_reg(info, FACTORY_REG_LCD_NOISE_START, 0x01);
    if (ret < 0) {
        FTS_TEST_SAVE_INFO("start lcdnoise test fail\n");
        goto restore_reg;
    }
    sys_delay(frame_num * FACTORY_TEST_DELAY / 2);
    for (i = 0; i < FACTORY_TEST_RETRY; i++) {
        status = 0xFF;
        ret = fts_test_read_reg(FACTORY_REG_LCD_NOISE_START, &status );
        if ((ret >= 0) && (0x00 == status)) {
            break;
        } else {
            FTS_TEST_DBG("reg%x=%x,retry:%d\n", FACTORY_REG_LCD_NOISE_START, status, i);
        }
        sys_delay(FACTORY_TEST_RETRY_DELAY);
    }
    if (i >= FACTORY_TEST_RETRY) {
        FTS_TEST_SAVE_ERR("lcdnoise test timeout\n");
        //ret = -ENODATA;
        goto restore_reg;
    }

    byte_num = tdata->node.node_num * 2;
    ret = read_mass_data(FACTORY_REG_RAWDATA_ADDR, byte_num, lcdnoise);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("read rawdata fail\n");
        goto restore_reg;
    }

    /* save */
    show_data(lcdnoise, true);
    save_data_csv(lcdnoise, "LCD Noise Test", \
                  CODE_LCD_NOISE_TEST, false, true);

    /* compare */
    max = thr->basic.lcdnoise_coefficient * tdata->va_touch_thr * 32 / 100;
    max_vk = thr->basic.lcdnoise_coefficient_vkey * tdata->vk_touch_thr * 32 / 100;
    tmp_result = compare_data(lcdnoise, 0, max, 0, max_vk, true);

    //ret = 0;

restore_reg:
    ret = fts_test_write_reg(FACTORY_REG_DATA_SELECT, old_mode);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("restore reg06 fail\n");
    }
    ret = fts_test_write_reg(FACTORY_NOISE_MODE_REG, reg_value);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("restore reg5e fail\n");
    }
    ret = fts_test_write_reg(FACTORY_REG_LCD_NOISE_START, 0x00);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("restore reg11 fail\n");
    }

test_err:
    if (tmp_result) {
        *test_result = true;
        FTS_TEST_SAVE_INFO("\n------ LCD Noise Test PASS\n");
    } else {
        *test_result = false;
        FTS_TEST_SAVE_INFO("\n------ LCD Noise Test NG\n");
    }
    FTS_TEST_FUNC_EXIT();
    return ret;

}

static int start_test_ft8201(void)
{
    int ret = 0;
    struct fts_test *tdata = fts_ftest;
    struct incell_testitem *test_item = &tdata->ic.incell.u.item;
    bool temp_result = false;
    bool test_result = true;
    struct ft8201_info info;

    FTS_TEST_FUNC_ENTER();
    FTS_TEST_INFO("test item:0x%x", fts_ftest->ic.incell.u.tmp);

    if (!tdata || !tdata->testresult || !tdata->buffer) {
        FTS_TEST_ERROR("tdata is null");
        return -EINVAL;
    }

    ret = ft8201_test_init(&info);
    if (ret) {
        FTS_TEST_SAVE_ERR("test init fail\n");
        return ret;
    }

    /* short test */
    if (true == test_item->short_test) {
        ret = ft8201_short_test(&info, tdata, &temp_result);
        if ((ret < 0) || (false == temp_result)) {
            test_result = false;
        }
    }

    /* open test */
    if (true == test_item->open_test) {
        ret = ft8201_open_test(&info, tdata, &temp_result);
        if ((ret < 0) || (false == temp_result)) {
            test_result = false;
        }
    }

    /* cb test */
    if (true == test_item->cb_test) {
        ret = ft8201_cb_test(&info, tdata, &temp_result);
        if ((ret < 0) || (false == temp_result)) {
            test_result = false;
        }
    }

    /* rawdata test */
    if (true == test_item->rawdata_test) {
        ret = ft8201_rawdata_test(&info, tdata, &temp_result);
        if ((ret < 0) || (false == temp_result)) {
            test_result = false;
        }
    }

    /* lcd noise test */
    if (true == test_item->lcdnoise_test) {
        ret = ft8201_lcdnoise_test(&info, tdata, &temp_result);
        if ((ret < 0) || (false == temp_result)) {
            test_result = false;
        }
    }

    return test_result;
}

struct test_funcs test_func_ft8201 = {
    .ctype = {0x10},
    .hwtype = IC_HW_INCELL,
    .key_num_total = 12,
    .start_test = start_test_ft8201,
};