/*
 *
 * 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.
 *
 */

#include "focaltech_test.h"

/*****************************************************************************
* Private constant and macro definitions using #define
*****************************************************************************/
struct ini_ic_type ic_types[] = {
    {"FT5X46",  0x54000002},
    {"FT5X46i", 0x54010002},
    {"FT5526",  0x54020002},
    {"FT3X17",  0x54030002},
    {"FT5436",  0x54040002},
    {"FT3X27",  0x54050002},
    {"FT5526i", 0x54060002},
    {"FT5416",  0x54070002},
    {"FT5426",  0x54080002},
    {"FT5435",  0x54090002},
    {"FT7681",  0x540A0002},
    {"FT7661",  0x540B0002},
    {"FT7511",  0x540C0002},
    {"FT7421",  0x540D0002},
    {"FT7311",  0x54100002},
    {"FT3327DQQ-001", 0x41000082},
    {"FT5446DQS-W01", 0x40000082},

    {"FT5452",  0x55000081},
    {"FT3518",  0x55010081},
    {"FT3558",  0x55020081},
    {"FT3528",  0x55030081},
    {"FT5536",  0x55040081},

    {"FT5472",  0x8F000083},
    {"FT5446U", 0x8F010083},
    {"FT5456U", 0x8F020083},
    {"FT3417U", 0x8F030083},
    {"FT5426U", 0x8F040083},
    {"FT3428",  0x8F050083},
    {"FT3437U", 0x8F060083},

    {"FT5822",  0x58000001},
    {"FT5626",  0x58010001},
    {"FT5726",  0x58020001},
    {"FT5826B", 0x58030001},
    {"FT3617",  0x58040001},
    {"FT3717",  0x58050001},
    {"FT7811",  0x58060001},
    {"FT5826S", 0x58070001},
    {"FT3517U", 0x58090001},
    {"FT3557",  0x580A0001},

    {"FT6X36",  0x63000003},
    {"FT3X07",  0x63010003},
    {"FT6416",  0x63020003},
    {"FT6336G/U", 0x63030003},
    {"FT7401",  0x63040003},
    {"FT3407U", 0x63050003},
    {"FT6236U", 0x63060003},
    {"FT6436U", 0x63070003},

    {"FT3267",  0x63080004},
    {"FT3367",  0x63090004},


    {"FT8607",  0x81000009},
    {"FT8716",  0x82000005},
    {"FT8716U", 0x44000005},
    {"FT8716F", 0x8A000005},
    {"FT8613",  0x4500000C},

    {"FT8736",  0x83000006},

    {"FT8006M", 0x87000007},
    {"FT8201",  0x87010010},
    {"FT7250",  0x87020007},

    {"FT8006U", 0x8900000B},
    {"FT8006S", 0x8901000B},

    {"FT8719",  0x9000000D},
    {"FT8615",  0x9100000F},

    {"FT8739",  0x8D00000E},

    {"FT8006P", 0x93000011},
};

/*****************************************************************************
* Global variable or extern global variabls/functions
*****************************************************************************/

/*****************************************************************************
* Static function prototypes
*****************************************************************************/
/* Works only for digits and letters, but small and fast */
#define TOLOWER(x) ((x) | 0x20)
static int fts_strncmp(const char *cs, const char *ct, int count)
{
    u8 c1 = 0, c2 = 0;

    while (count) {
        if  ((*cs == '\0') || (*ct == '\0'))
            return -1;
        c1 = TOLOWER(*cs++);
        c2 = TOLOWER(*ct++);
        if (c1 != c2)
            return c1 < c2 ? -1 : 1;
        if (!c1)
            break;
        count--;
    }

    return 0;
}

static int isspace(int x)
{
    if (x == ' ' || x == '\t' || x == '\n' || x == '\f' || x == '\b' || x == '\r')
        return 1;
    else
        return 0;
}

static int isdigit(int x)
{
    if (x <= '9' && x >= '0')
        return 1;
    else
        return 0;
}

static long fts_atol(char *nptr)
{
    int c; /* current char */
    long total; /* current total */
    int sign; /* if ''-'', then negative, otherwise positive */
    /* skip whitespace */
    while ( isspace((int)(unsigned char)*nptr) )
        ++nptr;
    c = (int)(unsigned char) * nptr++;
    sign = c; /* save sign indication */
    if (c == '-' || c == '+')
        c = (int)(unsigned char) * nptr++; /* skip sign */
    total = 0;
    while (isdigit(c)) {
        total = 10 * total + (c - '0'); /* accumulate digit */
        c = (int)(unsigned char) * nptr++; /* get next char */
    }
    if (sign == '-')
        return -total;
    else
        return total; /* return result, negated if necessary */
}

static int fts_atoi(char *nptr)
{
    return (int)fts_atol(nptr);
}

static int fts_test_get_ini_size(char *config_name)
{
    struct file *pfile = NULL;
    struct inode *inode = NULL;
    off_t fsize = 0;
    char filepath[128];

    FTS_TEST_FUNC_ENTER();

    memset(filepath, 0, sizeof(filepath));
    sprintf(filepath, "%s%s", FTS_INI_FILE_PATH, config_name);

    if (NULL == pfile)
        pfile = filp_open(filepath, O_RDONLY, 0);
    if (IS_ERR(pfile)) {
        FTS_TEST_ERROR("error occured while opening file %s.",  filepath);
        return -EIO;
    }

#if 1
    inode = pfile->f_inode;
#else
    /* reserved for linux earlier verion */
    inode = pfile->f_dentry->d_inode;
#endif
    fsize = inode->i_size;
    filp_close(pfile, NULL);

    FTS_TEST_FUNC_ENTER();

    return fsize;
}

static int fts_test_read_ini_data(char *config_name, char *config_buf)
{
    struct file *pfile = NULL;
    struct inode *inode = NULL;
    off_t fsize = 0;
    char filepath[128];
    loff_t pos = 0;
    mm_segment_t old_fs;

    FTS_TEST_FUNC_ENTER();

    memset(filepath, 0, sizeof(filepath));
    sprintf(filepath, "%s%s", FTS_INI_FILE_PATH, config_name);
    if (NULL == pfile) {
        pfile = filp_open(filepath, O_RDONLY, 0);
    }
    if (IS_ERR(pfile)) {
        FTS_TEST_ERROR("error occured while opening file %s.",  filepath);
        return -EIO;
    }

#if 1
    inode = pfile->f_inode;
#else
    /* reserved for linux earlier verion */
    inode = pfile->f_dentry->d_inode;
#endif
    fsize = inode->i_size;
    old_fs = get_fs();
    set_fs(KERNEL_DS);
    pos = 0;
    vfs_read(pfile, config_buf, fsize, &pos);
    filp_close(pfile, NULL);
    set_fs(old_fs);

    FTS_TEST_FUNC_EXIT();
    return 0;
}

static void str_space_remove(char *str)
{
    char *t = str;
    char *s = str;

    while (*t != '\0') {
        if (*t != ' ') {
            *s = *t;
            s++;
        }
        t++;
    }

    *s = '\0';
}

#ifdef INI_PRINT
static void print_ini_data(struct ini_data *ini)
{
    int i = 0;
    int j = 0;
    struct ini_section *section;
    struct ini_keyword *keyword;

    if (!ini || !ini->tmp) {
        FTS_TEST_DBG("ini is null");
        return;
    }

    FTS_TEST_DBG("section num:%d, keyword num total:%d\n",
                 ini->section_num, ini->keyword_num_total);
    for (i = 0; i < ini->section_num; i++) {
        section = &ini->section[i];
        FTS_TEST_DBG("section name:[%s] keyword num:%d\n",
                     section->name, section->keyword_num);
        for (j = 0; j < section->keyword_num; j++) {
            keyword = &section->keyword[j];
            FTS_TEST_DBG("%s=%s\n", keyword->name, keyword->value);
        }
    }
}
#endif

static int ini_get_line(char *filedata, char *line_data, int *line_len)
{
    int i = 0;
    int line_length = 0;
    int type;

    /* get a line data */
    for (i = 0; i < MAX_INI_LINE_LEN; i++) {
        if (('\n' == filedata[i]) || ('\r' == filedata[i])) {
            line_data[line_length++] = '\0';
            if (('\n' == filedata[i + 1]) || ('\r' == filedata[i + 1])) {
                line_length++;
            }
            break;
        } else {
            line_data[line_length++] = filedata[i];
        }
    }

    if (i >= MAX_INI_LINE_LEN) {
        FTS_TEST_ERROR("line length(%d)>max(%d)", line_length, MAX_INI_LINE_LEN);
        return -ENODATA;
    }

    /* remove space */
    str_space_remove(line_data);

    /* confirm line type */
    if (('\0' == line_data[0]) || ('#' == line_data[0])) {
        type = LINE_OTHER;
    } else if ('[' == line_data[0]) {
        type = LINE_SECTION;
    } else {
        type = LINE_KEYWORD; /* key word */
    }

    *line_len = line_length;
    return type;
}

static int ini_parse_keyword(struct ini_data *ini, char *line_buffer)
{
    int i = 0;
    int offset = 0;
    int length = strlen(line_buffer);
    struct ini_section *section = NULL;

    for (i = 0; i < length; i++) {
        if (line_buffer[i] == '=')
            break;
    }

    if ((i == 0) || (i >= length)) {
        FTS_TEST_ERROR("mark(=)in keyword line fail");
        return -ENODATA;
    }

    if ((ini->section_num > 0) && (ini->section_num < MAX_INI_SECTION_NUM)) {
        section = &ini->section[ini->section_num - 1];
    }

    if (NULL == section) {
        FTS_TEST_ERROR("section is null");
        return -ENODATA;
    }

    offset = ini->keyword_num_total;
    if (offset > MAX_KEYWORD_NUM) {
        FTS_TEST_ERROR("keyword num(%d)>max(%d),please check MAX_KEYWORD_NUM",
                       ini->keyword_num_total, MAX_KEYWORD_NUM);
        return -ENODATA;
    }
    memcpy(ini->tmp[offset].name, &line_buffer[0], i);
    ini->tmp[offset].name[i] = '\0';
    memcpy(ini->tmp[offset].value, &line_buffer[i + 1], length - i - 1);
    ini->tmp[offset].value[length - i - 1] = '\0';
    section->keyword_num++;
    ini->keyword_num_total++;

    return 0;
}

static int ini_parse_section(struct ini_data *ini, char *line_buffer)
{
    int length = strlen(line_buffer);
    struct ini_section *section = NULL;

    if ((length <= 2) || (length > MAX_KEYWORD_NAME_LEN)) {
        FTS_TEST_ERROR("section line length fail");
        return -EINVAL;
    }

    if ((ini->section_num < 0) || (ini->section_num > MAX_INI_SECTION_NUM)) {
        FTS_TEST_ERROR("section_num(%d) fail", ini->section_num);
        return -EINVAL;
    }
    section = &ini->section[ini->section_num];
    memcpy(section->name, line_buffer + 1, length - 2);
    section->name[length - 2] = '\0';
    FTS_TEST_INFO("section:%s, keyword offset:%d",
                  section->name, ini->keyword_num_total);
    section->keyword = (struct ini_keyword *)&ini->tmp[ini->keyword_num_total];
    section->keyword_num = 0;
    ini->section_num++;
    if (ini->section_num > MAX_INI_SECTION_NUM) {
        FTS_TEST_ERROR("section num(%d)>max(%d), please check MAX_INI_SECTION_NUM",
                       ini->section_num, MAX_INI_SECTION_NUM);
        return -ENOMEM;
    }

    return 0;
}

static int ini_init_inidata(struct ini_data *ini)
{
    int pos = 0;
    int ret = 0;
    char line_buffer[MAX_INI_LINE_LEN] = { 0 };
    int line_len = 0;

    if (!ini || !ini->data || !ini->tmp) {
        FTS_TEST_DBG("ini/data/tmp is null");
        return -EINVAL;
    }

    while (pos < ini->length) {
        ret = ini_get_line(ini->data + pos, line_buffer, &line_len);
        if (ret < 0) {
            FTS_TEST_ERROR("ini_get_line fail");
            return ret;
        } else if (ret == LINE_KEYWORD) {
            ret = ini_parse_keyword(ini, line_buffer);
            if (ret < 0) {
                FTS_TEST_ERROR("ini_parse_keyword fail");
                return ret;
            }
        } else if (ret == LINE_SECTION) {
            ret = ini_parse_section(ini, line_buffer);
            if (ret < 0) {
                FTS_TEST_ERROR("ini_parse_section fail");
                return ret;
            }
        }

        pos += line_len;
    }

    return 0;
}

static int ini_get_key(char *section_name, char *key_name, char *value)
{
    int i = 0;
    int j = 0;
    struct ini_data *ini = &fts_ftest->ini;
    struct ini_section *section;
    struct ini_keyword *keyword;
    int key_len = 0;

#ifdef INI_PRINT
    FTS_TEST_DBG("section name:%s, key name:%s\n", section_name, key_name);
    FTS_TEST_DBG("section num:%d\n", ini->section_num);
#endif
    for (i = 0; i < ini->section_num; i++) {
        section = &ini->section[i];
        key_len = strlen(section_name);
        if (key_len != strlen(section->name))
            continue;
        if (fts_strncmp(section->name, section_name, key_len) != 0)
            continue;
#ifdef INI_PRINT
        FTS_TEST_DBG("section name:%s keyword num:%d\n",
                     section->name, section->keyword_num);
#endif
        for (j = 0; j < section->keyword_num; j++) {
            keyword = &section->keyword[j];
            key_len = strlen(key_name);
            if (key_len == strlen(keyword->name)) {
                if (0 == fts_strncmp(keyword->name, key_name, key_len)) {
                    key_len = strlen(keyword->value);
                    memcpy(value, keyword->value, key_len);
                    FTS_TEST_DBG("section:%s,%s=%s\n", section_name, key_name, value);
                    return key_len;
                }
            }
        }
    }

    return -ENODATA;
}

/* return keyword's value length if success */
static int ini_get_string_value(char *section_name, char *key_name, char *rval)
{
    if (!section_name || !key_name || !rval) {
        FTS_TEST_ERROR("section_name/key_name/rval is null");
        return -EINVAL;
    }

    return ini_get_key(section_name, key_name, rval);
}

int get_keyword_value(char *section, char *name, int *value)
{
    int ret = 0;
    char str[MAX_KEYWORD_VALUE_LEN] = { 0 };

    ret = ini_get_string_value(section, name, str);
    if (ret > 0) {
        /* search successfully, so change value, otherwise keep default */
        *value = fts_atoi(str);
    }

    return ret;
}

static void fts_init_buffer(int *buffer, int value, int len)
{
    int i = 0;

    if (NULL == buffer) {
        FTS_TEST_ERROR("buffer is null\n");
        return;
    }

    for (i = 0; i < len; i++) {
        buffer[i] = value;
    }
}

static int get_test_item(char name[][MAX_KEYWORD_NAME_LEN], int length, int *val)
{
    int i = 0;
    int ret = 0;
    int tmpval = 0;

    if (length > TEST_ITEM_COUNT_MAX) {
        FTS_TEST_SAVE_ERR("test item count(%d) > max(%d)\n",
                          length, TEST_ITEM_COUNT_MAX);
        return -EINVAL;
    }

    FTS_TEST_INFO("test items in total of driver:%d", length);
    *val = 0;
    for (i = 0; i < length; i++) {
        tmpval = 0;
        ret = get_value_testitem(name[i], &tmpval);
        if (ret < 0) {
            FTS_TEST_DBG("test item:%s not found", name[i]);
        } else {
            FTS_TEST_DBG("test item:%s=%d", name[i], tmpval);
            *val |= (tmpval << i);
        }
    }

    return 0;
}

static int get_basic_threshold(char name[][MAX_KEYWORD_NAME_LEN], int length, int *val)
{
    int i = 0;
    int ret = 0;
    struct fts_test *tdata = fts_ftest;

    FTS_TEST_INFO("basic_thr string length(%d), count(%d)\n", length, tdata->basic_thr_count);
    if (length > fts_ftest->basic_thr_count) {
        FTS_TEST_SAVE_ERR("basic_thr string length > count\n");
        return -EINVAL;
    }

    for (i = 0; i < length; i++) {
        ret = get_value_basic(name[i], &val[i]);
        if (ret < 0) {
            FTS_TEST_DBG("basic thr:%s not found", name[i]);
        } else {
            FTS_TEST_DBG("basic thr:%s=%d", name[i], val[i]);
        }
    }

    return 0;
}

static void get_detail_threshold(char *key_name, bool is_prex, int *thr)
{
    char str[MAX_KEYWORD_VALUE_LEN] = { 0 };
    char str_temp[MAX_KEYWORD_NAME_LEN] = { 0 };
    char str_tmp[MAX_KEYWORD_VALUE_ONE_LEN] = { 0 };
    struct fts_test *tdata = fts_ftest;
    int divider_pos = 0;
    int index = 0;
    int i = 0;
    int j = 0;
    int k = 0;
    int tx_num = 0;
    int rx_num = 0;

    if (!key_name || !thr) {
        FTS_TEST_ERROR("key_name/thr is null");
        return;
    }

    if (is_prex) {
        tx_num = tdata->node.tx_num;
        rx_num = tdata->node.rx_num;
    }
    for (i = 0; i < tx_num + 1; i++) {
        if (is_prex) {
            snprintf(str_temp, MAX_KEYWORD_NAME_LEN, "%s%d", key_name, (i + 1));
        } else {
            snprintf(str_temp, MAX_KEYWORD_NAME_LEN, "%s", key_name);
        }
        divider_pos = ini_get_string_value("SpecialSet", str_temp, str);
        if (divider_pos <= 0)
            continue;
        index = 0;
        k = 0;
        memset(str_tmp, 0, sizeof(str_tmp));
        for (j = 0; j < divider_pos; j++) {
            if (',' == str[j]) {
                thr[i * rx_num + k] = (short)(fts_atoi(str_tmp));
                index = 0;
                memset(str_tmp, 0x00, sizeof(str_tmp));
                k++;
            } else {
                if (' ' == str[j])
                    continue;
                str_tmp[index] = str[j];
                index++;
            }
        }
    }
}

static int init_node_valid(void)
{
    char str[MAX_KEYWORD_NAME_LEN] = {0};
    int i = 0;
    int j = 0;
    int chy = 0;
    int node_num = 0;
    int cnt = 0;
    struct fts_test *tdata = fts_ftest;

    if (!tdata || !tdata->node_valid || !tdata->node_valid_sc) {
        FTS_TEST_ERROR("tdata/node_valid/node_valid_sc is null");
        return -EINVAL;
    }

    chy = tdata->node.rx_num;
    node_num = tdata->node.node_num;
    fts_init_buffer(tdata->node_valid, 1 , node_num);
    if ((tdata->func->hwtype == IC_HW_INCELL) || (tdata->func->hwtype == IC_HW_MC_SC)) {
        for (cnt = 0; cnt < node_num; cnt++) {
            i = cnt / chy + 1;
            j = cnt % chy + 1;
            snprintf(str, MAX_KEYWORD_NAME_LEN, "InvalidNode[%d][%d]", i, j);
            get_keyword_value("INVALID_NODE", str, &tdata->node_valid[cnt]);
        }
    }

    if (tdata->func->hwtype == IC_HW_MC_SC) {
        chy = tdata->sc_node.rx_num;
        node_num = tdata->sc_node.node_num;
        fts_init_buffer(tdata->node_valid_sc, 1, node_num);

        for (cnt = 0; cnt < node_num; cnt++) {
            i = (cnt >= chy) ? 2 : 1;
            j = (cnt >= chy) ? (cnt - chy + 1) : (cnt + 1);
            snprintf(str, MAX_KEYWORD_NAME_LEN, "InvalidNodeS[%d][%d]", i, j);
            get_keyword_value("INVALID_NODES", str, &tdata->node_valid_sc[cnt]);
        }
    }

    print_buffer(tdata->node_valid, tdata->node.node_num, tdata->node.rx_num);
    print_buffer(tdata->node_valid_sc, tdata->sc_node.node_num, tdata->sc_node.rx_num);
    return 0;
}

/* incell */
static int get_test_item_incell(void)
{
    int ret = 0;
    char item_name[][MAX_KEYWORD_NAME_LEN] = TEST_ITEM_INCELL;
    int length = sizeof(item_name) / MAX_KEYWORD_NAME_LEN;
    int item_val = 0;

    ret = get_test_item(item_name, length, &item_val);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("get test item fail\n");
        return ret;
    }

    fts_ftest->ic.incell.u.tmp = item_val;
    return 0;
}

static char bthr_name_incell[][MAX_KEYWORD_NAME_LEN] = BASIC_THRESHOLD_INCELL;
static int get_test_threshold_incell(void)
{
    int ret = 0;
    int length = sizeof(bthr_name_incell) / MAX_KEYWORD_NAME_LEN;
    struct fts_test *tdata = fts_ftest;
    struct incell_threshold *thr = &tdata->ic.incell.thr;
    int node_num = tdata->node.node_num;

    tdata->basic_thr_count = sizeof(struct incell_threshold_b) / sizeof(int);
    /* get standard basic threshold */
    ret = get_basic_threshold(bthr_name_incell, length, (int *)&thr->basic);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("get basic thr fail\n");
        return ret;
    }

    /* basic special set by ic */
    if (tdata->func->param_init) {
        ret = tdata->func->param_init();
        if (ret < 0) {
            FTS_TEST_SAVE_ERR("special basic thr init fail\n");
            return ret;
        }
    }

    /* init buffer */
    fts_init_buffer(thr->rawdata_max, thr->basic.rawdata_max, node_num);
    fts_init_buffer(thr->rawdata_min, thr->basic.rawdata_min, node_num);
    if (tdata->func->rawdata2_support) {
        fts_init_buffer(thr->rawdata2_max, thr->basic.rawdata2_max, node_num);
        fts_init_buffer(thr->rawdata2_min, thr->basic.rawdata2_min, node_num);
    }
    fts_init_buffer(thr->cb_max, thr->basic.cb_max, node_num);
    fts_init_buffer(thr->cb_min, thr->basic.cb_min, node_num);

    /* detail threshold */
    get_detail_threshold("RawData_Max_Tx", true, thr->rawdata_max);
    get_detail_threshold("RawData_Min_Tx", true, thr->rawdata_min);
    get_detail_threshold("CB_Max_Tx", true, thr->cb_max);
    get_detail_threshold("CB_Min_Tx", true, thr->cb_min);

    return 0;
}

static void print_thr_incell(void)
{
    struct fts_test *tdata = fts_ftest;
    struct incell_threshold *thr = &tdata->ic.incell.thr;

    FTS_TEST_DBG("short_res_min:%d", thr->basic.short_res_min);
    FTS_TEST_DBG("short_res_vk_min:%d", thr->basic.short_res_vk_min);
    FTS_TEST_DBG("open_cb_min:%d", thr->basic.open_cb_min);
    FTS_TEST_DBG("open_k1_check:%d", thr->basic.open_k1_check);
    FTS_TEST_DBG("open_k1_value:%d", thr->basic.open_k1_value);
    FTS_TEST_DBG("open_k2_check:%d", thr->basic.open_k2_check);
    FTS_TEST_DBG("open_k2_value:%d", thr->basic.open_k2_value);
    FTS_TEST_DBG("cb_min:%d", thr->basic.cb_min);
    FTS_TEST_DBG("cb_max:%d", thr->basic.cb_max);
    FTS_TEST_DBG("cb_vkey_check:%d", thr->basic.cb_vkey_check);
    FTS_TEST_DBG("cb_min_vk:%d", thr->basic.cb_min_vk);
    FTS_TEST_DBG("cb_max_vk:%d", thr->basic.cb_max_vk);
    FTS_TEST_DBG("rawdata_min:%d", thr->basic.rawdata_min);
    FTS_TEST_DBG("rawdata_max:%d", thr->basic.rawdata_max);
    FTS_TEST_DBG("rawdata_vkey_check:%d", thr->basic.rawdata_vkey_check);
    FTS_TEST_DBG("rawdata_min_vk:%d", thr->basic.rawdata_min_vk);
    FTS_TEST_DBG("rawdata_max_vk:%d", thr->basic.rawdata_max_vk);
    FTS_TEST_DBG("lcdnoise_frame:%d", thr->basic.lcdnoise_frame);
    FTS_TEST_DBG("lcdnoise_coefficient:%d", thr->basic.lcdnoise_coefficient);
    FTS_TEST_DBG("lcdnoise_coefficient_vkey:%d", thr->basic.lcdnoise_coefficient_vkey);

    FTS_TEST_DBG("open_nmos:%d", thr->basic.open_nmos);
    FTS_TEST_DBG("keyshort_k1:%d", thr->basic.keyshort_k1);
    FTS_TEST_DBG("keyshort_cb_max:%d", thr->basic.keyshort_cb_max);
    FTS_TEST_DBG("rawdata2_min:%d", thr->basic.rawdata2_min);
    FTS_TEST_DBG("rawdata2_max:%d", thr->basic.rawdata2_max);


    print_buffer(thr->rawdata_min, tdata->node.node_num, tdata->node.rx_num);
    print_buffer(thr->rawdata_max, tdata->node.node_num, tdata->node.rx_num);
    print_buffer(thr->cb_min, tdata->node.node_num, tdata->node.rx_num);
    print_buffer(thr->cb_max, tdata->node.node_num, tdata->node.rx_num);
    print_buffer(thr->rawdata2_min, tdata->node.node_num, tdata->node.rx_num);
    print_buffer(thr->rawdata2_max, tdata->node.node_num, tdata->node.rx_num);
}

static int ini_init_test_incell(void)
{
    int ret = 0;

    ret = get_test_item_incell();
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("get incell test item fail\n");
        return ret;
    }


    ret = get_test_threshold_incell();
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("get incell threshold fail\n");
        return ret;
    }

    print_thr_incell();
    return 0;
}

/* mc_sc */
static int get_test_item_mc_sc(void)
{
    int ret = 0;
    char item_name[][MAX_KEYWORD_NAME_LEN] = TEST_ITEM_MC_SC;
    int length = sizeof(item_name) / MAX_KEYWORD_NAME_LEN;
    int item_val = 0;

    ret = get_test_item(item_name, length, &item_val);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("get test item fail\n");
        return ret;
    }

    fts_ftest->ic.mc_sc.u.tmp = item_val;
    FTS_TEST_INFO("test item:0x%x in ini", fts_ftest->ic.mc_sc.u.tmp);
    return 0;
}

static char bthr_name_mc_sc[][MAX_KEYWORD_NAME_LEN] = BASIC_THRESHOLD_MC_SC;
static int get_test_threshold_mc_sc(void)
{
    int ret = 0;
    int length = sizeof(bthr_name_mc_sc) / MAX_KEYWORD_NAME_LEN;
    struct fts_test *tdata = fts_ftest;
    struct mc_sc_threshold *thr = &tdata->ic.mc_sc.thr;
    int node_num = tdata->node.node_num;
    int sc_num = tdata->sc_node.node_num;

    tdata->basic_thr_count = sizeof(struct mc_sc_threshold_b) / sizeof(int);
    /* get standard basic threshold */
    ret = get_basic_threshold(bthr_name_mc_sc, length, (int *)&thr->basic);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("get basic thr fail\n");
        return ret;
    }

    /* basic special set by ic */
    if (tdata->func->param_init) {
        ret = tdata->func->param_init();
        if (ret < 0) {
            FTS_TEST_SAVE_ERR("special basic thr init fail\n");
            return ret;
        }
    }

    /* init buffer */
    fts_init_buffer(thr->rawdata_h_min, thr->basic.rawdata_h_min, node_num);
    fts_init_buffer(thr->rawdata_h_max, thr->basic.rawdata_h_max, node_num);
    if (tdata->func->rawdata2_support) {
        fts_init_buffer(thr->rawdata_l_min, thr->basic.rawdata_l_min, node_num);
        fts_init_buffer(thr->rawdata_l_max, thr->basic.rawdata_l_max, node_num);
    }
    fts_init_buffer(thr->tx_linearity_max, thr->basic.uniformity_tx_hole, node_num);
    fts_init_buffer(thr->tx_linearity_min, 0, node_num);
    fts_init_buffer(thr->rx_linearity_max, thr->basic.uniformity_rx_hole, node_num);
    fts_init_buffer(thr->rx_linearity_min, 0, node_num);
    fts_init_buffer(thr->scap_cb_off_min, thr->basic.scap_cb_off_min, sc_num);
    fts_init_buffer(thr->scap_cb_off_max, thr->basic.scap_cb_off_max, sc_num);
    fts_init_buffer(thr->scap_cb_on_min, thr->basic.scap_cb_on_min, sc_num);
    fts_init_buffer(thr->scap_cb_on_max, thr->basic.scap_cb_on_max, sc_num);
    fts_init_buffer(thr->scap_rawdata_off_min, thr->basic.scap_rawdata_off_min, sc_num);
    fts_init_buffer(thr->scap_rawdata_off_max, thr->basic.scap_rawdata_off_max, sc_num);
    fts_init_buffer(thr->scap_rawdata_on_min, thr->basic.scap_rawdata_on_min, sc_num);
    fts_init_buffer(thr->scap_rawdata_on_max, thr->basic.scap_rawdata_on_max, sc_num);
    fts_init_buffer(thr->panel_differ_min, thr->basic.panel_differ_min, node_num);
    fts_init_buffer(thr->panel_differ_max, thr->basic.panel_differ_max, node_num);

    /* detail threshold */
    get_detail_threshold("RawData_Min_High_Tx", true, thr->rawdata_h_min);
    get_detail_threshold("RawData_Max_High_Tx", true, thr->rawdata_h_max);
    if (tdata->func->rawdata2_support) {
        get_detail_threshold("RawData_Min_Low_Tx", true, thr->rawdata_l_min);
        get_detail_threshold("RawData_Max_Low_Tx", true, thr->rawdata_l_max);
    }
    get_detail_threshold("Tx_Linearity_Max_Tx", true, thr->tx_linearity_max);
    get_detail_threshold("Rx_Linearity_Max_Tx", true, thr->rx_linearity_max);
    get_detail_threshold("ScapCB_OFF_Min_", true, thr->scap_cb_off_min);
    get_detail_threshold("ScapCB_OFF_Max_", true, thr->scap_cb_off_max);
    get_detail_threshold("ScapCB_ON_Min_", true, thr->scap_cb_on_min);
    get_detail_threshold("ScapCB_ON_Max_", true, thr->scap_cb_on_max);
    get_detail_threshold("ScapRawData_OFF_Min_", true, thr->scap_rawdata_off_min);
    get_detail_threshold("ScapRawData_OFF_Max_", true, thr->scap_rawdata_off_max);
    get_detail_threshold("ScapRawData_ON_Min_", true, thr->scap_rawdata_on_min);
    get_detail_threshold("ScapRawData_ON_Max_", true, thr->scap_rawdata_on_max);
    get_detail_threshold("Panel_Differ_Min_Tx", true, thr->panel_differ_min);
    get_detail_threshold("Panel_Differ_Max_Tx", true, thr->panel_differ_max);

    return 0;
}

static void print_thr_mc_sc(void)
{
    struct fts_test *tdata = fts_ftest;
    struct mc_sc_threshold *thr = &tdata->ic.mc_sc.thr;

    FTS_TEST_DBG("rawdata_h_min:%d", thr->basic.rawdata_h_min);
    FTS_TEST_DBG("rawdata_h_max:%d", thr->basic.rawdata_h_max);
    FTS_TEST_DBG("rawdata_set_hfreq:%d", thr->basic.rawdata_set_hfreq);
    FTS_TEST_DBG("rawdata_l_min:%d", thr->basic.rawdata_l_min);
    FTS_TEST_DBG("rawdata_l_max:%d", thr->basic.rawdata_l_max);
    FTS_TEST_DBG("rawdata_set_lfreq:%d", thr->basic.rawdata_set_lfreq);
    FTS_TEST_DBG("uniformity_check_tx:%d", thr->basic.uniformity_check_tx);
    FTS_TEST_DBG("uniformity_check_rx:%d", thr->basic.uniformity_check_rx);
    FTS_TEST_DBG("uniformity_check_min_max:%d", thr->basic.uniformity_check_min_max);
    FTS_TEST_DBG("uniformity_tx_hole:%d", thr->basic.uniformity_tx_hole);
    FTS_TEST_DBG("uniformity_rx_hole:%d", thr->basic.uniformity_rx_hole);
    FTS_TEST_DBG("uniformity_min_max_hole:%d", thr->basic.uniformity_min_max_hole);
    FTS_TEST_DBG("scap_cb_off_min:%d", thr->basic.scap_cb_off_min);
    FTS_TEST_DBG("scap_cb_off_max:%d", thr->basic.scap_cb_off_max);
    FTS_TEST_DBG("scap_cb_wp_off_check:%d", thr->basic.scap_cb_wp_off_check);
    FTS_TEST_DBG("scap_cb_on_min:%d", thr->basic.scap_cb_on_min);
    FTS_TEST_DBG("scap_cb_on_max:%d", thr->basic.scap_cb_on_max);
    FTS_TEST_DBG("scap_cb_wp_on_check:%d", thr->basic.scap_cb_wp_on_check);
    FTS_TEST_DBG("scap_rawdata_off_min:%d", thr->basic.scap_rawdata_off_min);
    FTS_TEST_DBG("scap_rawdata_off_max:%d", thr->basic.scap_rawdata_off_max);
    FTS_TEST_DBG("scap_rawdata_wp_off_check:%d", thr->basic.scap_rawdata_wp_off_check);
    FTS_TEST_DBG("scap_rawdata_on_min:%d", thr->basic.scap_rawdata_on_min);
    FTS_TEST_DBG("scap_rawdata_on_max:%d", thr->basic.scap_rawdata_on_max);
    FTS_TEST_DBG("scap_rawdata_wp_on_check:%d", thr->basic.scap_rawdata_wp_on_check);
    FTS_TEST_DBG("short_cg:%d", thr->basic.short_cg);
    FTS_TEST_DBG("short_cc:%d", thr->basic.short_cc);
    FTS_TEST_DBG("panel_differ_min:%d", thr->basic.panel_differ_min);
    FTS_TEST_DBG("panel_differ_max:%d", thr->basic.panel_differ_max);

    print_buffer(thr->rawdata_h_min, tdata->node.node_num, tdata->node.rx_num);
    print_buffer(thr->rawdata_h_max, tdata->node.node_num, tdata->node.rx_num);
    print_buffer(thr->rawdata_l_min, tdata->node.node_num, tdata->node.rx_num);
    print_buffer(thr->rawdata_l_max, tdata->node.node_num, tdata->node.rx_num);
    print_buffer(thr->scap_cb_off_min, tdata->sc_node.node_num, tdata->sc_node.rx_num);
    print_buffer(thr->scap_cb_off_max, tdata->sc_node.node_num, tdata->sc_node.rx_num);
    print_buffer(thr->scap_cb_on_min, tdata->sc_node.node_num, tdata->sc_node.rx_num);
    print_buffer(thr->scap_cb_on_max, tdata->sc_node.node_num, tdata->sc_node.rx_num);
    print_buffer(thr->scap_rawdata_off_min, tdata->sc_node.node_num, tdata->sc_node.rx_num);
    print_buffer(thr->scap_rawdata_off_max, tdata->sc_node.node_num, tdata->sc_node.rx_num);
    print_buffer(thr->scap_rawdata_on_min, tdata->sc_node.node_num, tdata->sc_node.rx_num);
    print_buffer(thr->scap_rawdata_on_max, tdata->sc_node.node_num, tdata->sc_node.rx_num);
    print_buffer(thr->panel_differ_min, tdata->node.node_num, tdata->node.rx_num);
    print_buffer(thr->panel_differ_max, tdata->node.node_num, tdata->node.rx_num);
}

static int ini_init_test_mc_sc(void)
{
    int ret = 0;

    ret = get_test_item_mc_sc();
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("get mc_sc test item fail\n");
        return ret;
    }

    ret = get_test_threshold_mc_sc();
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("get mc_sc threshold fail\n");
        return ret;
    }

    print_thr_mc_sc();
    return 0;
}

/* sc */
static int get_test_item_sc(void)
{
    int ret = 0;
    char item_name[][MAX_KEYWORD_NAME_LEN] = TEST_ITEM_SC;
    int length = sizeof(item_name) / MAX_KEYWORD_NAME_LEN;
    int item_val = 0;

    ret = get_test_item(item_name, length, &item_val);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("get test item fail\n");
        return ret;
    }

    fts_ftest->ic.sc.u.tmp = item_val;
    return 0;
}

static char bthr_name_sc[][MAX_KEYWORD_NAME_LEN] = BASIC_THRESHOLD_SC;
static int get_test_threshold_sc(void)
{
    int ret = 0;
    int length = sizeof(bthr_name_sc) / MAX_KEYWORD_NAME_LEN;
    struct fts_test *tdata = fts_ftest;
    struct sc_threshold *thr = &tdata->ic.sc.thr;
    int node_num = tdata->node.node_num;

    tdata->basic_thr_count = sizeof(struct sc_threshold_b) / sizeof(int);
    /* get standard basic threshold */
    ret = get_basic_threshold(bthr_name_sc, length, (int *)&thr->basic);
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("get basic thr fail\n");
        return ret;
    }

    /* basic special set by ic */
    if (tdata->func->param_init) {
        ret = tdata->func->param_init();
        if (ret < 0) {
            FTS_TEST_SAVE_ERR("special basic thr init fail\n");
            return ret;
        }
    }

    /* init buffer */
    fts_init_buffer(thr->rawdata_min, thr->basic.rawdata_min, node_num);
    fts_init_buffer(thr->rawdata_max, thr->basic.rawdata_max, node_num);
    fts_init_buffer(thr->cb_min, thr->basic.cb_min, node_num);
    fts_init_buffer(thr->cb_max, thr->basic.cb_max, node_num);
    fts_init_buffer(thr->dcb_sort, 0, node_num);
    fts_init_buffer(thr->dcb_base, thr->basic.dcb_base, node_num);

    /* detail threshold */
    get_detail_threshold("RawDataTest_Min", false, thr->rawdata_min);
    get_detail_threshold("RawDataTest_Max", false, thr->rawdata_max);
    get_detail_threshold("CbTest_Min", false, thr->cb_min);
    get_detail_threshold("CbTest_Max", false, thr->cb_max);
    get_detail_threshold("DeltaCxTest_Sort", false, thr->dcb_sort);
    get_detail_threshold("DeltaCbTest_Base", false, thr->dcb_base);

    return 0;
}

static void print_thr_sc(void)
{
    struct fts_test *tdata = fts_ftest;
    struct sc_threshold *thr = &tdata->ic.sc.thr;

    FTS_TEST_DBG("rawdata_min:%d", thr->basic.rawdata_min);
    FTS_TEST_DBG("rawdata_max:%d", thr->basic.rawdata_max);
    FTS_TEST_DBG("cb_min:%d", thr->basic.cb_min);
    FTS_TEST_DBG("cb_max:%d", thr->basic.cb_max);
    FTS_TEST_DBG("dcb_differ_max:%d", thr->basic.dcb_differ_max);
    FTS_TEST_DBG("dcb_key_check:%d", thr->basic.dcb_key_check);
    FTS_TEST_DBG("dcb_key_differ_max:%d", thr->basic.dcb_key_differ_max);
    FTS_TEST_DBG("dcb_ds1:%d", thr->basic.dcb_ds1);
    FTS_TEST_DBG("dcb_ds2:%d", thr->basic.dcb_ds2);
    FTS_TEST_DBG("dcb_ds3:%d", thr->basic.dcb_ds3);
    FTS_TEST_DBG("dcb_ds4:%d", thr->basic.dcb_ds4);
    FTS_TEST_DBG("dcb_ds5:%d", thr->basic.dcb_ds5);
    FTS_TEST_DBG("dcb_ds6:%d", thr->basic.dcb_ds6);
    FTS_TEST_DBG("dcb_critical_check:%d", thr->basic.dcb_critical_check);
    FTS_TEST_DBG("dcb_cs1:%d", thr->basic.dcb_cs1);
    FTS_TEST_DBG("dcb_cs2:%d", thr->basic.dcb_cs2);
    FTS_TEST_DBG("dcb_cs3:%d", thr->basic.dcb_cs3);
    FTS_TEST_DBG("dcb_cs4:%d", thr->basic.dcb_cs4);
    FTS_TEST_DBG("dcb_cs5:%d", thr->basic.dcb_cs5);
    FTS_TEST_DBG("dcb_cs6:%d", thr->basic.dcb_cs6);

    print_buffer(thr->rawdata_min, tdata->node.node_num, tdata->node.rx_num);
    print_buffer(thr->rawdata_max, tdata->node.node_num, tdata->node.rx_num);
    print_buffer(thr->cb_min, tdata->node.node_num, tdata->node.rx_num);
    print_buffer(thr->cb_max, tdata->node.node_num, tdata->node.rx_num);
    print_buffer(thr->dcb_sort, tdata->node.node_num, tdata->node.rx_num);
    print_buffer(thr->dcb_base, tdata->node.node_num, tdata->node.rx_num);
}

static int ini_init_test_sc(void)
{
    int ret = 0;

    ret = get_test_item_sc();
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("get sc test item fail\n");
        return ret;
    }

    ret = get_test_threshold_sc();
    if (ret < 0) {
        FTS_TEST_SAVE_ERR("get sc threshold fail\n");
        return ret;
    }

    print_thr_sc();
    return 0;
}

static u32 ini_get_ic_code(char *ic_name)
{
    int i = 0;
    int type_size = 0;
    int ini_icname_len = 0;
    int ic_types_len = 0;

    ini_icname_len = strlen(ic_name);
    type_size = sizeof(ic_types) / sizeof(ic_types[0]);
    for (i = 0; i < type_size; i++) {
        ic_types_len = strlen(ic_name);
        if (ini_icname_len == ic_types_len) {
            if (0 == strncmp(ic_name, ic_types[i].ic_name, ic_types_len))
                return ic_types[i].ic_type;
        }
    }

    FTS_TEST_ERROR("no IC type match");
    return 0;
}


static void ini_init_interface(struct ini_data *ini)
{
    char str[MAX_KEYWORD_VALUE_LEN] = { 0 };
    u32 value = 0;
    struct fts_test *tdata = fts_ftest;

    /* IC type */
    ini_get_string_value("Interface", "IC_Type", str);
    memcpy(ini->ic_name, str, sizeof(str));

    value = ini_get_ic_code(str);
    ini->ic_code = value;
    FTS_TEST_INFO("ic name:%s, ic code:%x", ini->ic_name, ini->ic_code);

    if (IC_HW_MC_SC == tdata->func->hwtype) {
        get_value_interface("Normalize_Type", &value);
        tdata->normalize = (u8)value;
        FTS_TEST_DBG("normalize:%d", tdata->normalize);
    }
}

static int ini_init_test(struct ini_data *ini)
{
    int ret = 0;
    struct fts_test *tdata = fts_ftest;

    /* interface init */
    ini_init_interface(ini);

    /* node valid */
    ret = init_node_valid();
    if (ret < 0) {
        FTS_TEST_ERROR("init node valid fail");
        return ret;
    }

    switch (tdata->func->hwtype) {
    case IC_HW_INCELL:
        ret = ini_init_test_incell();
        break;
    case IC_HW_MC_SC:
        ret = ini_init_test_mc_sc();
        break;
    case IC_HW_SC:
        ret = ini_init_test_sc();
        break;
    default:
        FTS_TEST_SAVE_ERR("test ic type(%d) fail\n", tdata->func->hwtype);
        ret = -EINVAL;
        break;
    }

    return ret;
}

/*
 * fts_test_get_testparam_from_ini - get test parameters from ini
 *
 * read, parse the configuration file, initialize the test variable
 *
 * return 0 if succuss, else errro code
 */
int fts_test_get_testparam_from_ini(char *config_name)
{
    int ret = 0;
    int inisize = 0;
    struct ini_data *ini = &fts_ftest->ini;

    inisize = fts_test_get_ini_size(config_name);
    FTS_TEST_DBG("ini file size:%d", inisize);
    if (inisize <= 0) {
        FTS_TEST_ERROR("get ini file size fail");
        return -ENODATA;
    }

    ini->data = vmalloc(inisize + 1);
    if (NULL == ini->data) {
        FTS_TEST_ERROR("malloc memory for ini data fail");
        return -ENOMEM;
    }
    memset(ini->data, 0, inisize + 1);
    ini->length = inisize + 1;
    ini->keyword_num_total = 0;
    ini->section_num = 0;

    ini->tmp = vmalloc(sizeof(struct ini_keyword) * MAX_KEYWORD_NUM);
    if (NULL == ini->tmp) {
        FTS_TEST_ERROR("malloc memory for ini tmp fail");
        ret = -ENOMEM;
        goto ini_tmp_err;
    }
    memset(ini->tmp, 0, sizeof(struct ini_keyword) * MAX_KEYWORD_NUM);

    ret = fts_test_read_ini_data(config_name, ini->data);
    if (ret) {
        FTS_TEST_ERROR("read ini file fail");
        goto get_inidata_err;
    }
    ini->data[inisize] = '\n';  /* last line is null line */

    /* parse ini data to get keyword name&value */
    ret = ini_init_inidata(ini);
    if (ret < 0) {
        FTS_TEST_ERROR("ini_init_inidata fail");
        goto get_inidata_err;
    }

    /* parse threshold & test item */
    ret = ini_init_test(ini);
    if (ret < 0) {
        FTS_TEST_ERROR("ini init fail");
        goto get_inidata_err;
    }

    ret = 0;
get_inidata_err:
    if (ini->tmp) {
        vfree(ini->tmp);
        ini->tmp = NULL;
    }
ini_tmp_err:
    if (ini->data) {
        vfree(ini->data);
        ini->data = NULL;
    }

    return ret;
}