From 0fb7a0d4adb29a8bead6d44ae6e234893db6a364 Mon Sep 17 00:00:00 2001 From: SnickerSun Date: Mon, 2 Dec 2024 18:17:03 +0800 Subject: [PATCH] =?utf8?q?=E6=B7=BB=E5=8A=A0=E6=B5=B7=E7=AB=8B=E5=88=9Bctp?= =?utf8?q?=E9=A9=B1=E5=8A=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit --- .vscode/settings.json | 86 ---- .../brandy/brandy_standard/thread_pri_init.c | 4 + .../config/target_config/brandy/config.py | 4 +- .../product/product_evb4_standard.h | 5 + .../drivers/driver/touch/CMakeLists.txt | 12 + .../driver/touch/cst86xx_touch/cst86xx_ctrl.c | 334 ++++++++++++++ .../driver/touch/cst86xx_touch/cst86xx_ctrl.h | 82 ++++ .../driver/touch/cst86xx_touch/cst86xx_drv1.c | 99 +++++ .../driver/touch/cst86xx_touch/cst86xx_drv1.h | 14 + .../touch/cst86xx_touch/cst86xx_touch1.c | 411 ++++++++++++++++++ .../touch/cst86xx_touch/cst86xx_touch1.h | 359 +++++++++++++++ .../driver/touch/ft6x46_touch/ft6x46_touch1.c | 157 +------ .../drivers/driver/touch/touch_screen_drv.c | 13 + 13 files changed, 1336 insertions(+), 244 deletions(-) delete mode 100644 .vscode/settings.json create mode 100644 code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_ctrl.c create mode 100644 code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_ctrl.h create mode 100644 code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_drv1.c create mode 100644 code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_drv1.h create mode 100644 code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_touch1.c create mode 100644 code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_touch1.h diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index d07e37f10..000000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,86 +0,0 @@ -{ - "files.associations": { - "*.def": "cpp", - "limits": "cpp", - "*.tcc": "cpp", - "type_traits": "cpp", - "iterator": "cpp", - "pm_core.h": "c", - "pm_veto.h": "c", - "chip_io.h": "c", - "pm.h": "c", - "tyhx_hrv_alg.h": "c", - "tyhx_hrs_custom.h": "c", - "osal_timer.h": "c", - "debug_print.h": "c", - "platform_core.h": "c", - "*.inc": "c", - "ohosfwk_at_process.h": "c", - "pm_clocks.h": "c", - "pmu_cmu.h": "c", - "pm_control.h": "c", - "__functional_base": "c", - "__functional_base_03": "c", - "__hash_table": "c", - "__tree": "c", - "__tuple": "c", - "algorithm": "c", - "array": "c", - "chrono": "c", - "cstddef": "c", - "filesystem": "c", - "forward_list": "c", - "functional": "c", - "memory": "c", - "random": "c", - "ratio": "c", - "tuple": "c", - "utility": "c", - "istream": "c", - "ostream": "c", - "soc_osal.h": "c", - "lis2doc_reg.h": "c", - "string.h": "c", - "clocks_config_priv.h": "c", - "lis2doc_at_cmd.h": "c", - "customer.h": "c", - "pinctrl.h": "c", - "at_cmd_api.h": "c", - "ios": "cpp", - "vibrator.h": "c", - "gpio_porting.h": "c", - "arch.h": "c", - "opt.h": "c", - "debug.h": "c", - "lwipopts.h": "c", - "cc.h": "c", - "sys_arch.h": "c", - "nv_key.h": "c", - "common.h": "c", - "custom_utils.h": "c", - "key_id.h": "c", - "custom_utils_cmd.h": "c", - "timer.h": "c", - "future": "cpp", - "__bit_reference": "c", - "bitset": "c", - "map": "c", - "set": "c", - "unordered_map": "c", - "unordered_set": "c", - "lis2doc_porting.h": "c", - "acc_service.h": "c", - "mmc5603.h": "c", - "mag_service.h": "c", - "mmc5603_hal.h": "c", - "clocks_config.h": "c", - "clocks_types.h": "c", - "nandflash_w25n01g.h": "c", - "nandflash_config.h": "c", - "hal_nandflash.h": "c", - "stddef.h": "c", - "nandflash_f35uqa001g.h": "c", - "alarmclocktimerconfig.h": "c", - "board_w9.h": "c" - } -} \ No newline at end of file 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 f4e39d22b..c25d8e431 100644 --- a/code/sdk/application/brandy/brandy_standard/thread_pri_init.c +++ b/code/sdk/application/brandy/brandy_standard/thread_pri_init.c @@ -32,6 +32,8 @@ #include "ztw523_touch1.h" #elif defined(TPTYPE_FT6X46) #include "ft6x46_touch1.h" +#elif defined(TPTYPE_CST86XX) +#include "cst86xx_touch1.h" #else #include "ztw523_touch1.h" #endif @@ -89,6 +91,8 @@ static void sample_gfx_init(void) ztw523_host_init_sample(); #elif defined(TPTYPE_FT6X46) ft6x46_host_init_sample(); +#elif defined(TPTYPE_CST86XX) + cst86xx_host_init_sample(); #else ztw523_host_init_sample(); #endif diff --git a/code/sdk/build/config/target_config/brandy/config.py b/code/sdk/build/config/target_config/brandy/config.py index 04546e6c4..444cfe7b2 100644 --- a/code/sdk/build/config/target_config/brandy/config.py +++ b/code/sdk/build/config/target_config/brandy/config.py @@ -401,7 +401,7 @@ target = { 'FT_SINGLE_UART', 'SUPPORT_AUTO_OTA_SERVER', 'CONFIG_DFX_SUPPORT_DIAG_UP_MACHINE=1', - 'TPTYPE_FT6X46', + 'TPTYPE_CST86XX', 'NANDFLASH_F35UQA' ], #添加自定义应用 @@ -434,7 +434,7 @@ target = { 'FT_SINGLE_UART', 'SUPPORT_AUTO_OTA_SERVER', 'CONFIG_DFX_SUPPORT_DIAG_UP_MACHINE=1', - 'TPTYPE_FT6X46', + 'TPTYPE_CST86XX', 'NANDFLASH_F35UQA' ], #添加自定义应用 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 2fcc808c8..7d48d6f0a 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 @@ -226,6 +226,11 @@ #define FT6X46_INT_GPIO S_AGPIO_R5 #define FT6X46_RESET_GPIO S_AGPIO_R4 +#define CST86XX_I2C_BUS I2C_BUS_1 +#define CST86XX_INT_GPIO S_AGPIO_R5 +#define CST86XX_RESET_GPIO S_AGPIO_R4 + + // TRACK MODE #define SND_TRACK_MODE_BT_MUSIC 0 // 参考 soc_uapi_sound.h 中 UAPI_SND_TRACK_STEREO 枚举 #define SND_TRACK_MODE_BT_SCO 1 // 参考 soc_uapi_sound.h 中 UAPI_SND_TRACK_DOUBLE_MONO 枚举 diff --git a/code/sdk/drivers/drivers/driver/touch/CMakeLists.txt b/code/sdk/drivers/drivers/driver/touch/CMakeLists.txt index 6971096df..db020dcc1 100644 --- a/code/sdk/drivers/drivers/driver/touch/CMakeLists.txt +++ b/code/sdk/drivers/drivers/driver/touch/CMakeLists.txt @@ -27,6 +27,12 @@ set(SOURCES ${SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/ft6x46_touch/ft6x46_drv1.c ${CMAKE_CURRENT_SOURCE_DIR}/ft6x46_touch/ft6x46_touch1.c ) +elseif("TPTYPE_CST86XX" IN_LIST DEFINES) +set(SOURCES ${SOURCES} + ${CMAKE_CURRENT_SOURCE_DIR}/cst86xx_touch/cst86xx_ctrl.c + ${CMAKE_CURRENT_SOURCE_DIR}/cst86xx_touch/cst86xx_drv1.c + ${CMAKE_CURRENT_SOURCE_DIR}/cst86xx_touch/cst86xx_touch1.c +) else() set(SOURCES ${SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/ztw523_touch/ztw523_ctrl.c @@ -53,6 +59,12 @@ set(PUBLIC_HEADER ${CMAKE_CURRENT_SOURCE_DIR}/ft6x46_touch ${ROOT_DIR}/middleware/services/gui/hal/input/include ) +elseif("TPTYPE_CST86XX" IN_LIST DEFINES) +set(PUBLIC_HEADER + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/cst86xx_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/cst86xx_touch/cst86xx_ctrl.c b/code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_ctrl.c new file mode 100644 index 000000000..4eea84762 --- /dev/null +++ b/code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_ctrl.c @@ -0,0 +1,334 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: cst86xx touch driver. + * Author: @CompanyNameTag + * Create: 2022-04-12 + */ + +#include "cst86xx_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; +cst86xx_ctrl_attr g_ctrl_attr; +touch_callback g_cst86xx_callback = NULL; +static uint8_t g_tp_send_buf[CST86XX_REG_WRITE_LEN] = {0}; +static uint8_t g_tp_recv_buf[CST86XX_INPUT_SIZE] = {0}; + +static void cst86xx_gpio_isr_handle(pin_t pin, uintptr_t param) +{ + unused(pin); + unused(param); + if (g_cst86xx_callback != NULL) { + g_cst86xx_callback(); + } +} + +ext_errno cst86xx_register_handle(const cst86xx_ctrl_ops *peri_data, touch_callback func) +{ + unused(peri_data); + ext_errno ret; + + g_cst86xx_callback = func; + /* register int io interrupt handler */ + uapi_gpio_init(); + gpio_select_core(CST86XX_INT_GPIO, CORE); + uapi_gpio_set_dir(CST86XX_INT_GPIO, GPIO_DIRECTION_INPUT); + ret = uapi_gpio_register_isr_func(CST86XX_INT_GPIO, GPIO_INTERRUPT_FALLING_EDGE, cst86xx_gpio_isr_handle); + if (ret != 0) { + tp_err("cst86xx int callback register fail! ret=0x%x", ret); + return ret; + } + + return EXT_ERR_SUCCESS; +} + +ext_errno cst86xx_unregister_handle(const cst86xx_ctrl_ops *peri_data) +{ + unused(peri_data); + ext_errno ret; + + /* unregister interrupt handler */ + uapi_gpio_unregister_isr_func(CST86XX_INT_GPIO); + g_cst86xx_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 cst86xx_ctrl_attr_check(const cst86xx_ctrl_attr *device_attr) +// { +// unused(device_attr); +// return EXT_ERR_SUCCESS; +// } + +static ext_errno cst86xx_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 cst86xx_tp_i2c_data_read(uint16_t reg_addr, uint8_t *data_buf, uint32_t data_len) +{ + errcode_t ret; + uint32_t retry; + i2c_data_t data; + + ret = cst86xx_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! ret=0x%x", ret); + return EXT_ERR_FAILURE; + } + g_tp_send_buf[CST86XX_I2C_SEND_INDEX0] = reg_addr & 0xff; + data.send_buf = g_tp_send_buf; + data.send_len = CST86XX_CMD_SEND_LEN; + data.receive_buf = g_tp_recv_buf; + data.receive_len = data_len; + for (retry = 0; retry < CST86XX_I2C_TIME_MAX; retry++) { + ret = uapi_i2c_master_writeread(CST86XX_I2C_BUS, CST86XX_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 cst86xx_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[CST86XX_I2C_SEND_INDEX0] = cmd & 0xff; + data.send_buf = g_tp_send_buf; + data.send_len = CST86XX_CMD_SEND_LEN; + data.receive_buf = NULL; + data.receive_len = 0; + + for (retry = 0; retry < CST86XX_I2C_TIME_MAX; retry++) { + ret = uapi_i2c_master_write(CST86XX_I2C_BUS, CST86XX_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 cst86xx_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[CST86XX_I2C_SEND_INDEX0] = reg_addr & 0xff; + + data.send_buf = g_tp_send_buf; + data.send_len = CST86XX_REG_WRITE_LEN; + data.receive_buf = NULL; + data.receive_len = 0; + + for (retry = 0; retry < CST86XX_I2C_TIME_MAX; retry++) { + ret = uapi_i2c_master_write(CST86XX_I2C_BUS, CST86XX_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 cst86xx_tp_i2c_data_write(uint16_t reg_addr, 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 = cst86xx_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 + sizeof(uint16_t); + + 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; + } + + write_data[CST86XX_I2C_SEND_INDEX0] = reg_addr & 0xff; + ret = (uint32_t)memcpy_s(write_data + sizeof(uint16_t), send_len - sizeof(uint16_t), 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 < CST86XX_I2C_TIME_MAX; retry++) { + ret = uapi_i2c_master_write(CST86XX_I2C_BUS, CST86XX_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 cst86xx_host_peripheral_init(cst86xx_ctrl_attr *attr) +{ + ext_errno ret; + + if (attr == NULL) { + tp_err("cst86xx communication interface cfg is empty!"); + return EXT_ERR_FAILURE; + } + // ret = cst86xx_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(cst86xx_ctrl_attr), attr, sizeof(cst86xx_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(CST86XX_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", + CST86XX_I2C_BUS, 100000, CST86XX_I2C_ADDR); + g_host_dev_init_flag = true; + + return EXT_ERR_SUCCESS; +} + +ext_errno cst86xx_host_init_sample(void) +{ + ext_errno ret; + tp_warning("cst86xx_host_init_sample"); + ret = cst86xx_host_peripheral_init(&g_ctrl_attr); + if (ret != EXT_ERR_SUCCESS) { + tp_err("tp host init fail! ret=0x%x", ret); + return ret; + } + ret = cst86xx_init(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("tp init fail! ret=0x%x", ret); + return ret; + } + + return EXT_ERR_SUCCESS; +} + +ext_errno cst86xx_reset(void) +{ + uapi_gpio_set_dir(CST86XX_RESET_GPIO, GPIO_DIRECTION_OUTPUT); + /* Config Gpio For Reset Pin */ + uapi_gpio_set_val(CST86XX_RESET_GPIO, GPIO_LEVEL_HIGH); + /* reset high delay 20ms */ + osDelay(1); + uapi_gpio_set_val(CST86XX_RESET_GPIO, GPIO_LEVEL_LOW); + /* reset low delay 100ms */ + osDelay(10); + uapi_gpio_set_val(CST86XX_RESET_GPIO, GPIO_LEVEL_HIGH); + /* reset high delay 200ms */ + osDelay(100); + return EXT_ERR_SUCCESS; +} + +void cst86xx_resume_reset(void) +{ + uapi_gpio_set_dir(CST86XX_RESET_GPIO, GPIO_DIRECTION_OUTPUT); + /* drvdata is global variable point and no need to handle null */ + uapi_gpio_set_val(CST86XX_RESET_GPIO, GPIO_LEVEL_HIGH); + osDelay(1); + uapi_gpio_set_val(CST86XX_RESET_GPIO, GPIO_LEVEL_LOW); + /* delay 10ms */ + osDelay(10); + uapi_gpio_set_val(CST86XX_RESET_GPIO, GPIO_LEVEL_HIGH); + /* delay 100ms */ + osDelay(100); + // uapi_gpio_set_dir(CST86XX_RESET_GPIO, GPIO_DIRECTION_INPUT); +} \ No newline at end of file diff --git a/code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_ctrl.h b/code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_ctrl.h new file mode 100644 index 000000000..4f731d9f0 --- /dev/null +++ b/code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_ctrl.h @@ -0,0 +1,82 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: cst86xx touch driver. + * Author: @CompanyNameTag + * Create: 2022-04-12 + */ + +#ifndef CST86XX_CTRL_H +#define CST86XX_CTRL_H + +#include "stdio.h" +#include "debug_print.h" +#include "stdint.h" +#include "product.h" +#include "td_base.h" +#include "platform_core.h" +#include "cst86xx_touch1.h" + + + +//_TODO: +#define CTP_USE_SW_I2C 0 //hard i2c:0 gpio i2c:1 +#define CTP_SLAVER_ADDR (0x2A) //(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 CST86XX_I2C_ADDR 0x15 +#define CST86XX_I2C_SPEED I2C_SPEED_MODE_SS +#define CST86XX_REG_WRITE_LEN 2 +#define CST86XX_CMD_SEND_LEN 1 +#define CST86XX_REG_DATA_LEN 1 +#define CST86XX_I2C_TIME_MAX 3 +#define CST86XX_INPUT_SIZE 6 +#define CST86XX_I2C_SEND_INDEX0 0 +// #define CST86XX_I2C_SEND_INDEX1 1 +// #define CST86XX_I2C_SEND_INDEX2 2 +// #define CST86XX_I2C_SEND_INDEX3 3 +typedef struct { + uint32_t int_gpio; + i2c_bus_t i2c_id; + uint32_t i2c_speed; +} cst86xx_ctrl_attr; + +typedef ext_errno (*cst86xx_bus_init)(cst86xx_ctrl_attr *attr); + +typedef struct { + cst86xx_ctrl_attr attr; + cst86xx_bus_init bus_init; +} cst86xx_ctrl_ops; + +ext_errno cst86xx_host_peripheral_init(cst86xx_ctrl_attr *attr); +ext_errno cst86xx_register_handle(const cst86xx_ctrl_ops *peri_data, touch_callback func); +ext_errno cst86xx_unregister_handle(const cst86xx_ctrl_ops *peri_data); +ext_errno cst86xx_reset(void); +void cst86xx_resume_reset(void); +void cst86xx_delay(uint32_t ms); + +ext_errno cst86xx_tp_i2c_data_read(uint16_t reg_addr, uint8_t *data_buf, uint32_t data_len); +ext_errno cst86xx_tp_i2c_cmd_write(uint16_t cmd); +ext_errno cst86xx_tp_i2c_reg_write(uint16_t reg_addr, uint16_t reg_cfg); +ext_errno cst86xx_tp_i2c_data_write(uint16_t reg_addr, uint8_t *data_buf, uint32_t data_len); + +#endif diff --git a/code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_drv1.c b/code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_drv1.c new file mode 100644 index 000000000..22fa202c3 --- /dev/null +++ b/code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_drv1.c @@ -0,0 +1,99 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: cst86xx touch driver. + * Author: @CompanyNameTag + * Create: 2022-04-12 + */ + +#include "cst86xx_drv1.h" +#include "touch_screen_def.h" +#include "cst86xx_ctrl.h" +#include "i2c.h" +#include "debug_print.h" +#include "hal_i2c.h" + +static ext_errno cst86xx_drv_init(cst86xx_ctrl_ops *config) +{ + ext_errno ret; + cst86xx_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("CST86XX bus_init fail! ret = 0x%x", ret); + return ret; + } + + ret = cst86xx_init(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("CST86XX init fail! ret = 0x%x", ret); + return ret; + } + + return EXT_ERR_SUCCESS; +} + +static ext_errno cst86xx_drv_deinit(void) +{ + return EXT_ERR_SUCCESS; +} + +static ext_errno cst86xx_drv_get_info(uint8_t *data, uint8_t data_len) +{ + return cst86xx_irq_callback(data, data_len); +} + +static ext_errno cst86xx_drv_suspend(void) +{ + return cst86xx_set_power_mode(MC_TP_SUSPEND_SCAN); +} + +static ext_errno cst86xx_drv_resume(void) +{ + return cst86xx_set_power_mode(MC_TP_RESUME_SCAN); +} + +static ext_errno cst86xx_drv_sleep(void) +{ + return cst86xx_set_power_mode(MC_TP_SLEEP_WORK_MODE); +} + +touch_peripheral_api g_cst86xx_api = { + .touch_init = cst86xx_drv_init, + .touch_deinit = cst86xx_drv_deinit, + .touch_get_tpinfo = cst86xx_drv_get_info, + .touch_suspend = cst86xx_drv_suspend, + .touch_resume = cst86xx_drv_resume, + .touch_sleep = cst86xx_drv_sleep, + .touch_bus_init = cst86xx_host_peripheral_init, + .register_callback = cst86xx_register_handle, + .unregister_callback = cst86xx_unregister_handle, +}; + +cst86xx_ctrl_ops g_cst86xx_ctrl = { + .attr = { + .int_gpio = CST86XX_INT_GPIO, + .i2c_id = CST86XX_I2C_BUS, + .i2c_speed = I2C_SPEED_MODE_SS, + }, + .bus_init = (cst86xx_bus_init)cst86xx_host_peripheral_init, +}; + +void *touch_screen_get_api(void) +{ + return ((void *)&g_cst86xx_api); +} + +void *touch_screen_get_peri_attr(void) +{ + return ((void *)&g_cst86xx_ctrl); +} \ No newline at end of file diff --git a/code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_drv1.h b/code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_drv1.h new file mode 100644 index 000000000..199d7dbbe --- /dev/null +++ b/code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_drv1.h @@ -0,0 +1,14 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: cst86xx touch driver. + * Author: @CompanyNameTag + * Create: 2022-04-12 + */ + +#ifndef CST86XX_DRV1_H +#define CST86XX_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/cst86xx_touch/cst86xx_touch1.c b/code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_touch1.c new file mode 100644 index 000000000..b01c5931c --- /dev/null +++ b/code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_touch1.c @@ -0,0 +1,411 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: cst86xx touch driver. + * Author: @CompanyNameTag + * Create: 2021-05-29 + */ + +#include "cst86xx_touch1.h" +#include "time.h" +#include "soc_osal.h" +#include "osal_timer.h" +#include "osal_mutex.h" +#include "securec.h" +#include "cst86xx_ctrl.h" +#include "tcxo.h" +#include "cmsis_os2.h" +#include "common_def.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif + +cst86xx_drv_data g_cst86xx_drv = { + .chip_status = CST86XX_NOT_READY, + .ops_mux = {0}, + .int_mask = CST86XX_INT_MASK, + .work_status = CST86XX_WORK_INVALID, + .fw_upgrade_flag = TD_FALSE, + .gesture_wakeup = TD_FALSE, + .host_dev_init_flag = TD_FALSE, + .chip_info = CST86XX_DEVICE_INFO, + .p_void = NULL, +}; + +static ext_errno cst86xx_config(void); + +static ext_errno cst86xx_parse_input(void) +{ + static uint8_t touch_input[CST86XX_TOUCHINFO_LEN] = { 0 }; + uint16_t touch_status; + uint16_t x_axis; + uint16_t y_axis; + uint8_t model; + static uint32_t point_count=0; + + ext_errno ret = cst86xx_tp_i2c_data_read(CST86XX_POINT_STATUS_REG, touch_input, CST86XX_TOUCHINFO_LEN); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:touch input read error! ret = 0x%x", ret); + return EXT_ERR_FAILURE; + } + model = touch_input[1]; + tp_print("TOUCH:ctp_get_data finger_num=%d", model); + /* + 0 fingure meas UP EVENT, so return FALSE; + And now we only support FIVE fingures at most, so if more than 5 fingures also return FALSE + */ + if (model > 2) + { + return EXT_ERR_FAILURE; + } + + x_axis = (((uint16_t)(touch_input[2]&0x0f))<<8) | touch_input[3]; + y_axis = (((uint16_t)(touch_input[4]&0x0f))<<8) | touch_input[5]; + tp_print("TOUCH:finger[%d], x:%d, y:%d", model, x_axis, y_axis); + + if (model == 0) + { + g_cst86xx_drv.touch_msg.tp_event = MC_TP_RELEASE; + point_count=0; + }else{ + if (point_count==0) + { + g_cst86xx_drv.touch_msg.tp_event = MC_TP_PRESS; + }else{ + g_cst86xx_drv.touch_msg.tp_event = MC_TP_MOVE; + } + point_count++; + } + + g_cst86xx_drv.touch_msg.tp_event_info.x_axis[0] = x_axis; + g_cst86xx_drv.touch_msg.tp_event_info.y_axis[0] = y_axis; + g_cst86xx_drv.touch_msg.tv_usec = (uint32_t)uapi_tcxo_get_ms(); + + // } else { + // g_cst86xx_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; +} + +ext_errno cst86xx_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 (g_cst86xx_drv.chip_status != CST86XX_READY) { + tp_warning("TOUCH: not ready skip read"); + return EXT_ERR_SUCCESS; + } + + g_cst86xx_drv.touch_msg.tp_event = MC_TP_INVALID; + + if ((g_cst86xx_drv.work_status == CST86XX_WORK_NORMAL) || (g_cst86xx_drv.work_status == CST86XX_WORK_STANDBY)) { + g_cst86xx_drv.irq_count++; + ret = cst86xx_parse_input(); + if (ret != EXT_ERR_SUCCESS) { + cst86xx_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), &(g_cst86xx_drv.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 cst86xx_configuration(void) +{ + ext_errno ret; + uint16_t reg_read; + + tp_print("ctp_cst0_init enter "); + + /* Read Firmware Version */ + reg_read = 0; + ret = cst86xx_tp_i2c_data_read(CST86XX_FIRMWARE_VERSION, (uint8_t *)®_read, 1); + if (ret != EXT_ERR_SUCCESS) { + return EXT_ERR_FAILURE; + } + g_cst86xx_drv.firmware_version = reg_read; + + /* Read Minor Firmware Version */ + reg_read = 0; + ret = cst86xx_tp_i2c_data_read(CST86XX_FACTORY_ID, (uint8_t *)®_read, 1); + if (ret != EXT_ERR_SUCCESS) { + return EXT_ERR_FAILURE; + } + g_cst86xx_drv.vendor_id = reg_read; + + /* Read Hw ID */ + reg_read = 0; + ret = cst86xx_tp_i2c_data_read(CST86XX_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_cst86xx_drv.chip_id = reg_read; + tp_print("chip_id = 0x%x FW_ver = 0x%x factory_id = 0x%x", + g_cst86xx_drv.chip_id, + g_cst86xx_drv.firmware_version, + g_cst86xx_drv.vendor_id); + + return EXT_ERR_SUCCESS; +} + +static ext_errno cst86xx_suspend(void) +{ + ext_errno ret; + uint16_t reg_write; + uint8_t retry_times = 0; + + if (g_cst86xx_drv.work_status == CST86XX_WORK_SLEEP) { + tp_print("TOUCH:alread suspend"); + return EXT_ERR_SUCCESS; + } + + /* Send Sleep Cmd */ + reg_write = CST86XX_SLEEP_CMD; + for (retry_times = 0; retry_times < CST86XX_INIT_RETRY_TIMERS; retry_times++) { + ret = cst86xx_tp_i2c_reg_write(CST86XX_SLEEP_CMD,0x03); + if (ret == EXT_ERR_SUCCESS) { + break; + } + osDelay(CST86XX_GENERAL_DELAY_10); + } + if (retry_times == CST86XX_INIT_RETRY_TIMERS) { + tp_err("suspend: overtimes %d", retry_times); + goto suspend_exit; + } + osDelay(CST86XX_GENERAL_DELAY_10); + + g_cst86xx_drv.work_status = CST86XX_WORK_SLEEP; + + return EXT_ERR_SUCCESS; + +suspend_exit: + + tp_err("TOUCH:suspend failed 0x%x", ret); + + return EXT_ERR_FAILURE; +} + +ext_errno cst86xx_resume(void) +{ + ext_errno ret; + uint8_t retry_times = 0; + + g_cst86xx_drv.work_status = CST86XX_WORK_RESUME; + + for (; retry_times < CST86XX_INIT_RETRY_TIMERS; retry_times++) { + ret = cst86xx_config(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("resume: post err %d", ret); + /* retry delay 200ms */ + osDelay(CST86XX_GENERAL_DELAY_200); + } else { + break; + } + } + + if (retry_times == CST86XX_INIT_RETRY_TIMERS) { + tp_err("resume: overtimes %d", retry_times); + goto resume_exit; + } + + g_cst86xx_drv.work_status = CST86XX_WORK_NORMAL; + + /* Enable Irq */ + // cst86xx_set_irq_mode(CST86XX_IRQ_ENABLE, CST86XX_INT_MASK); + + return EXT_ERR_SUCCESS; + +resume_exit: + + /* Enable Irq */ + // cst86xx_set_irq_mode(CST86XX_IRQ_DISABLE, CST86XX_INT_MASK); + + tp_err("resume failed 0x%x", ret); + + return EXT_ERR_FAILURE; +} + +ext_errno cst86xx_get_power_mode(uint32_t *power_mode) +{ + if (power_mode == NULL) { + return EXT_ERR_FAILURE; + } + + *power_mode = (uint32_t)(g_cst86xx_drv.work_status); + + return EXT_ERR_SUCCESS; +} + +static ext_errno cst86xx_set_standby_mode(void) +{ + ext_errno ret; + + return EXT_ERR_SUCCESS; +} + +static ext_errno cst86xx_set_sleep_mode(void) +{ + ext_errno ret; + + ret = cst86xx_suspend(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:cst86xx set suspend fail 0x%x", ret); + } + + g_cst86xx_drv.work_status = CST86XX_WORK_SLEEP; + return EXT_ERR_SUCCESS; +} + +static ext_errno cst86xx_set_normal_mode(void) +{ + ext_errno ret; + uint16_t reg_write; + + if (g_cst86xx_drv.work_status == CST86XX_WORK_NORMAL) { + return EXT_ERR_SUCCESS; + } + + ret = cst86xx_config(); + if (ret != EXT_ERR_SUCCESS) { + return EXT_ERR_FAILURE; + } + // cst86xx_set_irq_mode(CST86XX_IRQ_ENABLE, CST86XX_INT_MASK); + g_cst86xx_drv.work_status = CST86XX_WORK_NORMAL; + + return EXT_ERR_SUCCESS; +} + +ext_errno cst86xx_set_power_mode(tp_work_mode power_mode) +{ + ext_errno ret = EXT_ERR_SUCCESS; + + switch (power_mode) { + case MC_TP_SLEEP_WORK_MODE: + case MC_TP_SUSPEND_SCAN: + ret = cst86xx_set_sleep_mode(); + break; + case MC_TP_NORMAL_WORK_MODE: + case MC_TP_RESUME_SCAN: + ret = cst86xx_set_normal_mode(); + break; + case MC_TP_STANDBY_WORK_MODE: + ret = cst86xx_set_standby_mode(); + break; + default: + tp_err("TOUCH:cst86xx not support powermode 0x%x", power_mode); + ret = EXT_ERR_FAILURE; + break; + } + + return ret; +} + +static ext_errno cst86xx_config(void) +{ + ext_errno ret; + + /* Step 1 hardware reset */ + ret = cst86xx_reset(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:Init reset fail 0x%x", ret); + return EXT_ERR_FAILURE; + } + + /* Step 3 configuration */ + ret = cst86xx_configuration(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:init config fail 0x%x", ret); + return EXT_ERR_FAILURE; + } + + /* Record Status For Init */ + g_cst86xx_drv.chip_status = CST86XX_READY; + g_cst86xx_drv.work_status = CST86XX_WORK_NORMAL; + + return EXT_ERR_SUCCESS; +} + +static ext_errno cst86xx_resource_deinit(void) +{ + g_cst86xx_drv.work_status = CST86XX_WORK_INVALID; + g_cst86xx_drv.fw_upgrade_flag = TD_FALSE; + osal_mutex_destroy(&g_cst86xx_drv.ops_mux); + + return EXT_ERR_SUCCESS; +} + +ext_errno cst86xx_init(void) +{ + ext_errno ret = EXT_ERR_FAILURE; + ext_errno err_ret; + + /* create tp operation mutex */ + if (g_cst86xx_drv.ops_mux.mutex == NULL) { + ret = osal_mutex_init(&(g_cst86xx_drv.ops_mux)); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:cst86xx init create mux lock fail 0x%x", ret); + return EXT_ERR_FAILURE; + } + } + + /* get tp operater mutex */ + ret = osal_mutex_lock_timeout(&g_cst86xx_drv.ops_mux, CST86XX_OPERATER_MUTEX_WAIT_TIME); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:cst86xx init wait mux lock fail 0x%x", ret); + goto init_fail; + } + + /* tp hardware reset and init */ + ret = cst86xx_config(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:cst86xx init fail 0x%x", ret); + goto init_fail; + } + + /* release tp operater mutex */ + osal_mutex_unlock(&g_cst86xx_drv.ops_mux); + + tp_print("TOUCH:cst86xx init succ!"); + return EXT_ERR_SUCCESS; + +init_fail: + /* release tp operater mutex */ + osal_mutex_unlock(&g_cst86xx_drv.ops_mux); + err_ret = cst86xx_resource_deinit(); + if (err_ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:delete mux lock err! ret = 0x%x", err_ret); + } + return ret; +} + +ext_errno cst86xx_deinit(void) +{ + ext_errno ret = cst86xx_resource_deinit(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH: cst86xx deinit fail! ret = 0x%x", ret); + return ret; + } + + return EXT_ERR_SUCCESS; +} + +#ifdef __cplusplus +#if __cplusplus + } +#endif +#endif diff --git a/code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_touch1.h b/code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_touch1.h new file mode 100644 index 000000000..d44b1a9b5 --- /dev/null +++ b/code/sdk/drivers/drivers/driver/touch/cst86xx_touch/cst86xx_touch1.h @@ -0,0 +1,359 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: cst86xx touch driver. + * Author: @CompanyNameTag + * Create: 2021-05-29 + */ + +#ifndef CST86XX_TOUCH1_H +#define CST86XX_TOUCH1_H + +#include "stdio.h" +#include "soc_errno.h" +#include "soc_osal.h" +#include "touch_screen_def.h" +#include "platform_core.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif + +/* cst86xx definitions */ +/* max wait time */ +#define CST86XX_OPERATER_MUTEX_WAIT_TIME 3000 /* operater tp mutex timeout ms */ +#define CST86XX_CMCP_WAIT_TIMEOUT 1000 +/* define some properties value */ +#define CST86XX_ENABLE 0x0001 +#define CST86XX_DISABLE 0x0000 +#define CST86XX_DATA_LEN 2 +#define CST86XX_POWERON_DELAY 100 +#define CST86XX_POWEROFF_DELAY 100 +#define CST86XX_RESETHIGH_DELAY 10 +#define CST86XX_CLEARINT_DELAY 10 +#define CST86XX_FIRMWAREON_DELAY 200 +#define CST86XX_INIT_RETRY_TIMERS 3 +#define CST86XX_SETMODE_RETRY_TIMERS 3 +#define CST86XX_SOFTRESET_RETRY_TIMES 10 +#define CST86XX_RETRY_TIMES 10 +#define CST86XX_DEVICE_INFO "cst,cst86xx" +#define CST86XX_DEVICE_INFO_SIZE sizeof(CST86XX_DEVICE_INFO) +#define CST86XX_MAX_SUPPORTED_FINGER_NUM 1 +#define CST86XX_POINT_MODE 1 +#define CST86XX_CALIB_TOUCH_MODE 0x07 +#define CST86XX_REGDATA_SHIFT 8 +#define CST86XX_GENERAL_DELAY_1 1 +#define CST86XX_GENERAL_DELAY_5 5 +#define CST86XX_GENERAL_DELAY_10 10 +#define CST86XX_GENERAL_DELAY_20 20 +#define CST86XX_GENERAL_DELAY_25 25 +#define CST86XX_GENERAL_DELAY_30 30 +#define CST86XX_GENERAL_DELAY_50 50 +#define CST86XX_GENERAL_DELAY_100 100 +#define CST86XX_GENERAL_DELAY_200 200 +#define CST86XX_GENERAL_DELAY_500 500 +#define CST86XX_GENERAL_RETRY_1 1 +#define CST86XX_GENERAL_RETRY_2 2 +#define CST86XX_GENERAL_RETRY_3 3 +#define CST86XX_GENERAL_RETRY_4 4 +#define CST86XX_GENERAL_RETRY_10 10 +#define CST86XX_RAWDATA_DELAY_FOR_HOST 100 +#define CST86XX_FW_JUMP_CODE 0x0048 +#define CST86XX_REPORT_RATE 60 +#define CST86XX_PIXEL_THRESHOLD 5 + +#ifndef CST86XX_RES_MAX_X +#define CST86XX_RES_MAX_X 453 +#endif + +#ifndef CST86XX_RES_MAX_Y +#define CST86XX_RES_MAX_Y 453 +#endif + +#ifndef CST86XX_POINT_TRESHHOLD +#define CST86XX_POINT_TRESHHOLD 0x19 +#endif + +#define CST86XX_TOUCHINFO_LEN (6) + +#define CST86XX_INT_NONE 0x0000 +#define CST86XX_INT_MASK 0x081F +#define CST86XX_PALM_MASK 0x0010 +#define CST86XX_FIRMWARE_SIZE 48 +#define ZTW_PAGE_SIZE_128 128 +#define ZTW_PAGE_SIZE_64 64 +#define ZTW_SECTOR_SIZE 8 +#define ZTW_CHIPID_F400 0xF400 +#define ZTW_CHIPID_E240 0xE240 +#define ZTW_CHIPID_E700 0xE700 +#define ZTW_CHIPID_E548 0xE548 +#define ZTW_CHIPID_E538 0xE538 +#define ZTW_CHIPID_E532 0xE532 +#define ZTW_VENDOR_ID 0x5A49 +#define CST86XX_CHIP_ID 0xE628 +/* define touch info offset */ +#define CST86XX_STATUSL_OFFSET 0 +#define CST86XX_STATUSH_OFFSET 1 +#define CST86XX_EVENTL_OFFSET 2 +#define CST86XX_EVENTH_OFFSET 3 +#define CST86XX_XL_OFFSET 4 +#define CST86XX_XH_OFFSET 5 +#define CST86XX_YL_OFFSET 6 +#define CST86XX_YH_OFFSET 7 +#define CST86XX_WIDTH_OFFSET 8 +#define CST86XX_SUBSTATUS_OFFSET 9 +/* define data shift and mask */ +#define CST86XX_SHIFT_8_BIT 8 +#define CST86XX_SHIFT_16_BIT 16 +#define CST86XX_SHIFT_24_BIT 24 +#define CST86XX_MASK_BYTE 0xFF +/* define CST86XX_HIGH_SPEED_DMA rely on iic dma support */ +#ifdef CST86XX_HIGH_SPEED_DMA +#define CST86XX_TOUCH_POINT_MODE 0 +#else +#define CST86XX_TOUCH_POINT_MODE 1 +#endif + +#define CST86XX_SEC_MODE 48 +#define CST86XX_NORMAL_MODE 5 +#define CST86XX_DND_MODE 11 /* mutual cap */ +#define CST86XX_SELF_DND_MODE 17 /* self cap */ +#define CST86XX_DNDSKIP_CNT 1 +#define CST86XX_SELFDNDSKIP_CNT 1 +/* Config Reg Info */ +#define CST86XX_REG_CMD_ENABLE 0xC000 +#define CST86XX_REG_CHIP_ID 0xCC00 +#define CST86XX_REG_INTN_CLEAR 0xC004 +#define CST86XX_REG_NVM 0xC002 +#define CST86XX_REG_NVM_VPP 0xC003 +#define CST86XX_REG_NVM_WP 0xC104 +#define CST86XX_REG_PROGRAM_START 0xC001 +#define CST86XX_POWER_CTL_BEGIN 0x000A +#define CST86XX_POWER_CTL_END 0x000B +#define CST86XX_CALIB_CTL1 0xC003 +#define CST86XX_CALIB_CTL2 0xC104 +#define CST86XX_SDRAM_RESET 0x0FF8 +#define CST86XX_REPORT_REG 0x0186 /* 设置中断上报频率 */ +#define CST86XX_PIXEL_THRESHOLD_REG 0x00C3 +/* Register Map */ +#define CST86XX_SLEEP_CMD 0xA5 +#define CST86XX_FIRMWARE_VERSION 0xA9 +#define CST86XX_FACTORY_ID 0xAA +#define CST86XX_HW_ID 0xA7 +#define CST86XX_POINT_STATUS_REG 0x01 + +#ifndef CST86XX_TSP_X_CHANNEL_NUM +#define CST86XX_TSP_X_CHANNEL_NUM 6 +#endif + +#ifndef CST86XX_TSP_Y_CHANNEL_NUM +#define CST86XX_TSP_Y_CHANNEL_NUM 6 +#endif + +#define CST86XX_TSP_DND_NUM (CST86XX_TSP_X_CHANNEL_NUM * CST86XX_TSP_Y_CHANNEL_NUM) +#define CST86XX_TSP_SELFDND_NUM (CST86XX_TSP_X_CHANNEL_NUM + CST86XX_TSP_Y_CHANNEL_NUM) + +/* firmware info */ +#define CST86XX_FIRMWARE_VERSION_L 0 +#define CST86XX_FIRMWARE_VERSION_H 1 +#define CST86XX_FIRMWARE_VERSION_OFFSET 52 +#define CST86XX_FIRMWARE_MINOR_VERSION_OFFSET 56 +#define CST86XX_FIRMWARE_DATA_VERSION_OFFSET 60 +#define CST86XX_FIRMWARE_OFFSET_ZERO 0 +#define CST86XX_FIRMWARE_CONVERT_DATA_STEP 2 +#define CST86XX_FIRMWARE_CONVERT_DATA_OFFSET 1 +/* file op code */ +#define CST86XX_FILE_ERROR (-1) +#define CST86XX_FILE_OK 0 +/* upgrade info */ +#define CST86XX_FWGRADE_CMD_NUM 3 +/* rawdata info */ +#define CST86XX_RAWDATA_CMD_NUM 2 + +/* self_dnd dnd parameter */ +#define CST86XX_SEC_SELF_DND_N_COUNT 15 +#define CST86XX_SEC_SELF_DND_U_COUNT 2 +#define CST86XX_SEC_SELF_DND_FREQUENCY 80 + +#define CST86XX_SEC_DND_N_COUNT 27 +#define CST86XX_SEC_DND_U_COUNT 3 +#define CST86XX_SEC_DND_FREQUENCY 240 + +/* host peripheral typedef */ +typedef ext_errno (*tp_irq_callback)(void); + +/* CST86XX driver typedef */ +typedef enum { + CST86XX_POWERDOWN = 0, + CST86XX_POWERUP, +} cst86xx_sw_power_status; + +typedef enum { + CST86XX_WORK_NORMAL = 0, + CST86XX_WORK_STANDBY, + CST86XX_WORK_GETCMCP, + CST86XX_WORK_SLEEP, + CST86XX_WORK_SUSPEND, + CST86XX_WORK_RESUME, + CST86XX_WORK_INVALID, +} cst86xx_work_status; + +typedef enum { + CST86XX_NOT_READY = 0, + CST86XX_READY, +} cst86xx_device_status; + +typedef enum { + MC_BUTTON_RELEASE = 0, /* button release */ + MC_BUTTON_PRESSED = 1, /* button pressed */ +} button_event_type; + +typedef enum { + MC_TOUCHKEY_EVENT_PRESS = 0, + MC_TOUCHKEY_EVENT_RELASSE, + MC_TOUCHKEY_EVENT_LONG_PRESS, + MC_TOUCHKEY_EVENT_INVALID, +} touch_key_event_type; + +typedef enum { + CST86XX_GESTURE_NONE = 0, + CST86XX_GESTURE_SIGNAL_CLICK = 1, + CST86XX_GESTURE_DOUBLE_CLICK = 2, + CST86XX_GESTURE_SLIDE_UP = 4, + CST86XX_GESTURE_SLIDE_DOWN = 5, +} cst86xx_gesture_event; + +typedef enum { + CST86XX_IRQ_DISABLE = 0, + CST86XX_IRQ_ENABLE, +} cst86xx_irq_status; + +typedef enum { + MC_TP_NORMAL_WORK_MODE = 0, /* tp normal mode */ + MC_TP_STANDBY_WORK_MODE, /* tp idle mode */ + MC_TP_BOOTLOADER_WORK_MODE, + MC_TP_SLEEP_WORK_MODE, + MC_TP_SUSPEND_SCAN, + MC_TP_RESUME_SCAN, + MC_TP_MAX_MODE, +} tp_work_mode; + +typedef enum { + MC_TP_UPGRADE_NEED_FLAG, + MC_TP_UPGRADE_START_ASYN, + MC_TP_UPGRADE_STATUS, + MC_TP_UPGRADE_SYNC, +} mc_tp_upgrade; + +typedef struct { + uint32_t reset_gpio; + uint32_t int_gpio; + i2c_bus_t i2c_id; + uint32_t i2c_baudrate; +} tp_peripheral_attr; + +typedef struct { + uint16_t button_code; +} button_dev_info; + +typedef struct { + uint16_t xchannel_num; + uint16_t ychannel_num; + uint16_t total_dnd_num; + uint16_t total_self_dnd_num; +} cst86xx_panel_data; + +typedef struct { + uint32_t skip_cnt; + int16_t dnd_data[CST86XX_TSP_DND_NUM]; + int16_t self_dnd_data[CST86XX_TSP_SELFDND_NUM]; +} cst86xx_tsp_rawdata; + +typedef enum { + MC_TP_RAW_DATA, + MC_TP_BASE_DATA, + MC_TP_NOS_DATA, + MC_TP_SIG_DATA, + MC_TP_FT_DATA, + MC_TP_NT_DATA, + MC_TP_MAX_DATA, + MC_TP_CM_CP_DATA, /* 7, CM CP data */ + MC_TP_INT_COUNT_DATA, /* 8, TP Int count */ + MC_TP_NOISE_METRICS_DATA, + MC_TP_DATA_STRUCTURE_DATA, + MC_TP_PANEL_SCAN_CM_DATA, + MC_TP_PANEL_SCAN_CP_DATA, + MC_TP_START_RAW_TRANS, + MC_TP_STOP_RAW_TRANS, + MC_TP_START_GET_WATER_TEMPR, /* 15, start get and print water level and temprature */ + MC_TP_STOP_GET_WATER_TEMPR, /* 16, stop get and print water level and temprature */ + MC_TP_RAW_MAX, +} mc_tp_rawdata; + +typedef struct { + mc_tp_rawdata cmd; + uint8_t *data_buf; + uint8_t data_in_len; + uint32_t data_out_len; + uint32_t data_addr; +} touch_rawdata_info; + +/* define for drv process talbe */ +typedef ext_errno (*touch_drv_upgrade_handle)(uint8_t *data_buff, uint8_t buf_len); +typedef struct { + mc_tp_upgrade cmd_id; + touch_drv_upgrade_handle process_cb; +} touch_drv_upgrade_proc; + +typedef ext_errno (*touch_hal_rawdata_handle)(uint8_t *data_buf, uint8_t buf_len); +typedef struct { + mc_tp_rawdata cmd_id; + touch_hal_rawdata_handle process_cb; +} touch_drv_rawdata_proc; + +typedef struct { + uint16_t chip_id; + uint16_t vendor_id; + uint16_t chip_hw_id; + uint8_t chip_info[CST86XX_DEVICE_INFO_SIZE]; + uint16_t firmware_version; + uint16_t minor_firmware_version; + uint16_t reg_version; + uint32_t flash_fw_version; + uint16_t int_mask; + uint16_t touch_mode; + uint32_t irq_count; + uint32_t touch_count; + uint32_t page_size; + uint16_t header_size; + uint16_t image_size; + osal_mutex ops_mux; + bool fw_upgrade_flag; + bool gesture_wakeup; + bool host_dev_init_flag; + cst86xx_sw_power_status power_status; + cst86xx_work_status work_status; + cst86xx_sw_power_status chip_sw_power_status; + cst86xx_device_status chip_status; + input_event_info touch_msg; + cst86xx_panel_data panel_info; + tp_peripheral_attr dev_attr; + void *p_void; + uint32_t tp_event; +} cst86xx_drv_data; + +ext_errno cst86xx_init(void); +ext_errno cst86xx_deinit(void); +ext_errno cst86xx_set_power_mode(tp_work_mode power_mode); +ext_errno cst86xx_get_power_mode(uint32_t *power_mode); +ext_errno cst86xx_resume(void); +ext_errno cst86xx_irq_callback(uint8_t *data_buf, uint8_t data_len); +ext_errno cst86xx_host_init_sample(void); +#ifdef __cplusplus +#if __cplusplus + } +#endif +#endif + +#endif diff --git a/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_touch1.c b/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_touch1.c index 85f2db5a9..5fb480ef6 100644 --- a/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_touch1.c +++ b/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_touch1.c @@ -498,101 +498,6 @@ static ext_errno ft6x46_reg_config(void) return EXT_ERR_SUCCESS; } -static ext_errno ft6x46_configuration(void) -{ - ext_errno ret; - uint8_t retry_times = 0; - uint16_t reg_read; - uint16_t reg_write; - - /* Software Reset */ - reg_write = FT6X46_SWRESET_CMD; - for (retry_times = 0; retry_times < FT6X46_RETRY_TIMES; retry_times++) { - ret = tp_i2c_cmd_write(reg_write); - if (ret == EXT_ERR_SUCCESS) { - break; - } - osDelay(FT6X46_RESETHIGH_DELAY); - } - - if (retry_times >= FT6X46_RETRY_TIMES) { - tp_err("TOUCH:configuration sw reset fail! ret = 0x%x", ret); - return EXT_ERR_TP_ZTW523_CONFIG_RESET; - } - - /* Read Firmware Version */ - reg_read = 0; - ret = tp_i2c_data_read(FT6X46_FIRMWARE_VERSION, (uint8_t *)®_read, FT6X46_DATA_LEN); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_CONFIG_READ_FWVERSION; - } - g_ft6x46_drv.firmware_version = reg_read; - - /* Read Minor Firmware Version */ - reg_read = 0; - ret = tp_i2c_data_read(FT6X46_MINOR_FW_VERSION, (uint8_t *)®_read, FT6X46_DATA_LEN); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_CONFIG_READ_FWMINORVERSION; - } - g_ft6x46_drv.minor_firmware_version = reg_read; - - /* Read Hw ID */ - reg_read = 0; - ret = tp_i2c_data_read(FT6X46_HW_ID, (uint8_t *)®_read, FT6X46_DATA_LEN); - if (ret != EXT_ERR_SUCCESS) { - tp_err("configuration error (read hw id) 0x%x", ret); - return EXT_ERR_TP_ZTW523_GET_HWID_READ_ID; - } - g_ft6x46_drv.chip_hw_id = reg_read; - - /* Read Register Version */ - reg_read = 0; - ret = tp_i2c_data_read(FT6X46_DATA_VERSION_REG, (uint8_t *)®_read, FT6X46_DATA_LEN); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_CONFIG_READ_DATAREG; - } - g_ft6x46_drv.reg_version = reg_read; - - ret = ft6x46_reg_config(); - if (ret != EXT_ERR_SUCCESS) { - return ret; - } - - /* Write Clear Int Cmd */ - ft6x46_clear_interrupt(FT6X46_RETRY_TIMES, FT6X46_GENERAL_DELAY_1); - - return EXT_ERR_SUCCESS; -} - -static ext_errno ft6x46_get_panel_info(void) -{ - ext_errno ret; - uint16_t reg_read = 0; - /* Read X Channel Num */ - ret = tp_i2c_data_read(FT6X46_TOTAL_NUMBER_OF_X, (uint8_t *)®_read, FT6X46_DATA_LEN); - if (ret != EXT_ERR_SUCCESS) { - tp_err("TOUCH:GetPanelInfo error read x channel 0x%x", ret); - return EXT_ERR_FAILURE; - } - - g_ft6x46_drv.panel_info.xchannel_num = reg_read; - /* Read Y Channel Num */ - reg_read = 0; - ret = tp_i2c_data_read(FT6X46_TOTAL_NUMBER_OF_Y, (uint8_t *)®_read, FT6X46_DATA_LEN); - if (ret != EXT_ERR_SUCCESS) { - tp_err("TOUCH:GetPanelInfo error read y channel 0x%x", ret); - return EXT_ERR_FAILURE; - } - - g_ft6x46_drv.panel_info.ychannel_num = reg_read; - g_ft6x46_drv.panel_info.total_dnd_num = - g_ft6x46_drv.panel_info.xchannel_num * g_ft6x46_drv.panel_info.ychannel_num; - g_ft6x46_drv.panel_info.total_self_dnd_num = - g_ft6x46_drv.panel_info.xchannel_num + g_ft6x46_drv.panel_info.ychannel_num; - - return EXT_ERR_SUCCESS; -} - static ext_errno ft6x46_standby(void) { ext_errno ret; @@ -676,47 +581,6 @@ ext_errno ft6x46_suspend(void) return EXT_ERR_SUCCESS; } -static ext_errno ft6x46_resume_post(void) -{ - ext_errno ret; - // uint16_t reg_write; - // uint16_t cmd_write; - - // reg_write = FT6X46_ENABLE; - // ret = tp_i2c_reg_write(FT6X46_REG_CMD_ENABLE, reg_write); - // if (ret != EXT_ERR_SUCCESS) { - // tp_err("resume post reg cmd failed 0x%x", ret); - // return EXT_ERR_FAILURE; - // } - // /* delay for ms */ - // osDelay(FT6X46_GENERAL_DELAY_1); - - // cmd_write = FT6X46_REG_INTN_CLEAR; - // ret = tp_i2c_cmd_write(cmd_write); - // if (ret != EXT_ERR_SUCCESS) { - // return EXT_ERR_TP_ZTW523_POWERUP_INTN_CLEAR; - // } - // osDelay(FT6X46_GENERAL_DELAY_1); - - // reg_write = FT6X46_ENABLE; - // ret = tp_i2c_reg_write(FT6X46_REG_NVM, reg_write); - // if (ret != EXT_ERR_SUCCESS) { - // tp_err("resume post reg nvm failed 0x%x", ret); - // return EXT_ERR_FAILURE; - // } - // osDelay(FT6X46_GENERAL_DELAY_1); - - // reg_write = FT6X46_ENABLE; - // ret = tp_i2c_reg_write(FT6X46_REG_PROGRAM_START, reg_write); - // if (ret != EXT_ERR_SUCCESS) { - // tp_err("resume post reg program start failed 0x%x", ret); - // return EXT_ERR_FAILURE; - // } - - // osDelay(FT6X46_GENERAL_DELAY_50); /* delay 50 ms */ - - return EXT_ERR_SUCCESS; -} ext_errno ft6x46_resume(void) { ext_errno ret; @@ -726,31 +590,12 @@ ext_errno ft6x46_resume(void) ft6x46_resume_reset(); - // for (; retry_times < FT6X46_INIT_RETRY_TIMERS; retry_times++) { - // ret = ft6x46_resume_post(); - // if (ret != EXT_ERR_SUCCESS) { - // tp_err("resume: post err %d", ret); - // /* retry delay 200ms */ - // osDelay(FT6X46_GENERAL_DELAY_200); - // } else { - // break; - // } - // } - - // if (retry_times == FT6X46_INIT_RETRY_TIMERS) { - // tp_err("resume: overtimes %d", retry_times); - // goto resume_exit; - // } ret = ft6x46_config(); if (ret != EXT_ERR_SUCCESS) { tp_err("TOUCH:ft6x46 init fail 0x%x", ret); goto resume_exit; } - // ret = ft6x46_configuration(); - // if (ret != EXT_ERR_SUCCESS) { - // tp_err("TOUCH:resume config fail 0x%x", ret); - // return EXT_ERR_TP_ZTW523_INIT_CONFIG; - // } + g_ft6x46_drv.work_status = FT6X46_WORK_NORMAL; #ifdef FT6X46_GESTURE_WAKEUP 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 077ab322c..a1c4d540a 100644 --- a/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.c +++ b/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.c @@ -21,6 +21,9 @@ #elif defined(TPTYPE_FT6X46) #include "ft6x46_drv1.h" #include "ft6x46_ctrl.h" +#elif defined(TPTYPE_CST86XX) +#include "cst86xx_drv1.h" +#include "cst86xx_ctrl.h" #else #include "ztw523_drv1.h" #include "ztw523_ctrl.h" @@ -38,6 +41,10 @@ #define TOUCH_I2C_BUS FT6X46_I2C_BUS #define TOUCH_INT_GPIO FT6X46_INT_GPIO #define TOUCH_RESET_GPIO FT6X46_RESET_GPIO +#elif defined(TPTYPE_CST86XX) +#define TOUCH_I2C_BUS CST86XX_I2C_BUS +#define TOUCH_INT_GPIO CST86XX_INT_GPIO +#define TOUCH_RESET_GPIO CST86XX_RESET_GPIO #else #define TOUCH_I2C_BUS ZTW523_I2C_BUS #define TOUCH_INT_GPIO ZTW523_INT_GPIO @@ -458,6 +465,10 @@ void touch_screen_resume(void) if (ret != EXT_ERR_SUCCESS) { tp_err("touch resume ret=0x%x", ret); } #elif defined(TPTYPE_ZTW523) ztw523_resume(); +#elif defined(TPTYPE_CST86XX) + 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 @@ -484,6 +495,8 @@ void touch_screen_restart(void) tma525b_resume(); #elif defined(TPTYPE_ZTW523) ztw523_resume(); +#elif defined(TPTYPE_CST86XX) + cst86xx_resume(); #elif defined(TPTYPE_FT6X46) ft6x46_resume(); #else -- 2.17.1