From 871480933a1c28f8a9fed4c4d34d06c439a7a422 Mon Sep 17 00:00:00 2001 From: Srikant Patnaik Date: Sun, 11 Jan 2015 12:28:04 +0530 Subject: Moved, renamed, and deleted files The original directory structure was scattered and unorganized. Changes are basically to make it look like kernel structure. --- drivers/input/touchscreen/ft6x0x/ft5402_config.c | 2295 ++++++++++++++++++++++ 1 file changed, 2295 insertions(+) create mode 100755 drivers/input/touchscreen/ft6x0x/ft5402_config.c (limited to 'drivers/input/touchscreen/ft6x0x/ft5402_config.c') diff --git a/drivers/input/touchscreen/ft6x0x/ft5402_config.c b/drivers/input/touchscreen/ft6x0x/ft5402_config.c new file mode 100755 index 00000000..58683ebd --- /dev/null +++ b/drivers/input/touchscreen/ft6x0x/ft5402_config.c @@ -0,0 +1,2295 @@ +#include "ft5402_config.h" +//#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "ini.h" +#include "ft5402_ini_config.h" +#include "ft5x0x.h" + + +extern int ft5x0x_i2c_txdata(char *txdata, int length); + +int ft5402_write_reg(struct i2c_client * client, u8 regaddr, u8 regvalue) +{ + unsigned char buf[2] = {0}; + buf[0] = regaddr; + buf[1] = regvalue; + + return ft5x0x_i2c_txdata(buf, 2); +} + +int ft5402_read_reg(struct i2c_client * client, u8 regaddr, u8 * regvalue) +{ + int ret; + + struct i2c_msg msgs[] = { + { + .addr = client->addr, + .flags = 0, + .len = 1, + .buf = ®addr, + }, + { + .addr = client->addr, + .flags = I2C_M_RD, + .len = 1, + .buf = regvalue, + }, + }; + ret = i2c_transfer(client->adapter, msgs, 2); + if (ret < 0) + pr_err("function:%s. i2c read error: %d\n", __func__, ret); + return ret; +} + +/*set tx order +*@txNO: offset from tx order start +*@txNO1: tx NO. +*/ +static int ft5402_set_tx_order(struct i2c_client * client, u8 txNO, u8 txNO1) +{ + unsigned char ReCode = 0; + if (txNO < FT5402_TX_TEST_MODE_1) + ReCode = ft5402_write_reg(client, FT5402_REG_TX_ORDER_START + txNO, + txNO1); + else { + ReCode = ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE_2<<4); /*enter Test mode 2*/ + if (ReCode >= 0) + ReCode = ft5402_write_reg(client, + FT5402_REG_TX_ORDER_START + txNO - FT5402_TX_TEST_MODE_1, + txNO1); + ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE<<4); /*enter Test mode*/ + } + return ReCode; +} + +/*set tx order +*@txNO: offset from tx order start +*@pTxNo: return value of tx NO. +*/ +static int ft5402_get_tx_order(struct i2c_client * client, u8 txNO, u8 *pTxNo) +{ + unsigned char ReCode = 0; + if (txNO < FT5402_TX_TEST_MODE_1) + ReCode = ft5402_read_reg(client, FT5402_REG_TX_ORDER_START + txNO, + pTxNo); + else { + ReCode = ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE_2<<4); /*enter Test mode 2*/ + if(ReCode >= 0) + ReCode = ft5402_read_reg(client, + FT5402_REG_TX_ORDER_START + txNO - FT5402_TX_TEST_MODE_1, + pTxNo); + ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE<<4); /*enter Test mode*/ + } + return ReCode; +} + +/*set tx cap +*@txNO: tx NO. +*@cap_value: value of cap +*/ +static int ft5402_set_tx_cap(struct i2c_client * client, u8 txNO, u8 cap_value) +{ + unsigned char ReCode = 0; + if (txNO < FT5402_TX_TEST_MODE_1) + ReCode = ft5402_write_reg(client, FT5402_REG_TX_CAP_START + txNO, + cap_value); + else { + ReCode = ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE_2<<4); /*enter Test mode 2*/ + if (ReCode >= 0) + ReCode = ft5402_write_reg(client, + FT5402_REG_TX_CAP_START + txNO - FT5402_TX_TEST_MODE_1, + cap_value); + ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE<<4); /*enter Test mode*/ + } + return ReCode; +} + +/*get tx cap*/ +static int ft5402_get_tx_cap(struct i2c_client * client, u8 txNO, u8 *pCap) +{ + unsigned char ReCode = 0; + if (txNO < FT5402_TX_TEST_MODE_1) + ReCode = ft5402_read_reg(client, FT5402_REG_TX_CAP_START + txNO, + pCap); + else { + ReCode = ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE_2<<4); /*enter Test mode 2*/ + if (ReCode >= 0) + ReCode = ft5402_read_reg(client, + FT5402_REG_TX_CAP_START + txNO - FT5402_TX_TEST_MODE_1, + pCap); + ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE<<4); /*enter Test mode*/ + } + return ReCode; +} + +/*set tx offset*/ +static int ft5402_set_tx_offset(struct i2c_client * client, u8 txNO, u8 offset_value) +{ + unsigned char temp=0; + unsigned char ReCode = 0; + if (txNO < FT5402_TX_TEST_MODE_1) { + ReCode = ft5402_read_reg(client, + FT5402_REG_TX_OFFSET_START + (txNO>>1), &temp); + if (ReCode >= 0) { + if (txNO%2 == 0) + ReCode = ft5402_write_reg(client, + FT5402_REG_TX_OFFSET_START + (txNO>>1), + (temp&0xf0) + (offset_value&0x0f)); + else + ReCode = ft5402_write_reg(client, + FT5402_REG_TX_OFFSET_START + (txNO>>1), + (temp&0x0f) + (offset_value<<4)); + } + } else { + ReCode = ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE_2<<4); /*enter Test mode 2*/ + if (ReCode >= 0) { + ReCode = ft5402_read_reg(client, + FT5402_REG_DEVICE_MODE+((txNO-FT5402_TX_TEST_MODE_1)>>1), + &temp); /*enter Test mode 2*/ + if (ReCode >= 0) { + if(txNO%2 == 0) + ReCode = ft5402_write_reg(client, + FT5402_REG_TX_OFFSET_START+((txNO-FT5402_TX_TEST_MODE_1)>>1), + (temp&0xf0)+(offset_value&0x0f)); + else + ReCode = ft5402_write_reg(client, + FT5402_REG_TX_OFFSET_START+((txNO-FT5402_TX_TEST_MODE_1)>>1), + (temp&0xf0)+(offset_value<<4)); + } + } + ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE<<4); /*enter Test mode*/ + } + + return ReCode; +} + +/*get tx offset*/ +static int ft5402_get_tx_offset(struct i2c_client * client, u8 txNO, u8 *pOffset) +{ + unsigned char temp=0; + unsigned char ReCode = 0; + if (txNO < FT5402_TX_TEST_MODE_1) + ReCode = ft5402_read_reg(client, + FT5402_REG_TX_OFFSET_START + (txNO>>1), &temp); + else { + ReCode = ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE_2<<4); /*enter Test mode 2*/ + if (ReCode >= 0) + ReCode = ft5402_read_reg(client, + FT5402_REG_TX_OFFSET_START+((txNO-FT5402_TX_TEST_MODE_1)>>1), + &temp); + ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE<<4); /*enter Test mode*/ + } + + if (ReCode >= 0) + (txNO%2 == 0) ? (*pOffset = (temp&0x0f)) : (*pOffset = (temp>>4)); + return ReCode; +} + +/*set rx order*/ +static int ft5402_set_rx_order(struct i2c_client * client, u8 rxNO, u8 rxNO1) +{ + unsigned char ReCode = 0; + ReCode = ft5402_write_reg(client, FT5402_REG_RX_ORDER_START + rxNO, + rxNO1); + return ReCode; +} + +/*get rx order*/ +static int ft5402_get_rx_order(struct i2c_client * client, u8 rxNO, u8 *prxNO1) +{ + unsigned char ReCode = 0; + ReCode = ft5402_read_reg(client, FT5402_REG_RX_ORDER_START + rxNO, + prxNO1); + return ReCode; +} + +/*set rx cap*/ +static int ft5402_set_rx_cap(struct i2c_client * client, u8 rxNO, u8 cap_value) +{ + unsigned char ReCode = 0; + if (rxNO < FT5402_RX_TEST_MODE_1) + ReCode = ft5402_write_reg(client, FT5402_REG_RX_CAP_START + rxNO, + cap_value); + else { + ReCode = ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE_2<<4); /*enter Test mode 2*/ + if(ReCode >= 0) + ReCode = ft5402_write_reg(client, + FT5402_REG_RX_CAP_START + rxNO - FT5402_RX_TEST_MODE_1, + cap_value); + ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE<<4); /*enter Test mode*/ + } + + return ReCode; +} + +/*get rx cap*/ +static int ft5402_get_rx_cap(struct i2c_client * client, u8 rxNO, u8 *pCap) +{ + unsigned char ReCode = 0; + if (rxNO < FT5402_RX_TEST_MODE_1) + ReCode = ft5402_read_reg(client, FT5402_REG_RX_CAP_START + rxNO, + pCap); + else { + ReCode = ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE_2<<4); /*enter Test mode 2*/ + if(ReCode >= 0) + ReCode = ft5402_read_reg(client, + FT5402_REG_RX_CAP_START + rxNO - FT5402_RX_TEST_MODE_1, + pCap); + ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE<<4); /*enter Test mode*/ + } + + return ReCode; +} + +/*set rx offset*/ +static int ft5402_set_rx_offset(struct i2c_client * client, u8 rxNO, u8 offset_value) +{ + unsigned char temp=0; + unsigned char ReCode = 0; + if (rxNO < FT5402_RX_TEST_MODE_1) { + ReCode = ft5402_read_reg(client, + FT5402_REG_RX_OFFSET_START + (rxNO>>1), &temp); + if (ReCode >= 0) { + if (rxNO%2 == 0) + ReCode = ft5402_write_reg(client, + FT5402_REG_RX_OFFSET_START + (rxNO>>1), + (temp&0xf0) + (offset_value&0x0f)); + else + ReCode = ft5402_write_reg(client, + FT5402_REG_RX_OFFSET_START + (rxNO>>1), + (temp&0x0f) + (offset_value<<4)); + } + } + else { + ReCode = ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE_2<<4); /*enter Test mode 2*/ + if (ReCode >= 0) { + ReCode = ft5402_read_reg(client, + FT5402_REG_DEVICE_MODE+((rxNO-FT5402_RX_TEST_MODE_1)>>1), + &temp); /*enter Test mode 2*/ + if (ReCode >= 0) { + if (rxNO%2 == 0) + ReCode = ft5402_write_reg(client, + FT5402_REG_RX_OFFSET_START+((rxNO-FT5402_RX_TEST_MODE_1)>>1), + (temp&0xf0)+(offset_value&0x0f)); + else + ReCode = ft5402_write_reg(client, + FT5402_REG_RX_OFFSET_START+((rxNO-FT5402_RX_TEST_MODE_1)>>1), + (temp&0xf0)+(offset_value<<4)); + } + } + ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE<<4); /*enter Test mode*/ + } + + return ReCode; +} + +/*get rx offset*/ +static int ft5402_get_rx_offset(struct i2c_client * client, u8 rxNO, u8 *pOffset) +{ + unsigned char temp = 0; + unsigned char ReCode = 0; + if (rxNO < FT5402_RX_TEST_MODE_1) + ReCode = ft5402_read_reg(client, + FT5402_REG_RX_OFFSET_START + (rxNO>>1), &temp); + else { + ReCode = ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE_2<<4); /*enter Test mode 2*/ + if (ReCode >= 0) + ReCode = ft5402_read_reg(client, + FT5402_REG_RX_OFFSET_START+((rxNO-FT5402_RX_TEST_MODE_1)>>1), + &temp); + + ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, + FT5402_REG_TEST_MODE<<4); /*enter Test mode*/ + } + + if (ReCode >= 0) { + if (0 == (rxNO%2)) + *pOffset = (temp&0x0f); + else + *pOffset = (temp>>4); + } + + return ReCode; +} + +/*set tx num*/ +static int ft5402_set_tx_num(struct i2c_client *client, u8 txnum) +{ + return ft5402_write_reg(client, FT5402_REG_TX_NUM, txnum); +} + +/*get tx num*/ +static int ft5402_get_tx_num(struct i2c_client *client, u8 *ptxnum) +{ + return ft5402_read_reg(client, FT5402_REG_TX_NUM, ptxnum); +} + +/*set rx num*/ +static int ft5402_set_rx_num(struct i2c_client *client, u8 rxnum) +{ + return ft5402_write_reg(client, FT5402_REG_RX_NUM, rxnum); +} + +/*get rx num*/ +static int ft5402_get_rx_num(struct i2c_client *client, u8 *prxnum) +{ + return ft5402_read_reg(client, FT5402_REG_RX_NUM, prxnum); +} + +/*set resolution*/ +static int ft5402_set_Resolution(struct i2c_client *client, u16 x, u16 y) +{ + unsigned char cRet = 0; + cRet &= ft5402_write_reg(client, + FT5402_REG_RESOLUTION_X_H, ((unsigned char)(x>>8))); + cRet &= ft5402_write_reg(client, + FT5402_REG_RESOLUTION_X_L, ((unsigned char)(x&0x00ff))); + + cRet &= ft5402_write_reg(client, + FT5402_REG_RESOLUTION_Y_H, ((unsigned char)(y>>8))); + cRet &= ft5402_write_reg(client, + FT5402_REG_RESOLUTION_Y_L, ((unsigned char)(y&0x00ff))); + + return cRet; +} + +/*get resolution*/ +static int ft5402_get_Resolution(struct i2c_client *client, + u16 *px, u16 *py) +{ + unsigned char cRet = 0, temp1 = 0, temp2 = 0; + cRet &= ft5402_read_reg(client, + FT5402_REG_RESOLUTION_X_H, &temp1); + cRet &= ft5402_read_reg(client, + FT5402_REG_RESOLUTION_X_L, &temp2); + (*px) = (((u16)temp1) << 8) | ((u16)temp2); + + cRet &= ft5402_read_reg(client, + FT5402_REG_RESOLUTION_Y_H, &temp1); + cRet &= ft5402_read_reg(client, + FT5402_REG_RESOLUTION_Y_L, &temp2); + (*py) = (((u16)temp1) << 8) | ((u16)temp2); + + return cRet; +} + + +/*set voltage*/ +static int ft5402_set_vol(struct i2c_client *client, u8 Vol) +{ + return ft5402_write_reg(client, FT5402_REG_VOLTAGE, Vol); +} + +/*get voltage*/ +static int ft5402_get_vol(struct i2c_client *client, u8 *pVol) +{ + return ft5402_read_reg(client, FT5402_REG_VOLTAGE, pVol); +} + +/*set gain*/ +static int ft5402_set_gain(struct i2c_client *client, u8 Gain) +{ + return ft5402_write_reg(client, FT5402_REG_GAIN, Gain); +} + +/*get gain*/ +static int ft5402_get_gain(struct i2c_client *client, u8 *pGain) +{ + return ft5402_read_reg(client, FT5402_REG_GAIN, pGain); +} + +/*get start rx*/ +static int ft5402_get_start_rx(struct i2c_client *client, u8 *pRx) +{ + return ft5402_read_reg(client, FT5402_REG_START_RX, pRx); +} + + +/*get adc target*/ +static int ft5402_get_adc_target(struct i2c_client *client, u16 *pvalue) +{ + int err = 0; + u8 tmp1, tmp2; + err = ft5402_read_reg(client, FT5402_REG_ADC_TARGET_HIGH, + &tmp1); + if (err < 0) + dev_err(&client->dev, "%s:get adc target high failed\n", + __func__); + err = ft5402_read_reg(client, FT5402_REG_ADC_TARGET_LOW, + &tmp2); + if (err < 0) + dev_err(&client->dev, "%s:get adc target low failed\n", + __func__); + + *pvalue = ((u16)tmp1<<8) + (u16)tmp2; + return err; +} + +static int ft5402_set_face_detect_statistics_tx_num(struct i2c_client *client, u8 prevalue) +{ + return ft5402_write_reg(client, FT5402_REG_FACE_DETECT_STATISTICS_TX_NUM, + prevalue); +} + +static int ft5402_get_face_detect_statistics_tx_num(struct i2c_client *client, u8 *pprevalue) +{ + return ft5402_read_reg(client, FT5402_REG_FACE_DETECT_STATISTICS_TX_NUM, + pprevalue); +} + +static int ft5402_set_face_detect_pre_value(struct i2c_client *client, u8 prevalue) +{ + return ft5402_write_reg(client, FT5402_REG_FACE_DETECT_PRE_VALUE, + prevalue); +} + +static int ft5402_get_face_detect_pre_value(struct i2c_client *client, u8 *pprevalue) +{ + return ft5402_read_reg(client, FT5402_REG_FACE_DETECT_PRE_VALUE, + pprevalue); +} + +static int ft5402_set_face_detect_num(struct i2c_client *client, u8 num) +{ + return ft5402_write_reg(client, FT5402_REG_FACE_DETECT_NUM, + num); +} + +static int ft5402_get_face_detect_num(struct i2c_client *client, u8 *pnum) +{ + return ft5402_read_reg(client, FT5402_REG_FACE_DETECT_NUM, + pnum); +} + + +static int ft5402_set_peak_value_min(struct i2c_client *client, u8 min) +{ + return ft5402_write_reg(client, FT5402_REG_BIGAREA_PEAK_VALUE_MIN, + min); +} + +static int ft5402_get_peak_value_min(struct i2c_client *client, u8 *pmin) +{ + return ft5402_read_reg(client, FT5402_REG_BIGAREA_PEAK_VALUE_MIN, + pmin); +} + +static int ft5402_set_diff_value_over_num(struct i2c_client *client, u8 num) +{ + return ft5402_write_reg(client, FT5402_REG_BIGAREA_DIFF_VALUE_OVER_NUM, + num); +} +static int ft5402_get_diff_value_over_num(struct i2c_client *client, u8 *pnum) +{ + return ft5402_read_reg(client, FT5402_REG_BIGAREA_DIFF_VALUE_OVER_NUM, + pnum); +} + + +static int ft5402_set_customer_id(struct i2c_client *client, u8 num) +{ + return ft5402_write_reg(client, FT5402_REG_CUSTOMER_ID, + num); +} +static int ft5402_get_customer_id(struct i2c_client *client, u8 *pnum) +{ + return ft5402_read_reg(client, FT5402_REG_CUSTOMER_ID, + pnum); +} + +static int ft5402_set_kx(struct i2c_client *client, u16 value) +{ + int err = 0; + err = ft5402_write_reg(client, FT5402_REG_KX_H, + value >> 8); + if (err < 0) + dev_err(&client->dev, "%s:set kx high failed\n", + __func__); + err = ft5402_write_reg(client, FT5402_REG_KX_L, + value); + if (err < 0) + dev_err(&client->dev, "%s:set kx low failed\n", + __func__); + + return err; +} + +static int ft5402_get_kx(struct i2c_client *client, u16 *pvalue) +{ + int err = 0; + u8 tmp1, tmp2; + err = ft5402_read_reg(client, FT5402_REG_KX_H, + &tmp1); + if (err < 0) + dev_err(&client->dev, "%s:get kx high failed\n", + __func__); + err = ft5402_read_reg(client, FT5402_REG_KX_L, + &tmp2); + if (err < 0) + dev_err(&client->dev, "%s:get kx low failed\n", + __func__); + + *pvalue = ((u16)tmp1<<8) + (u16)tmp2; + return err; +} +static int ft5402_set_ky(struct i2c_client *client, u16 value) +{ + int err = 0; + err = ft5402_write_reg(client, FT5402_REG_KY_H, + value >> 8); + if (err < 0) + dev_err(&client->dev, "%s:set ky high failed\n", + __func__); + err = ft5402_write_reg(client, FT5402_REG_KY_L, + value); + if (err < 0) + dev_err(&client->dev, "%s:set ky low failed\n", + __func__); + + return err; +} + +static int ft5402_get_ky(struct i2c_client *client, u16 *pvalue) +{ + int err = 0; + u8 tmp1, tmp2; + err = ft5402_read_reg(client, FT5402_REG_KY_H, + &tmp1); + if (err < 0) + dev_err(&client->dev, "%s:get ky high failed\n", + __func__); + err = ft5402_read_reg(client, FT5402_REG_KY_L, + &tmp2); + if (err < 0) + dev_err(&client->dev, "%s:get ky low failed\n", + __func__); + + *pvalue = ((u16)tmp1<<8) + (u16)tmp2; + return err; +} +static int ft5402_set_lemda_x(struct i2c_client *client, u8 value) +{ + return ft5402_write_reg(client, FT5402_REG_LEMDA_X, + value); +} + +static int ft5402_get_lemda_x(struct i2c_client *client, u8 *pvalue) +{ + return ft5402_read_reg(client, FT5402_REG_LEMDA_X, + pvalue); +} +static int ft5402_set_lemda_y(struct i2c_client *client, u8 value) +{ + return ft5402_write_reg(client, FT5402_REG_LEMDA_Y, + value); +} + +static int ft5402_get_lemda_y(struct i2c_client *client, u8 *pvalue) +{ + return ft5402_read_reg(client, FT5402_REG_LEMDA_Y, + pvalue); +} +static int ft5402_set_pos_x(struct i2c_client *client, u8 value) +{ + return ft5402_write_reg(client, FT5402_REG_DIRECTION, + value); +} + +static int ft5402_get_pos_x(struct i2c_client *client, u8 *pvalue) +{ + return ft5402_read_reg(client, FT5402_REG_DIRECTION, + pvalue); +} + +static int ft5402_set_scan_select(struct i2c_client *client, u8 value) +{ + return ft5402_write_reg(client, FT5402_REG_SCAN_SELECT, + value); +} + +static int ft5402_get_scan_select(struct i2c_client *client, u8 *pvalue) +{ + return ft5402_read_reg(client, FT5402_REG_SCAN_SELECT, + pvalue); +} + +static int ft5402_set_other_param(struct i2c_client *client) +{ + int err = 0; + err = ft5402_write_reg(client, FT5402_REG_THGROUP, (u8)(g_param_ft5402.ft5402_THGROUP)); + if (err < 0) { + dev_err(&client->dev, "%s:write THGROUP failed.\n", __func__); + return err; + } + err = ft5402_write_reg(client, FT5402_REG_THPEAK, g_param_ft5402.ft5402_THPEAK); + if (err < 0) { + dev_err(&client->dev, "%s:write THPEAK failed.\n", + __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_PWMODE_CTRL, + g_param_ft5402.ft5402_PWMODE_CTRL); + if (err < 0) { + dev_err(&client->dev, "%s:write PERIOD_CTRL failed.\n", __func__); + return err; + } + err = ft5402_write_reg(client, FT5402_REG_PERIOD_ACTIVE, + g_param_ft5402.ft5402_PERIOD_ACTIVE); + if (err < 0) { + dev_err(&client->dev, "%s:write PERIOD_ACTIVE failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FACE_DETECT_STATISTICS_TX_NUM, + g_param_ft5402.ft5402_FACE_DETECT_STATISTICS_TX_NUM); + if (err < 0) { + dev_err(&client->dev, "%s:write FACE_DETECT_STATISTICS_TX_NUM failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_MAX_TOUCH_VALUE_HIGH, + g_param_ft5402.ft5402_MAX_TOUCH_VALUE>>8); + if (err < 0) { + dev_err(&client->dev, "%s:write MAX_TOUCH_VALUE_HIGH failed.\n", __func__); + return err; + } + err = ft5402_write_reg(client, FT5402_REG_MAX_TOUCH_VALUE_LOW, + g_param_ft5402.ft5402_MAX_TOUCH_VALUE); + if (err < 0) { + dev_err(&client->dev, "%s:write MAX_TOUCH_VALUE_LOW failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FACE_DETECT_MODE, + g_param_ft5402.ft5402_FACE_DETECT_MODE); + if (err < 0) { + dev_err(&client->dev, "%s:write FACE_DETECT_MODE failed.\n", __func__); + return err; + } + err = ft5402_write_reg(client, FT5402_REG_DRAW_LINE_TH, + g_param_ft5402.ft5402_DRAW_LINE_TH); + if (err < 0) { + dev_err(&client->dev, "%s:write DRAW_LINE_TH failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_POINTS_SUPPORTED, + g_param_ft5402.ft5402_POINTS_SUPPORTED); + if (err < 0) { + dev_err(&client->dev, "%s:write POINTS_SUPPORTED failed.\n", __func__); + return err; + } + err = ft5402_write_reg(client, FT5402_REG_ESD_FILTER_FRAME, + g_param_ft5402.ft5402_ESD_FILTER_FRAME); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_ESD_FILTER_FRAME failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_POINTS_STABLE_MACRO, + g_param_ft5402.ft5402_POINTS_STABLE_MACRO); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_POINTS_STABLE_MACRO failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_MIN_DELTA_X, + g_param_ft5402.ft5402_MIN_DELTA_X); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_MIN_DELTA_X failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_MIN_DELTA_Y, + g_param_ft5402.ft5402_MIN_DELTA_Y); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_MIN_DELTA_Y failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_MIN_DELTA_STEP, + g_param_ft5402.ft5402_MIN_DELTA_STEP); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_MIN_DELTA_STEP failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_ESD_NOISE_MACRO, + g_param_ft5402.ft5402_ESD_NOISE_MACRO); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_ESD_NOISE_MACRO failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_ESD_DIFF_VAL, + g_param_ft5402.ft5402_ESD_DIFF_VAL); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_ESD_DIFF_VAL failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_ESD_NEGTIVE, + g_param_ft5402.ft5402_ESD_NEGTIVE); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_ESD_NEGTIVE failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_ESD_FILTER_FRAMES, + g_param_ft5402.ft5402_ESD_FILTER_FRAMES); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_ESD_FILTER_FRAMES failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_IO_LEVEL_SELECT, + g_param_ft5402.ft5402_IO_LEVEL_SELECT); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_IO_LEVEL_SELECT failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_POINTID_DELAY_COUNT, + g_param_ft5402.ft5402_POINTID_DELAY_COUNT); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_POINTID_DELAY_COUNT failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_LIFTUP_FILTER_MACRO, + g_param_ft5402.ft5402_LIFTUP_FILTER_MACRO); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_LIFTUP_FILTER_MACRO failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_DIFF_HANDLE_MACRO, + g_param_ft5402.ft5402_DIFF_HANDLE_MACRO); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_DIFF_HANDLE_MACRO failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_MIN_WATER, + g_param_ft5402.ft5402_MIN_WATER); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_MIN_WATER failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_MAX_NOISE, + g_param_ft5402.ft5402_MAX_NOISE); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_MAX_NOISE failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_WATER_START_RX, + g_param_ft5402.ft5402_WATER_START_RX); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_WATER_START_RX failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_WATER_START_TX, + g_param_ft5402.ft5402_WATER_START_TX); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_WATER_START_TX failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_HOST_NUMBER_SUPPORTED_MACRO, + g_param_ft5402.ft5402_HOST_NUMBER_SUPPORTED_MACRO); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_HOST_NUMBER_SUPPORTED_MACRO failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_RAISE_THGROUP, + g_param_ft5402.ft5402_RAISE_THGROUP); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_RAISE_THGROUP failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_CHARGER_STATE, + g_param_ft5402.ft5402_CHARGER_STATE); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_CHARGER_STATE failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_FILTERID_START, + g_param_ft5402.ft5402_FILTERID_START); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_FILTERID_START failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_FRAME_FILTER_EN_MACRO, + g_param_ft5402.ft5402_FRAME_FILTER_EN_MACRO); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_FRAME_FILTER_EN_MACRO failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_FRAME_FILTER_SUB_MAX_TH, + g_param_ft5402.ft5402_FRAME_FILTER_SUB_MAX_TH); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_FRAME_FILTER_SUB_MAX_TH failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_FRAME_FILTER_ADD_MAX_TH, + g_param_ft5402.ft5402_FRAME_FILTER_ADD_MAX_TH); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_FRAME_FILTER_ADD_MAX_TH failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_FRAME_FILTER_SKIP_START_FRAME, + g_param_ft5402.ft5402_FRAME_FILTER_SKIP_START_FRAME); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_FRAME_FILTER_SKIP_START_FRAME failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_FRAME_FILTER_BAND_EN, + g_param_ft5402.ft5402_FRAME_FILTER_BAND_EN); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_FRAME_FILTER_BAND_EN failed.\n", __func__); + return err; + } + + err = ft5402_write_reg(client, FT5402_REG_FT5402_FRAME_FILTER_BAND_WIDTH, + g_param_ft5402.ft5402_FRAME_FILTER_BAND_WIDTH); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_FRAME_FILTER_BAND_WIDTH failed.\n", __func__); + return err; + } + + return err; +} + +static int ft5402_get_other_param(struct i2c_client *client) +{ + int err = 0; + u8 value = 0x00; + err = ft5402_read_reg(client, FT5402_REG_THGROUP, &value); + if (err < 0) { + dev_err(&client->dev, "%s:write THGROUP failed.\n", __func__); + return err; + } else + DBG("THGROUP=%02x\n", value); + err = ft5402_read_reg(client, FT5402_REG_THPEAK, &value); + if (err < 0) { + dev_err(&client->dev, "%s:write THPEAK failed.\n", + __func__); + return err; + } else + DBG("THPEAK=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_PWMODE_CTRL, &value); + if (err < 0) { + dev_err(&client->dev, "%s:write PWMODE_CTRL failed.\n", __func__); + return err; + } else + DBG("CTRL=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_PERIOD_ACTIVE, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write PERIOD_ACTIVE failed.\n", __func__); + return err; + } else + DBG("PERIOD_ACTIVE=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_MAX_TOUCH_VALUE_HIGH, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write MAX_TOUCH_VALUE_HIGH failed.\n", __func__); + return err; + } else + DBG("MAX_TOUCH_VALUE_HIGH=%02x\n", value); + err = ft5402_read_reg(client, FT5402_REG_MAX_TOUCH_VALUE_LOW, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write MAX_TOUCH_VALUE_LOW failed.\n", __func__); + return err; + } else + DBG("MAX_TOUCH_VALUE_LOW=%02x\n", value); + err = ft5402_read_reg(client, FT5402_REG_FACE_DETECT_MODE, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FACE_DETECT_MODE failed.\n", __func__); + return err; + } else + DBG("FACE_DEC_MODE=%02x\n", value); + err = ft5402_read_reg(client, FT5402_REG_DRAW_LINE_TH, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write DRAW_LINE_TH failed.\n", __func__); + return err; + } else + DBG("DRAW_LINE_TH=%02x\n", value); + err = ft5402_read_reg(client, FT5402_REG_POINTS_SUPPORTED, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write ft5402_POINTS_SUPPORTED failed.\n", __func__); + return err; + } else + DBG("ft5402_POINTS_SUPPORTED=%02x\n", value); + err = ft5402_read_reg(client, FT5402_REG_ESD_FILTER_FRAME, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_ESD_FILTER_FRAME failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_ESD_FILTER_FRAME=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_POINTS_STABLE_MACRO, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_POINTS_STABLE_MACRO failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_POINTS_STABLE_MACRO=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_MIN_DELTA_X, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_MIN_DELTA_X failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_MIN_DELTA_X=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_MIN_DELTA_Y, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_MIN_DELTA_Y failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_MIN_DELTA_Y=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_MIN_DELTA_STEP, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_MIN_DELTA_STEP failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_MIN_DELTA_STEP=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_ESD_NOISE_MACRO, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_ESD_NOISE_MACRO failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_ESD_NOISE_MACRO=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_ESD_DIFF_VAL, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_ESD_DIFF_VAL failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_ESD_DIFF_VAL=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_ESD_NEGTIVE, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_ESD_NEGTIVE failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_ESD_NEGTIVE=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_ESD_FILTER_FRAMES, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_ESD_FILTER_FRAMES failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_ESD_FILTER_FRAMES=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_IO_LEVEL_SELECT, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_IO_LEVEL_SELECT failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_IO_LEVEL_SELECT=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_POINTID_DELAY_COUNT, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_POINTID_DELAY_COUNT failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_POINTID_DELAY_COUNT=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_LIFTUP_FILTER_MACRO, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_LIFTUP_FILTER_MACRO failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_LIFTUP_FILTER_MACRO=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_DIFF_HANDLE_MACRO, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_DIFF_HANDLE_MACRO failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_DIFF_HANDLE_MACRO=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_MIN_WATER, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_MIN_WATER failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_MIN_WATER=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_MAX_NOISE, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_MAX_NOISE failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_MAX_NOISE=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_WATER_START_RX, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_WATER_START_RX failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_WATER_START_RX=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_WATER_START_TX, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_WATER_START_TX failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_WATER_START_TX=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_HOST_NUMBER_SUPPORTED_MACRO, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_HOST_NUMBER_SUPPORTED_MACRO failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_HOST_NUMBER_SUPPORTED_MACRO=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_RAISE_THGROUP, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_RAISE_THGROUP failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_RAISE_THGROUP=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_CHARGER_STATE, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_CHARGER_STATE failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_CHARGER_STATE=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_FILTERID_START, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_FILTERID_START failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_FILTERID_START=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_FRAME_FILTER_EN_MACRO, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_FRAME_FILTER_EN_MACRO failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_FRAME_FILTER_EN_MACRO=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_FRAME_FILTER_SUB_MAX_TH, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_FRAME_FILTER_SUB_MAX_TH failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_FRAME_FILTER_SUB_MAX_TH=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_FRAME_FILTER_ADD_MAX_TH, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_FRAME_FILTER_ADD_MAX_TH failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_FRAME_FILTER_ADD_MAX_TH=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_FRAME_FILTER_SKIP_START_FRAME, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_FRAME_FILTER_SKIP_START_FRAME failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_FRAME_FILTER_SKIP_START_FRAME=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_FRAME_FILTER_BAND_EN, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_FRAME_FILTER_BAND_EN failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_FRAME_FILTER_BAND_EN=%02x\n", value); + + err = ft5402_read_reg(client, FT5402_REG_FT5402_FRAME_FILTER_BAND_WIDTH, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:write FT5402_REG_FT5402_FRAME_FILTER_BAND_WIDTH failed.\n", __func__); + return err; + } else + DBG("FT5402_REG_FT5402_FRAME_FILTER_BAND_WIDTH=%02x\n", value); + + return err; +} +int ft5402_get_ic_param(struct i2c_client *client) +{ + int err = 0; + int i = 0; + u8 value = 0x00; + u16 xvalue = 0x0000, yvalue = 0x0000; + + /*enter factory mode*/ + err = ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, FT5402_FACTORYMODE_VALUE); + if (err < 0) { + dev_err(&client->dev, "%s:enter factory mode failed.\n", __func__); + goto RETURN_WORK; + } + + for (i = 0; i < g_ft5402_tx_num; i++) { + DBG("tx%d:", i); + /*get tx order*/ + err = ft5402_get_tx_order(client, i, &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get tx%d order.\n", + __func__, i); + goto RETURN_WORK; + } + DBG("order=%d ", value); + /*get tx cap*/ + err = ft5402_get_tx_cap(client, i, &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get tx%d cap.\n", + __func__, i); + goto RETURN_WORK; + } + DBG("cap=%02x\n", value); + } + /*get tx offset*/ + err = ft5402_get_tx_offset(client, 0, &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get tx 0 offset.\n", + __func__); + goto RETURN_WORK; + } else + DBG("tx offset = %02x\n", value); + + /*get rx offset and cap*/ + for (i = 0; i < g_ft5402_rx_num; i++) { + /*get rx order*/ + DBG("rx%d:", i); + err = ft5402_get_rx_order(client, i, &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get rx%d order.\n", + __func__, i); + goto RETURN_WORK; + } + DBG("order=%d ", value); + /*get rx cap*/ + err = ft5402_get_rx_cap(client, i, &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get rx%d cap.\n", + __func__, i); + goto RETURN_WORK; + } + DBG("cap=%02x ", value); + err = ft5402_get_rx_offset(client, i, &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get rx offset.\n", + __func__); + goto RETURN_WORK; + } + DBG("offset=%02x\n", value); + } + + /*get scan select*/ + err = ft5402_get_scan_select(client, &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get scan select.\n", + __func__); + goto RETURN_WORK; + } else + DBG("scan select = %02x\n", value); + + /*get tx number*/ + err = ft5402_get_tx_num(client, &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get tx num.\n", + __func__); + goto RETURN_WORK; + } else + DBG("tx num = %02x\n", value); + /*get rx number*/ + err = ft5402_get_rx_num(client, &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get rx num.\n", + __func__); + goto RETURN_WORK; + } else + DBG("rx num = %02x\n", value); + + /*get gain*/ + err = ft5402_get_gain(client, &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get gain.\n", + __func__); + goto RETURN_WORK; + } else + DBG("gain = %02x\n", value); + /*get voltage*/ + err = ft5402_get_vol(client, &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get voltage.\n", + __func__); + goto RETURN_WORK; + } else + DBG("voltage = %02x\n", value); + /*get start rx*/ + err = ft5402_get_start_rx(client, &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get start rx.\n", + __func__); + goto RETURN_WORK; + } else + DBG("start rx = %02x\n", value); + /*get adc target*/ + err = ft5402_get_adc_target(client, &xvalue); + if (err < 0) { + dev_err(&client->dev, "%s:could not get adc target.\n", + __func__); + goto ERR_EXIT; + } else + DBG("ADC target = %02x\n", xvalue); + + +RETURN_WORK: + /*enter work mode*/ + err = ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, FT5402_WORKMODE_VALUE); + if (err < 0) { + dev_err(&client->dev, "%s:enter work mode failed.\n", __func__); + goto ERR_EXIT; + } + + /*get resolution*/ + err = ft5402_get_Resolution(client, &xvalue, &yvalue); + if (err < 0) { + dev_err(&client->dev, "%s:could not get resolution.\n", + __func__); + goto ERR_EXIT; + } else + DBG("resolution X = %d Y = %d\n", xvalue, yvalue); + + + /*get face detect statistics tx num*/ + err = ft5402_get_face_detect_statistics_tx_num(client, + &value); + if (err < 0) { + dev_err(&client->dev, + "%s:could not get face detect statistics tx num.\n", + __func__); + goto ERR_EXIT; + } else + DBG("FT5402_FACE_DETECT_STATISTICS_TX_NUM = %02x\n", value); + /*get face detect pre value*/ + err = ft5402_get_face_detect_pre_value(client, + &value); + if (err < 0) { + dev_err(&client->dev, + "%s:could not get face detect pre value.\n", + __func__); + goto ERR_EXIT; + } else + DBG("FT5402_FACE_DETECT_PRE_VALUE = %02x\n", value); + /*get face detect num*/ + err = ft5402_get_face_detect_num(client, &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get face detect num.\n", + __func__); + goto ERR_EXIT; + } else + DBG("face detect num = %02x\n", value); + + /*get min peak value*/ + err = ft5402_get_peak_value_min(client, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get min peak value.\n", + __func__); + goto ERR_EXIT; + } else + DBG("FT5402_BIGAREA_PEAK_VALUE_MIN = %02x\n", value); + /*get diff value over num*/ + err = ft5402_get_diff_value_over_num(client, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get diff value over num.\n", + __func__); + goto ERR_EXIT; + } else + DBG("FT5402_BIGAREA_DIFF_VALUE_OVER_NUM = %02x\n", value); + /*get customer id*/ + err = ft5402_get_customer_id(client, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get customer id.\n", + __func__); + goto ERR_EXIT; + } else + DBG("FT5402_CUSTOMER_ID = %02x\n", value); + /*get kx*/ + err = ft5402_get_kx(client, &xvalue); + if (err < 0) { + dev_err(&client->dev, "%s:could not get kx.\n", + __func__); + goto ERR_EXIT; + } else + DBG("kx = %02x\n", xvalue); + /*get ky*/ + err = ft5402_get_ky(client, &xvalue); + if (err < 0) { + dev_err(&client->dev, "%s:could not get ky.\n", + __func__); + goto ERR_EXIT; + } else + DBG("ky = %02x\n", xvalue); + /*get lemda x*/ + err = ft5402_get_lemda_x(client, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get lemda x.\n", + __func__); + goto ERR_EXIT; + } else + DBG("lemda x = %02x\n", value); + /*get lemda y*/ + err = ft5402_get_lemda_y(client, + &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get lemda y.\n", + __func__); + goto ERR_EXIT; + } else + DBG("lemda y = %02x\n", value); + /*get pos x*/ + err = ft5402_get_pos_x(client, &value); + if (err < 0) { + dev_err(&client->dev, "%s:could not get pos x.\n", + __func__); + goto ERR_EXIT; + } else + DBG("pos x = %02x\n", value); + + err = ft5402_get_other_param(client); + +ERR_EXIT: + return err; +} + +int ft5402_Init_IC_Param(struct i2c_client *client) +{ + int err = 0; + int i = 0; + + /*enter factory mode*/ + err = ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, FT5402_FACTORYMODE_VALUE); + if (err < 0) { + dev_err(&client->dev, "%s:enter factory mode failed.\n", __func__); + goto RETURN_WORK; + } + + for (i = 0; i < g_ft5402_tx_num; i++) { + if (g_ft5402_tx_order[i] != 0xFF) { + /*set tx order*/ + err = ft5402_set_tx_order(client, i, g_ft5402_tx_order[i]); + if (err < 0) { + dev_err(&client->dev, "%s:could not set tx%d order.\n", + __func__, i); + goto RETURN_WORK; + } + } + /*set tx cap*/ + err = ft5402_set_tx_cap(client, i, g_ft5402_tx_cap[i]); + if (err < 0) { + dev_err(&client->dev, "%s:could not set tx%d cap.\n", + __func__, i); + goto RETURN_WORK; + } + } + /*set tx offset*/ + err = ft5402_set_tx_offset(client, 0, g_ft5402_tx_offset); + if (err < 0) { + dev_err(&client->dev, "%s:could not set tx 0 offset.\n", + __func__); + goto RETURN_WORK; + } + + /*set rx offset and cap*/ + for (i = 0; i < g_ft5402_rx_num; i++) { + /*set rx order*/ + err = ft5402_set_rx_order(client, i, g_ft5402_rx_order[i]); + if (err < 0) { + dev_err(&client->dev, "%s:could not set rx%d order.\n", + __func__, i); + goto RETURN_WORK; + } + /*set rx cap*/ + err = ft5402_set_rx_cap(client, i, g_ft5402_rx_cap[i]); + if (err < 0) { + dev_err(&client->dev, "%s:could not set rx%d cap.\n", + __func__, i); + goto RETURN_WORK; + } + } + for (i = 0; i < g_ft5402_rx_num/2; i++) { + err = ft5402_set_rx_offset(client, i*2, g_ft5402_rx_offset[i]>>4); + if (err < 0) { + dev_err(&client->dev, "%s:could not set rx offset.\n", + __func__); + goto RETURN_WORK; + } + err = ft5402_set_rx_offset(client, i*2+1, g_ft5402_rx_offset[i]&0x0F); + if (err < 0) { + dev_err(&client->dev, "%s:could not set rx offset.\n", + __func__); + goto RETURN_WORK; + } + } + + /*set scan select*/ + err = ft5402_set_scan_select(client, g_ft5402_scanselect); + if (err < 0) { + dev_err(&client->dev, "%s:could not set scan select.\n", + __func__); + goto RETURN_WORK; + } + + /*set tx number*/ + err = ft5402_set_tx_num(client, g_ft5402_tx_num); + if (err < 0) { + dev_err(&client->dev, "%s:could not set tx num.\n", + __func__); + goto RETURN_WORK; + } + /*set rx number*/ + err = ft5402_set_rx_num(client, g_ft5402_rx_num); + if (err < 0) { + dev_err(&client->dev, "%s:could not set rx num.\n", + __func__); + goto RETURN_WORK; + } + + /*set gain*/ + err = ft5402_set_gain(client, g_ft5402_gain); + if (err < 0) { + dev_err(&client->dev, "%s:could not set gain.\n", + __func__); + goto RETURN_WORK; + } + /*set voltage*/ + err = ft5402_set_vol(client, g_ft5402_voltage); + if (err < 0) { + dev_err(&client->dev, "%s:could not set voltage.\n", + __func__); + goto RETURN_WORK; + } + + err = ft5402_write_reg(client, FT5402_REG_ADC_TARGET_HIGH, + g_param_ft5402.ft5402_ADC_TARGET>>8); + if (err < 0) { + dev_err(&client->dev, "%s:write ADC_TARGET_HIGH failed.\n", __func__); + return err; + } + err = ft5402_write_reg(client, FT5402_REG_ADC_TARGET_LOW, + g_param_ft5402.ft5402_ADC_TARGET); + if (err < 0) { + dev_err(&client->dev, "%s:write ADC_TARGET_LOW failed.\n", __func__); + return err; + } + +RETURN_WORK: + /*enter work mode*/ + err = ft5402_write_reg(client, FT5402_REG_DEVICE_MODE, FT5402_WORKMODE_VALUE); + if (err < 0) { + dev_err(&client->dev, "%s:enter work mode failed.\n", __func__); + goto ERR_EXIT; + } + + /*set resolution*/ + err = ft5402_set_Resolution(client, g_param_ft5402.ft5402_RESOLUTION_X, + g_param_ft5402.ft5402_RESOLUTION_Y); + if (err < 0) { + dev_err(&client->dev, "%s:could not set resolution.\n", + __func__); + goto ERR_EXIT; + } + + /*set face detect statistics tx num*/ + err = ft5402_set_face_detect_statistics_tx_num(client, + g_param_ft5402.ft5402_FACE_DETECT_STATISTICS_TX_NUM); + if (err < 0) { + dev_err(&client->dev, + "%s:could not set face detect statistics tx num.\n", + __func__); + goto ERR_EXIT; + } + /*set face detect pre value*/ + err = ft5402_set_face_detect_pre_value(client, + g_param_ft5402.ft5402_FACE_DETECT_PRE_VALUE); + if (err < 0) { + dev_err(&client->dev, + "%s:could not set face detect pre value.\n", + __func__); + goto ERR_EXIT; + } + /*set face detect num*/ + err = ft5402_set_face_detect_num(client, + g_param_ft5402.ft5402_FACE_DETECT_NUM); + if (err < 0) { + dev_err(&client->dev, "%s:could not set face detect num.\n", + __func__); + goto ERR_EXIT; + } + + /*set min peak value*/ + err = ft5402_set_peak_value_min(client, + g_param_ft5402.ft5402_BIGAREA_PEAK_VALUE_MIN); + if (err < 0) { + dev_err(&client->dev, "%s:could not set min peak value.\n", + __func__); + goto ERR_EXIT; + } + /*set diff value over num*/ + err = ft5402_set_diff_value_over_num(client, + g_param_ft5402.ft5402_BIGAREA_DIFF_VALUE_OVER_NUM); + if (err < 0) { + dev_err(&client->dev, "%s:could not set diff value over num.\n", + __func__); + goto ERR_EXIT; + } + /*set customer id*/ + err = ft5402_set_customer_id(client, + g_param_ft5402.ft5402_CUSTOMER_ID); + if (err < 0) { + dev_err(&client->dev, "%s:could not set customer id.\n", + __func__); + goto ERR_EXIT; + } + /*set kx*/ + err = ft5402_set_kx(client, g_param_ft5402.ft5402_KX); + if (err < 0) { + dev_err(&client->dev, "%s:could not set kx.\n", + __func__); + goto ERR_EXIT; + } + /*set ky*/ + err = ft5402_set_ky(client, g_param_ft5402.ft5402_KY); + if (err < 0) { + dev_err(&client->dev, "%s:could not set ky.\n", + __func__); + goto ERR_EXIT; + } + /*set lemda x*/ + err = ft5402_set_lemda_x(client, + g_param_ft5402.ft5402_LEMDA_X); + if (err < 0) { + dev_err(&client->dev, "%s:could not set lemda x.\n", + __func__); + goto ERR_EXIT; + } + /*set lemda y*/ + err = ft5402_set_lemda_y(client, + g_param_ft5402.ft5402_LEMDA_Y); + if (err < 0) { + dev_err(&client->dev, "%s:could not set lemda y.\n", + __func__); + goto ERR_EXIT; + } + /*set pos x*/ + err = ft5402_set_pos_x(client, g_param_ft5402.ft5402_DIRECTION); + if (err < 0) { + dev_err(&client->dev, "%s:could not set pos x.\n", + __func__); + goto ERR_EXIT; + } + + err = ft5402_set_other_param(client); + +ERR_EXIT: + return err; +} + + +char dst[512]; +static char * ft5402_sub_str(char * src, int n) +{ + char *p = src; + int i; + int m = 0; + int len = strlen(src); + + while (n >= 1 && m <= len) { + i = 0; + dst[10] = ' '; + n--; + while ( *p != ',' && *p != ' ') { + dst[i++] = *(p++); + m++; + if (i >= len) + break; + } + dst[i++] = '\0'; + p++; + } + return dst; +} +static int ft5402_GetInISize(char *config_name) +{ + struct file *pfile = NULL; + struct inode *inode; + unsigned long magic; + off_t fsize = 0; + char filepath[128]; + memset(filepath, 0, sizeof(filepath)); + + sprintf(filepath, "%s%s", FT5402_INI_FILEPATH, config_name); + + if (NULL == pfile) + pfile = filp_open(filepath, O_RDONLY, 0); + + if (IS_ERR(pfile)) { + pr_err("error occured while opening file %s.\n", filepath); + return -EIO; + } + + inode = pfile->f_dentry->d_inode; + magic = inode->i_sb->s_magic; + fsize = inode->i_size; + filp_close(pfile, NULL); + return fsize; +} + +static int ft5x0x_ReadInIData(char *config_name, + char *config_buf) +{ + struct file *pfile = NULL; + struct inode *inode; + unsigned long magic; + off_t fsize; + char filepath[128]; + loff_t pos; + mm_segment_t old_fs; + + memset(filepath, 0, sizeof(filepath)); + sprintf(filepath, "%s%s", FT5402_INI_FILEPATH, config_name); + if (NULL == pfile) + pfile = filp_open(filepath, O_RDONLY, 0); + if (IS_ERR(pfile)) { + pr_err("error occured while opening file %s.\n", filepath); + return -EIO; + } + + inode = pfile->f_dentry->d_inode; + magic = inode->i_sb->s_magic; + 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); + + return 0; +} + +int ft5402_Get_Param_From_Ini(char *config_name) +{ + char key[64]; + char value[512]; + char section[64]; + int i = 0;//,ret=0; + int j = 0; + char *filedata = NULL; + unsigned char legal_byte1 = 0x00; + unsigned char legal_byte2 = 0x00; + + int inisize = ft5402_GetInISize(config_name); + + if (inisize <= 0) { + pr_err("%s ERROR:Get firmware size failed\n", + __func__); + return -EIO; + } + + filedata = kmalloc(inisize + 1, GFP_ATOMIC); + + if (ft5x0x_ReadInIData(config_name, filedata)) { + pr_err("%s() - ERROR: request_firmware failed\n", + __func__); + kfree(filedata); + return -EIO; + } + + /*check ini if it is illegal*/ + sprintf(section, "%s", FT5402_APP_LEGAL); + sprintf(key, "%s", FT5402_APP_LEGAL_BYTE_1_STR); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + legal_byte1 = atoi(value); + DBG("legal_byte1=%s\n", value); + sprintf(key, "%s", FT5402_APP_LEGAL_BYTE_2_STR); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + legal_byte2 = atoi(value); + DBG("lega2_byte1=%s\n", value); + if(FT5402_APP_LEGAL_BYTE_1_VALUE == legal_byte1 && + FT5402_APP_LEGAL_BYTE_2_VALUE == legal_byte2) + DBG("the ini file is valid\n"); + else { + pr_err("[FTS]-----the ini file is invalid!please check it.\n"); + goto ERROR_RETURN; + } + + /*get ini param*/ + sprintf(section, "%s", FT5402_APP_NAME); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_KX = atoi(value); + DBG("ft5402_KX=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_KY = atoi(value); + DBG("ft5402_KY=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_LEMDA_X = atoi(value); + DBG("ft5402_LEMDA_X=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_LEMDA_Y = atoi(value); + DBG("ft5402_LEMDA_Y=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_RESOLUTION_X = atoi(value); + DBG("ft5402_RESOLUTION_X=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_RESOLUTION_Y = atoi(value); + DBG("ft5402_RESOLUTION_Y=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_DIRECTION= atoi(value); + DBG("ft5402_DIRECTION=%s\n", value); + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_FACE_DETECT_PRE_VALUE = atoi(value); + DBG("ft5402_FACE_DETECT_PRE_VALUE=%s\n", value); + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_FACE_DETECT_NUM = atoi(value); + DBG("ft5402_FACE_DETECT_NUM=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_BIGAREA_PEAK_VALUE_MIN = atoi(value);/*The min value to be decided as the big point*/ + DBG("ft5402_BIGAREA_PEAK_VALUE_MIN=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_BIGAREA_DIFF_VALUE_OVER_NUM = atoi(value);/*The min big points of the big area*/ + DBG("ft5402_BIGAREA_DIFF_VALUE_OVER_NUM=%s\n", value); + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_CUSTOMER_ID = atoi(value); + DBG("ft5402_CUSTOM_ID=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_PERIOD_ACTIVE = atoi(value); + DBG("ft5402_PERIOD_ACTIVE=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_FACE_DETECT_STATISTICS_TX_NUM = atoi(value); + DBG("ft5402_FACE_DETECT_STATISTICS_TX_NUM=%s\n", value); + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_THGROUP = atoi(value); + DBG("ft5402_THGROUP=%s\n", value); + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_THPEAK = atoi(value); + DBG("ft5402_THPEAK=%s\n", value); + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_FACE_DETECT_MODE = atoi(value); + DBG("ft5402_FACE_DETECT_MODE=%s\n", value); + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_MAX_TOUCH_VALUE = atoi(value); + DBG("ft5402_MAX_TOUCH_VALUE=%s\n", value); + + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_PWMODE_CTRL= atoi(value); + DBG("ft5402_PWMODE_CTRL=%s\n", value); + + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + + i++; + g_param_ft5402.ft5402_DRAW_LINE_TH = atoi(value); + DBG("ft5402_DRAW_LINE_TH=%s\n", value); + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_POINTS_SUPPORTED= atoi(value); + DBG("ft5402_POINTS_SUPPORTED=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_START_RX = atoi(value); + DBG("ft5402_START_RX=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + + g_param_ft5402.ft5402_ADC_TARGET = atoi(value); + DBG("ft5402_ADC_TARGET=%s\n", value); + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + + g_param_ft5402.ft5402_ESD_FILTER_FRAME = atoi(value); + DBG("ft5402_ESD_FILTER_FRAME=%s\n", value); + +/*********************************************************************/ + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_ft5402_tx_num = atoi(value); + DBG("ft5402_tx_num=%s\n", value); + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_ft5402_rx_num = atoi(value); + DBG("ft5402_rx_num=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_ft5402_gain = atoi(value); + DBG("ft5402_gain=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_ft5402_voltage = atoi(value); + DBG("ft5402_voltage=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_ft5402_scanselect = atoi(value); + DBG("ft5402_scanselect=%s\n", value); + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + for(j = 0; j < g_ft5402_tx_num; j++) + { + char * psrc = value; + g_ft5402_tx_order[j] = atoi(ft5402_sub_str(psrc, j+1)); + } + DBG("ft5402_tx_order=%s\n", value); + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_ft5402_tx_offset = atoi(value); + DBG("ft5402_tx_offset=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + for(j = 0; j < g_ft5402_tx_num; j++) + { + char * psrc = value; + g_ft5402_tx_cap[j] = atoi(ft5402_sub_str(psrc, j+1)); + } + DBG("ft5402_tx_cap=%s\n", value); + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + for(j = 0; j < g_ft5402_rx_num; j++) + { + char * psrc = value; + g_ft5402_rx_order[j] = atoi(ft5402_sub_str(psrc, j+1)); + } + DBG("ft5402_rx_order=%s\n", value); + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + for(j = 0; j < g_ft5402_rx_num/2; j++) + { + char * psrc = value; + g_ft5402_rx_offset[j] = atoi(ft5402_sub_str(psrc, j+1)); + } + DBG("ft5402_rx_offset=%s\n", value); + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + for(j = 0; j < g_ft5402_rx_num; j++) + { + char * psrc = value; + g_ft5402_rx_cap[j] = atoi(ft5402_sub_str(psrc, j+1)); + } + DBG("ft5402_rx_cap=%s\n", value); + + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_POINTS_STABLE_MACRO = atoi(value); + DBG("ft5402_POINTS_STABLE_MACRO=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_MIN_DELTA_X = atoi(value); + DBG("ft5402_MIN_DELTA_X=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_MIN_DELTA_Y = atoi(value); + DBG("ft5402_MIN_DELTA_Y=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_MIN_DELTA_STEP = atoi(value); + DBG("ft5402_MIN_DELTA_STEP=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_ESD_NOISE_MACRO = atoi(value); + DBG("ft5402_ESD_NOISE_MACRO=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_ESD_DIFF_VAL = atoi(value); + DBG("ft5402_ESD_DIFF_VAL=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_ESD_NEGTIVE = atoi(value); + DBG("ft5402_ESD_NEGTIVE=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_ESD_FILTER_FRAMES = atoi(value); + DBG("ft5402_ESD_FILTER_FRAMES=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_IO_LEVEL_SELECT = atoi(value); + DBG("ft5402_IO_LEVEL_SELECT=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_POINTID_DELAY_COUNT = atoi(value); + DBG("ft5402_POINTID_DELAY_COUNT=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_LIFTUP_FILTER_MACRO = atoi(value); + DBG("ft5402_LIFTUP_FILTER_MACRO=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_DIFF_HANDLE_MACRO = atoi(value); + DBG("ft5402_DIFF_HANDLE_MACRO=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_MIN_WATER = atoi(value); + DBG("ft5402_MIN_WATER=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_MAX_NOISE = atoi(value); + DBG("ft5402_MAX_NOISE=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_WATER_START_RX = atoi(value); + DBG("ft5402_WATER_START_RX=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_WATER_START_TX = atoi(value); + DBG("ft5402_WATER_START_TX=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_HOST_NUMBER_SUPPORTED_MACRO = atoi(value); + DBG("ft5402_HOST_NUMBER_SUPPORTED_MACRO=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_RAISE_THGROUP = atoi(value); + DBG("ft5402_RAISE_THGROUP=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_CHARGER_STATE = atoi(value); + DBG("ft5402_CHARGER_STATE=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_FILTERID_START = atoi(value); + DBG("ft5402_FILTERID_START=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_FRAME_FILTER_EN_MACRO = atoi(value); + DBG("ft5402_FRAME_FILTER_EN_MACRO=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_FRAME_FILTER_SUB_MAX_TH = atoi(value); + DBG("ft5402_FRAME_FILTER_SUB_MAX_TH=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_FRAME_FILTER_ADD_MAX_TH = atoi(value); + DBG("ft5402_FRAME_FILTER_ADD_MAX_TH=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_FRAME_FILTER_SKIP_START_FRAME = atoi(value); + DBG("ft5402_FRAME_FILTER_SKIP_START_FRAME=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_FRAME_FILTER_BAND_EN = atoi(value); + DBG("ft5402_FRAME_FILTER_BAND_EN=%s\n", value); + + sprintf(key, "%s", String_Param_FT5402[i]); + if (ini_get_key(filedata,section,key,value)<0) + goto ERROR_RETURN; + i++; + g_param_ft5402.ft5402_FRAME_FILTER_BAND_WIDTH = atoi(value); + DBG("ft5402_FRAME_FILTER_BAND_WIDTH=%s\n", value); + + + if (filedata) + kfree(filedata); + return 0; +ERROR_RETURN: + if (filedata) + kfree(filedata); + return -1; +} + -- cgit