samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a5882cbf539372500ec469b8aa45dcba9fe9e637
android_kernel_samsung_sm86…/raydium/raydium_selftest.c
Surya Teja Kudiri e572c26f33 touch : raydium: resolve KW issues 
resolved KW issues in raydium touch driver

Change-Id: I1e922389ade468aada9e5b3eda263f3afe1ff6dc
Signed-off-by: Surya Teja Kudiri <quic_skudiri@quicinc.com>
2023-03-16 14:55:08 +05:30

627 lines
22 KiB
C
Raw Blame History

/* raydium_selftest.c
*
* Raydium TouchScreen driver.
*
* This file is provided under a dual BSD/GPLv2 license. When using or
* redistributing this file, you may do so under either license.
* Qualcomm Innovation Center, Inc. chooses to use it under GPLv2
* Copyright (c) 2021 Raydium tech Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be 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.
*
* BSD LICENSE
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. or Linaro Ltd. nor the names of
* its contributors may be used to endorse or promote products
* derived from this software without specific prior written
* permission.
* * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/unistd.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include "drv_interface.h"
#include "chip_raydium/ic_drv_interface.h"
#include "raydium_selftest.h"
#include "chip_raydium/ic_drv_global.h"
#include "tpselftest_30.h"
#if defined(FW_MAPPING_EN)
#include "tpselftest_21.h"
#endif
#define RM_SELF_TEST_CUSTOMER_VERSION 0x01
#define RM_SELF_TEST_PLATFORM_VERSION 0x01
#define RM_SELF_TEST_PROJECT_VERSION 0x40
#define RM_SELF_TEST_MAIN_VERSION 1
#define RM_SELF_TEST_SUB_VERSION 0
#define RESULT_SUCCESS 0
#define RESULT_NG 1
#define RELATIVE_PATH 0
#define RM_SELF_TEST_MAX_STR_LENGTH 1000
unsigned char g_u8_normal_fw_version_buf[4];
char str_ini_path[100];
static int self_test_all(void)
{
int ret = 0;
g_u8_raydium_flag |= ENG_MODE;
handle_ic_test();
ret = g_u32_wearable_test_result;
/*g_u8_raydium_flag &= ~ENG_MODE;*/
DEBUGOUT("%s\r\n", __func__);
return ret;
}
int self_test_save_to_file(char *file_name, char *p_string, short len)
{
struct file *filp = NULL;
mm_segment_t old_fs;
filp = filp_open_block(file_name, O_RDWR | O_CREAT | O_APPEND, 0666);
if (IS_ERR(filp)) {
DEBUGOUT("can't open file:%s\n", RM_SELF_TEST_LOGFILE);
return 0;
}
old_fs = force_uaccess_begin();
filp->f_op->write(filp, p_string, len, &filp->f_pos);
force_uaccess_end(old_fs);
filp_close(filp, NULL);
return 1;
}
#if 1
static int raydium_check_ini_version(void)
{
int ret = 0;
unsigned int u32_test_version;
memcpy(&u32_test_version, &g_rad_testpara_image[4], 4);
if (u32_test_version != g_st_test_para_resv.u32_test_fw_version) {
DEBUGOUT("test fw versio 0x%X != ini version 0x%X\n"
, u32_test_version, g_st_test_para_resv.u32_test_fw_version);
ret = WEARABLE_FT_TEST_RESULT_TEST_FW_VER_NG;
}
if (g_u16_dev_id == DEVICE_ID_3X) {
g_u32_dongle_flash_ini_addr = F303_DONGLE_FLASH_INI_ADDR;
g_u32_ini_threshold_addr = F303_INI_THRESHOLD_ADDR;
g_u32_ini_para_addr = F303_INI_PARA_ADDR;
g_u32_ini_raw_data_3_cc_addr = F303_INI_RAW_DATA_3_CC_ADDR;
g_u32_ini_uc_cc_addr = F303_INI_UC_CC_ADDR;
g_u32_initial_code_start_addr = F303_INITIAL_CODE_START_ADDR;
DEBUGOUT("[out_set_ic_version] F303 Set INI ADDR!\r\n");
} else if (g_u16_dev_id == DEVICE_ID_2X) {
g_u32_dongle_flash_ini_addr = F302_DONGLE_FLASH_INI_ADDR;
g_u32_ini_threshold_addr = F302_INI_THRESHOLD_ADDR;
g_u32_ini_para_addr = F302_INI_PARA_ADDR;
g_u32_ini_raw_data_3_cc_addr = F302_INI_RAW_DATA_3_CC_ADDR;
g_u32_ini_uc_cc_addr = F302_INI_UC_CC_ADDR;
g_u32_initial_code_start_addr = F302_INITIAL_CODE_START_ADDR;
DEBUGOUT("[out_set_ic_version] F302 Set INI ADDR!\r\n");
}
return ret;
}
#else
static int raydium_check_ini_version(void)
{
int ret = 0;
unsigned int u32_test_version, u32_version_20, u32_version_21;
memcpy(&u32_test_version, &g_st_test_para_resv.u32_test_fw_version, 4);
if (g_u16_dev_id == DEVICE_ID_2X) {
switch (g_raydium_ts->id) {
case RAD_SELFTEST_20:
memcpy(&u32_version_20, &u8_rad_testpara_20[4], 4);
DEBUGOUT("ini version 0x%X, 20 version 0x%X\n"
, u32_test_version, u32_version_20);
if (u32_test_version == u32_version_20)
DEBUGOUT("map version= 0x%X\r\n", u32_version_20);
else
ret = WEARABLE_FT_TEST_RESULT_TEST_FW_VER_NG;
case RAD_SELFTEST_21:
memcpy(&u32_version_21, &u8_rad_testpara_21[4], 4);
DEBUGOUT("ini version 0x%X, 21 version 0x%X\n"
, u32_test_version, u32_version_21);
if (u32_test_version == u32_version_21)
DEBUGOUT("map version= 0x%X\r\n", u32_version_21);
else
ret = WEARABLE_FT_TEST_RESULT_TEST_FW_VER_NG;
}
}
return ret;
}
#endif
static int self_test_init(void)
{
int ret = 0;
unsigned int u32_dev_id;
g_u8_drv_interface = I2C_INTERFACE;
g_u16_dev_id = DEVICE_ID_3X;
if (handle_ic_read(RAYDIUM_CHK_I2C_CMD, 4, (unsigned char *)&u32_dev_id, g_u8_drv_interface, I2C_WORD_MODE) == ERROR) {
ret = WEARABLE_FT_TEST_RESULT_SYSFS_NG;
return ret;
}
g_u16_dev_id = ((u32_dev_id & 0xFFFF0000) >> 16);
if (g_u16_dev_id == DEVICE_ID_2X) {
handle_ic_read(0x00006a04, 4, g_u8_normal_fw_version_buf, g_u8_drv_interface, I2C_WORD_MODE);
DEBUGOUT("FW Version=0x%.2X%.2X%.2X%.2X\n", g_u8_normal_fw_version_buf[0], g_u8_normal_fw_version_buf[1],
g_u8_normal_fw_version_buf[3], g_u8_normal_fw_version_buf[2]);
} else if (g_u16_dev_id == DEVICE_ID_3X) {
handle_ic_read(0x00007b04, 4, g_u8_normal_fw_version_buf, g_u8_drv_interface, I2C_WORD_MODE);
DEBUGOUT("FW Version=0x%.2X%.2X%.2X%.2X\n", g_u8_normal_fw_version_buf[0], g_u8_normal_fw_version_buf[1],
g_u8_normal_fw_version_buf[3], g_u8_normal_fw_version_buf[2]);
} else {
DEBUGOUT("read ic namd fail\n");
ret = WEARABLE_FT_TEST_RESULT_TEST_INIT_NG;
return ret;
}
if (raydium_check_ini_version() != 0)
ret = WEARABLE_FT_TEST_RESULT_TEST_FW_VER_NG;
return ret;
}
int self_test_save_test_raw_data_to_file(int i32_ng_type)
{
/*struct tm *time_infor;*/
/*time_t raw_time;*/
char write_string[1000];
unsigned char u8_i, u8_j;
short *p_i16_buf = (short *)g_u16_raw_data_tmp;
/*FW Version*/
memset(write_string, 0, strlen(write_string));
if (g_u16_dev_id != 0) {
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH,
"FW Version=0x%.2X%.2X%.2X%.2X\n",
g_u8_normal_fw_version_buf[0], g_u8_normal_fw_version_buf[1],
g_u8_normal_fw_version_buf[3], g_u8_normal_fw_version_buf[2]);
}
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
/*Version*/
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "Selftest Version=%x.%x.%x.%x.%x\n\n",
RM_SELF_TEST_CUSTOMER_VERSION, RM_SELF_TEST_PLATFORM_VERSION,
RM_SELF_TEST_PROJECT_VERSION, RM_SELF_TEST_MAIN_VERSION,
RM_SELF_TEST_SUB_VERSION);
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
/*Test result*/
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "Test Result = 0x%08X\n\n",
i32_ng_type);
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
if (i32_ng_type == 0) {
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "All pass\n\n\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
} else {
memset(write_string, 0, strlen(write_string));
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_SYSFS_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "System NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_I2C_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "I2C NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_INT_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "INT NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_RESET_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "RESET NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_PRAM_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "PRAM NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_NORMAL_FW_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "NORMAL_FW_NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_OPEN_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "OPEN NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_SHORT_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "SHORT NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_BURN_CC_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "BURN CC NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_GET_DATA_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "GET DATA NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_FLASH_ID_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "FLASH ID NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_NORMAL_FW_VER_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "NORMAL FW VER NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_TEST_FW_VER_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "TEST FW VER NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_TEST_INIT_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "TEST INIT NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_LOAD_TESTFW_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "LOAD TESTFW NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_BURN_FW_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "BURN FW NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_SINGLE_CC_OPEN_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "Open NG (Single Pin CC) ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_SINGLE_CC_SHORT_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "Short NG (Single Pin CC) ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_UB_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "Uniformity Baseline NG ");
}
if (i32_ng_type & WEARABLE_FT_TEST_RESULT_UC_NG) {
snprintf(write_string,
RM_SELF_TEST_MAX_STR_LENGTH, "Uniformity CC NG ");
}
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
}
/*Threshold*/
memset(write_string, 0, strlen(write_string));
/*snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "0x%02X, 0x%02X\n0x%02X,
0x%02X\n0x%02X, 0x%02X\n0x%02X, 0x%02X\n0x%02X, 0x%02X\n0x%02X, 0x%02X\n0x%02X,
0x%02X\n0x%02X, 0x%02X\n0x%02X, 0x%02X\n",
(g_st_test_thd.i16_ft_test_open_lower_thd >> 8) & 0xFF, (g_st_test_thd.i16_ft_test_open_lower_thd & 0xFF),
(g_st_test_thd.i16_ft_test_short_upper_thd >> 8) & 0xFF, (g_st_test_thd.i16_ft_test_short_upper_thd & 0xFF),
(g_st_test_thd.i16_ft_test_short_lower_thd >> 8) & 0xFF, (g_st_test_thd.i16_ft_test_short_lower_thd & 0xFF),
(g_st_test_thd.i16_ft_test_single_cc_upper_thd >> 8) & 0xFF, (g_st_test_thd.i16_ft_test_single_cc_upper_thd & 0xFF),
(g_st_test_thd.i16_ft_test_single_cc_lower_thd >> 8) & 0xFF, (g_st_test_thd.i16_ft_test_single_cc_lower_thd & 0xFF),
(g_st_test_thd.i16_ft_test_uniformity_bl_upper_thd >> 8) & 0xFF, (g_st_test_thd.i16_ft_test_uniformity_bl_upper_thd & 0xFF),
(g_st_test_thd.i16_ft_test_uniformity_bl_lower_thd >> 8) & 0xFF, (g_st_test_thd.i16_ft_test_uniformity_bl_lower_thd & 0xFF),
(g_st_test_thd.i16_ft_test_uniformity_cc_upper_thd >> 8) & 0xFF, (g_st_test_thd.i16_ft_test_uniformity_cc_upper_thd & 0xFF),
(g_st_test_thd.i16_ft_test_uniformity_cc_lower_thd >> 8) & 0xFF, (g_st_test_thd.i16_ft_test_uniformity_cc_lower_thd & 0xFF));*/
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
for (u8_i = 0; u8_i < MAX_SENSING_PIN_NUM; u8_i++) {
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "0x%2X,",
g_u16_uc_golden_cc_buf[u8_i]);
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
}
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
for (u8_i = 0; u8_i < MAX_SENSING_PIN_NUM; u8_i++) {
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "0x%2X,",
g_u16_raw_data3_golden_cc_buf[u8_i]);
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
}
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "\n\n\n\n\n\n\n\n\n\n\n\n\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
if ((i32_ng_type & 0xFFF0FBF8) < 4) {
if ((g_st_test_info.u16_ft_test_item & (IC_TEST_ITEMS_SHORT)) != 0) {
/*Raw data*/
/*Raw data slow*/
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "\r\n\n\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "Raw Data 1\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
/*Raw data1*/
memset(p_i16_buf, 0, MAX_IMAGE_BUFFER_SIZE * 2);
for (u8_i = 0; u8_i < MAX_IMAGE_BUFFER_SIZE; u8_i++)
if (g_u8_wearable_pin_map[u8_i] != F303_NA_P)
p_i16_buf[g_u8_wearable_pin_map[u8_i]] = g_i16_raw_data_1_short_buf[u8_i];
for (u8_j = 0; u8_j < g_u8_channel_y; u8_j++) {
for (u8_i = 0; u8_i < g_u8_channel_x; u8_i++) {
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH,
"%05d,", p_i16_buf[u8_i + u8_j * g_u8_channel_x]);
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
}
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "\r\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
}
}
if ((g_st_test_info.u16_ft_test_item & (IC_TEST_ITEMS_OPEN)) != 0) {
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "\r\n\n\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
/*Raw data slow*/
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "Raw Data 2\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
/*Raw data2*/
memset(p_i16_buf, 0, MAX_IMAGE_BUFFER_SIZE * 2);
for (u8_i = 0; u8_i < MAX_IMAGE_BUFFER_SIZE; u8_i++)
if (g_u8_wearable_pin_map[u8_i] != F303_NA_P)
p_i16_buf[g_u8_wearable_pin_map[u8_i]] = g_i16_raw_data_2_open_buf[u8_i];
for (u8_j = 0; u8_j < g_u8_channel_y; u8_j++) {
for (u8_i = 0; u8_i < g_u8_channel_x; u8_i++) {
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH,
"%05d,", p_i16_buf[u8_i + u8_j * g_u8_channel_x]);
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
}
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "\r\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
}
}
if ((g_st_test_info.u16_ft_test_item & (IC_TEST_ITEMS_OPEN | IC_TEST_ITEMS_SHORT)) != 0) {
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "\r\n\n\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
/*Raw data 3*/
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "Raw Data 3\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
/*Raw data3*/
memset(p_i16_buf, 0, MAX_IMAGE_BUFFER_SIZE * 2);
for (u8_i = 0; u8_i < MAX_IMAGE_BUFFER_SIZE; u8_i++)
if (g_u8_wearable_pin_map[u8_i] != F303_NA_P)
p_i16_buf[g_u8_wearable_pin_map[u8_i]] = g_u16_raw_data3_cc_buf[u8_i];
for (u8_j = 0; u8_j < g_u8_channel_y; u8_j++) {
for (u8_i = 0; u8_i < g_u8_channel_x; u8_i++) {
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH,
"%05d,", p_i16_buf[u8_i + u8_j * g_u8_channel_x]);
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
}
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "\r\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
}
}
if ((g_st_test_info.u16_ft_test_item & (IC_TEST_ITEMS_UC)) != 0) {
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "\r\n\n\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
/*Raw data Uniformity CC*/
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "Raw Data_UC\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
/*Raw data uc*/
memset(p_i16_buf, 0, MAX_IMAGE_BUFFER_SIZE * 2);
for (u8_i = 0; u8_i < MAX_IMAGE_BUFFER_SIZE; u8_i++)
if (g_u8_wearable_pin_map[u8_i] != F303_NA_P)
p_i16_buf[g_u8_wearable_pin_map[u8_i]] = g_u16_uc_buf[u8_i];
DEBUGOUT("Image:0x%x\r\n", p_i16_buf[0]);
for (u8_j = 0; u8_j < g_u8_channel_y; u8_j++) {
for (u8_i = 0; u8_i < g_u8_channel_x; u8_i++) {
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH,
"%05d,", p_i16_buf[u8_i + u8_j * g_u8_channel_x]);
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
}
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "\r\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
}
}
}
memset(write_string, 0, strlen(write_string));
snprintf(write_string, RM_SELF_TEST_MAX_STR_LENGTH, "\r\n\n\n");
self_test_save_to_file(RM_SELF_TEST_LOGFILE, write_string, strlen(write_string));
return 1;
}
int self_test_read_setting_from_file(void)
{
unsigned short u16_offset = 0;
DEBUGOUT("[touch]g_raydium_ts->id = 0x%x\r\n", g_raydium_ts->id);
switch (g_raydium_ts->id) {
case RAD_SELFTEST_30:
u16_offset = 0;
memcpy(&g_u8_ini_flash[u16_offset], &u8_test_info_30, sizeof(u8_test_info_30));
u16_offset += 16;
memcpy(&g_u8_ini_flash[u16_offset], &i8_ft_test_thd_30, sizeof(i8_ft_test_thd_30));
u16_offset += 36;
memcpy(&g_u8_ini_flash[u16_offset], &u8_test_para_30, sizeof(u8_test_para_30));
u16_offset += 48;
u16_offset += 128;/*reserve for BL*/
memcpy(&g_u8_ini_flash[u16_offset], &u8_raw_data_3_cc_30, sizeof(u8_raw_data_3_cc_30));
u16_offset += 128;
memcpy(&g_u8_ini_flash[u16_offset], &u8_raw_uc_cc_30, sizeof(u8_raw_uc_cc_30));
u16_offset += 128;
memcpy((void *)(&g_st_test_para_resv), &u8_test_para_30[0], sizeof(g_st_test_para_resv));
DEBUGOUT("ini length = %d\r\n", u16_offset);
break;
#if defined(FW_MAPPING_EN)
case RAD_SELFTEST_31:
u16_offset = 0;
memcpy(&g_u8_ini_flash[u16_offset], &u8_test_info_31, sizeof(u8_test_info_31));
u16_offset += 16;
memcpy(&g_u8_ini_flash[u16_offset], &i8_ft_test_thd_31, sizeof(i8_ft_test_thd_31));
u16_offset += 36;
memcpy(&g_u8_ini_flash[u16_offset], &u8_test_para_31, sizeof(u8_test_para_31));
u16_offset += 48;
u16_offset += 128;/*reserve for BL*/
memcpy(&g_u8_ini_flash[u16_offset], &u8_raw_data_3_cc_31, sizeof(u8_raw_data_3_cc_31));
u16_offset += 128;
memcpy(&g_u8_ini_flash[u16_offset], &u8_raw_uc_cc_31, sizeof(u8_raw_uc_cc_31));
u16_offset += 128;
memcpy((void *)(&g_st_test_para_resv), &u8_test_para_31[0], sizeof(g_st_test_para_resv));
DEBUGOUT("ini length = %d\r\n", u16_offset);
break;
#endif
}
return 0;
}
int raydium_do_selftest(struct raydium_ts_data *ts)
{
int ret = RESULT_SUCCESS;
unsigned int time_start, time_end, time_start2, time_end2;
time_start = get_system_time();
pr_info("Selftest Version=%x.%x.%x.%x.%x\n", RM_SELF_TEST_CUSTOMER_VERSION, RM_SELF_TEST_PLATFORM_VERSION,
RM_SELF_TEST_PROJECT_VERSION, RM_SELF_TEST_MAIN_VERSION, RM_SELF_TEST_SUB_VERSION);
self_test_read_setting_from_file();
ic_drv_init();
set_raydium_ts_data(ts);
ret = self_test_init();
if (ret != 0)
DEBUGOUT("mapping ic fw fail\n");
else {
DEBUGOUT("Test all\n");
ret |= self_test_all();
}
if (ret != WEARABLE_FT_TEST_RESULT_SYSFS_NG) {
gpio_touch_hw_reset();
g_u8_raydium_flag &= ~ENG_MODE;
}
raydium_i2c_mode_control(ts->client, ENABLE_TOUCH_INT);
#if ENABLE_TIME_MEASURMENT
time_start2 = get_system_time();
#endif
self_test_save_test_raw_data_to_file(ret);
#if ENABLE_TIME_MEASURMENT
time_end2 = get_system_time();
DEBUGOUT("Write log Finish(%ums)\n", time_end2 - time_start2);
#endif
if (ret != 0) {
DEBUGOUT("Selftest Test Result=0x%x\n", ret);
ret = RESULT_NG;
DEBUGOUT("Selftest Result=%d\n", ret);
} else {
DEBUGOUT("Selftest Pass ^_^!!!\n");
ret = RESULT_SUCCESS;
}
time_end = get_system_time();
DEBUGOUT("All Test Finish(%ums)\n", time_end - time_start);
return ret;
}
Reference in New Issue View Git Blame Copy Permalink