From 6a8ca52d17f83396d48ad8ee09cc5c01fe04130c Mon Sep 17 00:00:00 2001 From: penglei <1624952103@qq.com> Date: Fri, 7 Nov 2025 18:10:53 +0800 Subject: [PATCH] =?utf8?q?272=E5=8A=A0=E5=85=A5tp=E9=A9=B1=E5=8A=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit --- .../brandy/brandy_standard/thread_pri_init.c | 8 + .../config/target_config/brandy/config.py | 12 +- .../product/product_evb4_standard.h | 4 + .../drivers/driver/touch/CMakeLists.txt | 12 + .../driver/touch/cst92xx_touch/cst92xx_ctrl.c | 371 ++++++ .../driver/touch/cst92xx_touch/cst92xx_ctrl.h | 82 ++ .../driver/touch/cst92xx_touch/cst92xx_drv1.c | 112 ++ .../driver/touch/cst92xx_touch/cst92xx_drv1.h | 22 + .../touch/cst92xx_touch/cst92xx_touch1.c | 1019 +++++++++++++++++ .../touch/cst92xx_touch/cst92xx_touch1.h | 237 ++++ .../drivers/driver/touch/touch_screen_drv.c | 15 + .../factorytest_protocol.c | 10 +- 12 files changed, 1896 insertions(+), 8 deletions(-) create mode 100644 code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_ctrl.c create mode 100644 code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_ctrl.h create mode 100644 code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_drv1.c create mode 100644 code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_drv1.h create mode 100644 code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_touch1.c create mode 100644 code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_touch1.h diff --git a/code/sdk/application/brandy/brandy_standard/thread_pri_init.c b/code/sdk/application/brandy/brandy_standard/thread_pri_init.c index 8d0f885e0..2e726b433 100644 --- a/code/sdk/application/brandy/brandy_standard/thread_pri_init.c +++ b/code/sdk/application/brandy/brandy_standard/thread_pri_init.c @@ -40,6 +40,8 @@ #include "ft6x46_touch1.h" #elif defined(TPTYPE_CST86XX) #include "cst86xx_touch1.h" +#elif defined(TPTYPE_CST92XX) +#include "cst92xx_touch1.h" #else #include "ztw523_touch1.h" #endif @@ -166,13 +168,19 @@ static void sample_gfx_init(void) ft6x46_host_init_sample(); #elif defined(TPTYPE_CST86XX) cst86xx_host_init_sample(); +#elif defined(TPTYPE_CST92XX) + cst92xx_host_init_sample(); + printf("cst92xx_host_init_sample \n"); #else ztw523_host_init_sample(); #endif #endif + printf("11111 \n"); uapi_lcd_init(); uapi_vau_module_init(); + printf("22222 \n"); uapi_dpu_module_init(); + printf("33333 \n"); #ifdef SUPPORT_GPU_JPEG uapi_jpeg_module_init(); #endif diff --git a/code/sdk/build/config/target_config/brandy/config.py b/code/sdk/build/config/target_config/brandy/config.py index 7fd02940e..418c8a497 100644 --- a/code/sdk/build/config/target_config/brandy/config.py +++ b/code/sdk/build/config/target_config/brandy/config.py @@ -1127,7 +1127,7 @@ target = { 'SUPPORT_CHARGER_PLUG_DETECTION_NOTIFICATION', # 'SUPPORT_AT_CUSTOMUTILS', 'SUPPORT_BLE_SERVICE', - 'SUPPORT_MAG_SERVICE', + # 'SUPPORT_MAG_SERVICE', 'SUPPORT_PPG_SERVICE', 'SUPPORT_CYWEE_SERVICE', 'SUPPORT_BATTERY_SERVICE', @@ -1142,7 +1142,8 @@ target = { 'CFG_FLASH_SIZE=16', 'CONFIG_NORFLASH_SIZE=16', 'SINGLE_USER_PARTITION', - 'TPTYPE_FT6X46', + # 'TPTYPE_FT6X46', + 'TPTYPE_CST92XX', # 'ROTARYENCODER_HX3507', 'NANDFLASH_DS35X', 'BLE_INSTRUCT', @@ -1166,7 +1167,7 @@ target = { "ppg_sensor_hx3695", "ppgBleService", # "mag_sensor_mmc5603", - "mag_sensor_qmc6309", + # "mag_sensor_qmc6309", "vibrator", "vibrator_service", # "-:lwip", @@ -1197,7 +1198,7 @@ target = { # "hid_service", "producttest", "ppg_hal", - "mag_service", + # "mag_service", "cywee_dml", "cyweeBleService", "charge_ic_hp4570", @@ -1219,7 +1220,8 @@ target = { 'BOARD_FD272', 'FT_SINGLE_UART', 'NANDFLASH_DS35X', - 'TPTYPE_FT6X46', + # 'TPTYPE_FT6X46', + 'TPTYPE_CST92XX', 'CFG_FLASH_SIZE=16', 'CONFIG_NORFLASH_SIZE=16', 'CUSTOM_ZHIHUI', diff --git a/code/sdk/drivers/boards/brandy_evb/product/product_evb4_standard.h b/code/sdk/drivers/boards/brandy_evb/product/product_evb4_standard.h index f753c295c..9c041e006 100644 --- a/code/sdk/drivers/boards/brandy_evb/product/product_evb4_standard.h +++ b/code/sdk/drivers/boards/brandy_evb/product/product_evb4_standard.h @@ -263,6 +263,10 @@ #define CST86XX_INT_GPIO S_AGPIO_R5 #define CST86XX_RESET_GPIO S_AGPIO_R4 +#define CST92XX_I2C_BUS I2C_BUS_1 +#define CST92XX_INT_GPIO S_AGPIO_R5 +#define CST92XX_RESET_GPIO S_AGPIO_R4 + //GNSS Config #define GNSS_RESET_PIN // TRACK MODE diff --git a/code/sdk/drivers/drivers/driver/touch/CMakeLists.txt b/code/sdk/drivers/drivers/driver/touch/CMakeLists.txt index db020dcc1..d6768280f 100644 --- a/code/sdk/drivers/drivers/driver/touch/CMakeLists.txt +++ b/code/sdk/drivers/drivers/driver/touch/CMakeLists.txt @@ -33,6 +33,12 @@ set(SOURCES ${SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/cst86xx_touch/cst86xx_drv1.c ${CMAKE_CURRENT_SOURCE_DIR}/cst86xx_touch/cst86xx_touch1.c ) +elseif("TPTYPE_CST92XX" IN_LIST DEFINES) +set(SOURCES ${SOURCES} + ${CMAKE_CURRENT_SOURCE_DIR}/cst92xx_touch/cst92xx_ctrl.c + ${CMAKE_CURRENT_SOURCE_DIR}/cst92xx_touch/cst92xx_drv1.c + ${CMAKE_CURRENT_SOURCE_DIR}/cst92xx_touch/cst92xx_touch1.c +) else() set(SOURCES ${SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/ztw523_touch/ztw523_ctrl.c @@ -65,6 +71,12 @@ set(PUBLIC_HEADER ${CMAKE_CURRENT_SOURCE_DIR}/cst86xx_touch ${ROOT_DIR}/middleware/services/gui/hal/input/include ) +elseif("TPTYPE_CST92XX" IN_LIST DEFINES) +set(PUBLIC_HEADER + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/cst92xx_touch + ${ROOT_DIR}/middleware/services/gui/hal/input/include +) else() set(PUBLIC_HEADER ${CMAKE_CURRENT_SOURCE_DIR} diff --git a/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_ctrl.c b/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_ctrl.c new file mode 100644 index 000000000..46e2f6a4e --- /dev/null +++ b/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_ctrl.c @@ -0,0 +1,371 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: cst92xx touch driver. + * Author: @CompanyNameTag + * Create: 2022-04-12 + */ + +#include "cst92xx_ctrl.h" +#include "securec.h" +#include "cmsis_os2.h" +#include "soc_osal.h" +#include "common_def.h" +#include "pinctrl.h" +#include "chip_io.h" +#include "tcxo.h" +#include "time.h" +#include "i2c.h" +#include "gpio.h" +#include "hal_gpio.h" +#include "hal_i2c.h" +#include "touch_screen_def.h" + +bool g_host_dev_init_flag = TD_FALSE; +cst92xx_ctrl_attr g_ctrl_attr; +touch_callback g_cst92xx_callback = NULL; +static uint8_t g_tp_send_buf[CST92XX_REG_WRITE_LEN] = {0}; +static uint8_t g_tp_recv_buf[CST92XX_INPUT_SIZE] = {0}; + +static void cst92xx_gpio_isr_handle(pin_t pin, uintptr_t param) +{ + unused(pin); + unused(param); + if (g_cst92xx_callback != NULL) { + g_cst92xx_callback(); + } +} + +ext_errno cst92xx_register_handle(const cst92xx_ctrl_ops *peri_data, touch_callback func) +{ + unused(peri_data); + ext_errno ret; + + g_cst92xx_callback = func; + /* register int io interrupt handler */ + uapi_gpio_init(); + gpio_select_core(CST92XX_INT_GPIO, CORE); + uapi_gpio_set_dir(CST92XX_INT_GPIO, GPIO_DIRECTION_INPUT); + ret = uapi_gpio_register_isr_func(CST92XX_INT_GPIO, GPIO_INTERRUPT_FALLING_EDGE, cst92xx_gpio_isr_handle); + if (ret != 0) { + tp_err("cst92xx int callback register fail! ret=0x%x", ret); + return ret; + } + + return EXT_ERR_SUCCESS; +} + +ext_errno cst92xx_unregister_handle(const cst92xx_ctrl_ops *peri_data) +{ + unused(peri_data); + ext_errno ret; + + /* unregister interrupt handler */ + uapi_gpio_unregister_isr_func(CST92XX_INT_GPIO); + g_cst92xx_callback = NULL; + + return EXT_ERR_SUCCESS; +} + +static ext_errno tp_peripheral_init_status_check(void) +{ + if (g_host_dev_init_flag != TD_TRUE) { + return EXT_ERR_TP_DEV_INFO_NOT_REGISTER; + } + + return EXT_ERR_SUCCESS; +} + +// static ext_errno cst92xx_ctrl_attr_check(const cst92xx_ctrl_attr *device_attr) +// { +// unused(device_attr); +// return EXT_ERR_SUCCESS; +// } + +static ext_errno cst92xx_tp_i2c_rd_wr_param_check(const uint8_t *data_buf, uint32_t data_len) +{ + unused(data_buf); + unused(data_len); + ext_errno ret = tp_peripheral_init_status_check(); + if (ret != EXT_ERR_SUCCESS) { + return ret; + } + + return EXT_ERR_SUCCESS; +} + +ext_errno cst92xx_tp_i2c_data_read(uint32_t reg_addr, uint8_t reg_len, uint8_t *data_buf, uint32_t data_len) +{ + errcode_t ret; + uint32_t retry; + i2c_data_t data = {0}; + + uint8_t reg_addr_buf[4] = {0}; + + ret = cst92xx_tp_i2c_rd_wr_param_check(data_buf, data_len); + if (ret != 0) { + tp_err("tp data read param invalid! ret=0x%x", ret); + return ret; + } + + if (memset_s(g_tp_recv_buf, data_len, 0, data_len) != EOK) { + tp_err("tp read buff set fail!"); + return EXT_ERR_FAILURE; + } + + // printf("reg_addr : 0x%x\n",reg_addr); + // for(int i = 0; i < reg_len; i++) + // { + // data.send_buf[i] = ((uint8_t*)®_addr)[i]; + // } + + uint8_t reg_buf[4] = {0}; + + switch (reg_len) { + case 1: + reg_buf[0] = reg_addr & 0xFF; + break; + case 2: + reg_buf[0] = (reg_addr >> 8) & 0xFF; + reg_buf[1] = reg_addr & 0xFF; + break; + case 3: + reg_buf[0] = (reg_addr >> 16) & 0xFF; + reg_buf[1] = (reg_addr >> 8) & 0xFF; + reg_buf[2] = reg_addr & 0xFF; + break; + case 4: + reg_buf[0] = (reg_addr >> 24) & 0xFF; + reg_buf[1] = (reg_addr >> 16) & 0xFF; + reg_buf[2] = (reg_addr >> 8) & 0xFF; + reg_buf[3] = reg_addr & 0xFF; + break; + default: + return EXT_ERR_INVALID_PARAM; + } + + + data.send_buf = reg_buf; + data.send_len = reg_len; + data.receive_buf = g_tp_recv_buf; + data.receive_len = data_len; + + // printf("send_buf[0]:[%x] send_buf[1]:[%x] send_buf[2]:[%x] send_buf[3]:[%x]\n",data.send_buf[0],data.send_buf[1],data.send_buf[2],data.send_buf[3]); + + for (retry = 0; retry < CST92XX_I2C_TIME_MAX; retry++) { + ret = uapi_i2c_master_writeread(CST92XX_I2C_BUS, CST92XX_I2C_ADDR, &data); + if (ret == EXT_ERR_SUCCESS) { + break; + } + } + if (ret != EXT_ERR_SUCCESS) { + tp_err("tp data read fail! ret=0x%x", ret); + return ret; + } + + ret = (uint32_t)memcpy_s(data_buf, data_len, g_tp_recv_buf, data_len); + if (ret != EOK) { + tp_err("tp data buf content copy fail! ret=0x%x", ret); + return ret; + } + + return EXT_ERR_SUCCESS; +} + +ext_errno cst92xx_tp_i2c_cmd_write(uint16_t cmd) +{ + errcode_t ret; + uint32_t retry; + i2c_data_t data; + + ret = tp_peripheral_init_status_check(); + if (ret != 0) { + tp_err("host peripheral not init! ret=0x%x", ret); + return ret; + } + g_tp_send_buf[CST92XX_I2C_SEND_INDEX0] = cmd & 0xff; + data.send_buf = g_tp_send_buf; + data.send_len = CST92XX_CMD_SEND_LEN; + data.receive_buf = NULL; + data.receive_len = 0; + + for (retry = 0; retry < CST92XX_I2C_TIME_MAX; retry++) { + ret = uapi_i2c_master_write(CST92XX_I2C_BUS, CST92XX_I2C_ADDR, &data); + if (ret == EXT_ERR_SUCCESS) { + break; + } + } + if (ret != EXT_ERR_SUCCESS) { + tp_err("tp data write fail! ret=0x%x", ret); + return ret; + } + + return EXT_ERR_SUCCESS; +} + +ext_errno cst92xx_tp_i2c_reg_write(uint16_t reg_addr, uint16_t reg_cfg) +{ + errcode_t ret; + uint32_t retry; + i2c_data_t data; + + ret = tp_peripheral_init_status_check(); + if (ret != 0) { + tp_err("host peripheral not init! ret=0x%x", ret); + return ret; + } + + g_tp_send_buf[CST92XX_I2C_SEND_INDEX0] = reg_addr & 0xff; + g_tp_send_buf[1] = reg_cfg & 0xff; + + data.send_buf = g_tp_send_buf; + data.send_len = CST92XX_REG_WRITE_LEN; + data.receive_buf = NULL; + data.receive_len = 0; + + for (retry = 0; retry < CST92XX_I2C_TIME_MAX; retry++) { + ret = uapi_i2c_master_write(CST92XX_I2C_BUS, CST92XX_I2C_ADDR, &data); + if (ret == EXT_ERR_SUCCESS) { + break; + } + } + if (ret != EXT_ERR_SUCCESS) { + tp_err("tp reg write fail! ret=0x%x", ret); + return ret; + } + + return EXT_ERR_SUCCESS; +} + +ext_errno cst92xx_tp_i2c_data_write(uint8_t *data_buf, uint32_t data_len) +{ + errcode_t ret; + uint32_t retry; + i2c_data_t data; + uint8_t *write_data = NULL; + uint32_t send_len; + + ret = cst92xx_tp_i2c_rd_wr_param_check(data_buf, data_len); + if (ret != 0) { + tp_err("tp data write param invalid! ret=0x%x", ret); + return ret; + } + + send_len = data_len; + + write_data = (uint8_t *)osal_kmalloc(send_len, OSAL_GFP_KERNEL); + if (write_data == NULL) { + tp_err("tp send buff malloc fail!"); + return EXT_ERR_MALLOC_FAILURE; + } + + ret = (uint32_t)memcpy_s(write_data, send_len , data_buf, data_len); + if (ret != EOK) { + tp_err("tp send_buf content copy fail! ret=0x%x", ret); + osal_kfree(write_data); + return ret; + } + + data.send_buf = write_data; + data.send_len = send_len; + data.receive_buf = NULL; + data.receive_len = 0; + + for (retry = 0; retry < CST92XX_I2C_TIME_MAX; retry++) { + ret = uapi_i2c_master_write(CST92XX_I2C_BUS, CST92XX_I2C_ADDR, &data); + if (ret == EXT_ERR_SUCCESS) { + break; + } + } + if (ret != EXT_ERR_SUCCESS) { + tp_err("tp data write fail! ret=0x%x", ret); + osal_kfree(write_data); + return ret; + } + + osal_kfree(write_data); + return EXT_ERR_SUCCESS; +} + +ext_errno cst92xx_host_peripheral_init(cst92xx_ctrl_attr *attr) +{ + ext_errno ret; + + if (attr == NULL) { + tp_err("cst92xx communication interface cfg is empty!"); + return EXT_ERR_FAILURE; + } + // ret = cst92xx_ctrl_attr_check(attr); + // if (ret != EXT_ERR_SUCCESS) { + // tp_err("tp invalid dev attr! ret=0x%x", ret); + // return ret; + // } + + // ret = (ext_errno)memcpy_s(&(g_ctrl_attr), sizeof(cst92xx_ctrl_attr), attr, sizeof(cst92xx_ctrl_attr)); + // if (ret != EOK) { + // tp_err("tp attr content copy fail! ret=0x%x", ret); + // return ret; + // } + + /* init i2c */ + errcode_t result; + result = uapi_i2c_master_init(CST92XX_I2C_BUS, 100000, I2C_SPEED_MODE_SS); /* 400000: 400KHz */ + if (result != EXT_ERR_SUCCESS) { + tp_err("tp i2c init fail! ret=0x%x", result); + return EXT_ERR_SUCCESS; + } + + tp_warning("TOUCH:i2c_id = %d i2c_speed = %d slave_addr = 0x%x \r\n", + CST92XX_I2C_BUS, 100000, CST92XX_I2C_ADDR); + g_host_dev_init_flag = true; + + return EXT_ERR_SUCCESS; +} + +ext_errno cst92xx_host_init_sample(void) +{ + ext_errno ret; + tp_warning("cst92xx_host_init_sample"); + ret = cst92xx_host_peripheral_init(&g_ctrl_attr); + if (ret != EXT_ERR_SUCCESS) { + tp_err("tp host init fail! ret=0x%x", ret); + return ret; + } + ret = cst92xx_init(NULL); + if (ret != EXT_ERR_SUCCESS) { + tp_err("tp init fail! ret=0x%x", ret); + return ret; + } + + return EXT_ERR_SUCCESS; +} + +ext_errno cst92xx_reset(void) +{ + uapi_gpio_set_dir(CST92XX_RESET_GPIO, GPIO_DIRECTION_OUTPUT); + /* Config Gpio For Reset Pin */ + // uapi_gpio_set_val(CST92XX_RESET_GPIO, GPIO_LEVEL_HIGH); + // /* reset high delay 20ms */ + // osDelay(1); + uapi_gpio_set_val(CST92XX_RESET_GPIO, GPIO_LEVEL_LOW); + /* reset low delay 100ms */ + osDelay(8); + uapi_gpio_set_val(CST92XX_RESET_GPIO, GPIO_LEVEL_HIGH); + /* reset high delay 200ms */ + // osDelay(100); + return EXT_ERR_SUCCESS; +} + +void cst92xx_resume_reset(void) +{ + uapi_gpio_set_dir(CST92XX_RESET_GPIO, GPIO_DIRECTION_OUTPUT); + /* drvdata is global variable point and no need to handle null */ + uapi_gpio_set_val(CST92XX_RESET_GPIO, GPIO_LEVEL_HIGH); + osDelay(1); + uapi_gpio_set_val(CST92XX_RESET_GPIO, GPIO_LEVEL_LOW); + /* delay 10ms */ + osDelay(10); + uapi_gpio_set_val(CST92XX_RESET_GPIO, GPIO_LEVEL_HIGH); + /* delay 100ms */ + osDelay(100); + // uapi_gpio_set_dir(CST92XX_RESET_GPIO, GPIO_DIRECTION_INPUT); +} \ No newline at end of file diff --git a/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_ctrl.h b/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_ctrl.h new file mode 100644 index 000000000..6b940ea19 --- /dev/null +++ b/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_ctrl.h @@ -0,0 +1,82 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: cst92xx touch driver. + * Author: @CompanyNameTag + * Create: 2022-04-12 + */ + +#ifndef CST92XX_CTRL_H +#define CST92XX_CTRL_H + +#include "stdio.h" +#include "debug_print.h" +#include "stdint.h" +#include "product.h" +#include "td_base.h" +#include "platform_core.h" +#include "cst92xx_touch1.h" +#include "touch_screen_def.h" + + +//_TODO: +#define CTP_USE_SW_I2C 0 //hard i2c:0 gpio i2c:1 +#define CTP_SLAVER_ADDR (0x5A) //(8bit write addr 0x15<<1) + +#define CTP_HYNITRON_AUTO_UPDATE 0 // enable update +#define CTP_HYNITRON_CST816S_UPDATE 0 //820S 816S +#define CTP_HYNITRON_CST816T_UPDATE 0 //820 816t 816D +#define CTP_HYNITRON_CST78xx_UPDATE 0 //716 830 826 836U + +#define CTP_TRUE (0) +#define CTP_FALSE (-1) + +#define OUTPUT 1 +#define INPUT 0 + + +#define DBG_CTP +#ifdef DBG_CTP +#define ctp_dbg_print(fmt,args...) printf("[HYN]"fmt"\n\r", ##args) +#else +#define ctp_dbg_print(...) +#endif + + +/* host peripheral definitions */ +#define CST92XX_I2C_ADDR 0x5A +#define CST92XX_I2C_SPEED I2C_SPEED_MODE_SS +#define CST92XX_REG_WRITE_LEN 4 +#define CST92XX_CMD_SEND_LEN 1 +#define CST92XX_REG_DATA_LEN 1 +#define CST92XX_I2C_TIME_MAX 3 +#define CST92XX_INPUT_SIZE 64 +#define CST92XX_I2C_SEND_INDEX0 0 +// #define CST92XX_I2C_SEND_INDEX1 1 +// #define CST92XX_I2C_SEND_INDEX2 2 +// #define CST92XX_I2C_SEND_INDEX3 3 +typedef struct { + uint32_t int_gpio; + i2c_bus_t i2c_id; + uint32_t i2c_speed; +} cst92xx_ctrl_attr; + +typedef ext_errno (*cst92xx_bus_init)(cst92xx_ctrl_attr *attr); + +typedef struct { + cst92xx_ctrl_attr attr; + cst92xx_bus_init bus_init; +} cst92xx_ctrl_ops; + +ext_errno cst92xx_host_peripheral_init(cst92xx_ctrl_attr *attr); +ext_errno cst92xx_register_handle(const cst92xx_ctrl_ops *peri_data, touch_callback func); +ext_errno cst92xx_unregister_handle(const cst92xx_ctrl_ops *peri_data); +ext_errno cst92xx_reset(void); +void cst92xx_resume_reset(void); +void cst92xx_delay(uint32_t ms); + +ext_errno cst92xx_tp_i2c_data_read(uint32_t reg_addr, uint8_t reg_len , uint8_t *data_buf, uint32_t data_len); +ext_errno cst92xx_tp_i2c_cmd_write(uint16_t cmd); +ext_errno cst92xx_tp_i2c_reg_write(uint16_t reg_addr, uint16_t reg_cfg); +ext_errno cst92xx_tp_i2c_data_write(uint8_t *data_buf, uint32_t data_len); + +#endif diff --git a/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_drv1.c b/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_drv1.c new file mode 100644 index 000000000..5e7629d21 --- /dev/null +++ b/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_drv1.c @@ -0,0 +1,112 @@ +/* + * @Author: penglei 1624952103@qq.com + * @Date: 2025-11-07 10:11:38 + * @LastEditors: penglei 1624952103@qq.com + * @LastEditTime: 2025-11-07 11:41:11 + * @FilePath: /FD230/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_drv1.c + * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE + */ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: cst92xx touch driver. + * Author: @CompanyNameTag + * Create: 2022-04-12 + */ + +#include "cst92xx_drv1.h" +#include "touch_screen_def.h" +#include "cst92xx_ctrl.h" +#include "cst92xx_touch1.h" +#include "i2c.h" +#include "debug_print.h" +#include "hal_i2c.h" + +static ext_errno cst92xx_drv_init(cst92xx_ctrl_ops *config) +{ + ext_errno ret; + cst92xx_ctrl_ops *ops = config; + + if (ops == NULL) { + tp_err("peripheral ops is empty!"); + return EXT_ERR_FAILURE; + } + + if (ops->bus_init == NULL) { + tp_err("peripheral bus_init func is empty!"); + return EXT_ERR_FAILURE; + } + + ret = ops->bus_init(&(ops->attr)); + if (ret != EXT_ERR_SUCCESS) { + tp_err("CST92XX bus_init fail! ret = 0x%x", ret); + return ret; + } + + ret = cst92xx_init(NULL); + if (ret != EXT_ERR_SUCCESS) { + tp_err("CST92XX init fail! ret = 0x%x", ret); + return ret; + } + + return EXT_ERR_SUCCESS; +} + +static ext_errno cst92xx_drv_deinit(void) +{ + return EXT_ERR_SUCCESS; +} + +static ext_errno cst92xx_drv_get_info(uint8_t *data, uint8_t data_len) +{ + return cst92xx_irq_callback(data, data_len); +} + +static ext_errno cst92xx_drv_suspend(void) +{ + return cst92xx_set_workmode(DEEPSLEEP,1); +} + +static ext_errno cst92xx_drv_resume(void) +{ + cst92xx_reset(); + osDelay(50); + cst92xx_set_workmode(NOMAL_MODE,1); + return 0; + // return cst92xx_set_power_mode(MC_TP_RESUME_SCAN); +} + +static ext_errno cst92xx_drv_sleep(void) +{ + return cst92xx_set_workmode(DEEPSLEEP,1); +} + +touch_peripheral_api g_cst92xx_api = { + .touch_init = cst92xx_drv_init, + .touch_deinit = cst92xx_drv_deinit, + .touch_get_tpinfo = cst92xx_drv_get_info, + .touch_suspend = cst92xx_drv_suspend, + .touch_resume = cst92xx_drv_resume, + .touch_sleep = cst92xx_drv_sleep, + .touch_bus_init = cst92xx_host_peripheral_init, + .register_callback = cst92xx_register_handle, + .unregister_callback = cst92xx_unregister_handle, +}; + +cst92xx_ctrl_ops g_cst92xx_ctrl = { + .attr = { + .int_gpio = CST92XX_INT_GPIO, + .i2c_id = CST92XX_I2C_BUS, + .i2c_speed = I2C_SPEED_MODE_SS, + }, + .bus_init = (cst92xx_bus_init)cst92xx_host_peripheral_init, +}; + +void *touch_screen_get_api(void) +{ + return ((void *)&g_cst92xx_api); +} + +void *touch_screen_get_peri_attr(void) +{ + return ((void *)&g_cst92xx_ctrl); +} \ No newline at end of file diff --git a/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_drv1.h b/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_drv1.h new file mode 100644 index 000000000..f22bb9013 --- /dev/null +++ b/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_drv1.h @@ -0,0 +1,22 @@ +/* + * @Author: penglei 1624952103@qq.com + * @Date: 2025-11-07 10:12:23 + * @LastEditors: penglei 1624952103@qq.com + * @LastEditTime: 2025-11-07 10:12:47 + * @FilePath: /FD230/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_drv1.h + * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE + */ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: cst92xx touch driver. + * Author: @CompanyNameTag + * Create: 2022-04-12 + */ + +#ifndef CST92XX_DRV1_H +#define CST92XX_DRV1_H + +void *touch_screen_get_api(void); +void *touch_screen_get_peri_attr(void); + +#endif \ No newline at end of file diff --git a/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_touch1.c b/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_touch1.c new file mode 100644 index 000000000..ef6fee65d --- /dev/null +++ b/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_touch1.c @@ -0,0 +1,1019 @@ +#include "cst92xx_touch1.h" +#include "time.h" +#include "soc_osal.h" +#include "osal_timer.h" +#include "osal_mutex.h" +#include "securec.h" +#include "cst92xx_ctrl.h" +#include "tcxo.h" +#include "cmsis_os2.h" +#include "common_def.h" +#include "hal_gpio.h" + +#define CST92XX_I2C_BUS I2C_BUS_1 + + +#define BOOT_I2C_ADDR (0x5A) +#define MAIN_I2C_ADDR (0x5A) +#define RW_REG_LEN (2) + +#define MAX_FINGER (2) + +#define CST92XX_BIN_SIZE (0x7F80) + +#define HYNITRON_PROGRAM_PAGE_SIZE (128) + +#ifdef BOARD_FD272 +#define LCD_VDD_EN S_AGPIO_L18 +#endif + +static uint32_t point_count=0; + +static struct hyn_ts_data *hyn_92xxdata = NULL; + +static int hyn_wr_reg(struct hyn_ts_data *hyn_92xxdata, uint32_t reg_addr, uint8_t reg_len, uint8_t *rbuf, uint16_t rlen); +static int hyn_write_data(struct hyn_ts_data *hyn_92xxdata,uint8_t *buf, uint8_t reg_len, uint16_t len); +// static void cst92xx_reset(void); +static void hyn_set_i2c_addr(struct hyn_ts_data *ts_data,uint8_t addr); +static void hyn_delay_ms(int cnt); +static int cst92xx_updata_judge(uint8_t *p_fw, uint16_t len); +static uint32_t cst92xx_read_checksum(void); +static int cst92xx_updata_tpinfo(void); +static int cst92xx_enter_boot(void); + + +static int cst92xx_report(void); + +static void hyn_irq_set(struct hyn_ts_data *hyn_92xxdata,bool cmd) +{ + uapi_pin_set_ie(CST92XX_INT_GPIO,cmd); +} + +static void hyn_set_i2c_addr(struct hyn_ts_data *ts_data,uint8_t addr) +{ + ts_data->salve_addr = addr; +} + +static void hyn_delay_ms(int cnt) +{ + LOS_Mdelay(cnt); +} + +static int hyn_write_data(struct hyn_ts_data *hyn_92xxdata,uint8_t *buf, uint8_t reg_len, uint16_t len) +{ + cst92xx_tp_i2c_data_write(buf,reg_len+len); + + return 0; +} + +static int hyn_wr_reg(struct hyn_ts_data *hyn_92xxdata, uint32_t reg_addr, uint8_t reg_len, uint8_t *rbuf, uint16_t rlen) +{ + cst92xx_tp_i2c_data_read(reg_addr,reg_len,rbuf,rlen); + return 0; +} + +// cst92xx_drv_data g_cst92xx_drv = { +// .chip_status = CST92XX_NOT_READY, +// .ops_mux = {0}, +// .int_mask = CST92XX_INT_MASK, +// .work_status = CST92XX_WORK_INVALID, +// .fw_upgrade_flag = TD_FALSE, +// .gesture_wakeup = TD_FALSE, +// .host_dev_init_flag = TD_FALSE, +// .chip_info = CST92XX_DEVICE_INFO, +// .p_void = NULL, +// }; + + +ext_errno cst92xx_irq_callback(uint8_t *data_buf, uint8_t data_len) +{ + unused(data_len); + ext_errno ret; + int32_t mem_ret; + uint16_t reg_write; + + if(hyn_92xxdata == NULL) + { + return EXT_ERR_FAILURE; + } + + if (hyn_92xxdata->power_is_on != 1) { + tp_warning("TOUCH: not ready skip read"); + return EXT_ERR_SUCCESS; + } + + hyn_92xxdata->rp_buf.pos_info->event = MC_TP_INVALID; + + + if (hyn_92xxdata->work_mode == NOMAL_MODE) { + hyn_92xxdata->irq_cnt++; + ret = cst92xx_report(); + if (ret != EXT_ERR_SUCCESS) { + cst92xx_reset(); + tp_err("TOUCH: parse input fail, ret = 0x%x", ret); + return EXT_ERR_FAILURE; + } + } + + mem_ret = memcpy_s(data_buf, sizeof(input_event_info), &(hyn_92xxdata->touch_msg), sizeof(input_event_info)); + if (mem_ret != EOK) { + tp_err("TOUCH:mem cpy error, ret = 0x%x", mem_ret); + return EXT_ERR_FAILURE; + } + + return EXT_ERR_SUCCESS; +} + +// static ext_errno cst92xx_configuration(void) +// { +// ext_errno ret; +// uint16_t reg_read; + +// tp_print("ctp_cst0_init enter "); + +// /* Read Firmware Version */ +// reg_read = 0; +// ret = cst92xx_tp_i2c_data_read(CST92XX_FIRMWARE_VERSION, (uint8_t *)®_read, 1); +// if (ret != EXT_ERR_SUCCESS) { +// return EXT_ERR_FAILURE; +// } +// g_cst92xx_drv.firmware_version = reg_read; + +// /* Read Minor Firmware Version */ +// reg_read = 0; +// ret = cst92xx_tp_i2c_data_read(CST92XX_FACTORY_ID, (uint8_t *)®_read, 1); +// if (ret != EXT_ERR_SUCCESS) { +// return EXT_ERR_FAILURE; +// } +// g_cst92xx_drv.vendor_id = reg_read; + +// /* Read Hw ID */ +// reg_read = 0; +// ret = cst92xx_tp_i2c_data_read(CST92XX_HW_ID, (uint8_t *)®_read, 1); +// if (ret != EXT_ERR_SUCCESS) { +// tp_err("configuration error (read chip id) 0x%x", ret); +// return EXT_ERR_FAILURE; +// } +// g_cst92xx_drv.chip_id = reg_read; +// tp_print("chip_id = 0x%x FW_ver = 0x%x factory_id = 0x%x", +// g_cst92xx_drv.chip_id, +// g_cst92xx_drv.firmware_version, +// g_cst92xx_drv.vendor_id); + +// return EXT_ERR_SUCCESS; +// } + +#if HYN_POWER_ON_UPDATA +#include "cst92xx_fw.h" +int cst92xx_init(struct hyn_ts_data* ts_data) +{ + int ret = 0; + HYN_ENTER(); + hyn_92xxdata = ts_data; + hyn_set_i2c_addr(hyn_92xxdata,MAIN_I2C_ADDR); + cst92xx_reset(); + msleep(40); + ret = cst92xx_updata_tpinfo(); + if(ret == FALSE){ + HYN_INFO("cst92xx_updata_tpinfo failed"); + hyn_92xxdata->work_mode=ENTER_BOOT_MODE; + ret = cst92xx_enter_boot(); + if(ret){ + HYN_ERROR("cst92xx_ic check failed\r\n"); + return FALSE; + } + cst92xx_reset(); + } + hyn_92xxdata->fw_updata_addr = (uint8_t*)fw_bin; + hyn_92xxdata->fw_updata_len = CST92XX_BIN_SIZE; + hyn_92xxdata->need_updata_fw = cst92xx_updata_judge((uint8_t*)fw_bin,CST92XX_BIN_SIZE); + HYN_INFO("cst92xx_init done !!!"); + return TRUE; +} +#else +int cst92xx_init(struct hyn_ts_data* ts_data) +{ + if(hyn_92xxdata == NULL) + hyn_92xxdata = (struct hyn_ts_data*)malloc(sizeof(struct hyn_ts_data)); + + if(hyn_92xxdata == NULL) + { + printf("hyn_92xxdata malloc failed, tp init failed\n "); + return -1; + } + +#ifdef BOARD_FD272 + uapi_gpio_set_dir(LCD_VDD_EN, GPIO_DIRECTION_OUTPUT); + + uapi_gpio_set_val(LCD_VDD_EN, GPIO_LEVEL_HIGH); + uapi_tcxo_delay_ms(10); /* delay 10 ms */ +#endif + + int ret = 0; + HYN_ENTER(); + + cst92xx_reset(); + + hyn_delay_ms(40); + + ret = cst92xx_updata_tpinfo(); + if(ret == FALSE){ + HYN_INFO("cst92xx_updata_tpinfo failed"); + } + ret |= cst92xx_set_workmode(NOMAL_MODE,0); + + hyn_92xxdata->power_is_on = 1; + + return ret; +} +#endif + +static int cst92xx_enter_boot(void) +{ + if(hyn_92xxdata == NULL) + { + return EXT_ERR_FAILURE; + } + + int ok = FALSE,t,retry = 3; + uint8_t i2c_buf[4] = {0}; + hyn_set_i2c_addr(hyn_92xxdata,BOOT_I2C_ADDR); + for (t = 10;; t += 2) + { + if(t >= 30 || retry==0){ + return FALSE; + } + + // cst92xx_reset(); + cst92xx_reset(); + hyn_delay_ms(t); + + ok = hyn_wr_reg(hyn_92xxdata, 0xA001AA, 3, i2c_buf, 2); + if(ok == FALSE || (i2c_buf[0]==0x5A && i2c_buf[1]==0x5A)){ + if(ok==TRUE && retry){ + retry--; + t = 10; + } + continue; + } + hyn_delay_ms(1); + ok = hyn_wr_reg(hyn_92xxdata, 0xA002, 2, i2c_buf, 2); + if(ok == FALSE){ + continue; + } + if ((i2c_buf[0] == 0x55) && (i2c_buf[1] == 0xB0)) { + break; + } + } + ok = hyn_wr_reg(hyn_92xxdata, 0xA00100, 3, i2c_buf, 2); + if(ok == FALSE){ + return FALSE; + } + return TRUE; +} + +static int erase_all_mem(void) +{ + if(hyn_92xxdata == NULL) + { + return EXT_ERR_FAILURE; + } + + int ok = FALSE,t; + uint8_t i2c_buf[8]; + + //erase_all_mem + ok = hyn_wr_reg(hyn_92xxdata, 0xA0140000, 4, i2c_buf, 2); + if (ok == FALSE){ + return FALSE; + } + ok = hyn_wr_reg(hyn_92xxdata, 0xA00C807F, 4, i2c_buf, 2); + if (ok == FALSE){ + return FALSE; + } + ok = hyn_wr_reg(hyn_92xxdata, 0xA004EC, 3, i2c_buf, 2); + if (ok == FALSE){ + return FALSE; + } + + hyn_delay_ms(300); + for (t = 0;; t += 10) { + if (t >= 1000) { + return FALSE; + } + + hyn_delay_ms(10); + + ok = hyn_wr_reg(hyn_92xxdata, 0xA005, 2, i2c_buf, 1); + if (ok == FALSE) { + continue; + } + + if (i2c_buf[0] == 0x88) { + break; + } + } + + return TRUE; +} + + +static int write_mem_page(uint16_t addr, uint8_t *buf, uint16_t len) +{ + int ok = FALSE,t; + uint8_t i2c_buf[1024+2] = {0}; + + i2c_buf[0] = 0xA0; + i2c_buf[1] = 0x0C; + i2c_buf[2] = len; + i2c_buf[3] = len >> 8; + //ok = hyn_i2c_write_r16(HYN_BOOT_I2C_ADDR, 0xA00C, i2c_buf, 2); + ok = hyn_write_data(hyn_92xxdata, i2c_buf,RW_REG_LEN, 4); + if(ok == FALSE){ + return FALSE; + } + + + i2c_buf[0] = 0xA0; + i2c_buf[1] = 0x14; + i2c_buf[2] = addr; + i2c_buf[3] = addr >> 8; + ok = hyn_write_data(hyn_92xxdata, i2c_buf,RW_REG_LEN, 4); + if(ok == FALSE) { + return FALSE; + } + + + i2c_buf[0] = 0xA0; + i2c_buf[1] = 0x18; + memcpy(i2c_buf + 2, buf, len); + ok = hyn_write_data(hyn_92xxdata, i2c_buf,RW_REG_LEN, len+2); + if(ok == FALSE){ + return FALSE; + } + + + ok = hyn_wr_reg(hyn_92xxdata,0xA004EE,3,i2c_buf,2); + if(ok == FALSE){ + return FALSE; + } + + for (t = 0;; t += 10) { + if (t >= 1000) { + return FALSE; + } + + hyn_delay_ms(5); + + ok = hyn_wr_reg(hyn_92xxdata,0xA005,2,i2c_buf,1); + if(ok == FALSE){ + continue; + } + + if (i2c_buf[0] == 0x55) { + break; + } + } + + return TRUE; +} + + +static int write_code(uint8_t *bin_addr,uint8_t retry) +{ + uint8_t data[HYNITRON_PROGRAM_PAGE_SIZE+4];//= (uint8_t *)bin_addr; + uint16_t addr = 0; + uint16_t remain_len = CST92XX_BIN_SIZE; + int ret; + + while (remain_len > 0) { + uint16_t cur_len = remain_len; + if (cur_len > HYNITRON_PROGRAM_PAGE_SIZE) { + cur_len = HYNITRON_PROGRAM_PAGE_SIZE; + } + + if(0 == hyn_92xxdata->fw_file_name[0]){ + memcpy(data, bin_addr + addr, HYNITRON_PROGRAM_PAGE_SIZE); + }else{ + ret = copy_for_updata(hyn_92xxdata,data,addr,HYNITRON_PROGRAM_PAGE_SIZE); + if(ret == FALSE){ + HYN_ERROR("copy_for_updata error"); + return FALSE; + } + } + //HYN_INFO("write_code addr 0x%x 0x%x",addr,*data); + if (write_mem_page(addr, data, cur_len) == FALSE) { + return FALSE; + } + //data += cur_len; + addr += cur_len; + remain_len -= cur_len; + } + return TRUE; +} + + +static uint32_t cst92xx_read_checksum(void) +{ + int ok = FALSE; + uint8_t i2c_buf[4] = {0}; + uint32_t chip_checksum = 0; + uint8_t retry = 5; + + ok = hyn_wr_reg(hyn_92xxdata,0xA00300,3,i2c_buf,2); + if (ok == FALSE) { + return FALSE; + } + hyn_delay_ms(2); + while(retry--){ + hyn_delay_ms(5); + ok = hyn_wr_reg(hyn_92xxdata,0xA000,2,i2c_buf,1); + if (ok == FALSE) { + continue; + } + if(i2c_buf[0]!=0) break; + } + + hyn_delay_ms(1); + if(i2c_buf[0] == 0x01){ + memset(i2c_buf,0,sizeof(i2c_buf)); + ok = hyn_wr_reg(hyn_92xxdata,0xA008,2,i2c_buf,4); + if (ok == FALSE) { + return FALSE; + } + chip_checksum = uint8_tTO32(i2c_buf[3],i2c_buf[2],i2c_buf[1],i2c_buf[0]); + } + else{ + hyn_92xxdata->need_updata_fw = 1; + } + + return chip_checksum; +} + + +static int cst92xx_updata_fw(uint8_t *bin_addr, uint16_t len) +{ + #define CHECKSUM_OFFECT (0x7F6C) + int retry = 0; + int ok_copy = TRUE; + int ok = FALSE; + uint8_t i2c_buf[4]; + + uint32_t fw_checksum=0; + HYN_ENTER(); + + if(len < CST92XX_BIN_SIZE){ + HYN_ERROR("len = %d",len); + goto UPDATA_END; + } + if(len > CST92XX_BIN_SIZE) len = CST92XX_BIN_SIZE; + + if(0 != hyn_92xxdata->fw_file_name[0]){ + //node to update + ok = copy_for_updata(hyn_92xxdata,i2c_buf,CST92XX_BIN_SIZE-20,4); + fw_checksum = uint8_tTO32(i2c_buf[3],i2c_buf[2],i2c_buf[1],i2c_buf[0]); + if(hyn_92xxdata->hw_info.ic_fw_checksum == fw_checksum || ok != 0){ + HYN_INFO("no update,fw_checksum is same:0x%04x",fw_checksum); + goto UPDATA_END; + } + }else{ + fw_checksum = uint8_tTO32(bin_addr[CHECKSUM_OFFECT+3],bin_addr[CHECKSUM_OFFECT+2],bin_addr[CHECKSUM_OFFECT+1],bin_addr[CHECKSUM_OFFECT+0]); + } + HYN_INFO("updating fw checksum:0x%04x",fw_checksum); + + hyn_irq_set(hyn_92xxdata,DISABLE); + // hyn_esdcheck_switch(hyn_92xxdata,DISABLE); + hyn_set_i2c_addr(hyn_92xxdata,BOOT_I2C_ADDR); + + HYN_INFO("updata_fw start"); + for(retry = 1; retry<5; retry++){ + hyn_92xxdata->fw_updata_process = 0; + ok = cst92xx_enter_boot(); + if (ok == FALSE){ + continue; + } + hyn_92xxdata->fw_updata_process = 10; + ok = erase_all_mem(); + if (ok == FALSE){ + continue; + } + hyn_92xxdata->fw_updata_process = 20; + ok = write_code(bin_addr,retry); + if (ok == FALSE){ + continue; + } + hyn_92xxdata->fw_updata_process = 30; + hyn_92xxdata->hw_info.ic_fw_checksum = cst92xx_read_checksum(); + if(fw_checksum != hyn_92xxdata->hw_info.ic_fw_checksum){ + HYN_INFO("out data fw checksum err:0x%04x",hyn_92xxdata->hw_info.ic_fw_checksum); + hyn_92xxdata->fw_updata_process |= 0x80; + continue; + } + hyn_92xxdata->fw_updata_process = 100; + if(retry>=5){ + ok_copy = FALSE; + break; + } + break; + } + + hyn_wr_reg(hyn_92xxdata,0xA006EE,3,i2c_buf,2); //exit boot + hyn_delay_ms(2); + +UPDATA_END: + cst92xx_reset(); + hyn_delay_ms(50); + + hyn_set_i2c_addr(hyn_92xxdata,MAIN_I2C_ADDR); + + if(ok_copy == TRUE){ + cst92xx_updata_tpinfo(); + HYN_INFO("updata_fw success"); + } + else{ + HYN_INFO("updata_fw failed"); + } + + hyn_irq_set(hyn_92xxdata,ENABLE); + + return ok_copy; +} + +static int cst92xx_updata_tpinfo(void) +{ + if(hyn_92xxdata == NULL) + return -1; + + uint8_t buf[30],retry=8; + struct tp_info *ic = &hyn_92xxdata->hw_info; + if(ic == NULL) + return -1; + + int ret = 0; + hyn_92xxdata->boot_is_pass = 0; + while(retry--){ + cst92xx_set_workmode(0xff,DISABLE); + ret = hyn_wr_reg(hyn_92xxdata,0xD101,2,buf,2); + if(ret) continue; + ret = hyn_wr_reg(hyn_92xxdata,0xD1F4,2,buf,28); + printf("buf[19] :0x%x\n",buf[19]); + if(ret==0 && (buf[19]==0x92||buf[19]==0x91)){ + break; + } + ret = -1; + } + if(ret){ + return FALSE; + } + hyn_92xxdata->boot_is_pass = 1; + ic->fw_project_id = ((uint16_t)buf[17] <<8) + buf[16]; + ic->fw_chip_type = ((uint16_t)buf[19] <<8) + buf[18]; + + //firmware_version + ic->fw_ver = (buf[23]<<24)|(buf[22]<<16)|(buf[21]<<8)|buf[20]; + //tx_num rx_num key_num + ic->fw_sensor_txnum = ((uint16_t)buf[1]<<8) + buf[0]; + ic->fw_sensor_rxnum = buf[2]; + ic->fw_key_num = buf[3]; + + ic->fw_res_y = (buf[7]<<8)|buf[6]; + ic->fw_res_x = (buf[5]<<8)|buf[4]; + + //fw_checksum + ic->ic_fw_checksum = (buf[27]<<24)|(buf[26]<<16)|(buf[25]<<8)|buf[24]; + HYN_INFO("IC_info project_id:%04x ictype:%04x fw_ver:%x checksum:%#x",ic->fw_project_id,ic->fw_chip_type,ic->fw_ver,ic->ic_fw_checksum); + + cst92xx_set_workmode(NOMAL_MODE,ENABLE); + + return TRUE; +} + +static int cst92xx_updata_judge(uint8_t *p_fw, uint16_t len) +{ + uint32_t f_checksum,f_fw_ver,f_ictype,f_fw_project_id; + uint8_t *p_data = p_fw + len - 28; //7F64 + struct tp_info *ic = &hyn_92xxdata->hw_info; + + f_fw_project_id = uint8_tTO16(p_data[1],p_data[0]); + f_ictype = uint8_tTO16(p_data[3],p_data[2]); + + f_fw_ver = uint8_tTO16(p_data[7],p_data[6]); + f_fw_ver = (f_fw_ver<<16)|uint8_tTO16(p_data[5],p_data[4]); + + f_checksum = uint8_tTO16(p_data[11],p_data[10]); + f_checksum = (f_checksum << 16)|uint8_tTO16(p_data[9],p_data[8]); + + + HYN_INFO("Bin_info project_id:0x%04x ictype:0x%04x fw_ver:0x%x checksum:0x%x",f_fw_project_id,f_ictype,f_fw_ver,f_checksum); + if( + (f_checksum != ic->ic_fw_checksum && f_fw_ver >= ic->fw_ver && f_ictype == ic->fw_chip_type) + || (hyn_92xxdata->boot_is_pass==0) //empty chip + ){ + HYN_INFO("need update!"); + return 1; //need updata + } + HYN_INFO("cst92xx_updata_judge done, no need update"); + return 0; +} + +//------------------------------------------------------------------------------// + +int cst92xx_set_workmode(uint8_t mode,uint8_t enable) +{ + // printf("mode : %d\n",mode); + int ok = FALSE; + uint8_t i2c_buf[4] = {0}; + uint8_t i = 0; + hyn_92xxdata->work_mode = mode; + + for(i=0;i<3;i++){ + ok = hyn_wr_reg(hyn_92xxdata,0xD11E,2,i2c_buf,2); + LOS_Udelay(200); + ok |= hyn_wr_reg(hyn_92xxdata,0x0002,2,i2c_buf,2); + printf("i2c_buf[1] :0x%x\n",i2c_buf[1]); + if(ok==TRUE && i2c_buf[1] == 0x1E){ + break; + } + } + // hyn_esdcheck_switch(hyn_92xxdata,enable); + switch(mode){ + case NOMAL_MODE: + hyn_irq_set(hyn_92xxdata,ENABLE); + ok = hyn_wr_reg(hyn_92xxdata,0xD109,2,i2c_buf,2); + break; + case GESTURE_MODE: + ok = hyn_wr_reg(hyn_92xxdata,0xD104,2,i2c_buf,2); + break; + case LP_MODE: + ok = hyn_wr_reg(hyn_92xxdata,0xD107,2,i2c_buf,2); + break; + case DIFF_MODE: + ok = hyn_wr_reg(hyn_92xxdata,0xD10D,2,i2c_buf,2); + break; + case RAWDATA_MODE: + ok = hyn_wr_reg(hyn_92xxdata,0xD10A,2,i2c_buf,2); + break; + case FAC_TEST_MODE: + hyn_wr_reg(hyn_92xxdata,0xD114,2,i2c_buf,2); + msleep(50); + break; + case CHARGE_EXIT: + case CHARGE_ENTER: + hyn_92xxdata->charge_is_enable = mode&0x01; + ok = hyn_wr_reg(hyn_92xxdata,(mode&0x01)? 0xD01F:0xD020,2,i2c_buf,2); //charg mode + mode = hyn_92xxdata->work_mode; //not switch work mode + HYN_INFO("set_charge:%d",hyn_92xxdata->charge_is_enable); + break; + case ENTER_BOOT_MODE: + ok = cst92xx_enter_boot(); + break; + case DEEPSLEEP: + hyn_wr_reg(hyn_92xxdata,0xD105,2,i2c_buf,2); + break; + default : + hyn_92xxdata->work_mode = NOMAL_MODE; + ok = -2; + break; + } + if(ok != -2){ + hyn_92xxdata->work_mode = mode; + } + HYN_INFO("set_workmode:%d ret:%d",mode,ok); + return ok; +} + +static int cst92xx_supend(void) +{ + HYN_ENTER(); + cst92xx_set_workmode(DEEPSLEEP,0); + return 0; +} + + +static int cst92xx_resum(void) +{ + cst92xx_reset(); + msleep(50); + cst92xx_set_workmode(NOMAL_MODE,1); + return 0; +} + + + // if (model == 0) + // { + // g_cst92xx_drv.touch_msg.tp_event = MC_TP_RELEASE; + // point_count=0; + // }else{ + // if (point_count==0) + // { + // g_cst92xx_drv.touch_msg.tp_event = MC_TP_PRESS; + // }else{ + // g_cst92xx_drv.touch_msg.tp_event = MC_TP_MOVE; + // } + // point_count++; + // } + + // g_cst92xx_drv.touch_msg.tp_event_info.x_axis[0] = x_axis; + // g_cst92xx_drv.touch_msg.tp_event_info.y_axis[0] = y_axis; + // g_cst92xx_drv.touch_msg.tv_usec = (uint32_t)uapi_tcxo_get_ms(); + + // // } else { + // // g_cst92xx_drv.touch_msg.tp_event = MC_TP_INVALID; + // // tp_warning("TOUCH:parse wrong touchstatus %d", touch_status); + // // return EXT_ERR_SUCCESS; + // // } + + // return EXT_ERR_SUCCESS; + +static int cst92xx_report(void) +{ + if(hyn_92xxdata == NULL) + { + return EXT_ERR_FAILURE; + } + int ret = FALSE; + uint8_t i2c_buf[MAX_FINGER*5+5] = {0}; + uint8_t finger_num = 0,key_state=0,retry=3,re_len=0,ges_state; + + while(--retry){ + hyn_wr_reg(hyn_92xxdata,0xD000,2,i2c_buf,2); //wakeup + LOS_Udelay(200); + ret = hyn_wr_reg(hyn_92xxdata,0xD000,2,i2c_buf,7); + if(ret || i2c_buf[6]!=0xAB || i2c_buf[0]==0xAB){ + ret = -1; + continue; + } + finger_num = i2c_buf[5] & 0x7F; + printf("finger_num : %d\n",finger_num); + if(finger_num > MAX_FINGER){ + ret = -2; + continue; + } + key_state = i2c_buf[5]>>7; + printf("key_state : %d\n",key_state); + re_len = ((finger_num>1 ? finger_num-1:0)+key_state)*5; + if(re_len){ + ret = hyn_wr_reg(hyn_92xxdata,0xD007,2,i2c_buf+7,re_len); + if(ret){ + ret = -2; + continue; + } + } + ret = hyn_wr_reg(hyn_92xxdata,0xD000AB,3,i2c_buf,2); //write end flag + if(ret){ + ret = -3; + continue; + } + else{ + break; + } + } + + if(ret){ + HYN_ERROR("read point erro:%d\r\n",ret); + hyn_wr_reg(hyn_92xxdata,0xD000AB,3,i2c_buf,2); //write end flag + return ret; + } + + ges_state = i2c_buf[4]>>4; + // printf("ges_state :%d\n",ges_state); + if(ges_state){ //gesture + if((ges_state&0x80) == 0x80){ //palm + hyn_92xxdata->gesture_id = IDX_POWER;//IDX_Z;// palm + } + else{ //other gesture + hyn_92xxdata->gesture_id = IDX_POWER;//GESTURE wakeup + } + HYN_INFO("gesture buf4:%#x\r\n",i2c_buf[4]); + hyn_92xxdata->rp_buf.report_need |= REPORT_GES; + printf("111 hyn_92xxdata->rp_buf.report_need |= REPORT_GES \n"); + } + // printf("key_state :%d\n",key_state); + if(key_state){ + uint8_t *data_ptr = i2c_buf; + if(finger_num){ + data_ptr += (finger_num*5+2); + } + if( hyn_92xxdata->rp_buf.report_need==REPORT_NONE){ + hyn_92xxdata->rp_buf.report_need |= REPORT_KEY; + } + hyn_92xxdata->rp_buf.key_id = (data_ptr[1]>>4)-1; //0x17 0x27 0x37 + hyn_92xxdata->rp_buf.key_state = data_ptr[0]==0x83 ? 1:0; //0x83 0x80 + printf("hyn_92xxdata->rp_buf.key_id : %d\n",hyn_92xxdata->rp_buf.key_id); + printf("hyn_92xxdata->rp_buf.key_state : %d\n",hyn_92xxdata->rp_buf.key_state); + } + + if(finger_num){ + uint8_t i = 0,index = 0,id = 0; + uint8_t *data_ptr = i2c_buf; + if( hyn_92xxdata->rp_buf.report_need==REPORT_NONE){ + hyn_92xxdata->rp_buf.report_need |= REPORT_POS; + } + for (i = 0; i < finger_num; i++) { + id = data_ptr[0] >> 4; + + hyn_92xxdata->rp_buf.pos_info[index].pos_id = id; + hyn_92xxdata->rp_buf.pos_info[index].event = (data_ptr[0]&0x0F) ? 1 : 0; + hyn_92xxdata->rp_buf.pos_info[index].pos_x = (data_ptr[1] << 4) | (data_ptr[3] >> 4); + hyn_92xxdata->rp_buf.pos_info[index].pos_y = (data_ptr[2] << 4) | (data_ptr[3] & 0x0F); + hyn_92xxdata->rp_buf.pos_info[index].pres_z = (data_ptr[4] & 0x7F); + + data_ptr += (i==0 ? 7:5); + + + printf("hyn_92xxdata->rp_buf.pos_info[index].event : %d index:%d\n",hyn_92xxdata->rp_buf.pos_info[index].event,index); + uint8_t event = hyn_92xxdata->rp_buf.pos_info[index].event; // 事件标识（0=抬起，1=有效） + uint16_t curr_x = hyn_92xxdata->rp_buf.pos_info[index].pos_x; // 当前X坐标 + uint16_t curr_y = hyn_92xxdata->rp_buf.pos_info[index].pos_y; // 当前Y坐标 + + printf("curr_x:%d,curr_y:%d\n",curr_x,curr_y); + if(curr_x >= 466 || curr_y >= 466) + continue; + + + hyn_92xxdata->touch_msg.tp_event_info.x_axis[0] = curr_x; + hyn_92xxdata->touch_msg.tp_event_info.y_axis[0] = curr_y; + hyn_92xxdata->touch_msg.tv_usec = (uint32_t)uapi_tcxo_get_ms(); + + if(event == 0) + { + point_count = 0; + hyn_92xxdata->touch_msg.tp_event = MC_TP_RELEASE; + } + else + { + if(point_count == 0) + hyn_92xxdata->touch_msg.tp_event = MC_TP_PRESS; + else + hyn_92xxdata->touch_msg.tp_event = MC_TP_MOVE; + + point_count++; + } + + printf("hyn_92xxdata->touch_msg.tp_event %d\n",hyn_92xxdata->touch_msg.tp_event); + + index++; + } + hyn_92xxdata->rp_buf.rep_num = index; + + + + } + + + return 0; +} + + +static uint32_t cst92xx_check_esd(void) +{ + int ok = FALSE; + uint8_t i2c_buf[6], retry; + uint32_t esd_value = 0; + retry = 4; + while (retry--){ + hyn_wr_reg(hyn_92xxdata,0xD048,2,i2c_buf,2); + LOS_Udelay(200); + ok = hyn_wr_reg(hyn_92xxdata,0xD048,2,i2c_buf,1); + if (ok == 0 &&((i2c_buf[0]&0xF0) == 0x20 || (i2c_buf[0]&0xF0) == 0xA0)&&(i2c_buf[0]&0x0F)<10){ + break; + } + else{ + ok = -2; + } + } + if(-2==ok){ //esdcheck failed rest system + hyn_92xxdata->esd_fail_cnt = 3; + esd_value = hyn_92xxdata->esd_last_value; + } + else{ + esd_value = hyn_92xxdata->esd_last_value+1; + } + return esd_value; +} + + +static int cst92xx_prox_handle(uint8_t cmd) +{ + return TRUE; +} + + +static int cst92xx_get_dbg_data(uint8_t *buf, uint16_t len) +{ + int ret = -1; + uint16_t read_len = (hyn_92xxdata->hw_info.fw_sensor_txnum * hyn_92xxdata->hw_info.fw_sensor_rxnum)*2; + uint16_t total_len = read_len + (hyn_92xxdata->hw_info.fw_sensor_txnum + hyn_92xxdata->hw_info.fw_sensor_rxnum)*2; + HYN_ENTER(); + if(total_len > len){ + HYN_ERROR("buf too small"); + return -1; + } + switch(hyn_92xxdata->work_mode){ + case DIFF_MODE: + case RAWDATA_MODE: + ret = hyn_wr_reg(hyn_92xxdata,0x1000,2,buf,read_len); //mt + + buf += read_len; + read_len = hyn_92xxdata->hw_info.fw_sensor_rxnum*2; + ret |= hyn_wr_reg(hyn_92xxdata,0x7000,2,buf,read_len); //rx + + buf += read_len; + read_len = hyn_92xxdata->hw_info.fw_sensor_txnum*2; + ret |= hyn_wr_reg(hyn_92xxdata,0x7200,2,buf,read_len); //tx + + ret |= hyn_wr_reg(hyn_92xxdata,0x000500,3,buf,2); //end + break; + default: + HYN_ERROR("work_mode:%d",hyn_92xxdata->work_mode); + break; + } + return ret==0 ? total_len:-1; +} + + +#define FACTEST_PATH "/sdcard/hyn_fac_test_cfg.ini" +#define FACTEST_LOG_PATH "/sdcard/hyn_fac_test.log" +#define FACTEST_ITEM (MULTI_OPEN_TEST|MULTI_SHORT_TEST) + +static int cst92xx_get_test_result(uint8_t *buf, uint16_t len) +{ + int ret = 0; + struct tp_info *ic = &hyn_92xxdata->hw_info; + uint16_t scap_len = (ic->fw_sensor_txnum + ic->fw_sensor_rxnum)*2; + uint16_t mt_len = ic->fw_sensor_rxnum*ic->fw_sensor_txnum*2,i = 0; + uint16_t *raw_s; + + HYN_ENTER(); + if((mt_len*3 + scap_len) > len || mt_len==0){ + HYN_ERROR("buf too small"); + return FAC_GET_DATA_FAIL; + } + HYN_INFO("---open_higdrv---"); + hyn_wr_reg(hyn_92xxdata,0xD110,2,buf,2); ////test open high + hyn_wait_irq_timeout(hyn_92xxdata,7000); + if(hyn_wr_reg(hyn_92xxdata,0x3000,2,buf,mt_len)){ //open high + ret = FAC_GET_DATA_FAIL; + HYN_ERROR("read open high failed"); + goto selftest_end; + } + hyn_wr_reg(hyn_92xxdata,0x000005,3,buf,2); + + HYN_INFO("---open_low---"); + hyn_wr_reg(hyn_92xxdata,0xD111,2,buf,2); ////test open low + hyn_wait_irq_timeout(hyn_92xxdata,7000); + if(hyn_wr_reg(hyn_92xxdata,0x1000,2,buf + mt_len,mt_len)){ //open low + ret = FAC_GET_DATA_FAIL; + HYN_ERROR("read open low failed"); + goto selftest_end; + } + hyn_wr_reg(hyn_92xxdata,0x000005,3,buf,2); + + //short test + HYN_INFO("---short---"); + hyn_wr_reg(hyn_92xxdata,0xD112,2,buf,2); //// short test + hyn_wait_irq_timeout(hyn_92xxdata,7000); + if(hyn_wr_reg(hyn_92xxdata,0x5000,2,buf+(mt_len*2),scap_len)){ + ret = FAC_GET_DATA_FAIL; + HYN_ERROR("read fac short failed"); + goto selftest_end; + } + else{ + raw_s = (uint16_t*)(buf + mt_len*2); + HYN_INFO("raw_s start data = %d",*(raw_s)); + for(i = 0; i< ic->fw_sensor_rxnum+ic->fw_sensor_txnum; i++){ + HYN_INFO("short raw data = %d %d",i,*(raw_s+i)); + if(U16REV((uint16_t)*raw_s) != 0) *raw_s = 2000 / U16REV((uint16_t)*raw_s); + else *raw_s =0; + HYN_INFO("short reprocess data = %d %d",i,*(raw_s+i)); + raw_s++; + } + } + + //read data finlish start test + ret = factory_multitest(hyn_92xxdata ,FACTEST_PATH, buf,(int16_t*)(buf+scap_len+mt_len*2),FACTEST_ITEM); + +selftest_end: + if(0 == fac_test_log_save(FACTEST_LOG_PATH,hyn_92xxdata,(int16_t*)buf,ret,FACTEST_ITEM)){ + HYN_INFO("fac_test log save success"); + } + cst92xx_resum(); + + return ret; +} + +const struct hyn_ts_fuc cst92xx_fuc = { + .tp_rest = cst92xx_reset, + .tp_report = cst92xx_report, + .tp_supend = cst92xx_supend, + .tp_resum = cst92xx_resum, + .tp_chip_init = cst92xx_init, + .tp_updata_fw = cst92xx_updata_fw, + .tp_set_workmode = cst92xx_set_workmode, + .tp_check_esd = cst92xx_check_esd, + .tp_prox_handle = cst92xx_prox_handle, + .tp_get_dbg_data = cst92xx_get_dbg_data, + .tp_get_test_result = cst92xx_get_test_result +}; + + diff --git a/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_touch1.h b/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_touch1.h new file mode 100644 index 000000000..f8532813a --- /dev/null +++ b/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_touch1.h @@ -0,0 +1,237 @@ +#ifndef HYNITRON_CORE_H +#define HYNITRON_CORE_H + +#include +#include +#include "touch_screen_def.h" + +// #include "hyn_cfg.h" + +#define HYN_INFO(fmt, args...) printf("[HYN]"fmt"\n", ##args) +#define HYN_INFO2(fmt, args...) if(hyn_data->log_level > 0)printf("[HYN]"fmt"\n", ##args) +#define HYN_INFO3(fmt, args...) if(hyn_data->log_level > 1)printf("[HYN]"fmt"\n", ##args) +#define HYN_INFO4(fmt, args...) if(hyn_data->log_level > 2)printf("[HYN]"fmt"\n", ##args) +#define HYN_ERROR(fmt, args...) printf("[HYN][Error]%s:"fmt"\n",__func__,##args) +#define HYN_ENTER() printf("[HYN][enter]%s\n",__func__) + +#define HYN_POWER_ON_UPDATA (0) //touch fw updata + +#define MAX_POINTS_REPORT (5) //max report point + +#define HYN_DRIVER_VERSION "== Hynitron V2.10 20241111 ==" + +// #define IS_ERR_OR_NULL(x) (x <= 0) +#define U8TO16(x1,x2) ((((x1)&0xFF)<<8)|((x2)&0xFF)) +#define U8TO32(x1,x2,x3,x4) ((((x1)&0xFF)<<24)|(((x2)&0xFF)<<16)|(((x3)&0xFF)<<8)|((x4)&0xFF)) +#define U16REV(x) ((((x)<<8)&0xFF00)|(((x)>>8)&0x00FF)) + +#define CST92XX_TOUCHINFO_LEN (6) + +#undef DISABLE +#undef ENABLE + +#define DISABLE (0) +#define ENABLE (1) + +#define HIGH (1) + + +#define PS_FAR_AWAY 1 +#define PS_NEAR 0 + +#define MULTI_OPEN_TEST (0x80) +#define MULTI_SHORT_TEST (0x01) +#define MULTI_SCAP_TEST (0x02) + + + +enum work_mode{ + NOMAL_MODE = 0, + GESTURE_MODE = 1, + LP_MODE = 2, + DEEPSLEEP = 3, + DIFF_MODE = 4, + RAWDATA_MODE = 5, + BASELINE_MODE = 6, + CALIBRATE_MODE = 7, + FAC_TEST_MODE = 8, + GLOVE_EXIT = 0x10, + GLOVE_ENTER = 0x11, + CHARGE_EXIT = 0x12, + CHARGE_ENTER = 0x13, + ENTER_BOOT_MODE = 0xCA, +}; + +enum report_typ{ + REPORT_NONE = 0, + REPORT_POS = 0x01, + REPORT_KEY = 0x02, + REPORT_GES = 0x04, + REPORT_PROX = 0x08 +}; + +enum fac_test_ero{ + FAC_TEST_PASS = 0, + FAC_GET_DATA_FAIL = -1, + FAC_GET_CFG_FAIL = -4, + FAC_TEST_OPENL_FAIL = -5, + FAC_TEST_OPENH_FAIL = -7, + FAC_TEST_SHORT_FAIL = -6, + FAC_TEST_SCAP_FAIL = -8, +}; + +typedef enum { + CST92XX_POWERDOWN = 0, + CST92XX_POWERUP, +} cst92xx_sw_power_status; + + +enum ges_idx{ + IDX_U = 0, + IDX_UP, + IDX_DOWN, + IDX_LEFT, + IDX_RIGHT, + IDX_O, + IDX_e, + IDX_M, + IDX_L, + IDX_W, + IDX_S, + IDX_V, + IDX_C, + IDX_Z, + IDX_POWER, + IDX_NULL = 0xFF, +}; + + +struct hyn_plat_data { + int reset_gpio; + int irq_gpio; + + uint32_t x_resolution; + uint32_t y_resolution; + int swap_xy; + int reverse_x; + int reverse_y; + + int max_touch_num; + int key_num; + uint32_t key_x_coords[8]; // max support 8 keys + uint32_t key_y_coords; + uint32_t key_code[8]; +}; + +struct hyn_chip_series{ + uint32_t part_no; + uint32_t moudle_id; + uint8_t chip_name[20]; + uint8_t* fw_bin; +}; + +struct ts_frame{ + uint8_t rep_num; + enum report_typ report_need; + uint8_t key_id; + uint8_t key_state; + struct { + uint8_t pos_id; + uint8_t event; + uint16_t pos_x; + uint16_t pos_y; + uint16_t pres_z; + }pos_info[MAX_POINTS_REPORT]; +}; + +struct tp_info{ + uint8_t fw_sensor_txnum; + uint8_t fw_sensor_rxnum; + uint8_t fw_key_num; + uint8_t reserve; + uint16_t fw_res_y; + uint16_t fw_res_x; + uint32_t fw_boot_time; + uint32_t fw_project_id; + uint32_t fw_chip_type; + uint32_t fw_ver; + uint32_t ic_fw_checksum; + uint32_t fw_module_id; +}; + + +struct hyn_ts_data { + uint16_t bus_type; + uint8_t salve_addr; + int gpio_irq; + int esd_fail_cnt; + uint32_t esd_last_value; + enum work_mode work_mode; + + int power_is_on; + uint8_t hyn_irq_flg; + struct hyn_plat_data plat_data; + struct tp_info hw_info; + struct ts_frame rp_buf; + + int boot_is_pass; + int need_updata_fw; + uint8_t fw_file_name[128]; + uint8_t *fw_updata_addr; + int fw_updata_len; + int fw_dump_state; + uint8_t fw_updata_process; + uint8_t host_cmd_save[16]; + + uint8_t log_level; + uint8_t prox_is_enable; + uint8_t prox_state; + + uint8_t gesture_is_enable; + uint8_t gesture_id; + const struct hyn_ts_fuc *hyn_fuc_used; + uint8_t charge_is_enable; + uint8_t glove_is_enable; + input_event_info touch_msg; + int irq_cnt; +}; + +struct hyn_ts_fuc{ + void (*tp_rest)(void); + int (*tp_report)(void); + int (*tp_supend)(void); + int (*tp_resum)(void); + int (*tp_chip_init)(struct hyn_ts_data *ts_data); + int (*tp_updata_fw)(uint8_t *bin_addr, uint16_t len); + int (*tp_set_workmode)(enum work_mode mode,uint8_t enable); + uint32_t (*tp_check_esd)(void); + int (*tp_prox_handle)(uint8_t cmd); + int (*tp_get_dbg_data)(uint8_t *buf,uint16_t len); + int (*tp_get_test_result)(uint8_t *buf,uint16_t len); +}; + +// void hyn_irq_set(struct hyn_ts_data *ts_data, uint8_t value); +// void hyn_esdcheck_switch(struct hyn_ts_data *ts_data, uint8_t enable); +// int copy_for_updata(struct hyn_ts_data *ts_data,uint8_t *buf,uint32_t offset,uint16_t len); + +// int hyn_wait_irq_timeout(struct hyn_ts_data *ts_data,int msec); +// int factory_multitest(struct hyn_ts_data *ts_data ,char *cfg_path, uint8_t *data,s16 *test_th,uint8_t test_item); +// int fac_test_log_save(char *log_name,struct hyn_ts_data *ts_data,s16 *test_data, int test_ret, uint8_t test_item); +// uint16_t hyn_sum16(int val, uint8_t* buf,uint16_t len); +// uint32_t hyn_sum32(int val, uint32_t* buf,uint16_t len); + + +int cst92xx_init(struct hyn_ts_data* ts_data); +int cst92xx_set_workmode(uint8_t mode,uint8_t enable); + +//ic type +extern const struct hyn_ts_fuc cst1xx_fuc; +extern const struct hyn_ts_fuc cst3xx_fuc; +extern const struct hyn_ts_fuc cst66xx_fuc; +extern const struct hyn_ts_fuc cst7xx_fuc; +extern const struct hyn_ts_fuc cst8xxT_fuc; +extern const struct hyn_ts_fuc cst92xx_fuc; +extern const struct hyn_ts_fuc cst3240_fuc; +extern const struct hyn_ts_fuc cst226se_fuc; + +#endif diff --git a/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.c b/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.c index b0a5e6a17..a8a8ac4da 100644 --- a/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.c +++ b/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.c @@ -24,6 +24,9 @@ #elif defined(TPTYPE_CST86XX) #include "cst86xx_drv1.h" #include "cst86xx_ctrl.h" +#elif defined(TPTYPE_CST92XX) +#include "cst92xx_drv1.h" +#include "cst92xx_ctrl.h" #else #include "ztw523_drv1.h" #include "ztw523_ctrl.h" @@ -45,6 +48,10 @@ #define TOUCH_I2C_BUS CST86XX_I2C_BUS #define TOUCH_INT_GPIO CST86XX_INT_GPIO #define TOUCH_RESET_GPIO CST86XX_RESET_GPIO +#elif defined(TPTYPE_CST92XX) +#define TOUCH_I2C_BUS CST92XX_I2C_BUS +#define TOUCH_INT_GPIO CST92XX_INT_GPIO +#define TOUCH_RESET_GPIO CST92XX_RESET_GPIO #else #define TOUCH_I2C_BUS ZTW523_I2C_BUS #define TOUCH_INT_GPIO ZTW523_INT_GPIO @@ -469,6 +476,10 @@ void touch_screen_resume(void) touch_peripheral_api *touch_ptr = (touch_peripheral_api*)touch_screen_get_api(); ext_errno ret = touch_ptr->touch_resume(); if (ret != EXT_ERR_SUCCESS) { tp_err("touch resume ret=0x%x", ret); } +#elif defined(TPTYPE_CST92XX) + touch_peripheral_api *touch_ptr = (touch_peripheral_api*)touch_screen_get_api(); + ext_errno ret = touch_ptr->touch_resume(); + if (ret != EXT_ERR_SUCCESS) { tp_err("touch resume ret=0x%x", ret); } #elif defined(TPTYPE_FT6X46) if( ft6x46_resume() != ERRCODE_SUCC) { @@ -502,6 +513,10 @@ void touch_screen_restart(void) touch_peripheral_api *touch_ptr = (touch_peripheral_api*)touch_screen_get_api(); ext_errno ret = touch_ptr->touch_resume(); if (ret != EXT_ERR_SUCCESS) { tp_err("touch resume ret=0x%x", ret); } +#elif defined(TPTYPE_CST92XX) + touch_peripheral_api *touch_ptr = (touch_peripheral_api*)touch_screen_get_api(); + ext_errno ret = touch_ptr->touch_resume(); + if (ret != EXT_ERR_SUCCESS) { tp_err("touch resume ret=0x%x", ret); } #elif defined(TPTYPE_FT6X46) ft6x46_resume(); #else diff --git a/code/sdk/zhihui/services/factorytest_service/factorytest_protocol.c b/code/sdk/zhihui/services/factorytest_service/factorytest_protocol.c index 46e4c29d6..ba9263c30 100644 --- a/code/sdk/zhihui/services/factorytest_service/factorytest_protocol.c +++ b/code/sdk/zhihui/services/factorytest_service/factorytest_protocol.c @@ -2,7 +2,7 @@ * @Author: penglei 1624952103@qq.com * @Date: 2024-06-17 14:31:08 * @LastEditors: penglei 1624952103@qq.com - * @LastEditTime: 2025-11-02 10:40:05 + * @LastEditTime: 2025-11-07 12:21:41 * @FilePath: /FD230/code/sdk/application/wearable/service/factorytest_service/factorytest_protocol.c * @Description: * @@ -39,7 +39,9 @@ #endif #include "power_display_service.h" #include "efuse.h" +#ifdef SUPPORT_MAG_SERVICE #include "mag_service.h" +#endif #include "nandflash_config.h" #include "string.h" #include "custom_runtime.h" @@ -599,12 +601,14 @@ void aging_task(void) return; } uapi_get_timestampe_ss(¤t_time); +#ifdef SUPPORT_MAG_SERVICE do_mag_service_check_msg(MAG_SERVICE_CMD_START_CHECK); LOS_Msleep(1000); -#ifdef SUPPORT_MAG_SERVICE + mag_get_fAzimuth(&fAzimuth); -#endif + do_mag_service_check_msg(MAG_SERVICE_CMD_STOP_CHECK); +#endif if(fAzimuth < 0) { aging_t.mag_error++; -- 2.17.1