From 80ec0661e8690e4f63dd9211e058b670e14c0c9a Mon Sep 17 00:00:00 2001 From: SnickerSun Date: Tue, 10 Sep 2024 20:37:19 +0800 Subject: [PATCH] =?utf8?q?0906patch=5Fdriver=5Fpatch=20=E6=B2=BF=E7=94=A8s?= =?utf8?q?dk=E5=8E=9F=E6=9D=A5=E7=9A=84=E5=88=86=E5=8C=BA=EF=BC=8C?= =?utf8?q?=E4=B8=8E0615sdk=E7=9A=84=E5=88=86=E5=8C=BA=E4=B8=8D=E5=90=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit --- .../application/audio/vendor/CMakeLists.txt | 72 ++ .../audio/vendor/aw88166/aw88166.c | 278 +++++ .../brandy/brandy_standard/thread_pri_init.c | 381 +++++++ .../rebootdevice/src/RebootPresenter.cpp | 83 ++ .../config/target_config/brandy/config.py | 320 ++++++ .../brandy_evb/board_config/board_evb.h | 295 ++++++ .../product/product_evb4_standard.h | 247 +++++ .../chips/brandy/porting/uart/uart_porting.c | 509 +++++++++ .../drivers/drivers/driver/lcd/lcd_config.c | 429 ++++++++ .../drivers/drivers/driver/lcd/lcd_private.c | 69 ++ .../drivers/drivers/driver/lcd/soc_lcd_api.c | 767 ++++++++++++++ .../drivers/driver/touch/CMakeLists.txt | 92 ++ .../driver/touch/ft6x46_touch/ft6x46_ctrl.c | 397 +++++++ .../driver/touch/ft6x46_touch/ft6x46_ctrl.h | 69 ++ .../driver/touch/ft6x46_touch/ft6x46_drv1.c | 104 ++ .../driver/touch/ft6x46_touch/ft6x46_drv1.h | 14 + .../driver/touch/ft6x46_touch/ft6x46_touch1.c | 977 ++++++++++++++++++ .../driver/touch/ft6x46_touch/ft6x46_touch1.h | 421 ++++++++ .../drivers/driver/touch/touch_screen_drv.c | 493 +++++++++ 19 files changed, 6017 insertions(+) create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/application/audio/vendor/CMakeLists.txt create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/application/audio/vendor/aw88166/aw88166.c create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/application/brandy/brandy_standard/thread_pri_init.c create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/application/wearable/nativeapp/nativeui/rebootdevice/src/RebootPresenter.cpp create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/build/config/target_config/brandy/config.py create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/boards/brandy_evb/board_config/board_evb.h create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/boards/brandy_evb/product/product_evb4_standard.h create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/chips/brandy/porting/uart/uart_porting.c create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/lcd/lcd_config.c create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/lcd/lcd_private.c create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/lcd/soc_lcd_api.c create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/CMakeLists.txt create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_ctrl.c create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_ctrl.h create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_drv1.c create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_drv1.h create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_touch1.c create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_touch1.h create mode 100644 fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.c diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/application/audio/vendor/CMakeLists.txt b/fd230_driver_patch/0906patch_driver_patch/code/sdk/application/audio/vendor/CMakeLists.txt new file mode 100644 index 000000000..c1c31962b --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/application/audio/vendor/CMakeLists.txt @@ -0,0 +1,72 @@ +#[[ +Copyright (c) CompanyNameMagicTag 2023-2023. All rights reserved. +Description: CMake audio sample module. +Author: audio +Create: 2023-06-09 +]] + +set(SAP_TOP_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../drivers/drivers/driver/audio/source) +#=================================================================================== +include(${SAP_TOP_DIR}/build/cmake/audio_config.cmake) +#=================================================================================== +set(COMPONENT_NAME audio_vendor) +set(MODULE_NAME "dsp") +set(AUTO_DEF_FILE_ID TRUE) +#=================================================================================== +set(COMPONENT_SRC ) +#=================================================================================== +set(COMPONENT_INC + ${SAP_UAPI_DIR} + ${SAP_TOP_DIR}/include + ${SAP_TOP_DIR}/drv/vendor + ${SAP_TOP_DIR}/drv/include + ${SAP_TOP_DIR}/drv/common/include + ${SAP_TOP_DIR}/drv/arch/include + ${SAP_TOP_DIR}/drv/arch/${CFG_SAP_CHIP_TYPE}/include + ${SAP_TOP_DIR}/core/include + ${SAP_TOP_DIR}/core/common/include + ${SAP_TOP_DIR}/core/arch/${CFG_SAP_CHIP_TYPE}/include + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/common +) +#=================================================================================== +if("${CFG_SAP_VENDOR_DRIVER_AW88262_SUPPORT}" STREQUAL "y") +set(COMPONENT_SRC ${COMPONENT_SRC} + ${CMAKE_CURRENT_SOURCE_DIR}/aw88262/aw88262.c +) +set(COMPONENT_INC ${COMPONENT_INC} + ${CMAKE_CURRENT_SOURCE_DIR}/aw88262 +) +endif() + +if("${CFG_SAP_VENDOR_DRIVER_AW88166_SUPPORT}" STREQUAL "y") +set(COMPONENT_SRC ${COMPONENT_SRC} + ${CMAKE_CURRENT_SOURCE_DIR}/aw88166/aw88166.c + ${CMAKE_CURRENT_SOURCE_DIR}/aw88166/aw883xx.c + ${CMAKE_CURRENT_SOURCE_DIR}/aw88166/aw883xx_calib.c + ${CMAKE_CURRENT_SOURCE_DIR}/aw88166/aw883xx_device.c + ${CMAKE_CURRENT_SOURCE_DIR}/aw88166/product_init_files/aw88166/aw883xx_pid_2066_init.c +) +set(COMPONENT_INC ${COMPONENT_INC} + ${CMAKE_CURRENT_SOURCE_DIR}/aw88166 + ${CMAKE_CURRENT_SOURCE_DIR}/aw88166/product_init_files/aw88166 + ${CMAKE_CURRENT_SOURCE_DIR}/aw88166/config/aw88166/mono/16bit +) +endif() + +if("${CFG_SAP_VENDOR_DRIVER_ANC_CODEC_SUPPORT}" STREQUAL "y") +set(COMPONENT_SRC ${COMPONENT_SRC} + ${CMAKE_CURRENT_SOURCE_DIR}/anc_codec/anc_codec.c +) +set(COMPONENT_INC ${COMPONENT_INC} + ${CMAKE_CURRENT_SOURCE_DIR}/anc_codec + ${CMAKE_CURRENT_SOURCE_DIR}/anc_codec/sai01_dac_32.768k +) +endif() +#=================================================================================== +set(COMPONENT_DEF + "SAP_PROC_SUPPORT" +) +#=================================================================================== +include(${SAP_TOP_DIR}/build/cmake/audio_common.cmake) +install_sdk(${CMAKE_CURRENT_SOURCE_DIR}/aw88166 "*") diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/application/audio/vendor/aw88166/aw88166.c b/fd230_driver_patch/0906patch_driver_patch/code/sdk/application/audio/vendor/aw88166/aw88166.c new file mode 100644 index 000000000..a0f2d29a3 --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/application/audio/vendor/aw88166/aw88166.c @@ -0,0 +1,278 @@ +/* + * Copyright (c) CompanyNameMagicTag 2023-2023. All rights reserved. + * Description: source file for aw88166 driver + */ + +#include +#include "soc_osal.h" +#include "audio_debug.h" +#include "gpio.h" +#include "hal_gpio.h" +#include "i2c.h" +#include "pinctrl.h" +#include "vendor_common.h" +#include "soc_uapi_vendor.h" + +#include "aw883xx_init.h" +#include "aw883xx.h" +#include "aw_params.h" + +static td_bool g_aw88166_i2c_inited = TD_FALSE; + +#define AW88166_PWR_ON_PIN S_AGPIO_L25 +#define AW88166_I2C_BUS_ID I2C_BUS_3 +#define AW88166_I2C_DEV_ADDR 0x34 + +static td_s32 aw_dev0_i2c_write_func(td_u16 dev_addr, td_u8 reg_addr, td_u8 *pdata, td_u16 len) +{ + td_s32 ret; + i2c_data_t data; + const td_u8 reg_addr_len = sizeof(reg_addr); /* data len of reg_addr */ + const td_u8 send_len = len + reg_addr_len; /* pdata bytes && reg_addr len */ + td_u8 *send_data = osal_kmalloc_align(send_len, 0, 8); /* 8 : Align up to 8 bytes */ + + if (send_data == TD_NULL) { + ret = -1; /* -1:FAILED ERR CODE */ + vendor_log_fun_err(malloc, ret); + return ret; + } + + /* pack reg addr & reg data */ + *send_data = reg_addr; /* reg_addr */ + ret = memcpy_s(send_data + reg_addr_len, (send_len - reg_addr_len), pdata, len); /* pdata */ + if (ret != EOK) { + vendor_log_fun_err(memcpy_s, ret); + goto out; + } + + data.send_buf = send_data; + data.send_len = send_len; + data.receive_buf = NULL; + data.receive_len = 0; + ret = (td_s32)uapi_i2c_master_write(AW88166_I2C_BUS_ID, dev_addr, &data); + if (ret != ERRCODE_SUCC) { + vendor_log_fun_err(uapi_i2c_master_write, ret); + goto out; + } + +out: + if (send_data != TD_NULL) { + osal_kfree(send_data); + } + return ret; +} + +static td_s32 aw_dev0_i2c_read_func(td_u16 dev_addr, td_u8 reg_addr, td_u8 *pdata, td_u16 len) +{ + td_s32 ret; + + i2c_data_t data; + + data.send_buf = ®_addr; + data.send_len = sizeof(reg_addr); + data.receive_buf = pdata; + data.receive_len = len; + ret = (td_s32)uapi_i2c_master_writeread(AW88166_I2C_BUS_ID, dev_addr, &data); + if (ret != ERRCODE_SUCC) { + vendor_log_fun_err(uapi_i2c_master_writeread, ret); + return ret; + } + + return AUDIO_SUCCESS; +} + +static td_void aw_dev0_reset_gpio_ctl(bool state) +{ + uapi_gpio_set_val(AW88166_PWR_ON_PIN, state); +} + +static td_void aw88166_pwr_on_pin_init(td_void) +{ + uapi_gpio_set_dir(AW88166_PWR_ON_PIN, GPIO_DIRECTION_OUTPUT); +} + +static td_s32 aw88166_i2c_init(td_void) +{ + td_s32 ret; + audio_func_enter(); + + /* init i2c */ + vendor_trace_log_u32(AW88166_I2C_BUS_ID); + ret = (td_s32)uapi_i2c_master_init(AW88166_I2C_BUS_ID, I2C_BAUDRATE, I2C_HIGH_SPEED_CODE); + if (ret != AUDIO_SUCCESS) { + vendor_log_fun_err(uapi_i2c_master_init, ret); + return ret; + } + + vendor_printf("aw88166 i2c init success\n"); + audio_func_exit(); + return AUDIO_SUCCESS; +} + +static td_s32 aw88166_i2c_deinit(td_void) +{ + td_s32 ret; + audio_func_enter(); + + /* deinit i2c */ + vendor_trace_log_u32(AW88166_I2C_BUS_ID); + ret = (td_s32)uapi_i2c_deinit(AW88166_I2C_BUS_ID); + if (ret != AUDIO_SUCCESS) { + vendor_log_fun_err(uapi_i2c_deinit, ret); + return ret; + } + + vendor_printf("aw88166 i2c deinit success\n"); + audio_func_exit(); + return AUDIO_SUCCESS; +} + +td_s32 aw883xx_pid_2066_dev_init(td_void *aw883xx); + +struct aw_init_info init_info[] = { + { + .dev = AW_DEV_0, + .i2c_addr = AW88166_I2C_DEV_ADDR, + .re_min = 2000, /* awinic:If the re_min(ohms) and re_max(ohms) are not set, the default value is used */ + .re_max = 39000, + .mix_chip_count = AW_DEV0_MIX_CHIP_NUM, + .prof_info = g_dev0_prof_info, + .i2c_read_func = aw_dev0_i2c_read_func, + .i2c_write_func = aw_dev0_i2c_write_func, + .reset_gpio_ctl = aw_dev0_reset_gpio_ctl, + .dev_init_ops = {aw883xx_pid_2066_dev_init}, + } +}; + +static td_s32 audio_aw88166_configuration(const uapi_vendor_codec_attr *attr) +{ + td_s32 ret; + + /* awinic:Control interface of dev0 */ + /* awinic:initialization */ + ret = aw883xx_smartpa_init((td_void *)&init_info[AW_DEV_0]); + if (ret != AUDIO_SUCCESS) { + vendor_printf("aw883xx_smartpa_init already init\n"); + } + /* awinic:set mode "Music", "aw_params.h" contains id information */ + ret = aw883xx_set_profile_byname(AW_DEV_0, "Music"); + if (ret != AUDIO_SUCCESS) { + vendor_log_fun_err(aw883xx_set_profile_byname, ret); + } + + vendor_unused(attr); + return ret; +} + +static td_s32 audio_aw88166_deconfiguration(td_void) +{ + /* awinic:Free the requested memory when PA is not used */ + aw883xx_smartpa_deinit(AW_DEV_0); + + return AUDIO_SUCCESS; +} + +td_s32 audio_aw88166_init(const uapi_vendor_codec_attr *attr) +{ + td_s32 ret; + + audio_func_enter(); + + aw88166_pwr_on_pin_init(); + + if (g_aw88166_i2c_inited != TD_TRUE) { + ret = aw88166_i2c_init(); + if (ret != AUDIO_SUCCESS) { + vendor_log_fun_err(aw88166_i2c_init, ret); + return ret; + } + g_aw88166_i2c_inited = TD_TRUE; + } else { + ret = 0; + } + + ret = audio_aw88166_configuration(attr); + if (ret != AUDIO_SUCCESS) { + vendor_log_fun_err(audio_aw88166_configuration, ret); + } + + return AUDIO_SUCCESS; +} + +td_s32 audio_aw88166_deinit(td_void) +{ + td_s32 ret; + audio_func_enter(); + + ret = audio_aw88166_deconfiguration(); + if (ret != AUDIO_SUCCESS) { + vendor_log_fun_err(audio_aw88166_deconfiguration, ret); + } + + if (g_aw88166_i2c_inited != TD_FALSE) { + ret = aw88166_i2c_deinit(); + if (ret != AUDIO_SUCCESS) { + vendor_log_fun_err(aw88166_i2c_deinit, ret); + return ret; + } + g_aw88166_i2c_inited = TD_FALSE; + } else { + ret = AUDIO_SUCCESS; + } + + audio_func_exit(); + return ret; +} + +td_s32 audio_aw88166_start(const uapi_vendor_codec_attr *attr) +{ + td_s32 ret; + + audio_func_enter(); + + /* awinic:The platform needs to output I2s first, and then ctl start */ + ret = aw883xx_ctrl_state(AW_DEV_0, AW_START); + if (ret != AUDIO_SUCCESS) { + vendor_log_fun_err(aw883xx_ctrl_state, ret); + } + + vendor_unused(attr); + return ret; +} + +td_s32 audio_aw88166_stop(td_void) +{ + td_s32 ret; + audio_func_enter(); + + /* awinic:The platform needs to control the stop first and then stop I2S */ + ret = aw883xx_ctrl_state(AW_DEV_0, AW_STOP); + if (ret != AUDIO_SUCCESS) { + vendor_log_fun_err(aw883xx_ctrl_state, ret); + } + audio_func_exit(); + return ret; +} + +td_s32 audio_aw88166_set_aef_profile(uapi_snd_aef_profile aef_profile) +{ + td_s32 ret; + + audio_func_enter(); + + /* awinic:set mode "Receiver"/"Music", "aw_params.h" contains id information */ + if (aef_profile == UAPI_SND_AEF_PROFILE_VOIP) { + /* awinic:set mode "Receiver" */ + ret = aw883xx_set_profile_byname(AW_DEV_0, "Receiver"); + } else { + /* awinic:set mode "Music" */ + ret = aw883xx_set_profile_byname(AW_DEV_0, "Music"); + } + + if (ret != AUDIO_SUCCESS) { + vendor_log_fun_err(aw883xx_set_profile_byname, ret); + } + + audio_func_exit(); + return ret; +} diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/application/brandy/brandy_standard/thread_pri_init.c b/fd230_driver_patch/0906patch_driver_patch/code/sdk/application/brandy/brandy_standard/thread_pri_init.c new file mode 100644 index 000000000..abc56d91e --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/application/brandy/brandy_standard/thread_pri_init.c @@ -0,0 +1,381 @@ +/* + * Copyright (c) CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: Application Core OS Priority Initialize Interface for Standard + * Author: + * Create: 2022-12-03 + */ +#include "debug_print.h" +#include "thread_init.h" +#include "common_def.h" +#include "pm.h" +#include "watchdog.h" +/* after reboot system emmc need write exc info to the file system from sector */ +#if defined(SAVE_EXC_INFO) && defined(CFG_DRIVERS_MMC) +#include "exception.h" +#endif +#ifdef CFG_DRIVERS_MMC +#ifdef __LITEOS__ +#include "soc/mmc.h" +#endif +#include "soc_mmc.h" +#endif +#include "soc_lcd_api.h" +#ifdef CFG_DRIVERS_NANDFLASH +#include "nandflash_config.h" +#include "yaffs_nand_drv.h" +#endif +#if defined(TPTYPE_TMA525B) +#include "tma525b_drv1.h" +#elif defined(TPTYPE_ZTW523) +#include "ztw523_touch1.h" +#elif defined(TPTYPE_FT6X46) +#include "ft6x46_touch1.h" +#else +#include "ztw523_touch1.h" +#endif +#include "thread_pri_init.h" +#if DSP_EXIST == YES +#include "soc_uapi_audio_sys.h" +#include "soc_uapi_vendor.h" +#include "soc_uapi_sound.h" +/* Audio codec vendor select according to hardware connection: + * define AUDIO_SMARTPA_AW88166 : macro to init smartpa aw88166; + * define AUDIO_SMARTPA_AW88166_I2S_ID UAPI_SND_OUT_PORT_I2S0 : macro to specify i2s id connecting to smartpa aw88166; + */ +#if 0 +#define AUDIO_SMARTPA_AW88262 +#define AUDIO_SMARTPA_AW88262_I2S_ID UAPI_SND_OUT_PORT_I2S2 +#else +#define AUDIO_SMARTPA_AW88166 +#define AUDIO_SMARTPA_AW88166_I2S_ID UAPI_SND_OUT_PORT_I2S0 +#endif +#endif /* DSP_EXIST */ +#include "panic.h" +#include "board_init.h" +#include "kernel_init.h" +#ifdef SUPPORT_OHOSFWK +#include "ohosfwk_startup.h" +#endif +#include "clocks_config.h" +#include "board_init.h" +#include "upg.h" +#include "upg_definitions.h" +#include "nv.h" +#include "nv_upg.h" + +#define EMMC_BASE_ADDR 0x52062000 +#define TASK_PRIORITY_APP (osPriority_t)(17) +#define TICK_TEN_MS (10U) +#define WAIT_BT_BOOTUP_TIME 200U +#define UPG_HEAD_MAGIC 0x55AA55AA +#define UPG_END_MAGIC 0xAA55AA55 +#define UPG_FLAG_MAGIC 0xFFFFFFFF + +static void thread_main(const void *unused); +void bt_acore_btc_ipc_receive_init(void); + +app_task_definition_t g_thread_pri = { { "thread_pri", 0, NULL, 0, NULL, (0x1000), TASK_PRIORITY_APP, 0, 0 }, + (osThreadFunc_t)thread_main, NULL, NULL, USE_DTCM_MEM }; +store_class g_store_init_select = STORE_CLASS_NAND; + +#if defined(ENABLE_UIKIT) || defined(ENABLE_LVGL) +static void sample_gfx_init(void) +{ +#if defined(TPTYPE_TMA525B) + tma525b_host_init_sample(); +#elif defined(TPTYPE_ZTW523) + ztw523_host_init_sample(); +#elif defined(TPTYPE_FT6X46) + ft6x46_host_init_sample(); +#else + ztw523_host_init_sample(); +#endif + uapi_lcd_init(); +#ifdef SUPPORT_GPU_GMMU + drv_gmmu_module_init(); +#endif + uapi_vau_module_init(); + uapi_dpu_module_init(); +#ifdef SUPPORT_GPU_JPEG + uapi_jpeg_module_init(); +#endif +} +#endif + +#ifdef CFG_DRIVERS_MMC +static void emmc_init(void) +{ + /** + * FPGA解复位, 设置CMD_CONFLICT_CHECK + * 之后才能设置管脚 + */ + writew(EMMC_BASE_ADDR + 0x508, 0); + init_emmc_pinmux(); + int ret = emmc_drv_context_init(); + if (ret != ENOERR) { + PRINT("emmc init error:[%d]"NEWLINE, ret); + } + mmc_set_first_init_flag(true); + mmc_set_sleep_init_flag(true); + PRINT("emmc init success\r\n"); + +#if defined(SAVE_EXC_INFO) + if (emmc_exc_info_write() != ERRCODE_SUCC) { + PRINT("emmc_exc_info_write failed"NEWLINE); + } +#endif +} + +static void emmc_init_handle(void) +{ + emmc_init(); + g_store_init_select = STORE_CLASS_EMMC; + sdiom_internal_freq_handler_register(mmc_set_internal_clk); +} +#endif + +#ifdef CFG_SDIO_EMMC_COEXIST +static void sdio_init(void) +{ + init_sdio_pinmux(); + sdio_drv_context_init(); +} +#endif + +#ifdef CFG_DRIVERS_NANDFLASH +static void nandflash_init(void) +{ + int32_t ret = 0; + ret = nandflash_filesystem_init(); + if (ret != 0) { + PRINT("nandflash init error[%d]"NEWLINE, ret); + } + PRINT("nandflash init success\r\n"); +} + +static void nandflash_init_handle(void) +{ + yaffs_nand_drv_checkptset(YAFFS_CHECKPT_SKIPED); + nandflash_init(); + g_store_init_select = STORE_CLASS_NAND; +} +#endif + +static void board_version_class_print(void) +{ + PRINT("**********startup info**********\r\n"); + PRINT("os init class is %s."NEWLINE, (get_os_init_select() == OS_CLASS_LITEOS) ? "liteos" : "freertos"); + PRINT("store init class is %s."NEWLINE, (g_store_init_select == STORE_CLASS_NAND) ? "nandflash" : "emmc"); + PRINT("display init class is %s."NEWLINE, (get_display_init_select() == DISPLAY_CLASS_QSPI) ? "QSPI" : "MIPI"); + PRINT("board init class is %s."NEWLINE, (get_board_init_select() == BOARD_CLASS_E0B2) ? "E0B2" : "E0B4"); +#ifdef CONFIG_PSRAM_SUPPORT + PRINT("psram density is %s."NEWLINE, (get_psram_density() == PSRAM_DENSITY_16M) ? "16MB" : "32MB"); +#endif + PRINT("**********startup info**********\r\n"); +} + +#if DSP_EXIST == YES +/** + * The sample code of the vendor, + * which will be implemented by the customer in the future + */ +#ifdef AUDIO_SMARTPA_AW88262 +td_s32 audio_aw88262_init(const uapi_vendor_codec_attr *attr); +td_s32 audio_aw88262_deinit(td_void); + +static uapi_vendor_driver g_aw88262_driver = { + .out_port = AUDIO_SMARTPA_AW88262_I2S_ID, + .init = audio_aw88262_init, + .deinit = audio_aw88262_deinit, + .set_aef_profile = TD_NULL, +}; + +static td_s32 audio_aw88262_register_driver(void) +{ + return uapi_audio_vendor_register(&g_aw88262_driver); +} +#endif /* AUDIO_SMARTPA_AW88262 */ + +#ifdef AUDIO_SMARTPA_AW88166 +td_s32 audio_aw88166_init(const uapi_vendor_codec_attr *attr); +td_s32 audio_aw88166_deinit(td_void); /* Call when device power off */ +td_s32 audio_aw88166_start(const uapi_vendor_codec_attr *attr); +td_s32 audio_aw88166_stop(td_void); +td_s32 audio_aw88166_set_aef_profile(uapi_snd_aef_profile aef_profile); + +static uapi_vendor_driver g_aw88166_driver = { + .out_port = AUDIO_SMARTPA_AW88166_I2S_ID, + .init = audio_aw88166_start, + .deinit = audio_aw88166_stop, + .set_aef_profile = audio_aw88166_set_aef_profile, +}; + +static td_s32 audio_aw88166_register_driver(void) +{ + const uapi_vendor_codec_attr attr = {}; + + audio_aw88166_init(&attr); /* Init aw88166 once when device power on */ + + return uapi_audio_vendor_register(&g_aw88166_driver); +} +#endif /* AUDIO_SMARTPA_AW88166 */ + +static void audio_smartpa_init(void) +{ + uint32_t ret; + +#ifdef AUDIO_SMARTPA_AW88262 + ret = (uint32_t)audio_aw88262_register_driver(); + if (ret != 0) { + PRINT("aw88262 register driver error\r\n"); + } +#endif /* AUDIO_SMARTPA_AW88262 */ + +#ifdef AUDIO_SMARTPA_AW88166 + ret = (uint32_t)audio_aw88166_register_driver(); + if (ret != 0) { + PRINT("aw88166 register driver error\r\n"); + } +#endif /* AUDIO_SMARTPA_AW88166 */ +} +#endif /* DSP_EXIST */ + +#if DSP_EXIST == YES +static void audio_init() +{ + (void)osDelay(TICK_TEN_MS); + uapi_watchdog_kick(); + + audio_smartpa_init(); + + uint32_t ret = (uint32_t)uapi_audio_init(); + if (ret != 0) { + PRINT("audio init error:[%d]\r\n", ret); + } else { + PRINT("audio init OK\r\n"); + } +} +#endif + +void rc_calibration_func_notify(void) +{ +#ifdef SUPPORT_RC_CALIBRATION + /* BT核用来通知MCU 32K校准值 */ + writew(GLB_CTL_D_RB_BASE + GLB_GP_D_REG3, 0x0); + /* 通知BTæ ¸ 32K时钟来源 */ + writew(GLB_CTL_D_RB_BASE + GLB_GP_D_REG2, CLOCK_SOURCE_RC); +#else + writew(GLB_CTL_D_RB_BASE + GLB_GP_D_REG2, CLOCK_SOURCE_XO); +#endif +} + +static void force_to_sleep(void) +{ + if (reg16_getbits(0x5702C010, 0x8, 0x8) == 0x5A) { // 特殊模式下，强制进入深睡中 + reg16_clrbits(0x5702C010, 0x8, 0x8); + uapi_tcxo_delay_ms(WAIT_BT_BOOTUP_TIME); + hal_pmu_cldo_enable_slp_bypass(HAL_PMU_CLDO1, TURN_OFF); + uapi_sys_force_mcu_only_deep_sleep_mode(0); + } +} + +#ifdef CONFIG_OTA_UPDATE_SUPPORT +static void upg_check_upgrade(void) +{ + uint32_t fota_address = 0; + errcode_t ret_val = (errcode_t)upg_get_upgrade_flag_flash_start_addr(&fota_address); + if (ret_val != ERRCODE_SUCC) { + return; + } + + fota_upgrade_flag_area_t upg_flag_info; + ret_val = (errcode_t)upg_flash_read(fota_address, sizeof(fota_upgrade_flag_area_t), (uint8_t *)(&upg_flag_info)); + if (ret_val != ERRCODE_SUCC) { + return; + } + + if (!(upg_flag_info.head_magic == UPG_HEAD_MAGIC && + upg_flag_info.head_end_magic == UPG_END_MAGIC && + upg_flag_info.complete_flag == UPG_FLAG_MAGIC)) { + /* 不需要升级直接返回 */ + PRINT("No need to upgrade...\r\n"); + return; + } + + PRINT("upgrading.......\r\n"); + ret_val = uapi_upg_start(); + if (ret_val != ERRCODE_SUCC) { + PRINT("upgrade failed, ret = 0x%x\r\n", ret_val); + } else { + PRINT("upgrade success\r\n"); + } + upg_reboot(); +} +#endif + +static void thread_main(const void *unused) +{ + PRINT("thread_main start "NEWLINE); + unused(unused); + rc_calibration_func_notify(); + bt_acore_btc_ipc_receive_init(); + uapi_pm_control(PM_BT_POWER_UP_AND_RUN); +#ifdef FORCE_TO_DEEP_SLEEP + force_to_sleep(); +#endif + los_vfs_init(); + uint32_t ret = dpal_driver_base_init(); + if (ret != 0) { + PRINT("dpal driver base init error"NEWLINE); + panic(PANIC_ASSERT, __LINE__); + } +#ifdef CFG_DRIVERS_MMC + emmc_init_handle(); +#endif +#ifdef CFG_SDIO_EMMC_COEXIST + sdio_init(); +#endif +#ifdef CFG_DRIVERS_NANDFLASH + nandflash_init_handle(); +#endif + uapi_pm_control(PM_DISPLAY_POWER_UP_AND_RUN); + (void)osDelay(TICK_TEN_MS); + +#if defined(ENABLE_UIKIT) || defined(ENABLE_LVGL) + sample_gfx_init(); +#else + uapi_pm_control(PM_DISPLAY_POWER_OFF); +#endif + +#if DSP_EXIST == YES + audio_init(); +#endif + board_version_class_print(); + uapi_watchdog_kick(); +#ifdef CONFIG_OTA_UPDATE_SUPPORT + upg_check_upgrade(); +#endif + /* nv init and file system init must be before nv_upg_upgrade_task_process */ + (void)nv_upg_upgrade_task_process(); + thread_init(); + button_app_init(); + uapi_calendar_init(); +#ifdef SUPPORT_OHOSFWK + ohos_startup(); +#endif +#ifdef CONFIG_SYSTEM_VIEW + SEGGER_SYSVIEW_Conf(); + // 请在抓取systemview开始的地方调用SEGGER_SYSVIEW_Start接口 +#endif + uapi_pm_remove_sleep_veto(PM_ID_DEBUG); + set_startup_finish_flag(); +} + +void thread_pri_init(void) +{ + /* Create tasks */ + g_thread_pri.task_handle = osThreadNew(g_thread_pri.func, NULL, &(g_thread_pri.attr)); + if (g_thread_pri.task_handle == NULL) { + panic(PANIC_TASK_CREATE_FAILED, __LINE__); + } +} diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/application/wearable/nativeapp/nativeui/rebootdevice/src/RebootPresenter.cpp b/fd230_driver_patch/0906patch_driver_patch/code/sdk/application/wearable/nativeapp/nativeui/rebootdevice/src/RebootPresenter.cpp new file mode 100644 index 000000000..1c106f4ba --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/application/wearable/nativeapp/nativeui/rebootdevice/src/RebootPresenter.cpp @@ -0,0 +1,83 @@ +/* + * Copyright (c) CompanyNameMagicTag 2022-2022. All rights reserved. + * Description: Reboot Presenter + * Create: 2022-04-28 + */ + +#include "RebootPresenter.h" +#include "RebootView.h" +#include "RebootModel.h" +#include "drag_event.h" +#include "wearable_log.h" + +namespace OHOS { +static RebootPresenter *g_pRebootPresenter = nullptr; + +RebootPresenter::RebootPresenter() +{ + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RebootPresenter::RebootPresenter"); + g_pRebootPresenter = this; +} + +RebootPresenter::~RebootPresenter() +{ + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RebootPresenter::~RebootPresenter"); + g_pRebootPresenter = nullptr; +} + +RebootPresenter *RebootPresenter::GetInstance() +{ + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RebootPresenter GetInstance"); + return g_pRebootPresenter; +} + +extern "C" +{ +extern void uapi_sys_shipmode(uint32_t arg); +extern uint32_t mcu_os_sys_reset(uint8_t *para, uint32_t para_len); +} +bool RebootPresenter::OnClick(UIView& view, const ClickEvent& event) +{ + UNUSED(event); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "OnClick OnClick"); + if (strcmp(view.GetViewId(), REBOOT_BUTTON) == 0) { + RebootView::GetInstance()->ChangeView(REBOOTVIEW, REBOOTDEVICEVIEW); + } else if (strcmp(view.GetViewId(), SHUTDOWN_BUTTON) == 0) { + RebootView::GetInstance()->ChangeView(REBOOTVIEW, SHUTDOWNDEVICEVIEW); + } else if (strcmp(view.GetViewId(), REBOOTDEVICE_BUTTON) == 0) { + // 重启 + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "REBOOTDEVICE_BUTTON OnClick"); + mcu_os_sys_reset(NULL,NULL); + } else if (strcmp(view.GetViewId(), SHUTDOWNDEVICE_BUTTON) == 0) { + // 关机 + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "SHUTDOWNDEVICE_BUTTON OnClick"); + uapi_sys_shipmode(0); + } + return true; +} + +bool RebootPresenter::OnDrag(UIView& view, const DragEvent& event) +{ + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RebootPresenter::OnDrag"); + if (event.GetDragDirection() == DragEvent::DIRECTION_LEFT_TO_RIGHT) { + if (strcmp(view.GetViewId(), REBOOT_VIEW) == 0) { + NativeAbility::GetInstance().ChangeSlice(VIEW_MAIN_SAMPLE); + } else if (strcmp(view.GetViewId(), REBOOTDEVICE_VIEW) == 0) { + if (RebootModel::GetInstance()->GetExitsView() == 0) { + RebootView::GetInstance()->ChangeView(REBOOTDEVICEVIEW, REBOOTVIEW); + } else { + NativeAbility::GetInstance().ChangeSlice(VIEW_SETTING); + RebootModel::GetInstance()->SetExitsView(false); + } + } else if (strcmp(view.GetViewId(), SHUTDOWNDEVICE_VIEW) == 0) { + if (RebootModel::GetInstance()->GetExitsView() == 0) { + RebootView::GetInstance()->ChangeView(SHUTDOWNDEVICEVIEW, REBOOTVIEW); + } else { + NativeAbility::GetInstance().ChangeSlice(VIEW_SETTING); + RebootModel::GetInstance()->SetExitsView(false); + } + } + } + return true; +} +} diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/build/config/target_config/brandy/config.py b/fd230_driver_patch/0906patch_driver_patch/code/sdk/build/config/target_config/brandy/config.py new file mode 100644 index 000000000..704c1ba00 --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/build/config/target_config/brandy/config.py @@ -0,0 +1,320 @@ +#!/usr/bin/env python3 +# encoding=utf-8 +# ============================================================================ +# @brief Target Definitions File +# Copyright CompanyNameMagicTag 2022-2022. All rights reserved. +# ============================================================================ + +target = { + #target1: liteos + lvgl + nandflash + mipi + no psram + mini_audio 典型单封LVGL版本 + 'brandy-target1': { + 'board': 'evb', + 'base_target_name': 'target_standard_brandy_application_template', + 'std_libs': [], + 'defines': ['PRE_ASIC', 'BRANDY_PRODUCT_EVB4', 'VERSION_STANDARD', '__LITEOS__', 'CONFIG_OTA_UPDATE_SUPPORT', + '_ALL_SOURCE', 'SUPPORT_CXX', 'I2C_SLAVE_REG_ADDR_4BYTE', 'CONFIG_ZDIAG_NV_SUPPORT', + "-:TARGET_CHIP_BRANDY=1", "-:BRANDY_CHIP_V100=1", 'CFG_DRIVERS_NANDFLASH', + 'CONFIG_ZDIAG_AUDIO_PROC_SUPPORT', 'CONFIG_ZDIAG_AUDIO_DUMP_SUPPORT', 'CONFIG_ZDIAG_AUDIO_PROBE_SUPPORT', + 'SUPPORT_BLE', 'SUPPORT_BREDR', 'MEMORY_MINI', 'ENABLE_LVGL', 'SW_UART_DEBUG', "SAVE_EXC_INFO", + "CONFIG_LOW_POWER_TEST", 'MIPI_ULPS_SUPPORT', 'ENABLE_ECC', 'CONFIG_DIAG_GPU_PROC_SUPPORT', + 'CONFIG_NV_SUPPORT_ASYNCHRONOUS_STORE=0', 'SUPPORT_RC_CALIBRATION'], + 'ram_component': ["algorithm", "dfx_port_brandy", "dfx_update", 'dfx_nv', "osal", "arch_port", "-:testsuite", + "liteos_port", 'lcd', 'qspi_display', 'dfx_file_operation', + 'psram', 'hal_mipi', 'mipi_tx', 'non_os', 'touch', + 'ulp_aon', 'hal_l2ram', + 'x_dpal', 'x_vfs', 'x_disk', 'x_fat', 'drv_mmc','fs_yaffs2', 'x_vfs_private', + 'pm_service', 'pm_brandy', 'cmn_header', 'at_cmd', 'graphic_at_service', 'app_at_service', + 'audio_at_service', 'media_at_service', 'bt_manager_at_service', + "audio_proc", "audio_dump", "audio_probe", "gpu_proc", 'bts_header'], + 'ram_component_set': ['bgh', 'media_mini', 'gpu', 'graphic_lvgl_mini', 'bgh_audio', 'dfx_set'], + 'image_analysis': True, + 'dsp_version': 'mini', + 'packet': True, + 'fs_image': False, + }, + #target3: liteos + uikit + nandflash + mipi + psram + audio 典型合封UIKIT版本 + 'brandy-target3': { + 'board': 'evb', + 'base_target_name': 'target_standard_brandy_application_template', + 'defines': ['PRE_ASIC', 'BRANDY_PRODUCT_EVB4', 'VERSION_STANDARD', '__LITEOS__', 'CONFIG_OTA_UPDATE_SUPPORT', + '_ALL_SOURCE', 'SUPPORT_CXX', 'I2C_SLAVE_REG_ADDR_4BYTE', 'CONFIG_PSRAM_SUPPORT', + "-:TARGET_CHIP_BRANDY=1", "-:BRANDY_CHIP_V100=1", 'CFG_DRIVERS_NANDFLASH', 'CONFIG_ZDIAG_NV_SUPPORT', + 'CONFIG_ZDIAG_AUDIO_PROC_SUPPORT', 'CONFIG_ZDIAG_AUDIO_DUMP_SUPPORT', 'CONFIG_ZDIAG_AUDIO_PROBE_SUPPORT', 'CONFIG_SEA_PHS_SUPPORT', 'CONFIG_DIAG_GPU_PROC_SUPPORT', + 'SUPPORT_BLE', 'SUPPORT_BREDR', 'ENABLE_UIKIT', 'SUPPORT_GPU_JPEG', 'SUPPORT_GPU_GMMU', 'SUPPORT_GPU_OPENVG', + 'SW_UART_DEBUG', 'SAVE_EXC_INFO', 'HASH_MEM_COPY','MIPI_ULPS_SUPPORT', 'CONFIG_LOW_POWER_TEST', + 'ENABLE_ECC', 'SUPPORT_ALIPAY_SEC', 'SUPPORT_RC_CALIBRATION'], + 'ram_component': ["algorithm", "dfx_port_brandy", "dfx_update", 'dfx_nv', "osal", "arch_port", "-:testsuite", + "liteos_port", 'lcd', 'qspi_display', 'dfx_file_operation', + 'psram', 'hal_mipi', 'mipi_tx', 'non_os', 'touch', + 'ulp_aon', 'hal_l2ram', 'x_vfs_private', + 'x_dpal', 'x_vfs', 'x_disk', 'x_fat', 'drv_mmc', 'fs_yaffs2', + 'pm_service', 'pm_brandy', 'cmn_header', 'at_cmd', 'graphic_at_service', 'app_at_service', + 'audio_at_service', 'media_at_service', 'bt_manager_at_service', + "audio_proc", "audio_dump", "audio_probe", "gpu_proc", 'bts_header'], + 'ram_component_set': ['bgh', 'media', 'gpu', 'graphic_uikit', 'graphic_test', 'bgh_audio', 'dfx_set', 'alipay_set'], + 'dsp_version': 'max', + 'packet': True, + 'fs_image': False + }, + #target4: liteos + nandflash + psram + mini_audio + no gui 外设类版本 + 'brandy-target4': { + 'board': 'evb', + 'base_target_name': 'target_standard_brandy_application_template', + 'std_libs': ['c++', 'c++abi', 'unwind'], + 'defines': ['PRE_ASIC', 'BRANDY_PRODUCT_EVB4', 'VERSION_STANDARD', 'CONFIG_OTA_UPDATE_SUPPORT', + '_ALL_SOURCE', 'I2C_SLAVE_REG_ADDR_4BYTE', 'SUPPORT_CXX', + "-:TARGET_CHIP_BRANDY=1", "-:BRANDY_CHIP_V100=1", 'CFG_DRIVERS_NANDFLASH', 'HASH_MEM_COPY', + 'CONFIG_ZDIAG_NV_SUPPORT', 'SUPPORT_BLE', 'SUPPORT_BREDR', + 'SW_UART_DEBUG', 'SAVE_EXC_INFO', 'CONFIG_PSRAM_SUPPORT', 'CONFIG_SEA_PHS_SUPPORT', + 'CONFIG_LOW_POWER_TEST', 'CONFIG_ADC_SUPPORT_AUTO_SCAN', + 'CONFIG_ADC_SUPPORT_LONG_SAMPLE', 'ENABLE_ECC', 'CONFIG_DIAG_GPU_PROC_SUPPORT', + 'SUPPORT_ALIPAY_SEC', 'SUPPORT_RC_CALIBRATION'], + 'ram_component': ["algorithm", "dfx_port_brandy", "dfx_update", 'dfx_nv', "osal", "arch_port", "-:testsuite", + "liteos_port", 'lcd', 'qspi_display', 'partition', 'partition_brandy', 'dfx_file_operation', + 'psram', 'hal_mipi', 'mipi_tx', 'non_os', 'touch', + 'ulp_aon', 'hal_l2ram', 'x_vfs_private', + 'x_dpal', 'x_vfs', 'x_disk', 'x_fat', 'drv_mmc','fs_yaffs2', + 'pm_service', 'pm_brandy', 'cmn_header', 'at_cmd', 'app_at_service', + 'audio_at_service', 'bt_manager_at_service', "gpu_proc", 'bts_header'], + 'ram_component_set': ['bgh', 'gpu', 'media_target4', 'update_app', 'dfx_set', 'bgh_audio', 'alipay_set'], + 'dsp_version': 'max', + 'packet': True, + 'fs_image': False, + }, + #target5: freertos + lvgl + nand + mipi + psram + audio + media 典型合封LVGL版本 + 'brandy-target5': { + 'board': 'evb', + 'base_target_name': 'target_standard_brandy_application_freertos_template', + 'defines': ['PRE_ASIC', 'BRANDY_PRODUCT_EVB4', 'VERSION_STANDARD', 'CONFIG_OTA_UPDATE_SUPPORT', + '_ALL_SOURCE', 'SUPPORT_CXX', 'I2C_SLAVE_REG_ADDR_4BYTE', 'CONFIG_PSRAM_SUPPORT', + "-:TARGET_CHIP_BRANDY=1", "-:BRANDY_CHIP_V100=1", 'CFG_DRIVERS_NANDFLASH', 'CONFIG_ZDIAG_NV_SUPPORT', + 'CONFIG_ZDIAG_AUDIO_PROC_SUPPORT', 'CONFIG_ZDIAG_AUDIO_DUMP_SUPPORT', 'CONFIG_ZDIAG_AUDIO_PROBE_SUPPORT', 'CONFIG_SEA_PHS_SUPPORT', 'CONFIG_DIAG_GPU_PROC_SUPPORT', + 'SUPPORT_BLE', "SUPPORT_BREDR", 'ENABLE_LVGL', "SUPPORT_GPU_JPEG", "SUPPORT_GPU_GMMU", "SUPPORT_GPU_OPENVG", + 'SW_UART_DEBUG', 'MEMORY_NO_CACHE', "SAVE_EXC_INFO", "HASH_MEM_COPY", 'MIPI_ULPS_SUPPORT', + 'CONFIG_LOW_POWER_TEST', 'ENABLE_ECC', 'SUPPORT_ALIPAY_SEC', 'SUPPORT_RC_CALIBRATION'], + 'ram_component': ["algorithm", "dfx_port_brandy", "dfx_update", 'dfx_nv', "osal", "arch_port", "-:testsuite", + 'lcd', 'qspi_display', 'partition', 'partition_brandy', 'dfx_file_operation', + 'psram', 'hal_mipi', 'mipi_tx', 'non_os', 'touch', + 'ulp_aon', 'hal_l2ram', 'x_vfs_private', + 'x_dpal', 'x_vfs', 'x_disk', 'x_fat', 'drv_mmc', 'fs_yaffs2', + 'pm_service', 'pm_brandy', 'cmn_header', 'at_cmd','graphic_at_service', 'app_at_service', + 'audio_at_service', 'media_at_service', 'bt_manager_at_service', + "audio_proc", "audio_dump", "audio_probe", "gpu_proc", 'bts_header'], + 'ram_component_set': ['bgh', 'media', 'gpu', 'graphic_lvgl', 'bgh_audio', 'update_app', 'dfx_set', 'alipay_set'], + 'dsp_version': 'max', + 'packet': True, + 'fs_image': False + }, + #native-js: liteos + uikit + nandflash + mipi + psram + audio 典型合封UIKIT版本 + #用户可参考user版本，删除reg/mem dump + 'brandy-native-js': { + 'board': 'evb', + 'base_target_name': 'target_standard_brandy_application_template', + 'defines': ['PRE_ASIC', 'BRANDY_PRODUCT_EVB4', 'VERSION_STANDARD', '__LITEOS__', 'CONFIG_OTA_UPDATE_SUPPORT', + '_ALL_SOURCE', 'SUPPORT_CXX', 'I2C_SLAVE_REG_ADDR_4BYTE', 'CONFIG_PSRAM_SUPPORT', 'CONFIG_EFUSE_READ_TO_RAM', + "-:TARGET_CHIP_BRANDY=1", "-:BRANDY_CHIP_V100=1", 'CFG_DRIVERS_NANDFLASH', 'CONFIG_ZDIAG_NV_SUPPORT', + 'CONFIG_ZDIAG_AUDIO_PROC_SUPPORT', 'CONFIG_ZDIAG_AUDIO_DUMP_SUPPORT', 'CONFIG_ZDIAG_AUDIO_PROBE_SUPPORT', 'CONFIG_SEA_PHS_SUPPORT', 'CONFIG_DIAG_GPU_PROC_SUPPORT', + 'SUPPORT_BLE', 'SUPPORT_BREDR', 'ENABLE_UIKIT', 'SUPPORT_GPU_JPEG', 'SUPPORT_GPU_GMMU', 'SUPPORT_GPU_OPENVG', + 'SW_UART_DEBUG', 'SAVE_EXC_INFO', 'HASH_MEM_COPY', 'JS_ENABLE', 'CONFIG_LOW_POWER_TEST', 'SUPPORT_OHOSFWK', + 'FT_SINGLE_UART', + 'TPTYPE_FT6X46', + 'ENABLE_ECC', 'MIPI_ULPS_SUPPORT', 'SUPPORT_ALIPAY_SEC', 'SUPPORT_RC_CALIBRATION'], + 'ram_component': ["algorithm", "dfx_port_brandy", "dfx_update", 'dfx_nv', "osal", "arch_port", "-:testsuite", + "liteos_port", 'lcd', 'qspi_display', 'dfx_file_operation', + 'psram', 'hal_mipi', 'mipi_tx', 'non_os', 'touch', + 'ulp_aon', 'hal_l2ram', 'bt_manager_at_service', + 'x_dpal', 'x_vfs', 'x_disk', 'x_fat', 'drv_mmc', 'fs_yaffs2', 'x_vfs_private', + 'pm_service', 'pm_brandy', 'cmn_header', 'at_cmd', 'graphic_at_service', 'app_at_service', 'ohosfwk_at_service', + "audio_proc", "audio_dump", "audio_probe", "power_manager", "gpu_proc",'bts_header'], + 'ram_component_set': ['bgh', 'media', 'gpu', 'graphic_uikit', 'bgh_audio', 'dfx_set', 'ohos_set', 'wearable_set', 'alipay_set'], + 'dsp_version': 'max', + 'packet': True, + 'fs_image': True + }, + #native-js-user: liteos + uikit + nandflash + mipi + psram + audio 典型合封UIKIT版本 + #离线日志版本 + #删除reg/mem dump，写法如下：'-:DUMP_MEM_SUPPORT', '-:DUMP_REG_SUPPORT', '-:SUPPORT_DFX_EXCEPTION' + 'brandy-native-js-user': { + 'base_target_name': 'brandy-native-js', + 'defines': ['-:SW_UART_DEBUG', '-:DUMP_MEM_SUPPORT', '-:DUMP_REG_SUPPORT', '-:SUPPORT_DFX_EXCEPTION'], + }, + #auto-ota-server + 'brandy-auto-ota-ser': { + 'base_target_name': 'brandy-native-js', + 'defines': ['SUPPORT_AUTO_OTA_SERVER', 'CONFIG_DFX_SUPPORT_DIAG_UP_MACHINE=1'], + }, + #auto-ota-client + 'brandy-auto-ota-cli': { + 'base_target_name': 'brandy-native-js', + 'defines': ['SUPPORT_AUTO_OTA_SERVER', 'SUPPORT_AUTO_OTA', 'CONFIG_DFX_SUPPORT_DIAG_UP_MACHINE=1'], + 'ram_component': ['auto_ota'] + }, + #native-xts: liteos + uikit + nandflash + mipi + psram + audio 典型合封UIKIT版本 + 'brandy-xts': { + 'board': 'evb', + 'base_target_name': 'target_standard_brandy_application_template', + 'defines': ['PRE_ASIC', 'BRANDY_PRODUCT_EVB4', 'VERSION_STANDARD', '__LITEOS__', 'CONFIG_OTA_UPDATE_SUPPORT', + '_ALL_SOURCE', 'SUPPORT_CXX', 'I2C_SLAVE_REG_ADDR_4BYTE', 'CONFIG_PSRAM_SUPPORT', + "-:TARGET_CHIP_BRANDY=1", "-:BRANDY_CHIP_V100=1", 'CFG_DRIVERS_NANDFLASH', 'CONFIG_ZDIAG_NV_SUPPORT', + 'CONFIG_ZDIAG_AUDIO_PROC_SUPPORT', 'CONFIG_ZDIAG_AUDIO_DUMP_SUPPORT', 'CONFIG_ZDIAG_AUDIO_PROBE_SUPPORT', 'CONFIG_SEA_PHS_SUPPORT', + 'SUPPORT_BLE', 'SUPPORT_BREDR', 'ENABLE_UIKIT', 'SUPPORT_GPU_JPEG', 'SUPPORT_GPU_GMMU', 'SUPPORT_GPU_OPENVG', 'CONFIG_DIAG_GPU_PROC_SUPPORT', + 'SW_UART_DEBUG', 'SAVE_EXC_INFO', 'HASH_MEM_COPY', 'JS_ENABLE', 'CONFIG_LOW_POWER_TEST', 'SUPPORT_OHOSFWK', + 'ENABLE_ECC', 'XTS_SUPPORT', 'SUPPORT_ALIPAY_SEC'], + 'ram_component': ["algorithm", "dfx_port_brandy", "dfx_update", 'dfx_nv', "osal", "arch_port", "-:testsuite", + "liteos_port", 'lcd', 'qspi_display', 'dfx_file_operation', + 'psram', 'hal_mipi', 'mipi_tx', 'non_os', 'touch', + 'ulp_aon', 'hal_l2ram', + 'x_dpal', 'x_vfs', 'x_disk', 'x_fat', 'drv_mmc', 'fs_yaffs2', 'x_vfs_private', + 'pm_service', 'pm_brandy', 'cmn_header', 'at_cmd', 'graphic_at_service', 'app_at_service', 'ohosfwk_at_service', + "audio_proc", "audio_dump", "audio_probe", "power_manager", "gpu_proc", 'bts_header'], + 'ram_component_set': ['bgh', 'media', 'gpu', 'graphic_uikit', 'bgh_audio', 'dfx_set', 'ohos_set', 'wearable_set', 'xts_set', 'xts_test_set', 'alipay_set'], + 'dsp_version': 'max', + 'packet': True, + 'fs_image': False + }, + + 'brandy-target1-r': { + 'board': 'evb', + 'base_target_name': 'target_brandy_recovery_template', + 'defines': ['PRE_ASIC', 'BRANDY_PRODUCT_EVB4', 'VERSION_STANDARD', '__LITEOS__', + '_ALL_SOURCE', 'SUPPORT_CXX', 'I2C_SLAVE_REG_ADDR_4BYTE', 'CFG_DRIVERS_NANDFLASH', + "-:TARGET_CHIP_BRANDY=1", "-:BRANDY_CHIP_V100=1", 'ENABLE_UIKIT', 'MEMORY_MINI', 'SW_UART_DEBUG', + 'ENABLE_ECC', 'SUPPORT_RECOVERY_DISPLAY'], + 'ram_component': ["algorithm", "dfx_port_brandy", "dfx_update", "osal", "arch_port", "-:testsuite", + "liteos_port", 'lcd', 'qspi_display', 'dfx_file_operation', + 'psram', 'hal_mipi', 'mipi_tx', 'non_os', 'touch', + 'x_dpal', 'x_vfs', 'x_disk', 'x_fat', 'drv_mmc', 'x_vfs_private', + 'ulp_aon', 'hal_l2ram', 'pm_service', 'pm_brandy', 'cmn_header'], + 'ram_component_set': ['pinctrl', 'dfx_set', 'gpu'] + }, + 'brandy-target3-r': { + 'board': 'evb', + 'base_target_name': 'target_brandy_recovery_template', + 'defines': ['PRE_ASIC', 'BRANDY_PRODUCT_EVB4', 'VERSION_STANDARD', '__LITEOS__', + '_ALL_SOURCE', 'SUPPORT_CXX', 'I2C_SLAVE_REG_ADDR_4BYTE', 'CFG_DRIVERS_NANDFLASH', + "-:TARGET_CHIP_BRANDY=1", "-:BRANDY_CHIP_V100=1", 'ENABLE_UIKIT', 'SW_UART_DEBUG', "HASH_MEM_COPY", + 'ENABLE_ECC', 'SUPPORT_RECOVERY_DISPLAY'], + 'ram_component': ["algorithm", "dfx_port_brandy", "dfx_update", "osal", "arch_port", "-:testsuite", + "liteos_port", 'lcd', 'qspi_display', 'dfx_file_operation', + 'psram', 'hal_mipi', 'mipi_tx', 'non_os', 'touch', + 'x_dpal', 'x_vfs', 'x_disk', 'x_fat', 'drv_mmc', 'x_vfs_private', + 'ulp_aon', 'hal_l2ram', 'pm_service', 'pm_brandy', 'cmn_header'], + 'ram_component_set': ['pinctrl', 'dfx_set', 'gpu'] + }, + 'brandy-target4-r': { + 'board': 'evb', + 'base_target_name': 'target_brandy_recovery_template', + 'defines': ['PRE_ASIC', 'BRANDY_PRODUCT_EVB4', 'VERSION_STANDARD', '__LITEOS__', + '_ALL_SOURCE', 'SUPPORT_CXX', 'I2C_SLAVE_REG_ADDR_4BYTE', 'CFG_DRIVERS_NANDFLASH', + "-:TARGET_CHIP_BRANDY=1", "-:BRANDY_CHIP_V100=1", 'ENABLE_UIKIT', 'SW_UART_DEBUG', 'HASH_MEM_COPY', + 'ENABLE_ECC', 'SUPPORT_RECOVERY_DISPLAY'], + 'ram_component': ["algorithm", "dfx_port_brandy", "dfx_update", "osal", "arch_port", "-:testsuite", + "liteos_port", 'lcd', 'qspi_display', 'dfx_file_operation', + 'psram', 'hal_mipi', 'mipi_tx', 'non_os', 'touch', 'x_vfs_private', + 'x_dpal', 'x_vfs', 'x_disk', 'x_fat', 'drv_mmc', 'pm_service', 'pm_brandy', + 'ulp_aon', 'hal_l2ram', 'cmn_header'], + 'ram_component_set': ['pinctrl', 'dfx_set', 'gpu'] + }, + 'brandy-target5-r': { + 'board': 'evb', + 'base_target_name': 'target_brandy_recovery_freertos_template', + 'defines': ['PRE_ASIC', 'BRANDY_PRODUCT_EVB4', 'VERSION_STANDARD', + '_ALL_SOURCE', 'SUPPORT_CXX', 'I2C_SLAVE_REG_ADDR_4BYTE', 'CFG_DRIVERS_NANDFLASH', + "-:TARGET_CHIP_BRANDY=1", "-:BRANDY_CHIP_V100=1", "__FREERTOS__", 'ENABLE_UIKIT', 'SW_UART_DEBUG', + "HASH_MEM_COPY", 'ENABLE_ECC', 'SUPPORT_RECOVERY_DISPLAY'], + 'ram_component': ["algorithm", "dfx_port_brandy", "dfx_update", "osal", "arch_port", "-:testsuite", + 'lcd', 'qspi_display', 'dfx_file_operation', + 'psram', 'hal_mipi', 'mipi_tx', 'non_os', 'touch', + 'x_dpal', 'x_vfs', 'x_disk', 'x_fat', 'drv_mmc', 'pm_service', 'pm_brandy', 'x_vfs_private', + 'ulp_aon', 'hal_l2ram', 'cmn_header'], + 'ram_component_set': ['pinctrl', 'dfx_set', 'gpu'] + }, + 'brandy-native-js-r': { + 'board': 'evb', + 'base_target_name': 'target_brandy_recovery_template', + 'defines': ['PRE_ASIC', 'BRANDY_PRODUCT_EVB4', 'VERSION_STANDARD', '__LITEOS__', + '_ALL_SOURCE', 'SUPPORT_CXX', 'I2C_SLAVE_REG_ADDR_4BYTE', 'CFG_DRIVERS_NANDFLASH', + "-:TARGET_CHIP_BRANDY=1", "-:BRANDY_CHIP_V100=1", 'ENABLE_UIKIT', 'SW_UART_DEBUG', "HASH_MEM_COPY", + 'FT_SINGLE_UART', + 'TPTYPE_FT6X46', + 'ENABLE_ECC', 'SUPPORT_RECOVERY_DISPLAY'], + 'ram_component': ["algorithm", "dfx_port_brandy", "dfx_update", "osal", "arch_port", "-:testsuite", + "liteos_port", 'lcd', 'qspi_display', 'dfx_file_operation', + 'psram', 'hal_mipi', 'mipi_tx', 'non_os', 'touch', + 'x_dpal', 'x_vfs', 'x_disk', 'x_fat', 'drv_mmc', 'x_vfs_private', + 'ulp_aon', 'hal_l2ram', 'pm_service', 'pm_brandy', 'cmn_header', + 'at_cmd' + ], + 'ram_component_set': ['pinctrl', 'dfx_set' ,'gpu'] + }, + 'brandy-xts-r': { + 'board': 'evb', + 'base_target_name': 'target_brandy_recovery_template', + 'defines': ['PRE_ASIC', 'BRANDY_PRODUCT_EVB4', 'VERSION_STANDARD', '__LITEOS__', + '_ALL_SOURCE', 'SUPPORT_CXX', 'I2C_SLAVE_REG_ADDR_4BYTE', 'CFG_DRIVERS_NANDFLASH', + "-:TARGET_CHIP_BRANDY=1", "-:BRANDY_CHIP_V100=1", 'ENABLE_UIKIT', 'SW_UART_DEBUG', "HASH_MEM_COPY", + 'ENABLE_ECC'], + 'ram_component': ["algorithm", "dfx_port_brandy", "dfx_update", "osal", "arch_port", "-:testsuite", + "liteos_port", 'lcd', 'qspi_display', 'dfx_file_operation', + 'psram', 'hal_mipi', 'mipi_tx', 'non_os', 'touch', + 'x_dpal', 'x_vfs', 'x_disk', 'x_fat', 'drv_mmc', 'x_vfs_private', + 'ulp_aon', 'hal_l2ram', 'pm_service', 'pm_brandy', 'cmn_header'], + 'ram_component_set': ['pinctrl', 'dfx_set'] + }, + 'testsuite-brandy-sdk': { + 'base_target_name': 'target_brandy_testsuite_application', + 'board': 'evb', + 'defines': ['SW_UART_DEBUG', 'USE_CMSIS_OS', 'CFG_DRIVERS_NANDFLASH', + 'PRE_ASIC', 'BRANDY_PRODUCT_EVB4', + '_ALL_SOURCE', '__LITEOS__', 'SUPPORT_CXX', 'ENABLE_UIKIT', + "-:TARGET_CHIP_BRANDY=1", "-:BRANDY_CHIP_V100=1", 'MULTIPLEXING_UART', + 'CONFIG_SPI_SUPPORT_POLL_AND_DMA_AUTO_SWITCH', 'CONFIG_SPI_AUTO_SWITCH_DMA_THRESHOLD=0x8', + 'CONFIG_I2C_SUPPORT_POLL_AND_DMA_AUTO_SWITCH', 'CONFIG_I2C_POLL_AND_DMA_AUTO_SWITCH_THRESHOLD=0x8'], + 'ram_component': ["osal", "arch_port", "liteos_port", 'psram', 'pm_service', 'pm_brandy', + 'hal_mips', 'lcd', 'qspi_display', 'hal_dma_v100', "dfx_port_brandy", + 'dfx_log_brandy', 'hal_mipi', 'mipi_tx', 'non_os', 'touch', 'ulp_aon', + 'hal_l2ram', "test_security", "test_spi", 'dfx_file_operation', + "test_timer", "test_int", "test_pm", + "test_lcd", "test_qspi_display", "test_systick", "test_tcxo", "test_watchdog", + "test_flash", "test_pwm", "test_i2c", "test_cmsis", + "test_xip", "test_mipi", "test_touch", 'algorithm', 'test_sdio', 'x_vfs_private', + 'x_dpal', 'x_vfs', 'x_disk', 'x_fat', 'drv_mmc', 'fs_yaffs2' , 'nand_flash' , 'mtd_com', + 'cmn_header', 'test_calendar', 'test_gpio', 'test_pinctrl', 'test_dma', 'test_uart', + 'test_reboot', 'test_rtc_unified', 'test_adc', 'test_pmp', 'efuse', 'hal_efuse_v100', 'efuse_porting'], + 'ram_component_set': ['dfx_set', '-:gpu_test', 'rtc_unified'], + 'os': 'liteos', + }, + 'brandy-ssb': { + 'base_target_name': 'target_ssb_template_brandy', + 'board': 'evb', + 'defines': ["-:TARGET_CHIP_BRANDY=1", "-:BRANDY_CHIP_V100=1", "PRE_ASIC", "BRANDY_PRODUCT_EVB4", + "SSB_USE_PLL", "VERSION_STANDARD", "BUILD_APPLICATION_SSB", "LIBBOOTLOADER", "LIBCODELOADER", + "LIBCPU_UTILS", "LIBAPP_VERSION", "LIBPANIC", "LIBCONNECTIVITY", "LIBERROR_CODE", "LIBSEC_RANDOM", + "LIBCODELOADER_SSB", "LIBJLINK_LOAD", "LIBLIB_UTILS", "LIBBUILD_VERSION", + "NO_TIMEOUT", "CONFIG_UART_BAUD_RATE_DIV_8", 'SW_UART_DEBUG', 'LARGE_BUFFER', + 'ENABLE_ECC', + "CFG_DRIVERS_NANDFLASH", + 'FT_SINGLE_UART' + ], + 'ram_component': ['arch_port', 'hal_l2ram', 'sec_boot', 'libboundscheck', + 'dfx_exception', 'error_code', 'psram', 'osal', 'cmn_header', 'boot_ulp', 'boot_nandflash', 'boot_emmc'], + 'ram_component_set': ['pinctrl'], + 'target': 'ssb', + } +} + +target_group = { + # ci protect target list + 'pack_brandy_target1': ['brandy-ssb', 'brandy-target1-r', 'brandy-target1'], + 'pack_brandy_target3': ['brandy-ssb', 'brandy-target3-r', 'brandy-target3'], + 'pack_brandy_target4': ['brandy-ssb', 'brandy-target4-r', 'brandy-target4'], + 'pack_brandy_target5': ['brandy-ssb', 'brandy-target5-r', 'brandy-target5'], + 'pack_brandy_native_js': ['brandy-ssb', 'brandy-native-js-r', 'brandy-native-js'], + 'pack_brandy_native_js_user': ['brandy-ssb', 'brandy-native-js-r', 'brandy-native-js-user'], + 'pack_brandy_xts': ['brandy-ssb', 'brandy-xts-r', 'brandy-xts'], + + 'brandy_all': ['brandy-ssb', + 'brandy-target1', 'brandy-target3', 'brandy-target4', 'brandy-target5', 'brandy-native-js', 'brandy-native-js-user', 'brandy-xts', + 'brandy-target1-r', 'brandy-target3-r', 'brandy-target4-r', 'brandy-target5-r', 'brandy-native-js-r', 'brandy-xts-r', + 'testsuite-brandy-sdk'] +} diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/boards/brandy_evb/board_config/board_evb.h b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/boards/brandy_evb/board_config/board_evb.h new file mode 100644 index 000000000..c366e46d4 --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/boards/brandy_evb/board_config/board_evb.h @@ -0,0 +1,295 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2018-2021. All rights reserved. + * Description: brandy evb board config + * Author: @CompanyNameTag + * Create: 2020-02-19 + */ +#ifndef BOARD_EVB_CONFIG_H +#define BOARD_EVB_CONFIG_H + +#include "pinctrl_porting.h" +#include "gpio_porting.h" +#include "platform_types.h" + + +/** + * @addtogroup connectivity_config_boards + * @{ + */ +/** + * @brief Global evb pio functions. + */ +const hal_pio_config_t g_pio_function_config[PIN_MAX_NUMBER] = { + { HAL_PIO_FUNC_QSPI0, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_EGPIO0 + { HAL_PIO_FUNC_QSPI0, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO1 + { HAL_PIO_FUNC_QSPI0, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_EGPIO2 + { HAL_PIO_FUNC_QSPI0, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_EGPIO3 + { HAL_PIO_FUNC_QSPI0, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_EGPIO4 clk + { HAL_PIO_FUNC_QSPI0, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_EGPIO5 cs + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_EGPIO6 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO7 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO8 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO9 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO10 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO11 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO12 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO13 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO14 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO15 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO16 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO17 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO18 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO19 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO20 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO21 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_EGPIO22 clk + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_EGPIO23 ce + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO24 + { HAL_PIO_FUNC_OPI, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_EGPIO25 + + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_HGPIO0 NC + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_HGPIO1 NC + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_HGPIO2 NC + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_HGPIO3 NC + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_HGPIO4 NC + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_HGPIO5 NC +#if (defined CFG_DRIVERS_NANDFLASH) + { HAL_PIO_FUNC_QSPI1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_HGPIO6 + { HAL_PIO_FUNC_QSPI1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_HGPIO7 + { HAL_PIO_FUNC_QSPI1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_HGPIO8 + { HAL_PIO_FUNC_QSPI1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_HGPIO9 + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_DISABLE }, // S_HGPIO10 + { HAL_PIO_FUNC_QSPI1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_DISABLE }, // S_HGPIO11 cs0 + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_DISABLE }, // S_HGPIO12 cs1 + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_DISABLE }, // S_HGPIO13 + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_DISABLE }, // S_HGPIO14 + { HAL_PIO_FUNC_QSPI1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_DISABLE }, // S_HGPIO15 clk +#else + { HAL_PIO_FUNC_EMMC, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_HGPIO6 + { HAL_PIO_FUNC_EMMC, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_HGPIO7 + { HAL_PIO_FUNC_EMMC, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_HGPIO8 + { HAL_PIO_FUNC_EMMC, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_HGPIO9 + { HAL_PIO_FUNC_EMMC, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_HGPIO10 + { HAL_PIO_FUNC_EMMC, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_HGPIO11 + { HAL_PIO_FUNC_EMMC, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_HGPIO12 + { HAL_PIO_FUNC_EMMC, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_HGPIO13 + { HAL_PIO_FUNC_EMMC, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_HGPIO14 + { HAL_PIO_FUNC_EMMC, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_HGPIO15 emmc clk +#endif + { HAL_PIO_FUNC_SPI0, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_MGPIO0 NC + { HAL_PIO_FUNC_SPI0, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_MGPIO1 NC + { HAL_PIO_FUNC_SPI0, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_MGPIO2 NC + { HAL_PIO_FUNC_SPI0, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_MGPIO3 NC + +// #if (defined BRANDY_PRODUCT_EVB4) + { HAL_PIO_FUNC_SPI0, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_MGPIO4 NC +// #else + // { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO4 NC +// #endif + + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_MGPIO5 NC + { HAL_PIO_FUNC_SPI1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_MGPIO6 SPI1 DI + { HAL_PIO_FUNC_SPI1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_MGPIO7 SPI1 DO + { HAL_PIO_FUNC_SPI1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_MGPIO8 SPI1 CLK + { HAL_PIO_FUNC_SPI1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_ENBALE }, // S_MGPIO9 SPI1 CS0 + { HAL_PIO_FUNC_SPI1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_MGPIO10 SPI1 CS1 NC + + { HAL_PIO_FUNC_I2C0_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO11 i2c0 SCL NC + { HAL_PIO_FUNC_I2C0_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO12 I2C0 SDA + { HAL_PIO_FUNC_I2C1_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO13 I2C1 SCL touch i2c + { HAL_PIO_FUNC_I2C1_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO14 I2C1 SDA + { HAL_PIO_FUNC_I2C2_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO15 I2C2 SCL Sensor 6�� ָ���� ���� + { HAL_PIO_FUNC_I2C2_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO16 I2C2 SDA Sensor + { HAL_PIO_FUNC_I2C3_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO17 i2c3 SCL smart pa\ Ԥ��������� \��ȫоƬ + { HAL_PIO_FUNC_I2C3_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO18 I2C3 SDA + { HAL_PIO_FUNC_UART1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_MGPIO19 uart1 tx + { HAL_PIO_FUNC_UART1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_MGPIO20 uart1 rx + { HAL_PIO_FUNC_UART1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO21 uart1 rts + { HAL_PIO_FUNC_UART1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO22 uart1 cts + { HAL_PIO_FUNC_SPI2_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_MGPIO23 NC + { HAL_PIO_FUNC_SPI2_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_MGPIO24 NC + { HAL_PIO_FUNC_SPI2_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_MGPIO25 NC + { HAL_PIO_FUNC_SPI2_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_MGPIO26 NC +#if (defined QSPI_DISPLAY) + { HAL_PIO_FUNC_QSPI2, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO27 + { HAL_PIO_FUNC_QSPI2, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO28 + { HAL_PIO_FUNC_QSPI2, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO29 + { HAL_PIO_FUNC_QSPI2, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO30 + { HAL_PIO_FUNC_QSPI2, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO31 + { HAL_PIO_FUNC_QSPI2, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO32 +#else + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_MGPIO27 + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_MGPIO28 + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_MGPIO29 + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_MGPIO30 + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_MGPIO31 + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_MGPIO32 +#endif + { HAL_PIO_FUNC_UART_HS_UART, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_MGPIO33 huart tx + { HAL_PIO_FUNC_UART_HS_UART, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_MGPIO34 huart rx + { HAL_PIO_FUNC_UART_HS_UART, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO35 + { HAL_PIO_FUNC_UART_HS_UART, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_MGPIO36 +#if 0 + { HAL_PIO_FUNC_UART2_M2, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_MGPIO37 uart tx + { HAL_PIO_FUNC_UART2_M2, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_MGPIO38 uart rx +#else + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_MGPIO37 uart tx NC + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_MGPIO38 uart rx NC +#endif + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_L0 NC + + { HAL_PIO_FUNC_I2S1_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_L1 i2s1 + { HAL_PIO_FUNC_I2S1_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_L2 + { HAL_PIO_FUNC_I2S1_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_L3 + { HAL_PIO_FUNC_I2S1_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_L4 + + { HAL_PIO_FUNC_I2S0_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_L5 + { HAL_PIO_FUNC_I2S0_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_L6 i2s0 + { HAL_PIO_FUNC_I2S0_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_L7 + { HAL_PIO_FUNC_I2S0_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_L8 + +#if (defined FT_BT_UART) + { HAL_PIO_FUNC_UART2_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_AGPIO_L9 uart2 txd + { HAL_PIO_FUNC_UART2_M1, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_AGPIO_L10 uart2 rxd +#else + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_L9 dsp uart TP35 + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_L10 dsp uart TP36 +#endif + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_ENBALE }, // S_AGPIO_L11 G_INT1 + + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_L12 i2c data HX3507_SDIO + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_AGPIO_L13 i2c CLK HX3507_SCLK + + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_AGPIO_L14 NC + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_AGPIO_L15 NC + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_AGPIO_L16 NC + + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_AGPIO_L17 HX3507_INT not use + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_AGPIO_L18 VDDEN //��ʱ���ã�����VDDIO Ĭ�Ͽ��� EXt V3.0 EXt V1.8 + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_DISABLE }, // S_AGPIO_L19 G_INT2 //��ʱ���� + + + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_AGPIO_L20 0.2C_CHRG + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_AGPIO_L21 NTC_VDD_ON ���ʹ� NTC������Դ +#ifdef QSPI_DISPLAY + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_L22 QSPI TE +#else + { HAL_PIO_FUNC_TE, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_L22 MIPI TE +#endif + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_AGPIO_L23 CAT_1_PWR_ON ����CAT_1�����ţ����߿��� CAT1��Դ ������Ч + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_AGPIO_L24 LCM_EN + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_AGPIO_L25 //////////// audio pa reset + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_AGPIO_L26 ���ʸ�λ PPG reset + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_AGPIO_L27 LCM reset + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_AGPIO_L28 CAT_1��λ CAT1_RESET_N ������Ч + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_L29 charge done info ����Ƿ������ + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_AGPIO_L30 KP_MKIN1 ���� CAT1 ����� + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_L31 KP_MKOUIT1 ���� ���� ,���� + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_AGPIO_L32 NC + + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_AGPIO_R0 PRG_LED_POWER ON ���ʵȵ�Դ���ƽ� + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_AGPIO_R1 SE_REST ��ȫоƬ��λ���ѽ� +// #if VIB_USE_PWM + // { HAL_PIO_FUNC_PWMP1_M2, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_AGPIO_R2 VIBR_PWM ������ƽ� ����Ԥ������������λ�� + // { HAL_PIO_FUNC_PWMN1_M3, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_AGPIO_R2 VIBR_PWM ������ƽ� ����Ԥ������������λ�� +// #else + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_AGPIO_R2 VIBR_PWM ������ƽ� ����Ԥ������������λ�� +// #endif + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // S_AGPIO_R3 NC + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_UP, HAL_PIO_IE_DISABLE }, // S_AGPIO_R4 tp reset + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_R5 touch int + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_R6 PRG_INT �����ж� + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_AGPIO_R7 GYRO_INT2 + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_AGPIO_R8 GYRO_INT1 + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_DISABLE }, // S_AGPIO_R9 BAT_CHARGE_OFF �ص���� �¶ȸߵ�ʱ�� + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // S_AGPIO_R10 Key2 ///////////////////HAL_PIO_IE_ENBALE input enable + +#if CORE == APPS + { HAL_PIO_FUNC_INVALID, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // ULP_GPIO0 mode not config + { HAL_PIO_FUNC_INVALID, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // ULP_GPIO1 mode not config + { HAL_PIO_FUNC_INVALID, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // ULP_GPIO2 mode not config + { HAL_PIO_FUNC_INVALID, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // ULP_GPIO3 mode not config + { HAL_PIO_FUNC_GPIO, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_DOWN, HAL_PIO_IE_DISABLE }, // ULP_GPIO4 + { HAL_PIO_FUNC_SWD, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // ULP_GPIO5 + { HAL_PIO_FUNC_SWD, HAL_PIO_DRIVE_MAX, HAL_PIO_PULL_MAX, HAL_PIO_IE_ENBALE }, // ULP_GPIO6 +#endif +}; +/** + * @} + */ + + +/** + * @addtogroup connectivity_config_boards + * @{ + */ +/** + * @brief Global evb gpio functions. + * + * + * typedef struct { + pin_t gpio; + hal_gpio_direction_t direction; + hal_gpio_level_t level; + uint32_t triger; + hal_gpio_callback_t callback; +} hal_gpio_config_t; + */ + + +//Ĭ�Ͽ���Cat1 Ȼ���ٸ������þ����Ƿ�ر�. +//Ĭ�ϲ����� ppg checkidʧ�ܣ�ԭ��δ֪����ʱ��������cat1 +#define DEFAULT_POWERON_CAT1 0 + +//��Ҫ����Ĭ������ģ��Լ���Ҫ����Ĭ�������жϺ����ġ� +const hal_gpio_config_t g_gpio_function_config[PIN_MAX_NUMBER] = { + +#if DEFAULT_POWERON_CAT1 + // S_AGPIO_L23 CAT_1_PWR_ON ----- high power on + { S_AGPIO_L23, HAL_GPIO_DIRECTION_OUTPUT, HAL_GPIO_LEVEL_HIGH, 0, NULL }, + // S_AGPIO_L28 Cat1 reset ---- low reset + { S_AGPIO_L28, HAL_GPIO_DIRECTION_OUTPUT, HAL_GPIO_LEVEL_HIGH, 0, NULL }, +#else + // S_AGPIO_L23 CAT_1_PWR_ON ----- high power on + { S_AGPIO_L23, HAL_GPIO_DIRECTION_OUTPUT, HAL_GPIO_LEVEL_LOW, 0, NULL }, + // S_AGPIO_L28 Cat1 reset ---- low reset + { S_AGPIO_L28, HAL_GPIO_DIRECTION_OUTPUT, HAL_GPIO_LEVEL_LOW, 0, NULL }, +#endif + // S_AGPIO_L17 HX3507_INT + // { S_AGPIO_L17, HAL_GPIO_DIRECTION_INPUT, HAL_GPIO_LEVEL_LOW, 0, NULL }, + // S_AGPIO_L12 SDIO_BT + { S_AGPIO_L12, HAL_GPIO_DIRECTION_OUTPUT, HAL_GPIO_LEVEL_LOW, 0, NULL }, + // S_AGPIO_L13 SCLK_BT + { S_AGPIO_L13, HAL_GPIO_DIRECTION_OUTPUT, HAL_GPIO_LEVEL_LOW, 0, NULL }, + + // S_AGPIO_L26 ���ʸ�λ PPG reset + { S_AGPIO_L26, HAL_GPIO_DIRECTION_OUTPUT, HAL_GPIO_LEVEL_LOW, 0, NULL }, + // S_AGPIO_R0 PRG_LED_POWER ON ���ʵȵ�Դ���ƽ� + { S_AGPIO_R0, HAL_GPIO_DIRECTION_OUTPUT, HAL_GPIO_LEVEL_LOW, 0, NULL }, + + //S_AGPIO_L21 NTC_VDD_ON ���ʹ� NTC������Դ ,Ĭ�Ϲر� + { S_AGPIO_L21, HAL_GPIO_DIRECTION_OUTPUT, HAL_GPIO_LEVEL_HIGH, 0, NULL }, +#if 1 //Ĭ��������� +// #define GPIO_PIN_ENABLE_CHARGE S_AGPIO_R9 //low enable +// #define GPIO_PIN_ENABLE_CHARGE_0_2C S_AGPIO_L20 //low 0.2c �͵������ + { S_AGPIO_R9, HAL_GPIO_DIRECTION_OUTPUT, HAL_GPIO_LEVEL_LOW, 0, NULL }, + { S_AGPIO_L20, HAL_GPIO_DIRECTION_OUTPUT, HAL_GPIO_LEVEL_LOW, 0, NULL }, +#else + { S_AGPIO_R9, HAL_GPIO_DIRECTION_OUTPUT, HAL_GPIO_LEVEL_LOW, 0, NULL }, + { S_AGPIO_L20, HAL_GPIO_DIRECTION_OUTPUT, HAL_GPIO_LEVEL_HIGH, 0, NULL }, +#endif + +//Ĭ�Ϲر����� + { S_AGPIO_R2, HAL_GPIO_DIRECTION_OUTPUT, HAL_GPIO_LEVEL_LOW, 0, NULL }, +//Ĭ�Ͽ��� EXT LDO V3.0 V1.8 + { S_AGPIO_L18, HAL_GPIO_DIRECTION_OUTPUT, HAL_GPIO_LEVEL_HIGH, 0, NULL }, + + + /**S_AGPIO_R1 GPO alipayĬ��resetpin*/ + { S_AGPIO_R1, HAL_GPIO_DIRECTION_OUTPUT, HAL_GPIO_LEVEL_HIGH, 0, NULL }, + +}; +/** + * @} + */ +#endif diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/boards/brandy_evb/product/product_evb4_standard.h b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/boards/brandy_evb/product/product_evb4_standard.h new file mode 100644 index 000000000..d0ba14388 --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/boards/brandy_evb/product/product_evb4_standard.h @@ -0,0 +1,247 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2020-2023. All rights reserved. + * Description: product EVB4 standard config + * Author: @CompanyNameTag + * Create: 2023-03-07 + */ +#ifndef PRODUCT_EVB4_STANDARD_CONFIG_H +#define PRODUCT_EVB4_STANDARD_CONFIG_H + +/** + * @defgroup connectivity_config_product PRODUCT + * @ingroup connectivity_config + * @{ + */ +/* Platform board config, need check if it support or not carefully. */ +#define BTH_WITH_SMART_WEAR YES +#define APP_WRITE_OTP_ENABLE NO +#define APP_HEAP_SIZE 0x18000 // the minimum APP heap size (96kB) +#define USE_FLASH_SUSPEND_AND_RESUME NO +#define WAIT_APPS_DUMP_FOREVER NO +#define TWS_MPU_XIP_PROTECT NO +#define SSB_IMAGE_PAGES 27 +#ifdef CONFIG_LOW_POWER_TEST +#define ENABLE_LOW_POWER YES +#else +#define ENABLE_LOW_POWER NO +#endif +#if defined(CFG_FLASH_SIZE) && (CFG_FLASH_SIZE == 16) +#define DTB_IMAGE_PAGES 0 +#define RECOVERY_IMAGE_PAGES 256 +#define RESERVE_IMAGE_PAGES 64 +#define BT_IMAGE_PAGES 112 +#define HIFI0_IMAGE_PAGES 192 +#define HIFI0_CODEC_PAGES 448 +#define APP_IMAGE_PAGES 2048 +#else +#define DTB_IMAGE_PAGES 0 +#define RECOVERY_IMAGE_PAGES 64 +#define RESERVE_IMAGE_PAGES 0 +#define BT_IMAGE_PAGES 112 +#define HIFI0_IMAGE_PAGES 112 +#define HIFI0_CODEC_PAGES 320 +#define APP_IMAGE_PAGES 1353 +#endif +#define NV_IMAGE_PAGES 4 +#define FOTA_IMAGE_PAGES 3 +#define FOTA_IMAGE_START 0x770000 +#define SSB_FOTA_OFFSET 0x0 +#define XO_CTRIM_VALUR_DEFAULT 0x56 +#define DSP1_IPC_ENABLE NO +#define APP_BTN_TASK_MONITOR_ENABLE NO +#define SSB_FOTA_MODE_TWS YES +#define DSP_EXTEND_OCRAM_SIZE 1310720 // Unit byte, = 1280 KB +#define OSC_EN_CALLBACK_BY_PLT YES +#define BT_MIPS_DEBUG NO +#define NON_OS_CRITICAL_RECORD NO +#define ENABLE_MASSDATA_RECORD NO +#define USE_COMPRESS_LOG_INSTEAD_OF_SDT_LOG NO +#define COMPRESS_LOG_TRIGGER_THRESHOLD 0 +#define COMPRESS_LOG_COUNT_THRESHOLD 0xFFFFFFFF +#define EXCEPTION_TEST_ENABLE NO +#define LOG_LEVEL_APP_DEFAULT_CONFIG 3 // Info level +#define LOG_LEVEL_BT_DEFAULT_CONFIG 3 // Info level +#define LOG_LEVEL_DSP_DEFAULT_CONFIG 3 // Info level +#define BCPU_HEAP_MININUM_SIZE 0xA000 // 40KB +#ifdef BUILD_RECOVERY_IMAGE +#define SYS_DEBUG_MODE_ENABLE NO +#else +#define SYS_DEBUG_MODE_ENABLE NO +// #define SYS_DEBUG_MODE_ENABLE YES +#endif +#define PROMPT_TONE_REGION_LENGTH 0x2800 +#define AUDIO_DATA_STREAM_REGION_LENGTH 0x2000 +#define BT_MASSDATA_LENGTH 0x400 +#define APP_MASSDATA_LENGTH 0x800 +#define APP_LOGGING_LENGTH 0x1C00 +#define DSP_LOGGING_LENGTH 0x2000 +#define PSRAM_DENSITY_MB 32 +#define RC_CLOCK_ON NO +#define SMART_WATCH_BT_COEX_PIN_SWITCH NO // pinmux switch in the Coexistence of BT and WiFi of smart watch +#define CAP_SENSOR_BUFF_LEN 128 +#define BT_L2RAM_AREA_SIZE 3 // 384k, Reference the enum Value of hal_b_memory_share_config_t +#define DSP_L2RAM_AREA_TOTAL 10 +#define GPU_L2RAM_AREA_TOTAL 11 +#ifndef CONFIG_PSRAM_SUPPORT +#define DSP_L2RAM_AREA_SIZE 6 // 无PSRAM & 小型化场景分配给DSP 6块*128K=768KB 剩余512K系统使用 +#else +#if defined(CONFIG_SEA_PHS_SUPPORT) +#define DSP_L2RAM_AREA_SIZE 10 // 语音唤醒场景分配给DSP 10块*128K=1280KB DSP L2M不给系统使用 +#else +#define DSP_L2RAM_AREA_SIZE 8 // 正常场景分配给DSP 8块*128K=1024KB 剩余256K系统使用 +#endif /* CONFIG_SEA_PHS_SUPPORT */ +#endif /* CONFIG_PSRAM_SUPPORT */ +#define PUYA_FLASH_SUPPORT YES + +/********************display config********************/ +#define DOUBLE_BUFFER 1 +#if defined(QSPI_DISPLAY) +#define RESOLUTION_WIDTH 194 +#define RESOLUTION_HEIGHT 368 +#elif defined(MEMORY_MINI) +#define RESOLUTION_WIDTH 240 +#define RESOLUTION_HEIGHT 296 +#elif defined(SUPPORT_SOFT_SEND_FRM) +#define RESOLUTION_WIDTH 368 +#define RESOLUTION_HEIGHT 448 +#else +#define RESOLUTION_WIDTH 466//454 +#define RESOLUTION_HEIGHT 466//454 +#endif + +/********************Other module board config********************/ +#define BTC_SWITCH_COEX YES +#define BTC_SMART_WEAR_WLCOEX YES +#define BTC_WITH_SMART_WEAR YES +#define BTC_TWS_MONITOR YES +#define BTC_ICO_SUPPORT YES +#define BTC_DUAL_ANT_SWITCH_SUPPORT NO +#define BTC_GET_EMC_FROM_PLATFORM YES // 后续耳机产品通过HCI传递NV数据实现后，该选项需要置为NO +#define BTSNOOP_ENABLE NO +#define TWS_USER_CHR_RECORD NO +#define BTH_WEAR_ENABLE_AUDIO_SINK NO +#define BTH_WEAR_ENABLE_AUDIO_GATEWAY NO +#define BTH_WEAR_BREDR_DOUBLE_CONNECT NO +#define BTC_DFX_LOG_HELP_SUPPORT NO +#define FACTORY_CALI NO +#define BTH_WEAR_ENABLE_CONNECT_MANAGER NO +#define BTH_WEAR_ENABLE_BLE_FEATURES YES +#define BTH_WEAR_ENABLE_HFP_FEATURES NO +#define WEAR_USER_CONFIG NO +#define BTH_HIGH_POWER YES +#define MULTI_CONNECT YES +#define BTH_CONFIG_HDAP YES +#define DEVICE_MANAGE_FEATURE YES +#define BTH_CALL_LC3_32K YES +#define BTH_ENABLE_LC3_CODEC YES +#define ENABLE_CHANGE_DEVICE_NAME YES +#define BTH_DIP_PRODUCT_ID 0x4106 +#define BTH_ENABLE_L2HC_CODEC YES +#define ENABLE_BT_XO_16M NO +#define BTH_WSTP_CMD_SUPPORT YES +#define PRODUCT_SUPPORT_MODE_SWITCH YES +#define BT_MANAGER_DEPLOYED 2 +#define BT_CODEC_TID 2 +#define BTH_WEAR_ENABLE_AVRCP_TARGET NO +#define BTH_WEAR_ENABLE_AVRCP_CONTROLLER NO +#define BTH_WEAR_ENABLE_AUDIO_SOURCE NO +#define BTH_WEAR_ALLOW_INQUIRY_SCAN YES +#define BTH_WEAR_ENABLE_HALL_STATE NO + +// 音频内置输入设备 +#define BUILTIN_AI_PORT 0x50 // 参考 soc_uapi_ai.h 中 UAPI_AI_PORT_LPADC0 枚举 +#define BUILTIN_AI_PORT_ATTR_ADC_RX_TYPE 0 // 参考 soc_uapi_ai.h 中 UAPI_AI_RX_DEFAULT 枚举 +#define BUILTIN_AI_PCM_ATTR_AUDIO_CH 1 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_CHANNEL_1 枚举 +#define BUILTIN_AI_PCM_ATTR_BIT_DEPTH 16 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_BIT_DEPTH_16 枚举 +#define BUILTIN_AI_PCM_ATTR_SAMPLE_RATE 16000 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_SAMPLE_RATE_16K 枚举 +#define BUILTIN_AI_PCM_ATTR_FRAME_PER_SEC 100 // 每秒帧数 + +// 音频内置输出设备 +#define BUILTIN_SND_OUT_PORT 0x10 // 参考 soc_uapi_sound.h 中 UAPI_SND_OUT_PORT_I2S0 枚举 +#define BUILTIN_SND_OUT_PORT_NUM 1 // 端口个数 +#define BUILTIN_SND_OUT_AUDIO_CH 2 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_CHANNEL_2 枚举 +#define BUILTIN_SND_OUT_BIT_DEPTH 16 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_BIT_DEPTH_16 枚举 +#define BUILTIN_SND_OUT_SAMPLE_RATE 48000 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_SAMPLE_RATE_48K 枚举 +#define BUILTIN_SND_OUT_I2S_ATTR_I2S_BCLK 8 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_I2S_BCLK_8_DIV 枚举 +#define BUILTIN_SND_OUT_I2S_ATTR_BIT_DEPTH 16 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_BIT_DEPTH_16 枚举 +#define BUILTIN_SND_OUT_I2S_ATTR_AUDIO_CH 2 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_CHANNEL_2 枚举 +#define BUILTIN_SND_OUT_I2S_ATTR_I2S_STD_MODE 0 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_I2S_STD_MODE 枚举 +#define BUILTIN_SND_OUT_I2S_ATTR_MASTER 1 // 1:主设备,0:从设备 +#define BUILTIN_SND_OUT_I2S_ATTR_I2S_MCLK 1 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_I2S_MCLK_256_FS 枚举 +#define BUILTIN_SND_OUT_I2S_ATTR_I2S_PCM_DELAY 1 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_I2S_PCM_1_DELAY 枚举 +#define BUILTIN_SND_OUT_I2S_ATTR_SAMPLE_RISE_EDGE 1 // 参考 soc_uapi_audio.h 中 pcm_sample_rise_edge 成员 + +// 音频外挂输入设备 +#define EXTERNAL_AI_PORT 1 // 参考 soc_uapi_ai.h 中 UAPI_AI_PORT_I2S1 枚举 +#define EXTERNAL_AI_I2S_ATTR_MASTER 0 // 1:主设备,0:从设备 +#define EXTERNAL_AI_I2S_ATTR_I2S_MODE 1 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_I2S_PCM_MODE 枚举 +#define EXTERNAL_AI_I2S_ATTR_MCLK 6 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_I2S_MCLK_1536_FS 枚举 +#define EXTERNAL_AI_I2S_ATTR_BCLK 48 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_I2S_BCLK_48_DIV 枚举 +#define EXTERNAL_AI_I2S_ATTR_BIT_DEPTH 16 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_BIT_DEPTH_16 枚举 +#define EXTERNAL_AI_I2S_ATTR_AUDIO_CH 2 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_CHANNEL_2 枚举 +#define EXTERNAL_AI_I2S_ATTR_SAMPLE_RISE_EDGE 1 // 参考 soc_uapi_audio.h 中 pcm_sample_rise_edge 成员 +#define EXTERNAL_AI_I2S_ATTR_PCM_DELAY_CYCLE 1 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_I2S_PCM_1_DELAY 枚举 +#define EXTERNAL_AI_PCM_ATTR_CHANNELS 1 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_CHANNEL_2 枚举 +#define EXTERNAL_AI_PCM_ATTR_BIT_DEPTH 16 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_BIT_DEPTH_16 枚举 +#define EXTERNAL_AI_PCM_ATTR_SAMPLE_RATE 8000 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_SAMPLE_RATE_16K 枚举 +#define EXTERNAL_AI_PCM_ATTR_FRAME_PER_SEC 50 // 每秒帧数 , EG810 pcm 20ms 一帧 + +// 音频外挂输出设备 +#define EXTERNAL_SND_OUT_PORT 0x11 // 参考 soc_uapi_sound.h 中 UAPI_SND_OUT_PORT_I2S1 枚举 +#define EXTERNAL_SND_OUT_AUDIO_CHANNEL 1 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_CHANNEL_2 枚举 +#define EXTERNAL_SND_OUT_AUDIO_BIT_DEPTH 16 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_BIT_DEPTH_16 枚举 +#define EXTERNAL_SND_OUT_AUDIO_SAMPLE_RATE 8000 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_SAMPLE_RATE_16K 枚举 +#define EXTERNAL_SND_OUT_PORT_NUM 1 // 端口个数 +#define EXTERNAL_SND_OUT_I2S_ATTR_BIT_DEPTH 16 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_BIT_DEPTH_16 枚举 +#define EXTERNAL_SND_OUT_I2S_ATTR_CHANNEL 2 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_CHANNEL_2 枚举 +#define EXTERNAL_SND_OUT_I2S_ATTR_I2S_MODE 1 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_I2S_PCM_MODE 枚举 +#define EXTERNAL_SND_OUT_I2S_ATTR_MCLK 6 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_I2S_MCLK_1536_FS 枚举 12.288M /16k = +#define EXTERNAL_SND_OUT_I2S_ATTR_MASTER 0 // 1:主设备,0:从设备 +#define EXTERNAL_SND_OUT_I2S_ATTR_SAMPLE_RISE_EDGE 1 // 参考 soc_uapi_audio.h 中 pcm_sample_rise_edge 成员 +#define EXTERNAL_SND_OUT_I2S_ATTR_BCLK 48 // 参考 soc_uapi_audio.h 中 UAPI_AUDIO_I2S_BCLK_48_DIV 枚举 12.288M / 256k = 48 + +// Sleep option +#define CONFIG_PM_TICKLESS_EN YES +#define CONFIG_PM_POWER_GATING_EN YES +#define CONFIG_PM_SLEEP_RECORD_EN YES +#define CONFIG_PM_VETO_TRACK_EN NO +#define CONFIG_PM_SLEEP_INT_EN NO + +// Double-click the key +#define CONFIG_SUPPORT_BUTTON_DOUBLE_CLICK YES + +// LCD VCI_EN +#define VCI_LCD_GPIO S_AGPIO_L24 +#define DISPLAY_TE_GPIO S_AGPIO_L22 +#define RESET_LCD_GPIO S_AGPIO_L27 + +// TP CONFIG +#define ZTW523_I2C_BUS I2C_BUS_1 +#define ZTW523_INT_GPIO S_AGPIO_R5 +#define ZTW523_RESET_GPIO S_AGPIO_R4 +#define TMA525B_I2C_BUS I2C_BUS_1 +#define TMA525B_INT_GPIO S_AGPIO_R5 +#define TMA525B_RESET_GPIO S_AGPIO_R4 + +#define FT6X46_I2C_BUS I2C_BUS_1 +#define FT6X46_INT_GPIO S_AGPIO_R5 +#define FT6X46_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 枚举 +#define SND_TRACK_MODE_LOCAL_CAT1 1 // 参考 soc_uapi_sound.h 中 UAPI_SND_TRACK_DOUBLE_MONO 枚举 +#define SND_TRACK_MODE_BT_CAT1 0 // 参考 soc_uapi_sound.h 中 UAPI_SND_TRACK_STEREO 枚举 +#define SND_TRACK_MODE_LOCAL_MUSIC 1 // 参考 soc_uapi_sound.h 中 UAPI_SND_TRACK_DOUBLE_MONO 枚举 + +// AEF +#if defined(MEMORY_MINI) +#define SND_PORT_AEF_TYPE 0x130 // 参考 soc_uapi_aef.h 中 UAPI_AEF_TYPE_SWS1 枚举 +#else +#define SND_PORT_AEF_TYPE 0x180 // 参考 soc_uapi_aef.h 中 UAPI_AEF_TYPE_SMARTPA 枚举 +#endif +#define SND_PORT_AEF_ENABLE true // true代表开启aef算法，false代表关闭aef算法 +/** + * @} + */ +#endif diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/chips/brandy/porting/uart/uart_porting.c b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/chips/brandy/porting/uart/uart_porting.c new file mode 100644 index 000000000..931a7406d --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/chips/brandy/porting/uart/uart_porting.c @@ -0,0 +1,509 @@ +/** + * Copyright (c) @CompanyNameMagicTag 2022-2022. All rights reserved. \n + * + * Description: Provides uart port template \n + * Author: @CompanyNameTag \n + * History: \n + * 2022-06-06， Create file. \n + */ +#include +#include "dma_porting.h" +#include "debug_print.h" +#include "hal_uart_v120.h" +#include "uart_porting.h" +#ifdef SUPPORT_HAL_PINCTRL +#include "pinctrl_porting.h" +#include "pinctrl.h" +#endif +#include "uart.h" +#include "oal_interface.h" +#include "platform_core.h" +#include "securec.h" +#include "soc_osal.h" +#ifdef SUPPORT_CLOCKS_CORE +#include "clocks_core_common.h" +#endif +#if defined(SUPPORT_TEST_COMMON) +#include "test_suite_uart.h" +#endif +#if defined(SUPPORT_AT_CMD) +#include "at_cmd_api.h" +#endif +#ifndef BUILD_APPLICATION_SSB +#include "log_uart.h" +#include "cmsis_os.h" +#endif +#if defined(SW_RTT_DEBUG) +#include "SEGGER_RTT.h" +#endif + +#ifdef BUILD_APPLICATION_SSB +#define UART_RX_BUFFER_SIZE 1 +#else +#define UART_RX_BUFFER_SIZE 56 +#endif + +#define AT_BLE_HEADER_LENGTH 49 +#define AT_CMD_BUFSIZE_MAX 256 +#define UARTILPR 0x20 +#define UARTIBRD 0x24 +#define UARTFBRD 0x28 +#define UARTLCRH 0x2c +#define UARTCR 0x30 +#define UARTIFLS 0x34 +#define UARTIMSC 0x38 +#define UARTDMACR 0x48 +#define UARTRESET (M_CTL_RB_BASE + 0x0168) +#define UARTBUS0 0x1 +#define UARTBUS1 0x0 + +/** + * CUSTOM_UART_RATE = 500000 可以看蓝牙日志 + * 2000000 可以加快下载文件速度 +*/ +#define CUSTOM_UART_RATE 2000000 +typedef struct { + pin_mode_t tx_pin_mode; + pin_mode_t rx_pin_mode; + pin_mode_t cts_pin_mode; + pin_mode_t rts_pin_mode; +} uart_pin_mode_t; + +typedef struct uart_config { + uart_pin_config_t pin; + uart_pin_mode_t pin_mode; + core_irq_t irq_num; + osal_irq_handler irq_func; + uart_rx_callback_t rx_callback; + uart_attr_t line_config; + uart_buffer_config_t buffer_config; +#ifndef BUILD_APPLICATION_SSB + osal_mutex uart_mutex; + bool support_mutex; +#endif +} uart_config_t; + +const uintptr_t g_uart_base_addrs[UART_BUS_MAX_NUM] = { + (uintptr_t)UART0_BASE, + (uintptr_t)UART1_BASE, +}; + +uintptr_t uart_porting_base_addr_get(uart_bus_t bus) +{ + return g_uart_base_addrs[bus]; +} + +static bool g_sw_debug_uart_enabled = false; +uint8_t g_uart0_rx_buffer[UART_RX_BUFFER_SIZE]; +uint8_t g_uart1_rx_buffer[UART_RX_BUFFER_SIZE]; +#if defined(SUPPORT_AT_CMD) +static void at_cmd_uart_rx_callback(const void *buf, uint16_t buf_len, bool remaining); +#endif + +void log_factory_at_callback(const void *buffer, uint16_t length, bool remaining); + +static uart_config_t g_uart_config[UART_BUS_MAX_NUMBER] = { +#ifdef BUILD_APPLICATION_SSB + /* UART_BUS_0 for debug print */ + { + { + .tx_pin = S_MGPIO19, + .rx_pin = S_MGPIO20, + .cts_pin = PIN_NONE, + .rts_pin = PIN_NONE + }, + { + .tx_pin_mode = (pin_mode_t)HAL_PIO_FUNC_UART1, + .rx_pin_mode = (pin_mode_t)HAL_PIO_FUNC_UART1, + .cts_pin_mode = (pin_mode_t)HAL_PIO_FUNC_MAX, + .rts_pin_mode = (pin_mode_t)HAL_PIO_FUNC_MAX + }, + UART_0_IRQN, + (osal_irq_handler)irq_uart0_handler, + NULL, + { + .baud_rate = 115200, + .data_bits = UART_DATA_BIT_8, + .parity = UART_PARITY_NONE, + .stop_bits = UART_STOP_BIT_1, + }, + { + .rx_buffer_size = UART_RX_BUFFER_SIZE, + .rx_buffer = g_uart0_rx_buffer, + } + }, + /* UART_BUS_1 for codeloader */ + { + { + .tx_pin = S_MGPIO33, + .rx_pin = S_MGPIO34, + .cts_pin = PIN_NONE, + .rts_pin = PIN_NONE + }, + { + .tx_pin_mode = (pin_mode_t)HAL_PIO_FUNC_UART_HS_UART, + .rx_pin_mode = (pin_mode_t)HAL_PIO_FUNC_UART_HS_UART, + .cts_pin_mode = (pin_mode_t)HAL_PIO_FUNC_MAX, + .rts_pin_mode = (pin_mode_t)HAL_PIO_FUNC_MAX, + }, + UART_1_IRQN, + (osal_irq_handler)irq_uart1_handler, + NULL, + { + .baud_rate = 115200, + .data_bits = UART_DATA_BIT_8, + .parity = UART_PARITY_NONE, + .stop_bits = UART_STOP_BIT_1, + }, + { + .rx_buffer_size = UART_RX_BUFFER_SIZE, + .rx_buffer = g_uart1_rx_buffer, + } + } +#else + /** UART_BUS_0, which is used to at cmd and debug print in wstp version, + * and which is used to testustie and debug print in testsuite version + */ + { + { + .tx_pin = S_MGPIO19, + .rx_pin = S_MGPIO20, + .cts_pin = PIN_NONE, + .rts_pin = PIN_NONE + }, + { + .tx_pin_mode = (pin_mode_t)HAL_PIO_FUNC_UART1, + .rx_pin_mode = (pin_mode_t)HAL_PIO_FUNC_UART1, + .cts_pin_mode = (pin_mode_t)HAL_PIO_FUNC_MAX, + .rts_pin_mode = (pin_mode_t)HAL_PIO_FUNC_MAX + }, + UART_0_IRQN, + (osal_irq_handler)irq_uart0_handler, +#if defined(SUPPORT_TEST_COMMON) + test_suite_uart_rx_callback, +#elif defined(SUPPORT_AT_CMD) + at_cmd_uart_rx_callback, +#else + NULL, +#endif + { + .baud_rate = 115200, + .data_bits = UART_DATA_BIT_8, + .parity = UART_PARITY_NONE, + .stop_bits = UART_STOP_BIT_1, + }, + { + .rx_buffer_size = UART_RX_BUFFER_SIZE, + .rx_buffer = g_uart0_rx_buffer, + }, + NULL, +#if defined(SUPPORT_TEST_COMMON) + false, +#else + true, +#endif + }, + /* UART_BUS_1 is used to hso uart */ + { + { + .tx_pin = S_MGPIO33, + .rx_pin = S_MGPIO34, + .cts_pin = PIN_NONE, + .rts_pin = PIN_NONE + }, + { + .tx_pin_mode = (pin_mode_t)HAL_PIO_FUNC_UART_HS_UART, + .rx_pin_mode = (pin_mode_t)HAL_PIO_FUNC_UART_HS_UART, + .cts_pin_mode = (pin_mode_t)HAL_PIO_FUNC_MAX, + .rts_pin_mode = (pin_mode_t)HAL_PIO_FUNC_MAX + }, + UART_1_IRQN, + (osal_irq_handler)irq_uart1_handler, +#ifndef FT_SINGLE_UART +#if SYS_DEBUG_MODE_ENABLE == YES + log_uart_rx_callback, +#else + NULL, +#endif +#else + log_factory_at_callback, +#endif + { + .baud_rate = CUSTOM_UART_RATE, + .data_bits = UART_DATA_BIT_8, + .parity = UART_PARITY_NONE, + .stop_bits = UART_STOP_BIT_1, + }, + { + .rx_buffer_size = UART_RX_BUFFER_SIZE, + .rx_buffer = g_uart1_rx_buffer, + }, + NULL, + false + } +#endif +}; +static uart_recovery_regs_t g_uart_recovery_reg[UART_BUS_MAX_NUMBER] = { 0 }; + +#ifdef FT_SINGLE_UART +void log_factory_at_callback(const void *buffer, uint16_t length, bool remaining) +{ +#if SYS_DEBUG_MODE_ENABLE == YES + log_uart_rx_callback(buffer, length, remaining); +#endif + if (zdiag_is_enable() == false) { +#ifdef SUPPORT_AT_CMD + at_cmd_msg_receive_handler((uint8_t *)buffer, length); +#endif + hal_uart_clear_pending(UART_BUS_1); + } +} +#endif + +void uart_port_register_hal_funcs(uart_bus_t bus) +{ + hal_uart_register_funcs(bus, hal_uart_v120_funcs_get()); +} + +void uart_port_unregister_hal_funcs(uart_bus_t bus) +{ + hal_uart_unregister_funcs(bus); +} + +uint32_t uart_port_get_clock_value(uart_bus_t bus) +{ + return uart_get_clock_value(bus); +} + +void uart_port_config_pinmux(uart_bus_t bus) +{ + UNUSED(bus); + uapi_pin_set_mode(g_uart_config[UART_BUS_1].pin.tx_pin, g_uart_config[UART_BUS_1].pin_mode.tx_pin_mode); + uapi_pin_set_mode(g_uart_config[UART_BUS_1].pin.rx_pin, g_uart_config[UART_BUS_1].pin_mode.rx_pin_mode); + uapi_pin_set_mode(g_uart_config[UART_BUS_0].pin.tx_pin, g_uart_config[UART_BUS_0].pin_mode.tx_pin_mode); + uapi_pin_set_mode(g_uart_config[UART_BUS_0].pin.rx_pin, g_uart_config[UART_BUS_0].pin_mode.rx_pin_mode); +} + +void uart_port_register_irq(uart_bus_t bus) +{ + osal_irq_request(g_uart_config[bus].irq_num, g_uart_config[bus].irq_func, NULL, NULL, NULL); + osal_irq_set_priority(g_uart_config[bus].irq_num, irq_prio(g_uart_config[bus].irq_num)); + osal_irq_enable(g_uart_config[bus].irq_num); +} + +void uart_port_unregister_irq(uart_bus_t bus) +{ + osal_irq_disable(g_uart_config[bus].irq_num); +} + +void irq_uart0_handler(void) +{ + hal_uart_irq_handler(UART_BUS_0); +} + +void irq_uart1_handler(void) +{ + hal_uart_irq_handler(UART_BUS_1); +} + +#ifdef SUPPORT_AT_CMD +static void at_cmd_uart_rx_callback(const void *buf, uint16_t buf_len, bool remaining) +{ + unused(remaining); + #ifndef FT_SINGLE_UART + at_cmd_msg_receive_handler((uint8_t *)buf, buf_len); + #endif + hal_uart_clear_pending(SW_DEBUG_UART_BUS); +} +#endif + +void uart_config_init(void) +{ + for (uint8_t i = 0; i < UART_BUS_MAX_NUM; i++) { + if ((g_uart_config[i].pin.tx_pin != PIN_NONE) || (g_uart_config[i].pin.rx_pin != PIN_NONE)) { + uapi_uart_init(i, &(g_uart_config[i].pin), &(g_uart_config[i].line_config), NULL, + &(g_uart_config[i].buffer_config)); + } + if (g_uart_config[i].rx_callback != NULL) { + uapi_uart_register_rx_callback(i, UART_RX_CONDITION_FULL_OR_SUFFICIENT_DATA_OR_IDLE, + (uint32_t)(g_uart_config[i].buffer_config.rx_buffer_size), + g_uart_config[i].rx_callback); + } + +#ifndef BUILD_APPLICATION_SSB + if (g_uart_config[i].support_mutex == true) { + osal_mutex_init(&(g_uart_config[i].uart_mutex)); + } +#endif + } +} + +#if (defined SW_UART_DEBUG)||(defined FT_SINGLE_UART) +void sw_debug_uart_deinit(void) +{ + uapi_uart_deinit(SW_DEBUG_UART_BUS); +} + +void sw_debug_uart_init(uint32_t baud_rate) +{ + g_uart_config[SW_DEBUG_UART_BUS].line_config.baud_rate = baud_rate; + uapi_uart_init(SW_DEBUG_UART_BUS, &(g_uart_config[SW_DEBUG_UART_BUS].pin), + &(g_uart_config[SW_DEBUG_UART_BUS].line_config), NULL, + &(g_uart_config[SW_DEBUG_UART_BUS].buffer_config)); +} + +void sw_debug_uart_reset_baund(void) +{ + while (uapi_uart_has_pending_transmissions(SW_DEBUG_UART_BUS)) { } + uapi_uart_set_attr(SW_DEBUG_UART_BUS, &g_uart_config[SW_DEBUG_UART_BUS].line_config); +} +#endif + +void print_str(const char *str, ...) +{ + static uint8_t s[1024]; // 1024 means string max length. + va_list args; + int32_t str_len; + + if ((str == NULL) || (strlen(str) == 0)) { + return; + } + + va_start(args, str); + str_len = vsprintf_s((char *)s, sizeof(s), str, args); + va_end(args); + + if (str_len < 0) { + return; + } +#if defined(SW_RTT_DEBUG) + SEGGER_RTT_Write(0, (const char *)s, str_len); +#elif defined(SW_UART_DEBUG) + if (hal_uart_get_funcs(SW_DEBUG_UART_BUS) == NULL) { + return; + } + uapi_uart_write(SW_DEBUG_UART_BUS, (const void *)s, (uint32_t)str_len, 0); +#else +#endif +} + +void hal_uart_clear_pending(uart_bus_t uart) +{ + switch (uart) { + case UART_BUS_0: + int_clear_pending_irq(UART_0_IRQN); + break; + case UART_BUS_1: + int_clear_pending_irq(UART_1_IRQN); + break; + default: + break; + } +} + +#if defined(CONFIG_UART_SUPPORT_DMA) +uint8_t uart_port_get_dma_trans_dest_handshaking(uart_bus_t bus) +{ + switch (bus) { + case UART_BUS_0: + return (uint8_t)HAL_DMA_HANDSHAKING_UART_L_TX; + case UART_BUS_1: + return (uint8_t)HAL_DMA_HANDSHAKING_UART_H0_TX; + default: + return (uint8_t)HAL_DMA_HANDSHAKING_MAX_NUM; + } +} + +uint8_t uart_port_get_dma_trans_src_handshaking(uart_bus_t bus) +{ + switch (bus) { + case UART_BUS_0: + return (uint8_t)HAL_DMA_HANDSHAKING_UART_L_RX; + case UART_BUS_1: + return (uint8_t)HAL_DMA_HANDSHAKING_UART_H0_RX; + default: + return (uint8_t)HAL_DMA_HANDSHAKING_MAX_NUM; + } +} +#endif /* CONFIG_UART_SUPPORT_DMA */ + +uint32_t uart_porting_lock(uart_bus_t bus) +{ +#ifndef BUILD_APPLICATION_SSB + if ((g_uart_config[bus].support_mutex == true) && (osKernelGetState() == osKernelRunning) && + (osal_in_interrupt() == 0)) { + return (uint32_t)osal_mutex_lock_timeout(&(g_uart_config[bus].uart_mutex), OSAL_MUTEX_WAIT_FOREVER); + } +#else + UNUSED(bus); +#endif + return ERRCODE_SUCC; +} + +void uart_porting_unlock(uart_bus_t bus, uint32_t irq_sts) +{ +#ifndef BUILD_APPLICATION_SSB + unused(irq_sts); + if ((g_uart_config[bus].support_mutex == true) && (osKernelGetState() == osKernelRunning) && + (osal_in_interrupt() == 0)) { + osal_mutex_unlock(&(g_uart_config[bus].uart_mutex)); + } +#else + UNUSED(bus); + UNUSED(irq_sts); +#endif +} + +void uart_save_reg(uart_bus_t bus) +{ + uint32_t base = uart_porting_base_addr_get(bus); + g_uart_recovery_reg[bus].uartilpr = readw(base + UARTILPR); + g_uart_recovery_reg[bus].uartibrd = readw(base + UARTIBRD); + g_uart_recovery_reg[bus].uartfbrd = readw(base + UARTFBRD); + g_uart_recovery_reg[bus].uartlcr_h = readw(base + UARTLCRH); + g_uart_recovery_reg[bus].uartcr = readw(base + UARTCR); + g_uart_recovery_reg[bus].uartifls = readw(base + UARTIFLS); + g_uart_recovery_reg[bus].uartimsc = readw(base + UARTIMSC); + g_uart_recovery_reg[bus].uartdmacr = readw(base + UARTDMACR); +} + +void uart_recovery_reg(uart_bus_t bus) +{ + uint16_t uart_bit = UARTBUS0; + if (bus == UART_BUS_0) { + uart_bit = UARTBUS0; + } else if (bus == UART_BUS_1) { + uart_bit = UARTBUS1; + } + reg16_clrbit(UARTRESET, uart_bit); + reg16_setbit(UARTRESET, uart_bit); + uint32_t base = uart_porting_base_addr_get(bus); + writew(base + UARTILPR, g_uart_recovery_reg[bus].uartilpr); + writew(base + UARTIBRD, g_uart_recovery_reg[bus].uartibrd); + writew(base + UARTFBRD, g_uart_recovery_reg[bus].uartfbrd); + writew(base + UARTLCRH, g_uart_recovery_reg[bus].uartlcr_h); + writew(base + UARTCR, g_uart_recovery_reg[bus].uartcr); + writew(base + UARTIFLS, g_uart_recovery_reg[bus].uartifls); + writew(base + UARTIMSC, g_uart_recovery_reg[bus].uartimsc); + writew(base + UARTDMACR, g_uart_recovery_reg[bus].uartdmacr); +} + +void uart_h0_suspend(void) +{ + uart_save_reg(UART_BUS_0); +} + +void uart_h0_resume(void) +{ + uart_recovery_reg(UART_BUS_0); +} + +void uart_h1_suspend(void) +{ + uart_save_reg(UART_BUS_1); +} + +void uart_h1_resume(void) +{ + uart_recovery_reg(UART_BUS_1); +} \ No newline at end of file diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/lcd/lcd_config.c b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/lcd/lcd_config.c new file mode 100644 index 000000000..2b0b2b38a --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/lcd/lcd_config.c @@ -0,0 +1,429 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2022-2022. All rights reserved. + * Description: Lcd driver configuration. + * Author: @CompanyNameTag + * Create: 2022-03-05 + */ + +#include +#include "common_def.h" +#include "lcd_config.h" + +#define LCD_EDO_466X466_SCREEN_ID 0x1133 +#define LCD_EDO_454X454_SCREEN_ID 0xf00 +#define LCD_BOE_454X454_SCREEN_ID 0x500 +#define LCD_SH_240X296_SCREEN_ID 0x101 +#define LCD_BOE_194X368_SCREEN_ID 0x4a00 + +const combo_dev_cfg_t g_panel_466x466_60_config = { + .devno = 0, + .lane_id = {0, -1}, + .out_mode = OUT_MODE_DSI_CMD, + .out_format = OUT_FORMAT_RGB_24BIT, + .sync_info = { + .hsa_pixels = 10, // hsa 10 pixels + .hbp_pixels = 10, // hbp 10 pixels + .hact_pixels = 466, // hact 466 pixels + .hfp_pixels = 10, // hfp 10 pixels + .vsa_lines = 4, // vsa 4 lines + .vbp_lines = 12, // vbp 12 lines + .vact_lines = 466, // vact 466 lines + .vfp_lines = 10, // vfp 10 lines + }, + .phy_data_rate = 480, // 480Mbps + .pixel_clk = 20000, // 20000KHz +}; +const combo_dev_cfg_t g_panel_454x454_60_config = { + .devno = 0, + .lane_id = {0, -1}, + .out_mode = OUT_MODE_DSI_CMD, + .out_format = OUT_FORMAT_RGB_24BIT, + .sync_info = { + .hsa_pixels = 10, // hsa 10 pixels + .hbp_pixels = 10, // hbp 10 pixels + .hact_pixels = 454, // hact 454 pixels + .hfp_pixels = 10, // hfp 10 pixels + .vsa_lines = 4, // vsa 4 lines + .vbp_lines = 12, // vbp 12 lines + .vact_lines = 454, // vact 454 lines + .vfp_lines = 10, // vfp 10 lines + }, + .phy_data_rate = 480, // 480Mbps + .pixel_clk = 20000, // 20000KHz +}; + +const combo_dev_cfg_t g_panel_240x296_60_config = { + .devno = 0, + .lane_id = {0, -1}, + .out_mode = OUT_MODE_DSI_CMD, + .out_format = OUT_FORMAT_RGB_24BIT, + .sync_info = { + .hsa_pixels = 4, // hsa 14 pixels hpw + .hbp_pixels = 11, // hbp 11 pixels HBP + .hact_pixels = 368, // hact 240 pixels HPX + .hfp_pixels = 14, // hfp 14 pixels hfp + .vsa_lines = 2, // vsa 2 lines vpw + .vbp_lines = 6, // vbp 6 lines vbp + .vact_lines = 448, // vact 296 lines vpx + .vfp_lines = 8, // vfp 8 lines vfp + }, + .phy_data_rate = 480, // 480Mbps + .pixel_clk = 20000, // 20000KHz +}; + +const combo_dev_cfg_t g_panel_194x368_qspi_config = { + .out_format = OUT_FORMAT_RGB_24BIT, + .sync_info = { + .hact_pixels = 194, // hact 368 pixels + .vact_lines = 368, // vact 368 lines + }, +}; + +/* display off sequence for common lcd */ +const lcd_cmd_sequ g_common_cmd_display_off[] = { + {1, 2, {0xfe, 0x00}, 0}, /* select default cmd page */ + {1, 1, {0x28}, 0}, /* display off */ + {1, 1, {0x10}, 120}, /* sleep in */ +}; + +/* display off sequence for common lcd */ +const lcd_cmd_sequ g_common_466x466_cmd_display_off[] = { + {1, 2, {0xfe, 0x00}, 0}, /* select default cmd page */ + {1, 1, {0x28}, 0}, /* display off */ + {1, 1, {0x10}, 120}, /* sleep in */ + {1, 2, {0x4f, 0x01}, 0}, /* ½ødeepstandby ״̬ */ +}; + +/* sleep in sequence for common lcd */ +const lcd_cmd_sequ g_common_cmd_sleep_in[] = { + {1, 2, {0xfe, 0x00}, 0}, /* select default cmd page */ + {1, 1, {0x28}, 0}, /* display off */ + {1, 1, {0x10}, 120}, /* sleep in */ +}; + +/* sleep in sequence for common lcd */ +const lcd_cmd_sequ g_common_cmd_sleep_out[] = { + {1, 2, {0xfe, 0x00}, 0}, /* select default cmd page */ + {1, 1, {0x11}, 120}, /* sleep out */ + {1, 1, {0x29}, 0}, /* display on */ +}; + +/* idle in sequence for EDO and BOE 454*454 lcd */ +lcd_cmd_sequ g_common_cmd_idle_in[] = { + {1, 2, {0xfe, 0x00}, 0}, + {1, 1, {0x39}, 0}, +}; + +/* idle out sequence for EDO and BOE 454*454 lcd */ +const lcd_cmd_sequ g_common_cmd_idle_out[] = { + {1, 2, {0xfe, 0x00}, 0}, + {1, 1, {0x38}, 0}, +}; + +/* te on sequence for EDO and BOE 454*454 lcd */ +const lcd_cmd_sequ g_common_cmd_te_on[] = { + {1, 2, {0xfe, 0x00}, 0}, + {1, 1, {0x35}, 0}, +}; + +/* te off sequence for EDO and BOE 454*454 lcd */ +const lcd_cmd_sequ g_common_cmd_te_off[] = { + {1, 2, {0xfe, 0x00}, 0}, + {1, 1, {0x34}, 0}, +}; + +/* set brightness sequence for EDO and BOE 454*454 lcd */ +lcd_cmd_sequ g_common_cmd_brightness[] = { + {1, 2, {0xfe, 0x00}, 0}, + {1, 2, {0x51, 0xff}, 0}, +}; +const lcd_cmd_sequ g_edo_466x466_screen_init_on[] = { + {1, 2, {0xfe, 0x00}, 0}, + {1, 2, {0x3a, 0x77}, 0}, + {1, 2, {0x35, 0x00}, 0}, + {1, 2, {0x53, 0x20}, 0}, + // {1, 2, {0x51, 0xff}, 0}, + {1, 2, {0x63, 0xff}, 0}, + {1, 5, {0x2A, 0x00, 0x06, 0x01, 0xd7}, 0}, + {1, 5, {0x2B, 0x00, 0x00, 0x01, 0xd1}, 0}, + {1, 3, {0x44, 0x01, 0xc5}, 0}, + {1, 1, {0x11}, 120}, + {1, 1, {0x29}, 0}, +}; + + +/* init sequence for EDO 454*454 lcd */ +const lcd_cmd_sequ g_edo_454x454_screen_init_on[] = { + {1, 2, {0xfe, 0x01}, 0}, + {1, 2, {0x30, 0x43}, 0}, /* set LCD frequency to 15HZ */ + {1, 2, {0xfe, 0x00}, 0}, + {1, 2, {0x3a, 0x77}, 0}, + {1, 2, {0x53, 0x20}, 0}, + {1, 2, {0x51, 0xff}, 0}, + {0, 5, {0x2a, 0x00, 0x0e, 0x01, 0xd3}, 0}, + {0, 5, {0x2b, 0x00, 0x00, 0x01, 0xc5}, 0}, + {1, 3, {0x44, 0x01, 0xc5}, 0}, + {1, 2, {0x35, 0x00}, 0}, + {1, 1, {0x11}, 120}, + {1, 1, {0x29}, 0}, +}; + +/* init sequence for BOE 454*454 lcd */ +const lcd_cmd_sequ g_boe_454x454_screen_init_on[] = { + {1, 2, {0xfe, 0x0d}, 0}, + {1, 2, {0x01, 0x00}, 0}, + {1, 2, {0x03, 0x00}, 0}, + {1, 2, {0x1b, 0x00}, 0}, + {1, 2, {0x1d, 0x00}, 0}, + {1, 2, {0x37, 0x00}, 0}, + {1, 2, {0x39, 0x00}, 0}, + {1, 2, {0x52, 0x58}, 0}, + {1, 2, {0x53, 0x00}, 0}, + + {1, 2, {0xfe, 0x01}, 0}, + {1, 2, {0x72, 0x05}, 0}, + {1, 2, {0x73, 0x16}, 0}, + {1, 2, {0x74, 0x0c}, 0}, + + {1, 2, {0xfe, 0x01}, 0}, + {1, 2, {0x18, 0x55}, 0}, + {1, 2, {0xc5, 0x10}, 0}, + {1, 2, {0x72, 0x0e}, 0}, + {1, 2, {0x73, 0x1c}, 0}, + + {1, 2, {0xfe, 0x07}, 0}, + {1, 2, {0x15, 0x04}, 0}, + {1, 2, {0xfe, 0x01}, 0}, + {1, 2, {0x0a, 0xf8}, 0}, + + {1, 2, {0xfe, 0x00}, 0}, + {1, 2, {0x51, 0xff}, 0}, + {1, 2, {0x35, 0x00}, 0}, + {0, 5, {0x2a, 0x00, 0x0c, 0x01, 0xd1}, 0}, + {0, 5, {0x2b, 0x00, 0x00, 0x01, 0xc5}, 0}, + {1, 2, {0x53, 0x20}, 0}, + {1, 1, {0x11}, 120}, + {1, 1, {0x29}, 0}, +}; + +const lcd_cmd_sequ g_sh_240x296_screen_init_on[] = { + {1, 1, {0x11}, 5}, + {1, 5, {0x2a, 0x00, 0x00, 0x01, 0x6f}, 1}, + {1, 5, {0x2b, 0x00, 0x00, 0x01, 0xbf}, 1}, + {1, 3, {0x44, 0x01, 0xbf}, 1}, + {1, 2, {0x35, 0x00}, 1}, + {1, 2, {0x3a, 0x77}, 1}, + {1, 2, {0x53, 0x20}, 80}, + {1, 1, {0x29}, 0}, +}; + +const lcd_cmd_sequ g_boe_194x368_screen_init_on[] = { + {0, 2, {0xfe, 0x00}, 0}, + {0, 3, {0x44, 0x00, 0xB7}, 0}, + {0, 2, {0x3a, 0x77}, 0}, + {0, 2, {0x51, 0x80}, 0}, + {0, 2, {0x35, 0x0}, 0}, + {0, 5, {0x2a, 0x00, 0x00, 0x00, 0xc1}, 0}, + {0, 1, {0x11}, 120}, + {0, 1, {0x29}, 100}, + {0, 1, {0x39}, 0}, +}; + +const lcd_cmds_sequ g_display_off_cmds = { + .cmd = g_common_cmd_display_off, + .cmd_cnt = array_size(g_common_cmd_display_off), +}; + +const lcd_cmds_sequ g_466x466_display_off_cmds = { + .cmd = g_common_466x466_cmd_display_off, + .cmd_cnt = array_size(g_common_466x466_cmd_display_off), +}; + +const lcd_cmds_sequ g_idle_in_cmds = { + .cmd = g_common_cmd_idle_in, + .cmd_cnt = array_size(g_common_cmd_idle_in), +}; + +const lcd_cmds_sequ g_idle_out_cmds = { + .cmd = g_common_cmd_idle_out, + .cmd_cnt = array_size(g_common_cmd_idle_out), +}; + +const lcd_cmds_sequ g_te_on_cmds = { + .cmd = g_common_cmd_te_on, + .cmd_cnt = array_size(g_common_cmd_te_on), +}; + +const lcd_cmds_sequ g_te_off_cmds = { + .cmd = g_common_cmd_te_off, + .cmd_cnt = array_size(g_common_cmd_te_off), +}; + +const lcd_cmds_sequ g_brightness_cmds = { + .cmd = g_common_cmd_brightness, + .cmd_cnt = array_size(g_common_cmd_brightness), +}; + +const lcd_cmds_sequ g_edo_466x466_screen_init_on_cmds = { + .cmd = g_edo_466x466_screen_init_on, + .cmd_cnt = array_size(g_edo_466x466_screen_init_on), +}; + +const lcd_cmds_sequ g_edo_454x454_screen_init_on_cmds = { + .cmd = g_edo_454x454_screen_init_on, + .cmd_cnt = array_size(g_edo_454x454_screen_init_on), +}; + +const lcd_cmds_sequ g_boe_454x454_screen_init_on_cmds = { + .cmd = g_boe_454x454_screen_init_on, + .cmd_cnt = array_size(g_boe_454x454_screen_init_on), +}; + +const lcd_cmds_sequ g_sh_240x296_screen_init_on_cmds = { + .cmd = g_sh_240x296_screen_init_on, + .cmd_cnt = array_size(g_sh_240x296_screen_init_on), +}; + +const lcd_cmds_sequ g_boe_194x368_screen_init_on_cmds = { + .cmd = g_boe_194x368_screen_init_on, + .cmd_cnt = array_size(g_boe_194x368_screen_init_on), +}; + +const lcd_cmds_sequ g_sleep_in_cmds = { + .cmd = g_common_cmd_sleep_in, + .cmd_cnt = array_size(g_common_cmd_sleep_in), +}; + +const lcd_cmds_sequ g_sleep_out_cmds = { + .cmd = g_common_cmd_sleep_out, + .cmd_cnt = array_size(g_common_cmd_sleep_out), +}; + +const lcd_drv_cfg g_lcd_driver_ops[] = { + { + .bus_type = BUS_DISPLAY_MIPI, + .bus_cfg = &g_panel_466x466_60_config, + .x_start = 0x6, + .y_start = 0, + .fps = 60, + .lcd_id = LCD_EDO_466X466_SCREEN_ID, + .display_on_cmds = &g_edo_466x466_screen_init_on_cmds, + .display_off_cmds = &g_466x466_display_off_cmds, + .enter_idle_cmds = &g_idle_in_cmds, + .exit_idle_cmds = &g_idle_out_cmds, + .te_on_cmds = &g_te_on_cmds, + .te_off_cmds = &g_te_off_cmds, + .set_brightnes_cmds = &g_brightness_cmds, + .sleep_in_cmds = &g_sleep_in_cmds, + .sleep_out_cmds = &g_sleep_out_cmds, + .lcd_id_info.reg_addr = 0x04, + .lcd_id_info.read_len = 3, + }, + { + .bus_type = BUS_DISPLAY_MIPI, + .bus_cfg = &g_panel_454x454_60_config, + .x_start = 0xe, + .y_start = 0, + .fps = 60, + .lcd_id = LCD_EDO_454X454_SCREEN_ID, + .display_on_cmds = &g_edo_454x454_screen_init_on_cmds, + .display_off_cmds = &g_display_off_cmds, + .enter_idle_cmds = &g_idle_in_cmds, + .exit_idle_cmds = &g_idle_out_cmds, + .te_on_cmds = &g_te_on_cmds, + .te_off_cmds = &g_te_off_cmds, + .set_brightnes_cmds = &g_brightness_cmds, + .sleep_in_cmds = &g_sleep_in_cmds, + .sleep_out_cmds = &g_sleep_out_cmds, + .lcd_id_info.reg_addr = 0x04, + .lcd_id_info.read_len = 3, + }, + { + .bus_type = BUS_DISPLAY_MIPI, + .bus_cfg = &g_panel_454x454_60_config, + .x_start = 0xc, + .y_start = 0, + .fps = 60, + .lcd_id = LCD_BOE_454X454_SCREEN_ID, + .display_on_cmds = &g_boe_454x454_screen_init_on_cmds, + .display_off_cmds = &g_display_off_cmds, + .enter_idle_cmds = &g_idle_in_cmds, + .exit_idle_cmds = &g_idle_out_cmds, + .te_on_cmds = &g_te_on_cmds, + .te_off_cmds = &g_te_off_cmds, + .set_brightnes_cmds = &g_brightness_cmds, + .sleep_in_cmds = &g_sleep_in_cmds, + .sleep_out_cmds = &g_sleep_out_cmds, + .lcd_id_info.reg_addr = 0x04, + .lcd_id_info.read_len = 3, + }, + { + .bus_type = BUS_DISPLAY_MIPI, + .bus_cfg = &g_panel_240x296_60_config, + .x_start = 0, + .y_start = 0, + .fps = 60, + .lcd_id = LCD_SH_240X296_SCREEN_ID, + .display_on_cmds = &g_sh_240x296_screen_init_on_cmds, + .display_off_cmds = &g_display_off_cmds, + .enter_idle_cmds = &g_idle_in_cmds, + .exit_idle_cmds = &g_idle_out_cmds, + .te_on_cmds = &g_te_on_cmds, + .te_off_cmds = &g_te_off_cmds, + .set_brightnes_cmds = &g_brightness_cmds, + .sleep_in_cmds = &g_sleep_in_cmds, + .sleep_out_cmds = &g_sleep_out_cmds, + .lcd_id_info.reg_addr = 0xda, + .lcd_id_info.read_len = 3, + }, + { + .bus_type = BUS_DISPLAY_QSPI, + .bus_cfg = &g_panel_194x368_qspi_config, + .x_start = 0, + .y_start = 0, + .fps = 60, + .lcd_id = LCD_BOE_194X368_SCREEN_ID, + .display_on_cmds = &g_boe_194x368_screen_init_on_cmds, + .display_off_cmds = &g_display_off_cmds, + .enter_idle_cmds = &g_idle_in_cmds, + .exit_idle_cmds = &g_idle_out_cmds, + .te_on_cmds = &g_te_on_cmds, + .te_off_cmds = &g_te_off_cmds, + .set_brightnes_cmds = &g_brightness_cmds, + .sleep_in_cmds = &g_sleep_in_cmds, + .sleep_out_cmds = &g_sleep_out_cmds, + .lcd_id_info.reg_addr = 0x04, + .lcd_id_info.read_len = 3, + } +}; + +lcd_drv_cfg *lcd_get_driver_ops(void) +{ + return g_lcd_driver_ops; +} + +uint32_t lcd_get_ops_num(void) +{ + return array_size(g_lcd_driver_ops); +} + +combo_dev_cfg_t *lcd_get_bus_escape_config(void) +{ + return g_lcd_driver_ops[0].bus_cfg; +} + +lcd_drv_cfg *lcd_get_driver_config(uint32_t id) +{ + uint32_t i; + if (id == 0) { + return NULL; + } + + for (i = 0; i < array_size(g_lcd_driver_ops); i++) { + if (g_lcd_driver_ops[i].lcd_id == id) { + return &(g_lcd_driver_ops[i]); + } + } + + return NULL; +} diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/lcd/lcd_private.c b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/lcd/lcd_private.c new file mode 100644 index 000000000..e34f881d8 --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/lcd/lcd_private.c @@ -0,0 +1,69 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2022-2022. All rights reserved. + * Description: Lcd private interface. + * Author: @CompanyNameTag + * Create: 2022-03-05 + */ + +#include "lcd_private.h" +#include "tcxo.h" +#include "chip_io.h" +#include "platform_core.h" +#include "gpio.h" +#include "pinctrl_porting.h" +#include "product.h" +#include "pinctrl.h" +static void lcd_drv_power_on(void) +{ +#ifndef QSPI_DISPLAY + uapi_gpio_set_dir(VCI_LCD_GPIO, GPIO_DIRECTION_OUTPUT); + uapi_gpio_set_val(VCI_LCD_GPIO, GPIO_LEVEL_HIGH); +#endif + uapi_gpio_set_dir(RESET_LCD_GPIO, GPIO_DIRECTION_OUTPUT); + + uapi_gpio_set_val(RESET_LCD_GPIO, GPIO_LEVEL_LOW); + uapi_tcxo_delay_ms(10); /* delay 10 ms */ + + uapi_gpio_set_val(RESET_LCD_GPIO, GPIO_LEVEL_HIGH); + uapi_tcxo_delay_ms(10); /* delay 10 ms */ +} +#define USE_OUTPUT_CTL 1 +static void lcd_drv_power_off(void) +{ +#if USE_OUTPUT_CTL + //uapi_gpio_set_dir(RESET_LCD_GPIO, GPIO_DIRECTION_OUTPUT); + //uapi_gpio_set_val(RESET_LCD_GPIO, GPIO_LEVEL_LOW); + #ifndef QSPI_DISPLAY + uapi_gpio_set_dir(VCI_LCD_GPIO, GPIO_DIRECTION_OUTPUT); + uapi_gpio_set_val(VCI_LCD_GPIO, GPIO_LEVEL_LOW); + #endif + uapi_tcxo_delay_ms(10); /* delay 10 ms */ + int resetvalue = uapi_gpio_get_output_val(RESET_LCD_GPIO); + int lcd_envalue = uapi_gpio_get_output_val(VCI_LCD_GPIO); + printf("Output RESET_LCD_GPIO %d , VCI_LCD_GPIO %d\r\n",resetvalue,lcd_envalue); +#else + uapi_gpio_set_val(RESET_LCD_GPIO, GPIO_LEVEL_LOW); + uapi_gpio_set_dir(RESET_LCD_GPIO, GPIO_DIRECTION_INPUT); //¨¦¨¨??3¨¦Input¡ê?¨º??a¨¢??a????¦Ì? ¡ê?¡ê? + uapi_pin_set_pull(RESET_LCD_GPIO, PIN_PULL_DOWN); + #ifndef QSPI_DISPLAY + uapi_gpio_set_val(VCI_LCD_GPIO, GPIO_LEVEL_LOW); + uapi_gpio_set_dir(VCI_LCD_GPIO, GPIO_DIRECTION_INPUT); + uapi_pin_set_pull(VCI_LCD_GPIO, PIN_PULL_DOWN); + #endif + uapi_tcxo_delay_ms(10); /* delay 10 ms */ + int resetvalue = uapi_gpio_get_val(RESET_LCD_GPIO); + int lcd_envalue = uapi_gpio_get_val(VCI_LCD_GPIO); + printf("Input RESET_LCD_GPIO %d , VCI_LCD_GPIO %d\r\n",resetvalue,lcd_envalue); +#endif + +} + +static lcd_drv_private g_lcd_private_api = { + .power_on = lcd_drv_power_on, + .power_off = lcd_drv_power_off, +}; + +lcd_drv_private *lcd_drv_get_private_api(void) +{ + return &g_lcd_private_api; +} diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/lcd/soc_lcd_api.c b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/lcd/soc_lcd_api.c new file mode 100644 index 000000000..56f8542af --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/lcd/soc_lcd_api.c @@ -0,0 +1,767 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2022-2022. All rights reserved. + * Description: Lcd driver. + * Author: @CompanyNameTag + * Create: 2022-03-05 + */ + +#include "soc_lcd_api.h" +#include +#include "soc_errno.h" +#include "soc_osal.h" +#include "soc_mipi_tx.h" +#include "lcd_config.h" +#include "lcd_bus.h" +#include "lcd_mipi.h" +#include "lcd_qspi.h" +#include "lcd_common.h" +#include "lcd_private.h" +#include "pinctrl_porting.h" + +typedef struct lcd_attr { + bool info_register; /* 注册指定屏幕组件标志 */ + bool is_inited; /* LCD组件初始化标志 */ + lcd_type screen_type; /* LCD屏类型 */ + uint32_t lcd_id; /* LCD ID号 */ + lcd_drv_cfg *lcd_cfg; /* LCD参数 */ + uint8_t brightness; /* 显示亮度参数 */ + ext_lcd_status status; /* LCD状态标志 */ + osal_mutex lcd_mutex; /* LCD驱动多线程调用保护信号量 */ + lcd_bus_api *bus_api; /* 总线接口 */ + lcd_drv_common *common_api; /* LCD公共接口 */ + lcd_drv_private *private_api; /* LCD差异化接口 */ +} lcd_attr; + +lcd_attr g_lcd_info = {0}; +volatile bool g_idle_before_sleep = false; /* false: normal display, true: idle mode */ +static bool g_lcd_on_flag = false; + +bool lcd_get_status(void) +{ + return g_lcd_on_flag; +} + +void lcd_set_status(bool lcd_on) +{ + g_lcd_on_flag = lcd_on; +} + +static ext_errno lcd_lock_init(void) +{ + ext_errno ret; + if (g_lcd_info.lcd_mutex.mutex != NULL) { + return EXT_ERR_SUCCESS; + } + + ret = osal_mutex_init(&(g_lcd_info.lcd_mutex)); + if (ret != EXT_ERR_SUCCESS) { + g_lcd_info.lcd_mutex.mutex = NULL; + return ret; + } + if (g_lcd_info.lcd_mutex.mutex == NULL) { + return EXT_ERR_LCD_MUTEX_INIT_FAIL; + } + return EXT_ERR_SUCCESS; +} + +static void lcd_lock_deinit(void) +{ + if (g_lcd_info.lcd_mutex.mutex != NULL) { + osal_mutex_destroy(&(g_lcd_info.lcd_mutex)); + } + + g_lcd_info.lcd_mutex.mutex = NULL; +} + +static void lcd_lock(void) +{ + if (g_lcd_info.lcd_mutex.mutex == NULL) { + return; + } + osal_mutex_lock(&(g_lcd_info.lcd_mutex)); +} + +static void lcd_unlock(void) +{ + if (g_lcd_info.lcd_mutex.mutex == NULL) { + return; + } + osal_mutex_unlock(&(g_lcd_info.lcd_mutex)); +} + +static void lcd_set_display_info(void) +{ + if (g_lcd_info.bus_api->bus_register_panel_info != NULL) { + g_lcd_info.bus_api->bus_register_panel_info(g_lcd_info.lcd_cfg->x_start, g_lcd_info.lcd_cfg->y_start, + g_lcd_info.lcd_cfg->fps); + } +} + +static ext_errno lcd_auto_adapt_init_prepare(void) +{ + ext_errno ret; + combo_dev_cfg_t *escape_config = lcd_get_bus_escape_config(); + + /* init with default parameter */ + ret = g_lcd_info.bus_api->bus_init(escape_config); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("default bus_init fail, ret = %X\r\n", ret); + return ret; + } + + ret = g_lcd_info.common_api->get_chip_id(&g_lcd_info.lcd_id); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("get_chip_id fail, ret = %X\r\n", ret); + } + + if (g_lcd_info.bus_api->bus_deinit() != EXT_ERR_SUCCESS) { + lcd_err("bus deinit fail\r\n"); + } + + return ret; +} + +static ext_errno lcd_assigned_id_check(void) +{ + if (g_lcd_info.common_api->chip_id_check == NULL) { + return EXT_ERR_LCD_INVALID_NULL_POINTER; + } + + return g_lcd_info.common_api->chip_id_check(); +} + +static ext_errno lcd_get_ops(void) +{ + ext_errno ret = 0; + g_lcd_info.bus_api = lcd_get_bus_api(); + g_lcd_info.common_api = lcd_drv_get_common_api(); + g_lcd_info.private_api = lcd_drv_get_private_api(); + + if (g_lcd_info.bus_api == NULL || g_lcd_info.common_api == NULL || g_lcd_info.private_api == NULL) { + return EXT_ERR_LCD_GET_ATTR_FAIL; + } + + if (g_lcd_info.private_api->power_on == NULL) { + return EXT_ERR_LCD_GET_ATTR_FAIL; + } + g_lcd_info.private_api->power_on(); + + if (!g_lcd_info.info_register) { + ret = lcd_auto_adapt_init_prepare(); + if (ret != EXT_ERR_SUCCESS) { + goto fail; + } + } + + g_lcd_info.lcd_cfg = g_lcd_info.common_api->get_lcd_config(); + if (g_lcd_info.lcd_cfg == NULL) { + lcd_err("lcd_cfg empty!\r\n"); + goto fail; + } + ret = g_lcd_info.bus_api->bus_init(g_lcd_info.lcd_cfg->bus_cfg); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("bus_init fail, ret = %X\r\n", ret); + return ret; + } + + if (g_lcd_info.info_register) { + ret = lcd_assigned_id_check(); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("chip id check error, ret = 0x%x\r\n", ret); + g_lcd_info.bus_api->bus_deinit(); + goto fail; + } + } + + if (g_lcd_info.brightness == 0) + g_lcd_info.brightness = DEFAULT_BRIGHTNESS; + + return EXT_ERR_SUCCESS; +fail: + + if (g_lcd_info.private_api->power_off != NULL) { + g_lcd_info.private_api->power_off(); + } + g_lcd_info.bus_api = NULL; + g_lcd_info.common_api = NULL; + g_lcd_info.private_api = NULL; + return ret; +} + +ext_lcd_status uapi_lcd_get_status(void) +{ + return g_lcd_info.status; +} + +bool uapi_is_lcd_connect(void) +{ + return g_lcd_info.is_inited; +} + +static ext_errno lcd_display_on(void) +{ + ext_errno ret; + uint32_t retry_count = 3; + lcd_lock(); + + for (; retry_count > 0; retry_count--) { + ret = g_lcd_info.common_api->display_on(g_lcd_info.brightness); + if (ret == EXT_ERR_SUCCESS) { + ret = g_lcd_info.bus_api->bus_enable(); + if (ret == EXT_ERR_SUCCESS) { + break; + } + } + + g_lcd_info.private_api->power_off(); + g_lcd_info.private_api->power_on(); + + g_lcd_info.bus_api->bus_deinit(); + ret = g_lcd_info.bus_api->bus_init(g_lcd_info.lcd_cfg->bus_cfg); + if (ret != EXT_ERR_SUCCESS) { + g_lcd_info.private_api->power_off(); + continue; + } + } + if (retry_count > 0) { + g_lcd_info.status.disp_status = LCD_NORMAL_DISPLAY; + g_lcd_info.status.te_status = LCD_TE_ON; + } + + lcd_unlock(); + + return ret; +} + +ext_errno uapi_lcd_display_on(void) +{ + ext_errno ret; + if (!g_lcd_info.is_inited) { + return EXT_ERR_LCD_NOT_INIT; + } + if (g_lcd_info.status.disp_status == LCD_NORMAL_DISPLAY) { + return EXT_ERR_SUCCESS; + } + + ret = lcd_display_on(); + + return ret; +} + +ext_errno uapi_lcd_display_off(void) +{ + ext_errno ret; + if (!g_lcd_info.is_inited) { + return EXT_ERR_LCD_NOT_INIT; + } + if (g_lcd_info.status.disp_status == LCD_DISPLAY_OFF) { + return EXT_ERR_SUCCESS; + } + + ret = g_lcd_info.common_api->display_off(); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("display_off fail, ret = %X\r\n", ret); + lcd_unlock(); + return ret; + } + ret = g_lcd_info.bus_api->bus_disable(); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("bus_disable fail, ret = %X\r\n", ret); + lcd_unlock(); + return ret; + } + + g_lcd_info.status.disp_status = LCD_DISPLAY_OFF; + + return EXT_ERR_SUCCESS; +} + +ext_errno uapi_lcd_enter_sleep_mode(void) +{ + ext_errno ret; + if (!g_lcd_info.is_inited) { + return EXT_ERR_LCD_NOT_INIT; + } + if (g_lcd_info.status.disp_status == LCD_SLEEP_MODE) { + return EXT_ERR_SUCCESS; + } else if (g_lcd_info.status.disp_status == LCD_DISPLAY_OFF) { + return EXT_ERR_LCD_NOT_SUPPORT_OFF_TO_SLEEP; + } + + if (g_lcd_info.status.disp_status == LCD_IDLE_MODE) { + g_idle_before_sleep = true; + } else { + g_idle_before_sleep = false; + } + + ret = g_lcd_info.common_api->enter_sleep_mode(); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("enter sleep mode fail, ret = %X\r\n", ret); + lcd_unlock(); + return ret; + } + ret = g_lcd_info.bus_api->bus_disable(); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("bus_disable fail, ret = %X\r\n", ret); + return ret; + } + g_lcd_info.status.disp_status = LCD_SLEEP_MODE; + + return EXT_ERR_SUCCESS; +} + +ext_errno uapi_lcd_exit_sleep_mode(void) +{ + ext_errno ret; + if (!g_lcd_info.is_inited) { + return EXT_ERR_LCD_NOT_INIT; + } + if (g_lcd_info.status.disp_status != LCD_SLEEP_MODE) { + return EXT_ERR_LCD_NOT_IN_SLEEP_MODE; + } + + ret = g_lcd_info.common_api->exit_sleep_mode(); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("exit sleep mode fail, ret = %X\r\n", ret); + return ret; + } + + lcd_lock(); + ret = g_lcd_info.bus_api->bus_enable(); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("enable bus fail when exit sleep, ret = %X\r\n", ret); + lcd_unlock(); + return ret; + } + + if (g_idle_before_sleep) { + g_lcd_info.status.disp_status = LCD_IDLE_MODE; + } else { + g_lcd_info.status.disp_status = LCD_NORMAL_DISPLAY; + } + + lcd_unlock(); + + return EXT_ERR_SUCCESS; +} + +ext_errno uapi_lcd_enter_idle_mode(void) +{ + ext_errno ret; + if (!g_lcd_info.is_inited) { + return EXT_ERR_LCD_NOT_INIT; + } + if (g_lcd_info.status.disp_status == LCD_IDLE_MODE) { + return EXT_ERR_SUCCESS; + } + if (g_lcd_info.status.disp_status != LCD_NORMAL_DISPLAY) { + return EXT_ERR_LCD_NOT_SUPPORT_CUR_TO_IDLE; + } + + lcd_lock(); + ret = g_lcd_info.common_api->enter_idle_mode(); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("enter_idle_mode fail, ret = %X\r\n", ret); + lcd_unlock(); + return ret; + } + g_lcd_info.status.disp_status = LCD_IDLE_MODE; + lcd_unlock(); + + return EXT_ERR_SUCCESS; +} + +ext_errno uapi_lcd_exit_idle_mode(void) +{ + ext_errno ret; + if (!g_lcd_info.is_inited) { + return EXT_ERR_LCD_NOT_INIT; + } + if (g_lcd_info.status.disp_status != LCD_IDLE_MODE) { + return EXT_ERR_LCD_NOT_IN_IDLE_MODE; + } + + lcd_lock(); + ret = g_lcd_info.common_api->exit_idle_mode(); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("exit_idle_mode fail, ret = %X\r\n", ret); + lcd_unlock(); + return ret; + } + g_lcd_info.status.disp_status = LCD_NORMAL_DISPLAY; + lcd_unlock(); + + return EXT_ERR_SUCCESS; +} + +static ext_errno lcd_te_param_check(void) +{ + if (!g_lcd_info.is_inited) { + return EXT_ERR_LCD_NOT_INIT; + } + if (g_lcd_info.screen_type == VIDEO_LCD) { + return EXT_ERR_LCD_VIDEO_SCREEN_NOT_SUPPORT_TE; + } + if (g_lcd_info.status.disp_status != LCD_NORMAL_DISPLAY && g_lcd_info.status.disp_status != LCD_IDLE_MODE) { + return EXT_ERR_LCD_INVALID_TE_ON_MODE; + } + + return EXT_ERR_SUCCESS; +} + +ext_errno uapi_lcd_te_on(void) +{ + ext_errno ret = lcd_te_param_check(); + if (ret != EXT_ERR_SUCCESS) { + return ret; + } + if (g_lcd_info.status.te_status == LCD_TE_ON) { + return EXT_ERR_SUCCESS; + } + + lcd_lock(); + ret = g_lcd_info.common_api->te_on(); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("te_on fail, ret = %X\r\n", ret); + lcd_unlock(); + return ret; + } + g_lcd_info.status.te_status = LCD_TE_ON; + lcd_unlock(); + + return EXT_ERR_SUCCESS; +} + +ext_errno uapi_lcd_te_off(void) +{ + ext_errno ret = lcd_te_param_check(); + if (ret != EXT_ERR_SUCCESS) { + return ret; + } + if (g_lcd_info.status.te_status == LCD_TE_OFF) { + return EXT_ERR_SUCCESS; + } + + lcd_lock(); + ret = g_lcd_info.common_api->te_off(); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("te_off fail, ret = %X\r\n", ret); + lcd_unlock(); + return ret; + } + g_lcd_info.status.te_status = LCD_TE_OFF; + lcd_unlock(); + + return EXT_ERR_SUCCESS; +} + +ext_errno uapi_lcd_set_brightness(uint16_t value) +{ + ext_errno ret; + if (!g_lcd_info.is_inited) { + return EXT_ERR_LCD_NOT_INIT; + } + if (g_lcd_info.status.disp_status > LCD_IDLE_MODE) { + return EXT_ERR_LCD_IN_DISPLAY_OFF_STATE; + } + + lcd_lock(); + ret = g_lcd_info.common_api->set_brightness(value); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("set_brightness fail, ret = %X\r\n", ret); + lcd_unlock(); + return ret; + } + g_lcd_info.brightness = (uint8_t)value; + lcd_unlock(); + + return EXT_ERR_SUCCESS; +} + +ext_errno uapi_lcd_get_brightness(uint16_t *value) +{ + if (!g_lcd_info.is_inited) { + return EXT_ERR_LCD_NOT_INIT; + } + *value = g_lcd_info.brightness; + return EXT_ERR_SUCCESS; +} + +ext_errno uapi_lcd_write_reg(lcd_cmd_sequ *cmds, uint32_t cmd_count) +{ + ext_errno ret; + if (!g_lcd_info.is_inited) { + return EXT_ERR_LCD_NOT_INIT; + } + + if (cmds == NULL || cmd_count == 0) { + return EXT_ERR_LCD_INVALID_WRITE_CMD; + } + lcd_lock(); + ret = g_lcd_info.common_api->write(cmds, cmd_count); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("write reg fail, ret = %X\r\n", ret); + lcd_unlock(); + return ret; + } + lcd_unlock(); + + return EXT_ERR_SUCCESS; +} + +ext_errno uapi_lcd_read_reg(uint8_t cmd, uint8_t *buff, uint8_t buff_len) +{ + ext_errno ret; + if (!g_lcd_info.is_inited) { + return EXT_ERR_LCD_NOT_INIT; + } + if (g_lcd_info.status.disp_status > LCD_SLEEP_MODE) { + return EXT_ERR_LCD_IN_DISPLAY_OFF_STATE; + } + if (buff == NULL || buff_len == 0) { + return EXT_ERR_LCD_INVALID_READ_CMD; + } + lcd_lock(); + ret = g_lcd_info.common_api->read(cmd, buff, buff_len); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("read reg fail, ret = %X\r\n", ret); + lcd_unlock(); + return ret; + } + lcd_unlock(); + + return EXT_ERR_SUCCESS; +} + +ext_errno uapi_lcd_init(void) +{ + if (g_lcd_info.is_inited) { + return EXT_ERR_SUCCESS; + } + + ext_errno ret = lcd_get_ops(); + if (ret != EXT_ERR_SUCCESS && ret != EXT_ERR_MIPI_ALREADY_INIT) { + lcd_err("lcd_get_ops fail, ret = %X\r\n", ret); + return ret; + } + + ret = lcd_lock_init(); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("lcd_lock_init fail, ret = %X\r\n", ret); + return ret; + } + + lcd_set_display_info(); + + ret = lcd_display_on(); + if (ret != EXT_ERR_SUCCESS) { + g_lcd_info.bus_api->bus_deinit(); + lcd_lock_deinit(); + lcd_err("lcd_display_on fail, ret = %X\r\n", ret); + return ret; + } + + g_lcd_info.is_inited = true; + + return EXT_ERR_SUCCESS; +} + +ext_errno uapi_lcd_deinit(void) +{ + ext_errno ret; + if (!g_lcd_info.is_inited) { + return EXT_ERR_SUCCESS; + } + + if (g_lcd_info.status.disp_status != LCD_DISPLAY_OFF) { + ret = g_lcd_info.common_api->display_off(); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("display_off fail, ret = %X\r\n", ret); + } + + ret = g_lcd_info.bus_api->bus_disable(); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("bus_disable fail, ret = %X\r\n", ret); + } + } + lcd_lock(); + ret = g_lcd_info.bus_api->bus_deinit(); + if (ret != EXT_ERR_SUCCESS) { + lcd_err("bus_deinit fail, ret = %X\r\n", ret); + } + g_lcd_info.private_api->power_off(); + + g_lcd_info.status.disp_status = LCD_DISPLAY_OFF; + g_lcd_info.is_inited = false; + lcd_unlock(); + + lcd_lock_deinit(); + + return EXT_ERR_SUCCESS; +} + +static ext_errno lcd_lp_ctrl_check(void) +{ + if (!g_lcd_info.is_inited) { + return EXT_ERR_LCD_NOT_INIT; + } + + if (g_lcd_info.bus_api == NULL) { + return EXT_ERR_LCD_GET_ATTR_FAIL; + } + + if (g_lcd_info.bus_api->bus_lp_ctrl == NULL) { + return EXT_ERR_LCD_NOT_SUPPORT_FUNC; + } + + return EXT_ERR_SUCCESS; +} + +ext_errno uapi_lcd_enter_sdlp(void) +{ + ext_errno ret; + + ret = lcd_lp_ctrl_check(); + if (ret != EXT_ERR_SUCCESS) { + return ret; + } + + return g_lcd_info.bus_api->bus_lp_ctrl(LP_CTRL_ENTER_SDLP); +} + +ext_errno uapi_lcd_exit_sdlp(void) +{ + ext_errno ret; + + ret = lcd_lp_ctrl_check(); + if (ret != EXT_ERR_SUCCESS) { + return ret; + } + + return g_lcd_info.bus_api->bus_lp_ctrl(LP_CTRL_EXIT_SDLP); +} + +ext_errno uapi_lcd_exit_ulps(void) +{ + ext_errno ret; + + ret = lcd_lp_ctrl_check(); + if (ret != EXT_ERR_SUCCESS) { + return ret; + } + + return g_lcd_info.bus_api->bus_lp_ctrl(LP_CTRL_EXIT_ULPS); +} + +ext_errno uapi_lcd_clear_exit_ulps(void) +{ + ext_errno ret; + + ret = lcd_lp_ctrl_check(); + if (ret != EXT_ERR_SUCCESS) { + return ret; + } + + return g_lcd_info.bus_api->bus_lp_ctrl(LP_CTRL_CLEAR_EXIT_ULPS); +} + +static void lcd_register_qspi_bus(void) +{ + lcd_bus_api qspi_bus_api = {0}; + + qspi_bus_api.bus_init = lcd_qspi_init; + qspi_bus_api.bus_deinit = lcd_qspi_deinit; + qspi_bus_api.bus_enable = lcd_qspi_enable; + qspi_bus_api.bus_disable = lcd_qspi_disable; + qspi_bus_api.bus_write_cmd = lcd_qspi_write_cmd; + qspi_bus_api.bus_read_cmd = lcd_qspi_read_cmd; + qspi_bus_api.bus_send_frame = lcd_qspi_send_frame; + qspi_bus_api.bus_suspend = lcd_qspi_suspend; + qspi_bus_api.bus_resume = lcd_qspi_resume; + qspi_bus_api.bus_register_te_isr = lcd_qspi_register_te_isr; + + lcd_bus_register_api(&qspi_bus_api, BUS_DISPLAY_QSPI); +} + +static void lcd_register_mipi_bus(void) +{ + lcd_bus_api mipi_bus_api = {0}; + + mipi_bus_api.bus_init = mipi_bus_init, + mipi_bus_api.bus_deinit = mipi_bus_deinit, + mipi_bus_api.bus_enable = mipi_bus_enable, + mipi_bus_api.bus_disable = mipi_bus_disable, + mipi_bus_api.bus_write_cmd = mipi_bus_write, + mipi_bus_api.bus_read_cmd = mipi_bus_read, + mipi_bus_api.bus_lp_ctrl = mipi_bus_lp_ctrl, + mipi_bus_api.bus_register_panel_info = mipi_bus_register_panel_info, + mipi_bus_api.bus_get_panel_timing = mipi_bus_get_panel_timing, + mipi_bus_api.bus_get_partial_display_cmd = mipi_bus_get_partial_display_cmd, + mipi_bus_api.bus_update_panel = mipi_bus_update_panel, + mipi_bus_api.bus_refresh_area = mipi_bus_refresh_area, + mipi_bus_api.bus_suspend = mipi_bus_suspend, + mipi_bus_api.bus_resume = mipi_bus_resume, + lcd_bus_register_api(&mipi_bus_api, BUS_DISPLAY_MIPI); +} + +static ext_errno lcd_info_check(const lcd_drv_cfg *info) +{ + if (info == NULL) { + return EXT_ERR_LCD_INVALID_NULL_POINTER; + } + + if ((info->bus_type != BUS_DISPLAY_MIPI) && (info->bus_type != BUS_DISPLAY_QSPI)) { + return EXT_ERR_LCD_INVALID_SCREEN_OPS; + } + + if (info->lcd_id == 0) { + return EXT_ERR_LCD_INVALID_CHIP_ID; + } + + if ((info->display_on_cmds == NULL) || (info->display_off_cmds == NULL)) { + return EXT_ERR_LCD_INVALID_WRITE_CMD; + } + + if (info->lcd_id_info.read_len == 0) { + return EXT_ERR_LCD_INVALID_READ_CMD; + } + + return EXT_ERR_SUCCESS; +} + +ext_errno uapi_lcd_info_register(lcd_drv_cfg *info) +{ + ext_errno ret; + + ret = lcd_info_check(info); + if (ret != EXT_ERR_SUCCESS) { + return ret; + } + + if (g_lcd_info.is_inited) { + return EXT_ERR_LCD_INIT_ALREADY; + } + + if (g_lcd_info.common_api == NULL) { + g_lcd_info.common_api = lcd_drv_get_common_api(); + } + + if (g_lcd_info.common_api->set_lcd_config == NULL) { + return EXT_ERR_LCD_NOT_SUPPORT_FUNC; + } + + ret = g_lcd_info.common_api->set_lcd_config(info); + if (ret != EXT_ERR_SUCCESS) { + return ret; + } + + if (info->bus_type == BUS_DISPLAY_MIPI) { + lcd_register_mipi_bus(); + } else { + lcd_register_qspi_bus(); + } + + g_lcd_info.info_register = true; + + return EXT_ERR_SUCCESS; +} diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/CMakeLists.txt b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/CMakeLists.txt new file mode 100644 index 000000000..6971096df --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/CMakeLists.txt @@ -0,0 +1,92 @@ +#=============================================================================== +# @brief cmake file +# Copyright (c) @CompanyNameMagicTag 2023-2023. All rights reserved. +#=============================================================================== +set(COMPONENT_NAME "touch") + +set(SOURCES + ${CMAKE_CURRENT_SOURCE_DIR}/touch_screen_drv.c + ${CMAKE_CURRENT_SOURCE_DIR}/touch_screen_queue1.c +) + +if("TPTYPE_TMA525B" IN_LIST DEFINES) +set(SOURCES ${SOURCES} + ${CMAKE_CURRENT_SOURCE_DIR}/tma525b_touch/tma525b_ctrl.c + ${CMAKE_CURRENT_SOURCE_DIR}/tma525b_touch/tma525b_drv1.c + ${CMAKE_CURRENT_SOURCE_DIR}/tma525b_touch/tma525b_touch1.c +) +elseif("TPTYPE_ZTW523" IN_LIST DEFINES) +set(SOURCES ${SOURCES} + ${CMAKE_CURRENT_SOURCE_DIR}/ztw523_touch/ztw523_ctrl.c + ${CMAKE_CURRENT_SOURCE_DIR}/ztw523_touch/ztw523_drv1.c + ${CMAKE_CURRENT_SOURCE_DIR}/ztw523_touch/ztw523_touch1.c +) +elseif("TPTYPE_FT6X46" IN_LIST DEFINES) +set(SOURCES ${SOURCES} + ${CMAKE_CURRENT_SOURCE_DIR}/ft6x46_touch/ft6x46_ctrl.c + ${CMAKE_CURRENT_SOURCE_DIR}/ft6x46_touch/ft6x46_drv1.c + ${CMAKE_CURRENT_SOURCE_DIR}/ft6x46_touch/ft6x46_touch1.c +) +else() +set(SOURCES ${SOURCES} + ${CMAKE_CURRENT_SOURCE_DIR}/ztw523_touch/ztw523_ctrl.c + ${CMAKE_CURRENT_SOURCE_DIR}/ztw523_touch/ztw523_drv1.c + ${CMAKE_CURRENT_SOURCE_DIR}/ztw523_touch/ztw523_touch1.c +) +endif() + +if("TPTYPE_TMA525B" IN_LIST DEFINES) +set(PUBLIC_HEADER + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/tma525b_touch + ${ROOT_DIR}/middleware/services/gui/hal/input/include +) +elseif("TPTYPE_ZTW523" IN_LIST DEFINES) +set(PUBLIC_HEADER + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/ztw523_touch + ${ROOT_DIR}/middleware/services/gui/hal/input/include +) +elseif("TPTYPE_FT6X46" IN_LIST DEFINES) +set(PUBLIC_HEADER + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/ft6x46_touch + ${ROOT_DIR}/middleware/services/gui/hal/input/include +) +else() +set(PUBLIC_HEADER + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/ztw523_touch + ${ROOT_DIR}/middleware/services/gui/hal/input/include +) +endif() + +set(PRIVATE_HEADER +) + +set(PRIVATE_DEFINES +) + +set(PUBLIC_DEFINES +) + +# use this when you want to add ccflags like -include xxx +set(COMPONENT_PUBLIC_CCFLAGS +) + +set(COMPONENT_CCFLAGS + -Wno-incompatible-function-pointer-types + -Wno-unused-function +) + +set(WHOLE_LINK + true +) + +set(MAIN_COMPONENT + false +) + +build_component() + +install_sdk(${CMAKE_CURRENT_SOURCE_DIR} "*") diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_ctrl.c b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_ctrl.c new file mode 100644 index 000000000..f6a42fdb1 --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_ctrl.c @@ -0,0 +1,397 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: ztw523 touch driver. + * Author: @CompanyNameTag + * Create: 2022-04-12 + */ + +#include "ft6x46_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; +ft6x46_ctrl_attr g_ctrl_attr; +touch_callback g_ft6x46_callback = NULL; + +static uint8_t g_tp_recv_buf[FT6X46_INPUT_SIZE] = {0}; + +static void ft6x46_gpio_isr_handle(pin_t pin, uintptr_t param) +{ + unused(pin); + unused(param); + if (g_ft6x46_callback != NULL) { + g_ft6x46_callback(); + } +} + +ext_errno ft6x46_register_handle(const ft6x46_ctrl_ops *peri_data, touch_callback func) +{ + unused(peri_data); + ext_errno ret; + + + //tp_err("ft6x46_register_handle*****************888888888"); + g_ft6x46_callback = func; + /* register int io interrupt handler */ + uapi_gpio_init(); + gpio_select_core(FT6X46_INT_GPIO, CORE); + uapi_gpio_set_dir(FT6X46_INT_GPIO, GPIO_DIRECTION_INPUT); + ret = uapi_gpio_register_isr_func(FT6X46_INT_GPIO, GPIO_INTERRUPT_FALLING_EDGE, ft6x46_gpio_isr_handle); + if (ret != 0) { + tp_err("ft6x46 int callback register fail! ret=0x%x", ret); + return ret; + } + + return EXT_ERR_SUCCESS; +} + +ext_errno ft6x46_unregister_handle(const ft6x46_ctrl_ops *peri_data) +{ + unused(peri_data); + ext_errno ret; + + /* unregister interrupt handler */ + uapi_gpio_unregister_isr_func(FT6X46_INT_GPIO); + g_ft6x46_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 ft6x46_ctrl_attr_check(const ft6x46_ctrl_attr *device_attr) +{ + unused(device_attr); + return EXT_ERR_SUCCESS; +} + +static ext_errno 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 tp_i2c_data_read(uint8_t reg_addr, uint8_t *data_buf, uint32_t data_len) +{ + errcode_t ret; + uint32_t retry; + i2c_data_t data; + + + ret = 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; + } + + data.send_buf = ®_addr; + data.send_len = FT6X46_CMD_SEND_LEN; + data.receive_buf = g_tp_recv_buf; + data.receive_len = data_len; + + for (retry = 0; retry < FT6X46_I2C_TIME_MAX; retry++) { + ret = uapi_i2c_master_writeread(FT6X46_I2C_BUS, FT6X46_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 tp_ft6x46_i2c_data_read(uint8_t reg_addr, uint8_t *data_buf, uint32_t data_len) +{ + errcode_t ret; + uint32_t retry; + i2c_data_t data; + //uint8_t tp_reg_addr[FT6X46_REG_BYTE_LEN]; + + ret = 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; + } + + memset_s(data_buf, data_len, 0, data_len); + //tp_reg_addr[FT6X46_I2C_SEND_INDEX0] = reg_addr & 0xff; + //tp_reg_addr[FT6X46_I2C_SEND_INDEX1] = (reg_addr >> OFFSET_8_BITS) & 0xff; + + data.send_buf = ®_addr; + data.send_len = sizeof(reg_addr); + data.receive_buf = data_buf; + data.receive_len = data_len; + + for (retry = 0; retry < FT6X46_I2C_TIME_MAX; retry++) { + ret = uapi_i2c_master_writeread(FT6X46_I2C_BUS, FT6X46_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; + } + + return EXT_ERR_SUCCESS; +} + +ext_errno tp_i2c_cmd_write(uint8_t cmd) +{ + errcode_t ret; + uint32_t retry; + i2c_data_t data; + //uint8_t tp_reg_addr[FT6X46_CMD_SEND_LEN]; + + ret = tp_peripheral_init_status_check(); + if (ret != 0) { + tp_err("host peripheral not init! ret=0x%x", ret); + return ret; + } + //tp_reg_addr[FT6X46_I2C_SEND_INDEX0] = cmd & 0xff; + //tp_reg_addr[FT6X46_I2C_SEND_INDEX1] = (cmd >> OFFSET_8_BITS) & 0xff; + + data.send_buf = &cmd; + data.send_len = FT6X46_CMD_SEND_LEN; + data.receive_buf = NULL; + data.receive_len = 0; + + for (retry = 0; retry < FT6X46_I2C_TIME_MAX; retry++) { + ret = uapi_i2c_master_write(FT6X46_I2C_BUS, FT6X46_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 tp_i2c_data_write(uint8_t reg_addr, uint8_t *data_buf, uint16_t data_len) +{ + errcode_t ret; + uint32_t retry; + i2c_data_t data; + uint8_t *write_data = NULL; + uint16_t send_len; + + ret = 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(uint8_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[FT6X46_I2C_SEND_INDEX0] = reg_addr; + ret = (uint32_t)memcpy_s(write_data + sizeof(uint8_t), send_len - sizeof(uint8_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 < FT6X46_I2C_TIME_MAX; retry++) { + ret = uapi_i2c_master_write(FT6X46_I2C_BUS, FT6X46_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 tp_ft6x46_i2c_data_write(uint8_t reg_addr, uint8_t *data_buf, uint16_t data_len) +{ + errcode_t ret; + uint32_t retry; + i2c_data_t data; + uint8_t *write_data = NULL; + uint16_t send_len; + + ret = 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(uint8_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[FT6X46_I2C_SEND_INDEX0] = reg_addr; + ret = (uint32_t)memcpy_s(write_data + sizeof(uint8_t), send_len - sizeof(uint8_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 < FT6X46_I2C_TIME_MAX; retry++) { + ret = uapi_i2c_master_write(FT6X46_I2C_BUS, FT6X46_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 tp_ft6x46_i2c_data_write_reg(uint8_t addr, uint8_t val) +{ + return tp_ft6x46_i2c_data_write(addr, &val, 1); +} + + +ext_errno ft6x46_host_peripheral_init(ft6x46_ctrl_attr *attr) +{ + ext_errno ret; + + if (attr == NULL) { + tp_err("ft6x46 communication interface cfg is empty!"); + return EXT_ERR_FAILURE; + } + ret = ft6x46_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(ft6x46_ctrl_attr), attr, sizeof(ft6x46_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(FT6X46_I2C_BUS, 400000, I2C_SPEED_MODE_FS); /* 400000: 400KHz */ + if (result != EXT_ERR_SUCCESS) { + tp_err("tp i2c init fail! ret=0x%x", result); + return EXT_ERR_SUCCESS; + } + + tp_print("TOUCH:i2c_id = %d i2c_speed = %d slave_addr = 0x%x \r\n", + g_ctrl_attr.i2c_id, g_ctrl_attr.i2c_speed, FT6X46_I2C_ADDR); + g_host_dev_init_flag = true; + + return EXT_ERR_SUCCESS; +} + +ext_errno ft6x46_host_init_sample(void) +{ + ext_errno ret; + PRINT("**********ft6x46_host_init_sample**********\r\n"); + ret = ft6x46_host_peripheral_init(&g_ctrl_attr); + ret = ft6x46_init(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("tp host init fail! ret=0x%x", ret); + return ret; + } + + return EXT_ERR_SUCCESS; +} + +ext_errno ft6x46_reset(void) +{ + uapi_gpio_set_dir(FT6X46_RESET_GPIO, GPIO_DIRECTION_OUTPUT); + /* Config Gpio For Reset Pin */ + uapi_gpio_set_val(FT6X46_RESET_GPIO, GPIO_LEVEL_HIGH); + /* reset high delay 20ms */ + osDelay(20); + uapi_gpio_set_val(FT6X46_RESET_GPIO, GPIO_LEVEL_LOW); + /* reset low delay 100ms */ + osDelay(100); + uapi_gpio_set_val(FT6X46_RESET_GPIO, GPIO_LEVEL_HIGH); + /* reset high delay 200ms */ + osDelay(200); + return EXT_ERR_SUCCESS; +} + +void ft6x46_resume_reset(void) +{ + uapi_gpio_set_dir(FT6X46_RESET_GPIO, GPIO_DIRECTION_OUTPUT); + /* drvdata is global variable point and no need to handle null */ + uapi_gpio_set_val(FT6X46_RESET_GPIO, GPIO_LEVEL_HIGH); + osDelay(1); + uapi_gpio_set_val(FT6X46_RESET_GPIO, GPIO_LEVEL_LOW); + /* delay 10ms */ + osDelay(10); + uapi_gpio_set_val(FT6X46_RESET_GPIO, GPIO_LEVEL_HIGH); + /* delay 100ms */ + osDelay(200); + uapi_gpio_set_dir(FT6X46_RESET_GPIO, GPIO_DIRECTION_INPUT); +} + diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_ctrl.h b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_ctrl.h new file mode 100644 index 000000000..24ef8f419 --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_ctrl.h @@ -0,0 +1,69 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: ztw523 touch driver. + * Author: @CompanyNameTag + * Create: 2022-04-12 + */ + +#ifndef FT6X46_CTRL_H +#define FT6X46_CTRL_H + +#include "stdio.h" +#include "debug_print.h" +#include "stdint.h" +#include "product.h" +#include "td_base.h" +#include "platform_core.h" +#include "ft6x46_touch1.h" + +/* host peripheral definitions */ + +//#define FT6X46_I2C_ADDR 0x20 +#define FT6X46_I2C_ADDR 0x38 +#define FT6X46_I2C_SPEED I2C_SPEED_MODE_SS +#define FT6X46_REG_BYTE_LEN 2 +#define OFFSET_8_BITS 8 +#define FT6X46_REG_WRITE_LEN 4 + +#define FT6X46_CMD_SEND_LEN 2 +// #define FT6X46_CMD_SEND_LEN 1 + +#define FT6X46_REG_DATA_LEN 2 +#define FT6X46_I2C_TIME_MAX 3 +#define FT6X46_INPUT_SIZE 156 + +#define FT6X46_I2C_SEND_INDEX0 0 +#define FT6X46_I2C_SEND_INDEX1 1 +#define FT6X46_I2C_SEND_INDEX2 2 +#define FT6X46_I2C_SEND_INDEX3 3 + + +#define FTS_REG_POWER_MODE 0xA5 + + +typedef struct { + uint32_t int_gpio; + uint32_t reset_gpio; + i2c_bus_t i2c_id; + uint32_t i2c_speed; +} ft6x46_ctrl_attr; + +typedef ext_errno (*ft6x46_bus_init)(ft6x46_ctrl_attr *attr); + +typedef struct { + ft6x46_ctrl_attr attr; + ft6x46_bus_init bus_init; +} ft6x46_ctrl_ops; + +ext_errno ft6x46_host_peripheral_init(ft6x46_ctrl_attr *attr); +ext_errno ft6x46_register_handle(const ft6x46_ctrl_ops *peri_data, touch_callback func); +ext_errno ft6x46_unregister_handle(const ft6x46_ctrl_ops *peri_data); +ext_errno ft6x46_reset(void); +void ft6x46_resume_reset(void); +void ft6x46_delay(uint32_t ms); + +ext_errno tp_ft6x46_i2c_data_read(uint8_t reg_addr, uint8_t *data_buf, uint32_t data_len); +ext_errno tp_ft6x46_i2c_data_write(uint8_t reg_addr, uint8_t *data_buf, uint16_t data_len); +ext_errno tp_ft6x46_i2c_data_write_reg(uint8_t addr, uint8_t val); + +#endif diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_drv1.c b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_drv1.c new file mode 100644 index 000000000..928c58eac --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_drv1.c @@ -0,0 +1,104 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: ztw523 touch driver. + * Author: @CompanyNameTag + * Create: 2022-04-12 + */ + +#include "ft6x46_drv1.h" +#include "touch_screen_def.h" +#include "ft6x46_ctrl.h" +#include "i2c.h" +#include "debug_print.h" +#include "hal_i2c.h" + +static ext_errno ft6x46_drv_init(ft6x46_ctrl_ops *config) +{ + ext_errno ret; + ft6x46_ctrl_ops *ops = config; + + tp_err("ft6x46_drv_init!11111"); + + 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("ZTW523 bus_init fail! ret = 0x%x", ret); + return ret; + } + + ret = ft6x46_init(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("ZTW523 init fail! ret = 0x%x", ret); + return ret; + } + + return EXT_ERR_SUCCESS; +} + +static ext_errno ft6x46_drv_deinit(void) +{ + return EXT_ERR_SUCCESS; +} + +static ext_errno ft6x46_drv_get_info(uint8_t *data, uint8_t data_len) +{ + return ft6x46_irq_callback(data, data_len); +} + +static ext_errno ft6x46_drv_suspend(void) +{ + //return ft6x46_set_power_mode(MC_TP_SUSPEND_SCAN); + return EXT_ERR_SUCCESS; +} + +static ext_errno ft6x46_drv_resume(void) +{ + //return ft6x46_set_power_mode(MC_TP_RESUME_SCAN); + return EXT_ERR_SUCCESS; +} + +static ext_errno ft6x46_drv_sleep(void) +{ + //return ft6x46_set_power_mode(MC_TP_SLEEP_WORK_MODE); + return EXT_ERR_SUCCESS; +} + +touch_peripheral_api g_ft6x46_api = { + .touch_init = ft6x46_drv_init, + .touch_deinit = ft6x46_drv_deinit, + .touch_get_tpinfo = ft6x46_drv_get_info, + .touch_suspend = ft6x46_drv_suspend, + .touch_resume = ft6x46_drv_resume, + .touch_sleep = ft6x46_drv_sleep, + .touch_bus_init = ft6x46_host_peripheral_init, + .register_callback = ft6x46_register_handle, + .unregister_callback = ft6x46_unregister_handle, +}; + +ft6x46_ctrl_ops g_ft6x46_ctrl = { + .attr = { + .int_gpio = FT6X46_INT_GPIO, + .i2c_id = FT6X46_I2C_BUS, + .i2c_speed = I2C_SPEED_MODE_SS, + }, + .bus_init = (ft6x46_bus_init)ft6x46_host_peripheral_init, +}; + +void *touch_screen_get_api(void) +{ + return ((void *)&g_ft6x46_api); +} + +void *touch_screen_get_peri_attr(void) +{ + return ((void *)&g_ft6x46_ctrl); +} \ No newline at end of file diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_drv1.h b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_drv1.h new file mode 100644 index 000000000..c26f3a4f0 --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_drv1.h @@ -0,0 +1,14 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: ztw523 touch driver. + * Author: @CompanyNameTag + * Create: 2022-04-12 + */ + +#ifndef FT6X46_DRV1_H +#define FT6X46_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/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_touch1.c b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_touch1.c new file mode 100644 index 000000000..85f2db5a9 --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_touch1.c @@ -0,0 +1,977 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: ft6x46 touch driver. + * Author: @CompanyNameTag + * Create: 2021-05-29 + */ + +#include "ft6x46_touch1.h" +#include "time.h" +#include "soc_osal.h" +#include "osal_timer.h" +#include "osal_mutex.h" +#include "securec.h" +#include "ft6x46_ctrl.h" +#include "tcxo.h" +#include "cmsis_os2.h" +#include "common_def.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif + +ft6x46_drv_data g_ft6x46_drv = { + .chip_status = FT6X46_NOT_READY, + .ops_mux = {0}, + .int_mask = FT6X46_INT_MASK, + .work_status = FT6X46_WORK_INVALID, + .fw_upgrade_flag = TD_FALSE, + .gesture_wakeup = TD_FALSE, + .host_dev_init_flag = TD_FALSE, + .chip_info = FT6X46_DEVICE_INFO, + .p_void = NULL, +}; +static ext_errno ft6x46_config(void); +static void ft6x46_set_irq_mode(ft6x46_irq_status irq_status, uint16_t irq_mask) +{ + unused(irq_mask); + ext_errno ret; + uint16_t reg_write = 0; + + tp_print("TOUCH:set irq mode %d", irq_status); + + switch (irq_status) { + case FT6X46_IRQ_DISABLE: + /* Write Int Register */ + reg_write = FT6X46_INT_NONE; + // ret = tp_i2c_reg_write(FT6X46_INT_ENABLE_FLAG, reg_write); + // if (ret != EXT_ERR_SUCCESS) { + // tp_err("TOUCH:set irq mode disable 0x%x", ret); + // return; + // } + break; + + case FT6X46_IRQ_ENABLE: + /* Write Int Register */ + reg_write = FT6X46_INT_MASK; + // ret = tp_i2c_reg_write(FT6X46_INT_ENABLE_FLAG, reg_write); + // if (ret != EXT_ERR_SUCCESS) { + // tp_err("TOUCH:set irq mode enable 0x%x", ret); + // return; + // } + break; + + default: + tp_err("TOUCH:not support irq mode 0x%x", irq_status); + break; + } + + return; +} + +static ext_errno ft6x46_parse_gesture_input(void) +{ + ext_errno ret; + uint16_t gesture_val; + uint16_t reg_read; + uint16_t reg_write; + + reg_read = 0; + // ret = tp_i2c_data_read(FT6X46_GESTURE_WAKEUP_REG, (uint8_t *)®_read, FT6X46_DATA_LEN); + // if (ret != EXT_ERR_SUCCESS) { + // tp_err("TOUCH:parse gesture input read fail 0x%x", ret); + // return EXT_ERR_FAILURE; + // } + gesture_val = reg_read; + tp_print("TOUCH:parse gesture input ok 0x%x", reg_read); + + reg_write = 0; + // ret = tp_i2c_reg_write(FT6X46_GESTURE_WAKEUP_REG, reg_write); + // if (ret != EXT_ERR_SUCCESS) { + // tp_err("TOUCH:parse gesture input write fail 0x%x", ret); + // return EXT_ERR_FAILURE; + // } + + switch (gesture_val) { + case FT6X46_GESTURE_SIGNAL_CLICK: + g_ft6x46_drv.touch_msg.tp_event = MC_TP_SHORT_CLICK; + break; + case FT6X46_GESTURE_DOUBLE_CLICK: + g_ft6x46_drv.touch_msg.tp_event = MC_TP_DOUBLE_CLICK; + break; + case FT6X46_GESTURE_SLIDE_UP: + g_ft6x46_drv.touch_msg.tp_event = MC_TP_SLIDE_UP; + break; + case FT6X46_GESTURE_SLIDE_DOWN: + g_ft6x46_drv.touch_msg.tp_event = MC_TP_SLIDE_DOWN; + break; + default: + tp_err("TOUCH:gesture %d not Support", gesture_val); + return EXT_ERR_FAILURE; + } + + return EXT_ERR_SUCCESS; +} + +static ext_errno ft6x46_parse_touch_input(void) +{ + static uint8_t touch_input[FT6X46_TOUCHINFO_LEN] = { 0 }; + uint16_t touch_status; + uint16_t x_axis; + uint16_t y_axis; + uint8_t sub_status; + + ext_errno ret = tp_i2c_data_read(FT6X46_POINT_STATUS_REG, touch_input, FT6X46_TOUCHINFO_LEN); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:touch input read error! ret = 0x%x", ret); + return EXT_ERR_FAILURE; + } + touch_status = ((uint16_t)touch_input[FT6X46_STATUSH_OFFSET] << FT6X46_REGDATA_SHIFT) | + (touch_input[FT6X46_STATUSL_OFFSET]); + if ((touch_status & FT6X46_PALM_MASK) != 0) { + g_ft6x46_drv.touch_msg.tp_event = MC_TP_COVER; + return EXT_ERR_SUCCESS; + } + + if (touch_status != 0) { + sub_status = touch_input[FT6X46_SUBSTATUS_OFFSET] & FT6X46_TOUCHINFO_MASK; + x_axis = ((uint16_t)touch_input[FT6X46_XH_OFFSET] << FT6X46_REGDATA_SHIFT) | (touch_input[FT6X46_XL_OFFSET]); + y_axis = ((uint16_t)touch_input[FT6X46_YH_OFFSET] << FT6X46_REGDATA_SHIFT) | (touch_input[FT6X46_YL_OFFSET]); + + switch (sub_status) { + case FT6X46_TOUCH_DOWN: + g_ft6x46_drv.touch_msg.tp_event = MC_TP_PRESS; + break; + /* Need To Modify For UI */ + case FT6X46_TOUCH_EXIST: + case FT6X46_TOUCH_MOVE: + case FT6X46_TOUCH_NONE: + g_ft6x46_drv.touch_msg.tp_event = MC_TP_MOVE; + break; + case FT6X46_TOUCH_UP: + g_ft6x46_drv.touch_msg.tp_event = MC_TP_RELEASE; + break; + + default: + tp_err("TOUCH:parse input wrong status|substatus 0x%08x", + ((uint32_t)touch_status << FT6X46_SHIFT_16_BIT) | (uint32_t)sub_status); + return EXT_ERR_FAILURE; + } + g_ft6x46_drv.touch_msg.tp_event_info.x_axis[0] = x_axis; + g_ft6x46_drv.touch_msg.tp_event_info.y_axis[0] = y_axis; + g_ft6x46_drv.touch_msg.tv_usec = (uint32_t)uapi_tcxo_get_ms(); + } else { + g_ft6x46_drv.touch_msg.tp_event = MC_TP_INVALID; + tp_print("TOUCH:parse wrong touchstatus %d", touch_status); + return EXT_ERR_SUCCESS; + } + + return EXT_ERR_SUCCESS; +} + + +/*Max point numbers of gesture trace*/ +#define MAX_POINTS_GESTURE_TRACE 6 +/*Length of gesture information*/ +#define MAX_LEN_GESTURE_INFO (MAX_POINTS_GESTURE_TRACE * 4 + 2) + +/*Max point numbers of touch trace*/ +#define MAX_POINTS_TOUCH_TRACE 1 +/*Length of touch information*/ +#define MAX_LEN_TOUCH_INFO (MAX_POINTS_TOUCH_TRACE * 6 + 2) + +/*Max touch points that touch controller supports*/ +#define FTS_MAX_POINTS_SUPPORT 10 + +struct fts_ts_event { + int x; /*x coordinate */ + int y; /*y coordinate */ + int p; /* pressure */ + int type; /* touch event flag: 0 -- down; 1-- up; 2 -- contact */ + int id; /*touch ID */ + int area; /*touch area*/ +}; + +static ext_errno fts_touch_process(void) +{ + ext_errno ret; + uint8_t i = 0; + uint8_t base = 0; + uint8_t regaddr = 0x01; + uint8_t buf[MAX_LEN_TOUCH_INFO];/*A maximum of two points are supported*/ + uint8_t point_num = 0; + uint8_t touch_event_nums = 0; + uint8_t point_id = 0; + struct fts_ts_event events[FTS_MAX_POINTS_SUPPORT]; /* multi-touch */ + + + /*read touch information from reg0x01*/ + ret = tp_ft6x46_i2c_data_read(regaddr, buf, MAX_LEN_TOUCH_INFO); + if (ret != EXT_ERR_SUCCESS) { + tp_err("Read touch information from reg0x01 fails"); + return ret; + } + + /*print touch buffer, for debug usage*/ + //log_touch_buf(buf, MAX_LEN_TOUCH_INFO); + + //if ((buf[1] == 0xFF) && (buf[2] == 0xFF) && (buf[3] == 0xFF)) { + // tp_err("FW initialization, need recovery"); + // if (fts_data->gesture_support && fts_data->suspended) + // fts_write_reg(FTS_REG_GESTURE_EN, FTS_REG_GESTURE_ENABLE); + //} + + /*parse touch information based on register map*/ + memset(events, 0xFF, sizeof(struct fts_ts_event) * FTS_MAX_POINTS_SUPPORT); + point_num = buf[1] & 0x0F; + if (point_num > FTS_MAX_POINTS_SUPPORT) { + tp_err("invalid point_num(%d)", point_num); + return EXT_ERR_FAILURE; + } + + for (i = 0; i < MAX_POINTS_TOUCH_TRACE; i++) { + base = 2 + i * 6; + point_id = buf[base + 2] >> 4; + if (point_id >= MAX_POINTS_TOUCH_TRACE) { + tp_err("abnormal touch data point_id %d\r\n",point_id); + break; + } + + events[i].x = ((buf[base] & 0x0F) << 8) + buf[base + 1]; + events[i].y = ((buf[base + 2] & 0x0F) << 8) + buf[base + 3]; + events[i].id = point_id; + events[i].type = (buf[base] >> 6) & 0x03; + events[i].p = buf[base + 4]; + events[i].area = buf[base + 5]; + if (((events[i].type == 0) || (events[i].type == 2)) & (point_num == 0)) { + tp_err("abnormal touch data from fw"); + return EXT_ERR_FAILURE; + } + + touch_event_nums++; + } + + if (touch_event_nums == 0) { + tp_err("no touch point information(%02x)", buf[1]); + return EXT_ERR_FAILURE; + } + + /*print touch information*/ + //log_touch_info(events, touch_event_nums); + + /*Now you have get the touch information, you can report anything(X/Y coordinates...) you want to system*/ + /*TODO...(report touch information to system)*/ + /*Below sample code is a pseudo code*/ + + for (i = 0; i < touch_event_nums; i++) { + #if 0 + if ((events[i].type == 0) || (events[i].type == 2)) { + /* The event of point(point id is events[i].id) is down event, the finger of this id stands for is + * pressing on the screen.*/ + /*TODO...(down event)*/ + } else { + /*TODO...(up event)*/ + } + #endif + switch (events[i].type) { + case 0: + g_ft6x46_drv.touch_msg.tp_event = MC_TP_PRESS; + break; + /* Need To Modify For UI */ + case 2: + g_ft6x46_drv.touch_msg.tp_event = MC_TP_MOVE; + break; + case 1: + g_ft6x46_drv.touch_msg.tp_event = MC_TP_RELEASE; + break; + + default: + tp_err("TOUCH:parse input wrong status|substatus"); + return EXT_ERR_FAILURE; + } + g_ft6x46_drv.touch_msg.tp_event_info.x_axis[0] = events[i].x; + g_ft6x46_drv.touch_msg.tp_event_info.y_axis[0] = events[i].y; + g_ft6x46_drv.touch_msg.tv_usec = (uint32_t)uapi_tcxo_get_ms(); + tp_print("event %d, x %d, y %d, time %d", + g_ft6x46_drv.touch_msg.tp_event, + g_ft6x46_drv.touch_msg.tp_event_info.x_axis[0], + g_ft6x46_drv.touch_msg.tp_event_info.y_axis[0], + g_ft6x46_drv.touch_msg.tv_usec); + } + + return EXT_ERR_SUCCESS; +} + +static ext_errno ft6x46_parse_input(void) +{ + ext_errno ret = EXT_ERR_FAILURE; + uint16_t reg_write; + + if (g_ft6x46_drv.gesture_wakeup == TD_TRUE) { + ret = ft6x46_parse_gesture_input(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:parse gesture input fail 0x%x", ret); + return EXT_ERR_FAILURE; + } + } else { + ret = ft6x46_parse_touch_input(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:parse touch input fail 0x%x", ret); + return EXT_ERR_FAILURE; + } + } + /* clear int */ + reg_write = FT6X46_CLEAR_INT_STATUS_CMD; + ret = tp_i2c_cmd_write(reg_write); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:parse input clear int fail 0x%x", ret); + return EXT_ERR_FAILURE; + } + + return EXT_ERR_SUCCESS; +} + +ext_errno ft6x46_irq_callback(uint8_t *data_buf, uint8_t data_len) +{ + unused(data_len); + g_ft6x46_drv.touch_msg.tp_event = MC_TP_INVALID; + + int32_t mem_ret; + + fts_touch_process(); + + + mem_ret = memcpy_s(data_buf, sizeof(input_event_info), &(g_ft6x46_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; +} + +/* chip id */ +#define FTS_CHIP_IDH 0x64 +#define FTS_CHIP_IDL 0x56 + + +#define FTS_CMD_READ_ID 0x90 + +/* register address */ +#define FTS_REG_CHIP_ID 0xA3 +#define FTS_REG_CHIP_ID2 0x9F + +#define FTS_CMD_START_DELAY 12 + + +static ext_errno ft6x46_power_sequence(void) +{ + ext_errno ret; + uint8_t chip_id[2] = { 0 }; + + /*delay 200ms,wait fw*/ + osDelay(FT6X46_GENERAL_DELAY_200); + + /*get chip id*/ + ret = tp_ft6x46_i2c_data_read(FTS_REG_CHIP_ID, &chip_id[0], 1); + if (ret != EXT_ERR_SUCCESS) { + tp_err("222222222get ic information, error1"); + return EXT_ERR_TP_ZTW523_POWERUP_READ_CHIPID; + } + ret = tp_ft6x46_i2c_data_read(FTS_REG_CHIP_ID2, &chip_id[1], 1); + if (ret != EXT_ERR_SUCCESS) { + tp_err("3333333get ic information, error2"); + return EXT_ERR_TP_ZTW523_POWERUP_READ_CHIPID; + } + // tp_print("11111111111111get ic information, chip id = 0x%02x%02x", chip_id[0], chip_id[1]); + if ((FTS_CHIP_IDH == chip_id[0]) && (FTS_CHIP_IDL == chip_id[1])) { + tp_warning("get ic information, chip id = 0x%02x%02x", chip_id[0], chip_id[1]); + return EXT_ERR_SUCCESS; + } + + // tp_err("fw is invalid, need read boot id"); + ret = tp_ft6x46_i2c_data_write_reg(0x55, 0xAA); + if (ret != EXT_ERR_SUCCESS) { + tp_err("start cmd write fail"); + return ret; + } + + osDelay(FTS_CMD_START_DELAY); + ret = tp_ft6x46_i2c_data_read(FTS_CMD_READ_ID, chip_id, 2); + if((ret == EXT_ERR_SUCCESS) && ((FTS_CHIP_IDH == chip_id[0]) && (FTS_CHIP_IDL == chip_id[1]))) { + tp_err("get ic information, boot id = 0x%02x%02x", chip_id[0], chip_id[1]); + ret = EXT_ERR_SUCCESS; + } else { + tp_err("read boot id fail,read:0x%02x%02x", chip_id[0], chip_id[1]); + return EXT_ERR_FAILURE; + } + return ret; + +} + +static void ft6x46_clear_interrupt(uint8_t retry_times, uint16_t delay) +{ + uint16_t reg_write = FT6X46_CLEAR_INT_STATUS_CMD; + ext_errno ret; + uint8_t times; + for (times = 1; times <= retry_times; times++) { + ret = tp_i2c_cmd_write(reg_write); + if (ret == EXT_ERR_SUCCESS) { + return; + } + osDelay(delay); + } + + if (times > retry_times) { + tp_warning("TOUCH:Clear Int Cmd1! ret = 0x%x", ret); + } +} + +static ext_errno ft6x46_reg_config(void) +{ + ext_errno ret; + // uint16_t reg_write; + + // /* Initial Touch Mode */ + // reg_write = FT6X46_POINT_MODE; +// ret = tp_i2c_reg_write(FT6X46_INITIAL_TOUCH_MODE, reg_write); +// if (ret != EXT_ERR_SUCCESS) { +// return EXT_ERR_TP_ZTW523_CONFIG_INIT_TOUCHMODE; +// } + +// ret = tp_i2c_reg_write(FT6X46_TOUCH_MODE, reg_write); +// if (ret != EXT_ERR_SUCCESS) { +// return EXT_ERR_TP_ZTW523_CONFIG_WRITE_TOUCHMODE; +// } + +// /* Set Finger Num */ +// reg_write = FT6X46_MAX_SUPPORTED_FINGER_NUM; +// ret = tp_i2c_reg_write(FT6X46_SUPPORTED_FINGER_NUM, reg_write); +// if (ret != EXT_ERR_SUCCESS) { +// return EXT_ERR_TP_ZTW523_CONFIG_WRITE_FINGER_NUM; +// } + +// /* Set X Resolution */ +// reg_write = FT6X46_RES_MAX_X; +// ret = tp_i2c_reg_write(FT6X46_X_RESOLUTION, reg_write); +// if (ret != EXT_ERR_SUCCESS) { +// return EXT_ERR_TP_ZTW523_CONFIG_WRITE_XRES; +// } + +// /* Set Y Resolution */ +// reg_write = FT6X46_RES_MAX_Y; +// ret = tp_i2c_reg_write(FT6X46_Y_RESOLUTION, reg_write); +// if (ret != EXT_ERR_SUCCESS) { +// return EXT_ERR_TP_ZTW523_CONFIG_WRITE_YRES; +// } + +// /* Set Lock Point Range */ +// ret = tp_i2c_reg_write(FT6X46_HOLD_POINT_TRESHHOLD, FT6X46_POINT_TRESHHOLD); +// if (ret != EXT_ERR_SUCCESS) { +// return EXT_ERR_TP_ZTW523_CONFIG_WRITE_YRES; +// } + +// /* Write Calib Cmd */ +// reg_write = FT6X46_CALIBRATE_CMD; +// ret = tp_i2c_cmd_write(reg_write); +// if (ret != EXT_ERR_SUCCESS) { +// return EXT_ERR_TP_ZTW523_CONFIG_WRITE_CALIBCMD; +// } + +// /* Write Int Register */ +// reg_write = FT6X46_INT_MASK; +// ret = tp_i2c_reg_write(FT6X46_INT_ENABLE_FLAG, reg_write); +// if (ret != EXT_ERR_SUCCESS) { +// return EXT_ERR_TP_ZTW523_CONFIG_WRITE_INTMASK; +// } +// #ifdef FT6X46_GESTURE_WAKEUP +// /* Write Gesture Register */ +// reg_write = FT6X46_GESTURE_WAKEUP_INIT; +// ret = tp_i2c_reg_write(FT6X46_GESTURE_WAKEUP_REG, reg_write); +// if (ret != EXT_ERR_SUCCESS) { +// return EXT_ERR_TP_ZTW523_CONFIG_WRITE_GESWAKEUP; +// } +// #endif + + 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; + uint16_t reg_write; + uint8_t retry_times; + + if ((g_ft6x46_drv.work_status == FT6X46_WORK_STANDBY) || (g_ft6x46_drv.work_status == FT6X46_WORK_SLEEP)) { + tp_print("alread standby or sleep"); + return EXT_ERR_SUCCESS; + } + /* Disabel Irq */ + ft6x46_set_irq_mode(FT6X46_IRQ_DISABLE, FT6X46_INT_NONE); + + reg_write = FT6X46_POWER_CTL_BEGIN; + ret = tp_i2c_cmd_write(reg_write); + if (ret != EXT_ERR_SUCCESS) { + ft6x46_set_irq_mode(FT6X46_IRQ_ENABLE, FT6X46_INT_MASK); + tp_err("standby failed 0x%x", ret); + return EXT_ERR_FAILURE; + } + /* delay 10 ms */ + osDelay(FT6X46_GENERAL_DELAY_10); + /* Send Clear Int Cmd */ + reg_write = FT6X46_CLEAR_INT_STATUS_CMD; + for (retry_times = 0; retry_times < FT6X46_INIT_RETRY_TIMERS; retry_times++) { + ret = tp_i2c_cmd_write(reg_write); + if (ret == EXT_ERR_SUCCESS) { + break; + } + /* delay 10 ms */ + osDelay(FT6X46_GENERAL_DELAY_10); + } + + /* Send Idle Cmd */ + reg_write = FT6X46_IDLE_CMD; + for (retry_times = 0; retry_times < FT6X46_INIT_RETRY_TIMERS; retry_times++) { + ret = tp_i2c_cmd_write(reg_write); + if (ret == EXT_ERR_SUCCESS) { + break; + } + /* delay 10 ms */ + osDelay(FT6X46_GENERAL_DELAY_10); + } + + reg_write = FT6X46_POWER_CTL_END; + ret = tp_i2c_cmd_write(reg_write); + if (ret != EXT_ERR_SUCCESS) { + ft6x46_set_irq_mode(FT6X46_IRQ_ENABLE, FT6X46_INT_MASK); + tp_err("standby failed 0x%x", ret); + return EXT_ERR_FAILURE; + } + /* delay 10 ms */ + osDelay(FT6X46_GENERAL_DELAY_10); + ft6x46_set_irq_mode(FT6X46_IRQ_ENABLE, FT6X46_INT_MASK); + g_ft6x46_drv.work_status = FT6X46_WORK_STANDBY; + return EXT_ERR_SUCCESS; +} + +ext_errno ft6x46_suspend(void) +{ + ext_errno ret; + // uint16_t reg_write; + // uint8_t retry_times = 0; + + if (g_ft6x46_drv.work_status == FT6X46_WORK_SLEEP) { + tp_print("TOUCH:alread suspend"); + return EXT_ERR_SUCCESS; + } + /*Host writes 0x03 to register address 0xA5 to enter into sleep mode.*/ + ret = tp_ft6x46_i2c_data_write_reg(FTS_REG_POWER_MODE, 0x03); + if(ret != 0) { + tp_err("ft6x46_suspend enter sleep mode fails.ret:0x%X",ret); + return EXT_ERR_FAILURE; + } else { + tp_warning("ft6x46_suspend enter sleep mode success."); + } + + ft6x46_set_irq_mode(FT6X46_IRQ_DISABLE, FT6X46_INT_MASK); + g_ft6x46_drv.work_status = FT6X46_WORK_SLEEP; + + 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; + uint8_t retry_times = 0; + + g_ft6x46_drv.work_status = FT6X46_WORK_RESUME; + + 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 + g_ft6x46_drv.gesture_wakeup = TD_FALSE; +#endif + /* Enable Irq */ + ft6x46_set_irq_mode(FT6X46_IRQ_ENABLE, FT6X46_INT_MASK); + + return EXT_ERR_SUCCESS; + +resume_exit: + + /* Enable Irq */ + ft6x46_set_irq_mode(FT6X46_IRQ_DISABLE, FT6X46_INT_MASK); + + tp_err("resume failed 0x%x", ret); + + return EXT_ERR_FAILURE; +} + +ext_errno ft6x46_get_power_mode(uint32_t *power_mode) +{ + if (power_mode == NULL) { + return EXT_ERR_FAILURE; + } + + *power_mode = (uint32_t)(g_ft6x46_drv.work_status); + + return EXT_ERR_SUCCESS; +} + +static ext_errno ft6x46_set_standby_mode(void) +{ + ext_errno ret; + + ret = ft6x46_standby(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:ft6x46 set standby 0x%x", ret); + return EXT_ERR_FAILURE; + } +#ifdef FT6X46_GESTURE_WAKEUP + g_ft6x46_drv.gesture_wakeup = TD_TRUE; +#endif + return EXT_ERR_SUCCESS; +} + +static ext_errno ft6x46_set_sleep_mode(void) +{ + ext_errno ret; + + ret = ft6x46_suspend(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:ft6x46 set suspend fail 0x%x", ret); + } +#ifdef FT6X46_GESTURE_WAKEUP + g_ft6x46_drv.gesture_wakeup = TD_FALSE; +#endif + g_ft6x46_drv.work_status = FT6X46_WORK_SLEEP; + return EXT_ERR_SUCCESS; +} + +static ext_errno ft6x46_set_normal_mode(void) +{ + ext_errno ret; + uint16_t reg_write; + + if (g_ft6x46_drv.work_status == FT6X46_WORK_NORMAL) { + return EXT_ERR_SUCCESS; + } + + reg_write = FT6X46_SDRAM_RESET; + ret = tp_i2c_cmd_write(reg_write); + if (ret != EXT_ERR_SUCCESS) { + return EXT_ERR_FAILURE; + } + /* delay 50ms */ + osDelay(FT6X46_GENERAL_DELAY_50); + ret = ft6x46_power_sequence(); + if (ret != EXT_ERR_SUCCESS) { + return EXT_ERR_FAILURE; + } + ft6x46_set_irq_mode(FT6X46_IRQ_ENABLE, FT6X46_INT_MASK); + g_ft6x46_drv.work_status = FT6X46_WORK_NORMAL; +#ifdef FT6X46_GESTURE_WAKEUP + g_ft6x46_drv.gesture_wakeup = TD_FALSE; +#endif + return EXT_ERR_SUCCESS; +} + +ext_errno ft6x46_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 = ft6x46_set_sleep_mode(); + break; + case MC_TP_NORMAL_WORK_MODE: + case MC_TP_RESUME_SCAN: + ret = ft6x46_set_normal_mode(); + break; + case MC_TP_STANDBY_WORK_MODE: + ret = ft6x46_set_standby_mode(); + break; + default: + tp_err("TOUCH:ft6x46 not support powermode 0x%x", power_mode); + ret = EXT_ERR_FAILURE; + break; + } + + return ret; +} + +static ext_errno ft6x46_config(void) +{ + ext_errno ret; + + /* Step 1 hardware reset */ + ret = ft6x46_reset(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:Init reset fail 0x%x", ret); + return EXT_ERR_TP_ZTW523_INIT_RESET; + } + + /* Step 2 power up */ + ret = ft6x46_power_sequence(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:init powerup fail 0x%x", ret); + return EXT_ERR_TP_ZTW523_INIT_POWERUP; + } + +#if 0 + /* Step 3 configuration */ + ret = ft6x46_configuration(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:init config fail 0x%x", ret); + return EXT_ERR_TP_ZTW523_INIT_CONFIG; + } + + /* Step 3 Panel Info */ + ret = ft6x46_get_panel_info(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:init get panelinfo fail 0x%x", ret); + return EXT_ERR_TP_ZTW523_INIT_GETINFO; + } +#endif + + /* Record Status For Init */ + g_ft6x46_drv.chip_status = FT6X46_READY; + g_ft6x46_drv.work_status = FT6X46_WORK_NORMAL; + + return EXT_ERR_SUCCESS; +} + +static ext_errno ft6x46_resource_deinit(void) +{ + g_ft6x46_drv.work_status = FT6X46_WORK_INVALID; + g_ft6x46_drv.fw_upgrade_flag = TD_FALSE; + osal_mutex_destroy(&g_ft6x46_drv.ops_mux); + + return EXT_ERR_SUCCESS; +} + +ext_errno ft6x46_init(void) +{ + ext_errno ret = EXT_ERR_FAILURE; + ext_errno err_ret; + + /* create tp operation mutex */ + if (g_ft6x46_drv.ops_mux.mutex == NULL) { + ret = osal_mutex_init(&(g_ft6x46_drv.ops_mux)); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:ft6x46 init create mux lock fail 0x%x", ret); + return EXT_ERR_FAILURE; + } + } + + /* get tp operater mutex */ + ret = osal_mutex_lock_timeout(&g_ft6x46_drv.ops_mux, FT6X46_OPERATER_MUTEX_WAIT_TIME); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:ft6x46 init wait mux lock fail 0x%x", ret); + goto init_fail; + } + + /* tp hardware reset and init */ + ret = ft6x46_config(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:ft6x46 init fail 0x%x", ret); + goto init_fail; + } + + /* release tp operater mutex */ + osal_mutex_unlock(&g_ft6x46_drv.ops_mux); + + tp_print("TOUCH:ft6x46 init succ!"); + return EXT_ERR_SUCCESS; + +init_fail: + /* release tp operater mutex */ + osal_mutex_unlock(&g_ft6x46_drv.ops_mux); + err_ret = ft6x46_resource_deinit(); + if (err_ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH:delete mux lock err! ret = 0x%x", err_ret); + } + return ret; +} + +ext_errno ft6x46_deinit(void) +{ + ext_errno ret = ft6x46_resource_deinit(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("TOUCH: ft6x46 deinit fail! ret = 0x%x", ret); + return ret; + } + + return EXT_ERR_SUCCESS; +} + +#ifdef __cplusplus +#if __cplusplus + } +#endif +#endif diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_touch1.h b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_touch1.h new file mode 100644 index 000000000..b0e57762f --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/ft6x46_touch/ft6x46_touch1.h @@ -0,0 +1,421 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. + * Description: ztw523 touch driver. + * Author: @CompanyNameTag + * Create: 2021-05-29 + */ + +#ifndef FT6X46_TOUCH1_H +#define FT6X46_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 + +/* ztw523 definitions */ +/* max wait time */ +#define FT6X46_OPERATER_MUTEX_WAIT_TIME 3000 /* operater tp mutex timeout ms */ +#define FT6X46_CMCP_WAIT_TIMEOUT 1000 +/* define some properties value */ +#define FT6X46_ENABLE 0x0001 +#define FT6X46_DISABLE 0x0000 +#define FT6X46_DATA_LEN 2 +#define FT6X46_POWERON_DELAY 100 +#define FT6X46_POWEROFF_DELAY 100 +#define FT6X46_RESETHIGH_DELAY 10 +#define FT6X46_CLEARINT_DELAY 10 +#define FT6X46_FIRMWAREON_DELAY 200 +#define FT6X46_INIT_RETRY_TIMERS 3 +#define FT6X46_SETMODE_RETRY_TIMERS 3 +#define FT6X46_SOFTRESET_RETRY_TIMES 10 +#define FT6X46_RETRY_TIMES 10 +#define FT6X46_DEVICE_INFO "zinitix,ft6x46" +#define FT6X46_DEVICE_INFO_SIZE sizeof(FT6X46_DEVICE_INFO) +#define FT6X46_MAX_SUPPORTED_FINGER_NUM 1 +#define FT6X46_POINT_MODE 1 +#define FT6X46_CALIB_TOUCH_MODE 0x07 +#define FT6X46_REGDATA_SHIFT 8 +#define FT6X46_GENERAL_DELAY_1 1 +#define FT6X46_GENERAL_DELAY_5 5 +#define FT6X46_GENERAL_DELAY_10 10 +#define FT6X46_GENERAL_DELAY_20 20 +#define FT6X46_GENERAL_DELAY_25 25 +#define FT6X46_GENERAL_DELAY_30 30 +#define FT6X46_GENERAL_DELAY_50 50 +#define FT6X46_GENERAL_DELAY_100 100 +#define FT6X46_GENERAL_DELAY_200 200 +#define FT6X46_GENERAL_DELAY_500 500 +#define FT6X46_GENERAL_RETRY_1 1 +#define FT6X46_GENERAL_RETRY_2 2 +#define FT6X46_GENERAL_RETRY_3 3 +#define FT6X46_GENERAL_RETRY_4 4 +#define FT6X46_GENERAL_RETRY_10 10 +#define FT6X46_RAWDATA_DELAY_FOR_HOST 100 +#define FT6X46_FW_JUMP_CODE 0x0048 +#define FT6X46_REPORT_RATE 60 +#define FT6X46_PIXEL_THRESHOLD 5 + +#ifndef FT6X46_RES_MAX_X +#define FT6X46_RES_MAX_X 466 +#endif + +#ifndef FT6X46_RES_MAX_Y +#define FT6X46_RES_MAX_Y 466 +#endif + +#ifndef FT6X46_POINT_TRESHHOLD +#define FT6X46_POINT_TRESHHOLD 0x19 +#endif + +#define FT6X46_TOUCHINFO_HEAD_LEN 4 +#define FT6X46_POINTINFO_LEN 6 +#define FT6X46_TOUCHINFO_LEN (FT6X46_TOUCHINFO_HEAD_LEN + FT6X46_POINTINFO_LEN * FT6X46_MAX_SUPPORTED_FINGER_NUM) + +#define FT6X46_INT_NONE 0x0000 +#define FT6X46_INT_MASK 0x081F +#define FT6X46_PALM_MASK 0x0010 +#define FT6X46_GESTURE_WAKEUP_INIT 0 +#define FT6X46_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 FT6X46_CHIP_ID 0xE628 +/* define touch info offset */ +#define FT6X46_STATUSL_OFFSET 0 +#define FT6X46_STATUSH_OFFSET 1 +#define FT6X46_EVENTL_OFFSET 2 +#define FT6X46_EVENTH_OFFSET 3 +#define FT6X46_XL_OFFSET 4 +#define FT6X46_XH_OFFSET 5 +#define FT6X46_YL_OFFSET 6 +#define FT6X46_YH_OFFSET 7 +#define FT6X46_WIDTH_OFFSET 8 +#define FT6X46_SUBSTATUS_OFFSET 9 +/* define data shift and mask */ +#define FT6X46_SHIFT_8_BIT 8 +#define FT6X46_SHIFT_16_BIT 16 +#define FT6X46_SHIFT_24_BIT 24 +#define FT6X46_MASK_BYTE 0xFF +/* define FT6X46_HIGH_SPEED_DMA rely on iic dma support */ +#ifdef FT6X46_HIGH_SPEED_DMA +#define FT6X46_TOUCH_POINT_MODE 0 +#else +#define FT6X46_TOUCH_POINT_MODE 1 +#endif + +#define FT6X46_SEC_MODE 48 +#define FT6X46_NORMAL_MODE 5 +#define FT6X46_DND_MODE 11 /* mutual cap */ +#define FT6X46_SELF_DND_MODE 17 /* self cap */ +#define FT6X46_DNDSKIP_CNT 1 +#define FT6X46_SELFDNDSKIP_CNT 1 +/* Config Reg Info */ +#define FT6X46_REG_CMD_ENABLE 0xC000 +#define FT6X46_REG_CHIP_ID 0xCC00 +#define FT6X46_REG_INTN_CLEAR 0xC004 +#define FT6X46_REG_NVM 0xC002 +#define FT6X46_REG_NVM_VPP 0xC003 +#define FT6X46_REG_NVM_WP 0xC104 +#define FT6X46_REG_PROGRAM_START 0xC001 +#define FT6X46_POWER_CTL_BEGIN 0x000A +#define FT6X46_POWER_CTL_END 0x000B +#define FT6X46_CALIB_CTL1 0xC003 +#define FT6X46_CALIB_CTL2 0xC104 +#define FT6X46_SDRAM_RESET 0x0FF8 +#define FT6X46_REPORT_REG 0x0186 /* 设置中断上报频率 */ +#define FT6X46_PIXEL_THRESHOLD_REG 0x00C3 +/* Register Map */ +#define FT6X46_SWRESET_CMD 0x0000 +#define FT6X46_WAKEUP_CMD 0x0001 +#define FT6X46_IDLE_CMD 0x0004 +#define FT6X46_SLEEP_CMD 0x0005 +#define FT6X46_CLEAR_INT_STATUS_CMD 0x0003 +#define FT6X46_CALIBRATE_CMD 0x0006 +#define FT6X46_SAVE_STATUS_CMD 0x0007 +#define FT6X46_SAVE_CALIBRATION_CMD 0x0008 +#define FT6X46_RECALL_FACTORY_CMD 0x000f +#define FT6X46_SENSITIVITY 0x0020 +#define FT6X46_I2C_CHECKSUM_WCNT 0x016a +#define FT6X46_I2C_CHECKSUM_RESULT 0x016c +#define FT6X46_DEBUG_REG 0x0115 /* 0~7 */ +#define FT6X46_TOUCH_MODE 0x0010 +#define FT6X46_CHIP_REVISION 0x0011 +#define FT6X46_FIRMWARE_VERSION 0x0012 +#define FT6X46_MINOR_FW_VERSION 0x0121 +#define FT6X46_DATA_VERSION_REG 0x0013 +#define FT6X46_HW_ID 0x0014 +#define FT6X46_SUPPORTED_FINGER_NUM 0x0015 +#define FT6X46_EEPROM_INFO 0x0018 +#define FT6X46_INITIAL_TOUCH_MODE 0x0019 +#define FT6X46_CHIP_HW_REVISION 0x001A +#define FT6X46_IC_VENDOR_ID 0x001C +#define FT6X46_TSM_MODULE_ID 0x001E +#define FT6X46_TOTAL_NUMBER_OF_X 0x0060 +#define FT6X46_TOTAL_NUMBER_OF_Y 0x0061 +#define FT6X46_DELAY_RAW_FOR_HOST 0x007f +#define FT6X46_BUTTON_SUPPORTED_NUM 0x00B0 +#define FT6X46_BUTTON_SENSITIVITY 0x00B2 +#define FT6X46_X_RESOLUTION 0x00C0 +#define FT6X46_Y_RESOLUTION 0x00C1 +#define FT6X46_HOLD_POINT_TRESHHOLD 0x00C3 +#define FT6X46_POINT_STATUS_REG 0x0080 +#define FT6X46_ICON_STATUS_REG 0x00AA +#define FT6X46_AFE_FREQUENCY 0x0100 +#define FT6X46_DND_N_COUNT 0x0122 +#define FT6X46_DND_U_COUNT 0x0135 +#define FT6X46_RAWDATA_REG 0x0200 +#define FT6X46_EEPROM_INFO_REG 0x0018 +#define FT6X46_INT_ENABLE_FLAG 0x00f0 +#define FT6X46_PERIODICAL_INTERRUPT_INTERVAL 0x00f1 +#define FT6X46_CHECKSUM_RESULT 0x012c +#define FT6X46_GESTURE_WAKEUP_REG 0x0126 + +#define FT6X46_TOUCHINFO_MASK 0x0F +#define FT6X46_TOUCH_EXIST 0x01 +#define FT6X46_TOUCH_DOWN 0x03 +#define FT6X46_TOUCH_MOVE 0x05 +#define FT6X46_TOUCH_UP 0x08 +#define FT6X46_TOUCH_NONE 0x07 + +#define FT6X46_SUB_BIT_EXIST 0 +#define FT6X46_SUB_BIT_DOWN 1 +#define FT6X46_SUB_BIT_MOVE 2 +#define FT6X46_SUB_BIT_UP 3 +#define FT6X46_SUB_BIT_UPDATE 4 +#define FT6X46_SUB_BIT_WAIT 5 + +#ifndef FT6X46_TSP_X_CHANNEL_NUM +#define FT6X46_TSP_X_CHANNEL_NUM 6 +#endif + +#ifndef FT6X46_TSP_Y_CHANNEL_NUM +#define FT6X46_TSP_Y_CHANNEL_NUM 6 +#endif + +#define FT6X46_TSP_DND_NUM (FT6X46_TSP_X_CHANNEL_NUM * FT6X46_TSP_Y_CHANNEL_NUM) +#define FT6X46_TSP_SELFDND_NUM (FT6X46_TSP_X_CHANNEL_NUM + FT6X46_TSP_Y_CHANNEL_NUM) + +/* firmware info */ +#define FT6X46_FIRMWARE_VERSION_L 0 +#define FT6X46_FIRMWARE_VERSION_H 1 +#define FT6X46_FIRMWARE_VERSION_OFFSET 52 +#define FT6X46_FIRMWARE_MINOR_VERSION_OFFSET 56 +#define FT6X46_FIRMWARE_DATA_VERSION_OFFSET 60 +#define FT6X46_FIRMWARE_OFFSET_ZERO 0 +#define FT6X46_FIRMWARE_CONVERT_DATA_STEP 2 +#define FT6X46_FIRMWARE_CONVERT_DATA_OFFSET 1 +/* file op code */ +#define FT6X46_FILE_ERROR (-1) +#define FT6X46_FILE_OK 0 +/* upgrade info */ +#define FT6X46_FWGRADE_CMD_NUM 3 +/* rawdata info */ +#define FT6X46_RAWDATA_CMD_NUM 2 +/* define gesture macro */ +#define FT6X46_GESTURE_WAKEUP 1 + +/* self_dnd dnd parameter */ +#define FT6X46_SEC_SELF_DND_N_COUNT 15 +#define FT6X46_SEC_SELF_DND_U_COUNT 2 +#define FT6X46_SEC_SELF_DND_FREQUENCY 80 + +#define FT6X46_SEC_DND_N_COUNT 27 +#define FT6X46_SEC_DND_U_COUNT 3 +#define FT6X46_SEC_DND_FREQUENCY 240 + +/* host peripheral typedef */ +typedef ext_errno (*tp_irq_callback)(void); + +/* ZTW523 driver typedef */ +typedef enum { + FT6X46_POWERDOWN = 0, + FT6X46_POWERUP, +} ft6x46_sw_power_status; + +typedef enum { + FT6X46_WORK_NORMAL = 0, + FT6X46_WORK_STANDBY, + FT6X46_WORK_GETCMCP, + FT6X46_WORK_SLEEP, + FT6X46_WORK_SUSPEND, + FT6X46_WORK_RESUME, + FT6X46_WORK_INVALID, +} ft6x46_work_status; + +typedef enum { + FT6X46_NOT_READY = 0, + FT6X46_READY, +} ft6x46_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 { + FT6X46_GESTURE_NONE = 0, + FT6X46_GESTURE_SIGNAL_CLICK = 1, + FT6X46_GESTURE_DOUBLE_CLICK = 2, + FT6X46_GESTURE_SLIDE_UP = 4, + FT6X46_GESTURE_SLIDE_DOWN = 5, +} ft6x46_gesture_event; + +typedef enum { + FT6X46_IRQ_DISABLE = 0, + FT6X46_IRQ_ENABLE, +} ft6x46_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; +} ft6x46_panel_data; + +typedef struct { + uint32_t skip_cnt; + int16_t dnd_data[FT6X46_TSP_DND_NUM]; + int16_t self_dnd_data[FT6X46_TSP_SELFDND_NUM]; +} ft6x46_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[FT6X46_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; + ft6x46_sw_power_status power_status; + ft6x46_work_status work_status; + ft6x46_sw_power_status chip_sw_power_status; + ft6x46_device_status chip_status; + input_event_info touch_msg; + ft6x46_panel_data panel_info; + tp_peripheral_attr dev_attr; + ft6x46_tsp_rawdata tsp_raw_data; + void *p_void; + uint32_t tp_event; + touch_drv_upgrade_proc upgrade_table[FT6X46_FWGRADE_CMD_NUM]; + touch_drv_rawdata_proc raw_data_table[FT6X46_RAWDATA_CMD_NUM]; +} ft6x46_drv_data; + +ext_errno ft6x46_init(void); +ext_errno ft6x46_deinit(void); +ext_errno ft6x46_set_power_mode(tp_work_mode power_mode); +ext_errno ft6x46_get_power_mode(uint32_t *power_mode); +ext_errno ft6x46_resume(void); +ext_errno ft6x46_suspend(void); +ext_errno ft6x46_irq_callback(uint8_t *data_buf, uint8_t data_len); +ext_errno ft6x46_host_init_sample(void); +#ifdef __cplusplus +#if __cplusplus + } +#endif +#endif + +#endif diff --git a/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.c b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.c new file mode 100644 index 000000000..077ab322c --- /dev/null +++ b/fd230_driver_patch/0906patch_driver_patch/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.c @@ -0,0 +1,493 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2021-2021. All rights reserved. + * Description: touch screen driver. + * Author: @CompanyNameTag + * Create: 2022-04-12 + */ + +#include "touch_screen_drv.h" +#include "tcxo.h" +#include "i2c.h" +#include "common_def.h" +#include "soc_osal.h" +#include "touch_screen_def.h" +#include "input_app.h" +#if defined(TPTYPE_TMA525B) +#include "tma525b_drv1.h" +#include "tma525b_ctrl.h" +#elif defined(TPTYPE_ZTW523) +#include "ztw523_drv1.h" +#include "ztw523_ctrl.h" +#elif defined(TPTYPE_FT6X46) +#include "ft6x46_drv1.h" +#include "ft6x46_ctrl.h" +#else +#include "ztw523_drv1.h" +#include "ztw523_ctrl.h" +#endif + +#if defined(TPTYPE_TMA525B) +#define TOUCH_I2C_BUS TMA525B_I2C_BUS +#define TOUCH_INT_GPIO TMA525B_INT_GPIO +#define TOUCH_RESET_GPIO TMA525B_RESET_GPIO +#elif defined(TPTYPE_ZTW523) +#define TOUCH_I2C_BUS ZTW523_I2C_BUS +#define TOUCH_INT_GPIO ZTW523_INT_GPIO +#define TOUCH_RESET_GPIO ZTW523_RESET_GPIO +#elif defined(TPTYPE_FT6X46) +#define TOUCH_I2C_BUS FT6X46_I2C_BUS +#define TOUCH_INT_GPIO FT6X46_INT_GPIO +#define TOUCH_RESET_GPIO FT6X46_RESET_GPIO +#else +#define TOUCH_I2C_BUS ZTW523_I2C_BUS +#define TOUCH_INT_GPIO ZTW523_INT_GPIO +#define TOUCH_RESET_GPIO ZTW523_RESET_GPIO +#endif + +#define TOUCH_SCREEN_DEV_NAME_LEN 16 +#define TOUCH_SCREEN_DEVNAME "input/event" +#define TOUCH_SCREEN_DYNAMIC_MINOR 65 +#define TOUCH_SCREEN_CMDID_MAX 16 + +#define TOUCH_SCREEN_TASK_PRIO 5 +#define TOUCH_SCREEN_TASK_SIZE 0x800 +#define TOUCH_SCREEN_QUEUE_MAX_SIZE 60 +#define TOUCH_SCREEN_READY_EVENT (1 << 0) + +struct ts_driver_data g_touch_drv = {0}; +struct ts_driver_data *g_attr = NULL; + +report_event_cb g_report_event_cb = NULL; + +#if defined(SUPPORT_POWER_MANAGER) +event_callback_func g_power_manager_cb = NULL; +#endif + +static struct ts_driver_data *touch_screen_get_driver_data(void) +{ + return &g_touch_drv; +} + +static uint32_t touch_screen_get_state(struct ts_driver_data *tsdd) +{ + if (tsdd != NULL && tsdd->queue != NULL) { + return (uint32_t)ts_queue_is_empty(tsdd->queue); + } + + if (tsdd == NULL) { + tp_err("tsdd is null!"); + return EXT_ERR_FAILURE; + } + if (tsdd->queue == NULL) { + tp_err("tsdd queue is null!"); + } + + return EXT_ERR_FAILURE; +} + +static void convert_touch_info(input_dev_data_t* data, input_event_info* touch_info) +{ + data->x = (int16_t)touch_info->tp_event_info.x_axis[0]; + data->y = (int16_t)touch_info->tp_event_info.y_axis[0]; + data->type = INDEV_TYPE_TOUCH; + data->timestamp = (uint32_t)touch_info->tv_usec; + if ((touch_info->tp_event == MC_TP_PRESS) || (touch_info->tp_event == MC_TP_MOVE)) { + data->state = INDEV_STATE_PRESS; + } else if (touch_info->tp_event == MC_TP_RELEASE) { + data->state = INDEV_STATE_RELEASE; + } else { + data->state = INDEV_STATE_UNKNOWN; + } +} + +static void report_or_enqueue_event(input_event_info* touch_info, struct ts_driver_data *tsdd) +{ + if (g_report_event_cb != NULL) { + input_dev_data_t data; + convert_touch_info(&data, touch_info); + if (data.state == INDEV_STATE_UNKNOWN) { + return; + } + g_report_event_cb(&data); + } else { + int32_t ret = ts_en_queue(tsdd->queue, touch_info); + if (ret != EXT_ERR_SUCCESS) { + tp_err("Failed to enqueue ts queue! ret=0x%x", ret); + } + } +} + +#if defined(SUPPORT_POWER_MANAGER) +static void report_event_to_power_manager(input_event_info *touch_info) +{ + if (g_power_manager_cb != NULL) { + input_dev_data_t data; + convert_touch_info(&data, touch_info); + if (data.state == INDEV_STATE_UNKNOWN) { + return; + } + g_power_manager_cb(data.state, 0); + } + return; +} + +uint32_t ts_register_power_manager_cb(event_callback_func callback) +{ + if (g_power_manager_cb != NULL) { + return EXT_ERR_FAILURE; + } + g_power_manager_cb = callback; + return EXT_ERR_SUCCESS; +} +#endif +ext_errno touch_info_process(void) +{ + struct ts_driver_data *tsdd = touch_screen_get_driver_data(); + input_event_info touch_info; + int32_t ret = 0; + + if (tsdd->touch_api->touch_get_tpinfo != NULL) { + ret = tsdd->touch_api->touch_get_tpinfo((uint8_t *)(&touch_info), sizeof(input_event_info)); + if (ret != EXT_ERR_SUCCESS) { + tp_err("get touch info fail! ret=0x%x", ret); + return ret; + } + + report_or_enqueue_event(&touch_info, tsdd); +#if defined(SUPPORT_POWER_MANAGER) + report_event_to_power_manager(&touch_info); +#endif + } + + return EXT_ERR_SUCCESS; +} + +static void ts_callback_func(void) +{ + ext_errno ret; + if (g_attr != NULL) { + common_notify_mail_t mail = {0}; + mail.comm.app = APP_TOUCH; + ret = osal_msg_queue_write_copy(get_app_queue_id(), (void *)&mail, + sizeof(common_notify_mail_t), 0); + if (ret != OSAL_SUCCESS) { + tp_err("touch app msg send failed! err=0x%x! \r\n", ret); + } + } +} + +static ext_errno ts_register_callback(struct ts_driver_data *attr) +{ + ext_errno ret = EXT_ERR_FAILURE; + g_attr = attr; + + if (attr->touch_api->register_callback != NULL) { + ret = attr->touch_api->register_callback(attr->private_data, ts_callback_func); + if (ret != EXT_ERR_SUCCESS) { + tp_err("register touch screen callback fail! ret=0x%x", ret); + return ret; + } + } else { + tp_err("touch screen callback register func is empty!"); + } + + return ret; +} + +static ext_errno ts_unregister_callback(struct ts_driver_data *attr) +{ + ext_errno ret = EXT_ERR_FAILURE; + + if (attr->touch_api->unregister_callback != NULL) { + ret = attr->touch_api->unregister_callback(attr->private_data); + if (ret != EXT_ERR_SUCCESS) { + tp_err("unregister touch screen callback fail! ret=0x%x", ret); + return ret; + } + g_attr = NULL; + } else { + tp_err("touch screen callback unregister func is empty!"); + } + + return ret; +} + +static int32_t ts_dev_open(const void *private_data) +{ + int32_t ret; + struct ts_driver_data *tsdd = NULL; + if (private_data == NULL) { + tp_err("ts_open: invalid dev or driver_data!\n"); + return EXT_ERR_FAILURE; + } + + // todo: get tsdd from private_data + tsdd = touch_screen_get_driver_data(); + tsdd->queue = ts_init_queue(TOUCH_SCREEN_QUEUE_MAX_SIZE); + if (tsdd->queue == NULL) { + tp_err("create touch screen queue fail!\r\n"); + return EXT_ERR_FAILURE; + } + ret = osal_event_init(&(tsdd->event)); + if (ret != EXT_ERR_SUCCESS) { + tp_err("touch osal_event_init fail! ret=0x%x\r\n", ret); + return ret; + } + + tsdd->task_handle = osal_kthread_create((osal_kthread_handler)touch_info_process, + (void *)touch_screen_get_driver_data(), + "touch_screen", TOUCH_SCREEN_TASK_SIZE); + if (tsdd->task_handle == NULL) { + tp_err("create touch screen thread fail!\r\n"); + return EXT_ERR_FAILURE; + } + osal_kthread_set_priority(tsdd->task_handle, TOUCH_SCREEN_TASK_PRIO); + + if (tsdd->touch_api->touch_init != NULL) { + ret = tsdd->touch_api->touch_init(tsdd->private_data); + if (ret != EXT_ERR_SUCCESS) { + tp_err("touch_init fail! ret=0x%x\r\n", ret); + return ret; + } + } + + ret = ts_register_callback(tsdd); + if (ret != EXT_ERR_SUCCESS) { + tp_err("register callback fail! ret=0x%x\r\n", ret); + return ret; + } + + return EXT_ERR_SUCCESS; +} + +static int32_t ts_dev_release(const void *private_data) +{ + int32_t ret; + struct ts_driver_data *tsdd = NULL; + if (private_data == NULL) { + tp_err("ts_dev_release: invalid dev or driver_data!\n"); + return EXT_ERR_FAILURE; + } + + // todo: get tsdd from private_data + tsdd = touch_screen_get_driver_data(); + ret = ts_unregister_callback(tsdd); + if (ret != EXT_ERR_SUCCESS) { + tp_err("unregister callback fail! ret=0x%x\r\n", ret); + return ret; + } + return EXT_ERR_SUCCESS; +} + +static uint32_t ts_dev_poll(const osal_poll *osal_poll, const void *private_data) +{ + unused(osal_poll); + unused(private_data); + // todo: get tsdd from private_data + struct ts_driver_data *tsdd = NULL; + tsdd = touch_screen_get_driver_data(); + if (tsdd == NULL) { + tp_err("ts_driver_data is NULL"); + return EXT_ERR_FAILURE; + } + + if (tsdd->ops->priv_operator != NULL && tsdd->ops->priv_operator(tsdd) == 0) { + return OSAL_POLLIN | OSAL_POLLRDNORM; + } + + return EXT_ERR_SUCCESS; +} + +static int32_t ts_ioctl_read_touch_info(uint32_t cmd, void *arg, const void *private_data) +{ + unused(cmd); + ext_errno ret; + struct ts_driver_data *tsdd = NULL; + input_event_info *touch_info = (input_event_info *)arg; + + if (private_data == NULL) { + tp_err("invalid dev or driver_data!"); + return EXT_ERR_FAILURE; + } + + // todo: get tsdd from private_data + tsdd = touch_screen_get_driver_data(); + if (tsdd->queue == NULL) { + tp_err("invalid touch screen queue!"); + return EXT_ERR_FAILURE; + } + + ret = ts_de_queue(tsdd->queue, touch_info); + if (ret != EXT_ERR_SUCCESS) { + tp_err("get touch info fail! ret=0x%x", ret); + return ret; + } + + return EXT_ERR_SUCCESS; +} + +static osal_ioctl_cmd g_ts_cmd_list[TOUCH_SCREEN_CMDID_MAX] = { + {TOUCH_SCREEN_GET_EVENT, ts_ioctl_read_touch_info}, +}; + +static osal_dev *g_ts_dev = NULL; +static osal_fileops g_ts_ops = { + .open = ts_dev_open, + .release = ts_dev_release, + .poll = ts_dev_poll, + .cmd_list = g_ts_cmd_list, + .cmd_cnt = sizeof(g_ts_cmd_list) / sizeof(g_ts_cmd_list[0]), +}; + +struct ts_ops g_ts_status_ops = { + .priv_operator = touch_screen_get_state, +}; + +static ext_errno touch_screen_register_device(void) +{ + ext_errno ret; + + g_touch_drv.private_data = touch_screen_get_peri_attr(); + g_touch_drv.touch_api = touch_screen_get_api(); + g_touch_drv.ops = &g_ts_status_ops; + g_ts_dev = osal_dev_create(TOUCH_SCREEN_DEVNAME); + g_ts_dev->minor = TOUCH_SCREEN_DYNAMIC_MINOR; + g_ts_dev->fops = &g_ts_ops; + + ret = osal_dev_register(g_ts_dev); + if (ret != 0) { + tp_err("touch screen osal_dev_register --------failed! ret=0x%x\n", ret); + return EXT_ERR_FAILURE; + } + + return EXT_ERR_SUCCESS; +} + +ext_errno touch_screen_module_init(void) +{ + ext_errno ret; + + ret = touch_screen_register_device(); + if (ret != EXT_ERR_SUCCESS) { + tp_err("touch_screen_register_device ----------failed! ret=0x%x\n", ret); + } + tp_err("touch_screen_register_device ----------succ!!!\n"); + + return EXT_ERR_SUCCESS; +} + +ext_errno touch_screen_module_deinit(void) +{ + return EXT_ERR_SUCCESS; +} + +uint32_t ts_register_report_event_cb(report_event_cb callback) +{ + if (g_report_event_cb != NULL) { + return EXT_ERR_FAILURE; + } + g_report_event_cb = callback; + return EXT_ERR_SUCCESS; +} + +uint32_t ts_unregister_report_event_cb(void) +{ + g_report_event_cb = NULL; + return EXT_ERR_SUCCESS; +} + +uint32_t ts_init(void) +{ + int32_t ret; + struct ts_driver_data *tsdd = NULL; + + g_touch_drv.private_data = touch_screen_get_peri_attr(); + g_touch_drv.touch_api = touch_screen_get_api(); + g_touch_drv.ops = &g_ts_status_ops; + tsdd = touch_screen_get_driver_data(); + tsdd->queue = ts_init_queue(TOUCH_SCREEN_QUEUE_MAX_SIZE); + if (tsdd->queue == NULL) { + tp_err("create touch screen queue fail!\r\n"); + return EXT_ERR_FAILURE; + } + + ret = ts_register_callback(tsdd); + if (ret != EXT_ERR_SUCCESS) { + tp_err("register callback fail! ret=0x%x\r\n", ret); + return EXT_ERR_FAILURE; + } + + return EXT_ERR_SUCCESS; +} + +uint32_t ts_read(const input_dev_data_t* data) +{ + unused(data); + return EXT_ERR_SUCCESS; +} + +uint32_t ts_close(void) +{ + return EXT_ERR_SUCCESS; +} + +void touch_screen_suspend(void) +{ + touch_peripheral_api *touch_ptr = touch_screen_get_api(); + ext_errno ret = touch_ptr->touch_sleep(); + if (ret != EXT_ERR_SUCCESS) { tp_err("touch sleep ret=0x%x", ret); } +#if defined(TPTYPE_FT6X46) + if (ft6x46_suspend() == EXT_ERR_SUCCESS){ + i2c_save_reg(TOUCH_I2C_BUS); + uapi_gpio_disable_interrupt(TOUCH_INT_GPIO); // close tp_int gpio interrupt + } +#else + i2c_save_reg(TOUCH_I2C_BUS); + uapi_gpio_disable_interrupt(TOUCH_INT_GPIO); // close tp_int gpio interrupt +#endif +} + +void touch_screen_resume(void) +{ + uapi_gpio_disable_interrupt(TOUCH_INT_GPIO); // close tp_int gpio interrupt + i2c_recovery_reg(TOUCH_I2C_BUS); +#if defined(TPTYPE_TMA525B) + tma525b_init(); + 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_ZTW523) + ztw523_resume(); +#elif defined(TPTYPE_FT6X46) + ft6x46_resume(); +#else + ztw523_resume(); +#endif + uapi_gpio_enable_interrupt(TOUCH_INT_GPIO); // open tp_int gpio interrupt +} + +void touch_suspend_for_i2c(void) +{ + i2c_save_reg(TOUCH_I2C_BUS); +} + +void touch_resume_for_i2c(void) +{ + i2c_recovery_reg(TOUCH_I2C_BUS); +} + +void touch_screen_restart(void) +{ + uapi_i2c_deinit(TOUCH_I2C_BUS); + uapi_i2c_master_init(TOUCH_I2C_BUS, 400000, I2C_SPEED_MODE_FS); /* 400000: 400KHz */ +#if defined(TPTYPE_TMA525B) + tma525b_resume(); +#elif defined(TPTYPE_ZTW523) + ztw523_resume(); +#elif defined(TPTYPE_FT6X46) + ft6x46_resume(); +#else + ztw523_resume(); +#endif + uapi_gpio_enable_interrupt(TOUCH_INT_GPIO); // open tp_int gpio interrupt +} -- 2.17.1