From: SnickerSun Date: Mon, 8 Apr 2024 08:57:23 +0000 (+0800) Subject: 优化touch驱动，添加休眠处理 X-Git-Tag: release_V1.2.70_20241020_135402~1200^2~22^2~2 X-Git-Url: http://git.snicker.com.cn/css/static/gitweb.css?a=commitdiff_plain;h=8c15f08bb16e1e4781029e3e6bacfb80f78f170d;p=mirrors%2FFD230.git 优化touch驱动，添加休眠处理 --- diff --git a/code/sdk/application/brandy/brandy_standard/thread_pri_init.c b/code/sdk/application/brandy/brandy_standard/thread_pri_init.c index 1c90a9199..4966c2d43 100755 --- a/code/sdk/application/brandy/brandy_standard/thread_pri_init.c +++ b/code/sdk/application/brandy/brandy_standard/thread_pri_init.c @@ -111,7 +111,7 @@ static void sample_gfx_init(void) #elif defined(TPTYPE_ZTW523) ztw523_host_init_sample(); #elif defined(TPTYPE_FT6X46) - ztw523_host_init_sample(); + ft6x46_host_init_sample(); #else ztw523_host_init_sample(); #endif diff --git a/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_ctrl.c b/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_ctrl.c index da5596b71..883324bad 100644 --- a/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_ctrl.c +++ b/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_ctrl.c @@ -21,31 +21,31 @@ #include "touch_screen_def.h" bool g_host_dev_init_flag = TD_FALSE; -ztw523_ctrl_attr g_ctrl_attr; -touch_callback g_ztw523_callback = NULL; +ft6x46_ctrl_attr g_ctrl_attr; +touch_callback g_ft6x46_callback = NULL; -static void ztw523_gpio_isr_handle(pin_t pin, uintptr_t param) +static void ft6x46_gpio_isr_handle(pin_t pin, uintptr_t param) { unused(pin); unused(param); - if (g_ztw523_callback != NULL) { - g_ztw523_callback(); + if (g_ft6x46_callback != NULL) { + g_ft6x46_callback(); } } -ext_errno ztw523_register_handle(const ztw523_ctrl_ops *peri_data, touch_callback func) +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_ztw523_callback = func; + 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, ztw523_gpio_isr_handle); + 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; @@ -54,14 +54,14 @@ ext_errno ztw523_register_handle(const ztw523_ctrl_ops *peri_data, touch_callbac return EXT_ERR_SUCCESS; } -ext_errno ztw523_unregister_handle(const ztw523_ctrl_ops *peri_data) +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_ztw523_callback = NULL; + g_ft6x46_callback = NULL; return EXT_ERR_SUCCESS; } @@ -75,7 +75,7 @@ static ext_errno tp_peripheral_init_status_check(void) return EXT_ERR_SUCCESS; } -static ext_errno ztw523_ctrl_attr_check(const ztw523_ctrl_attr *device_attr) +static ext_errno ft6x46_ctrl_attr_check(const ft6x46_ctrl_attr *device_attr) { unused(device_attr); return EXT_ERR_SUCCESS; @@ -93,50 +93,12 @@ static ext_errno tp_i2c_rd_wr_param_check(const uint8_t *data_buf, uint32_t data return EXT_ERR_SUCCESS; } -#define ZTW523_DRV 1 -#if ZTW523_DRV -ext_errno tp_i2c_data_read(uint16_t reg_addr, uint8_t *data_buf, uint32_t data_len) -{ - errcode_t ret; - uint32_t retry; - i2c_data_t data; - uint8_t tp_reg_addr[ZTW523_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[ZTW523_I2C_SEND_INDEX0] = reg_addr & 0xff; - tp_reg_addr[ZTW523_I2C_SEND_INDEX1] = (reg_addr >> OFFSET_8_BITS) & 0xff; - - data.send_buf = tp_reg_addr; - data.send_len = ZTW523_CMD_SEND_LEN; - data.receive_buf = data_buf; - data.receive_len = data_len; - - for (retry = 0; retry < ZTW523_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; -} -#else 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; - //uint8_t tp_reg_addr[ZTW523_REG_BYTE_LEN]; + //uint8_t tp_reg_addr[FT6X46_REG_BYTE_LEN]; ret = tp_i2c_rd_wr_param_check(data_buf, data_len); if (ret != 0) { @@ -145,15 +107,15 @@ ext_errno tp_i2c_data_read(uint8_t reg_addr, uint8_t *data_buf, uint32_t data_le } memset_s(data_buf, data_len, 0, data_len); - //tp_reg_addr[ZTW523_I2C_SEND_INDEX0] = reg_addr & 0xff; - //tp_reg_addr[ZTW523_I2C_SEND_INDEX1] = (reg_addr >> OFFSET_8_BITS) & 0xff; + //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 = ZTW523_CMD_SEND_LEN; + data.send_len = FT6X46_CMD_SEND_LEN; data.receive_buf = data_buf; data.receive_len = data_len; - for (retry = 0; retry < ZTW523_I2C_TIME_MAX; retry++) { + 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; @@ -166,7 +128,6 @@ ext_errno tp_i2c_data_read(uint8_t reg_addr, uint8_t *data_buf, uint32_t data_le return EXT_ERR_SUCCESS; } -#endif ext_errno tp_ft6x46_i2c_data_read(uint8_t reg_addr, uint8_t *data_buf, uint32_t data_len) @@ -174,7 +135,7 @@ ext_errno tp_ft6x46_i2c_data_read(uint8_t reg_addr, uint8_t *data_buf, uint32_t errcode_t ret; uint32_t retry; i2c_data_t data; - //uint8_t tp_reg_addr[ZTW523_REG_BYTE_LEN]; + //uint8_t tp_reg_addr[FT6X46_REG_BYTE_LEN]; ret = tp_i2c_rd_wr_param_check(data_buf, data_len); if (ret != 0) { @@ -183,15 +144,15 @@ ext_errno tp_ft6x46_i2c_data_read(uint8_t reg_addr, uint8_t *data_buf, uint32_t } memset_s(data_buf, data_len, 0, data_len); - //tp_reg_addr[ZTW523_I2C_SEND_INDEX0] = reg_addr & 0xff; - //tp_reg_addr[ZTW523_I2C_SEND_INDEX1] = (reg_addr >> OFFSET_8_BITS) & 0xff; + //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 = FT6X46_CMD_SEND_LEN; + data.send_len = sizeof(reg_addr); data.receive_buf = data_buf; data.receive_len = data_len; - for (retry = 0; retry < ZTW523_I2C_TIME_MAX; retry++) { + 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; @@ -205,62 +166,27 @@ ext_errno tp_ft6x46_i2c_data_read(uint8_t reg_addr, uint8_t *data_buf, uint32_t return EXT_ERR_SUCCESS; } -#if ZTW523_DRV -ext_errno tp_i2c_cmd_write(uint16_t cmd) -{ - errcode_t ret; - uint32_t retry; - i2c_data_t data; - uint8_t tp_reg_addr[ZTW523_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[ZTW523_I2C_SEND_INDEX0] = cmd & 0xff; - tp_reg_addr[ZTW523_I2C_SEND_INDEX1] = (cmd >> OFFSET_8_BITS) & 0xff; - - data.send_buf = tp_reg_addr; - data.send_len = ZTW523_CMD_SEND_LEN; - data.receive_buf = NULL; - data.receive_len = 0; - - for (retry = 0; retry < ZTW523_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; -} -#else ext_errno tp_i2c_cmd_write(uint8_t cmd) { errcode_t ret; uint32_t retry; i2c_data_t data; - //uint8_t tp_reg_addr[ZTW523_CMD_SEND_LEN]; + //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[ZTW523_I2C_SEND_INDEX0] = cmd & 0xff; - //tp_reg_addr[ZTW523_I2C_SEND_INDEX1] = (cmd >> OFFSET_8_BITS) & 0xff; + //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 = ZTW523_CMD_SEND_LEN; + data.send_len = FT6X46_CMD_SEND_LEN; data.receive_buf = NULL; data.receive_len = 0; - for (retry = 0; retry < ZTW523_I2C_TIME_MAX; retry++) { + 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; @@ -273,97 +199,7 @@ ext_errno tp_i2c_cmd_write(uint8_t cmd) return EXT_ERR_SUCCESS; } -#endif - - -ext_errno tp_i2c_reg_write(uint16_t reg_addr, uint16_t reg_cfg) -{ - errcode_t ret; - uint32_t retry; - i2c_data_t data; - uint8_t tp_reg_addr[ZTW523_REG_WRITE_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[ZTW523_I2C_SEND_INDEX0] = reg_addr & 0xff; - tp_reg_addr[ZTW523_I2C_SEND_INDEX1] = (reg_addr >> OFFSET_8_BITS) & 0xff; - tp_reg_addr[ZTW523_I2C_SEND_INDEX2] = reg_cfg & 0xff; - tp_reg_addr[ZTW523_I2C_SEND_INDEX3] = (reg_cfg >> OFFSET_8_BITS) & 0xff; - - data.send_buf = tp_reg_addr; - data.send_len = ZTW523_REG_WRITE_LEN; - data.receive_buf = NULL; - data.receive_len = 0; - - for (retry = 0; retry < ZTW523_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 reg write fail! ret=0x%x", ret); - return ret; - } - - return EXT_ERR_SUCCESS; -} -#if ZTW523_DRV -ext_errno tp_i2c_data_write(uint16_t reg_addr, uint8_t *data_buf, uint32_t data_len) -{ - errcode_t ret; - uint32_t retry; - i2c_data_t data; - uint8_t *write_data = NULL; - uint32_t send_len; - - ret = tp_i2c_rd_wr_param_check(data_buf, data_len); - if (ret != 0) { - tp_err("tp data write param invalid! ret=0x%x", ret); - return ret; - } - - send_len = data_len + sizeof(uint16_t); - - write_data = (uint8_t *)osal_kmalloc(send_len, OSAL_GFP_KERNEL); - if (write_data == NULL) { - tp_err("tp send buff malloc fail!"); - return EXT_ERR_MALLOC_FAILURE; - } - - write_data[ZTW523_I2C_SEND_INDEX0] = reg_addr & 0xff; - write_data[ZTW523_I2C_SEND_INDEX1] = (reg_addr >> OFFSET_8_BITS) & 0xff; - ret = (uint32_t)memcpy_s(write_data + sizeof(uint16_t), send_len - sizeof(uint16_t), data_buf, data_len); - if (ret != EOK) { - tp_err("tp send_buf content copy fail! ret=0x%x", ret); - return ret; - } - - data.send_buf = write_data; - data.send_len = send_len; - data.receive_buf = NULL; - data.receive_len = 0; - - for (retry = 0; retry < ZTW523_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; - } - - tp_mem_free(write_data); - return EXT_ERR_SUCCESS; -} -#else ext_errno tp_i2c_data_write(uint8_t reg_addr, uint8_t *data_buf, uint16_t data_len) { errcode_t ret; @@ -386,7 +222,7 @@ ext_errno tp_i2c_data_write(uint8_t reg_addr, uint8_t *data_buf, uint16_t data_l return EXT_ERR_MALLOC_FAILURE; } - write_data[ZTW523_I2C_SEND_INDEX0] = reg_addr; + 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); @@ -398,7 +234,7 @@ ext_errno tp_i2c_data_write(uint8_t reg_addr, uint8_t *data_buf, uint16_t data_l data.receive_buf = NULL; data.receive_len = 0; - for (retry = 0; retry < ZTW523_I2C_TIME_MAX; retry++) { + 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; @@ -412,7 +248,6 @@ ext_errno tp_i2c_data_write(uint8_t reg_addr, uint8_t *data_buf, uint16_t data_l tp_mem_free(write_data); return EXT_ERR_SUCCESS; } -#endif ext_errno tp_ft6x46_i2c_data_write(uint8_t reg_addr, uint8_t *data_buf, uint16_t data_len) { @@ -436,7 +271,7 @@ ext_errno tp_ft6x46_i2c_data_write(uint8_t reg_addr, uint8_t *data_buf, uint16_t return EXT_ERR_MALLOC_FAILURE; } - write_data[ZTW523_I2C_SEND_INDEX0] = reg_addr; + 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); @@ -448,7 +283,7 @@ ext_errno tp_ft6x46_i2c_data_write(uint8_t reg_addr, uint8_t *data_buf, uint16_t data.receive_buf = NULL; data.receive_len = 0; - for (retry = 0; retry < ZTW523_I2C_TIME_MAX; retry++) { + 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; @@ -469,7 +304,7 @@ ext_errno tp_ft6x46_i2c_data_write_reg(uint8_t addr, uint8_t val) } -ext_errno ztw523_host_peripheral_init(ztw523_ctrl_attr *attr) +ext_errno ft6x46_host_peripheral_init(ft6x46_ctrl_attr *attr) { ext_errno ret; @@ -477,13 +312,13 @@ ext_errno ztw523_host_peripheral_init(ztw523_ctrl_attr *attr) tp_err("ft6x46 communication interface cfg is empty!"); return EXT_ERR_FAILURE; } - ret = ztw523_ctrl_attr_check(attr); + 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(ztw523_ctrl_attr), attr, sizeof(ztw523_ctrl_attr)); + 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; @@ -504,12 +339,12 @@ ext_errno ztw523_host_peripheral_init(ztw523_ctrl_attr *attr) return EXT_ERR_SUCCESS; } -ext_errno ztw523_host_init_sample(void) +ext_errno ft6x46_host_init_sample(void) { ext_errno ret; PRINT("**********ft6x46_host_init_sample**********\r\n"); - ret = ztw523_host_peripheral_init(&g_ctrl_attr); - ret = ztw523_init(); + 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; @@ -518,65 +353,34 @@ ext_errno ztw523_host_init_sample(void) return EXT_ERR_SUCCESS; } -#ifdef PRE_ASIC -ext_errno ztw523_reset(void) +ext_errno ft6x46_reset(void) { - uapi_gpio_set_dir(ZTW523_RESET_GPIO, GPIO_DIRECTION_OUTPUT); + uapi_gpio_set_dir(FT6X46_RESET_GPIO, GPIO_DIRECTION_OUTPUT); /* Config Gpio For Reset Pin */ - uapi_gpio_set_val(ZTW523_RESET_GPIO, GPIO_LEVEL_HIGH); + uapi_gpio_set_val(FT6X46_RESET_GPIO, GPIO_LEVEL_HIGH); /* reset high delay 20ms */ osDelay(20); - uapi_gpio_set_val(ZTW523_RESET_GPIO, GPIO_LEVEL_LOW); + uapi_gpio_set_val(FT6X46_RESET_GPIO, GPIO_LEVEL_LOW); /* reset low delay 100ms */ osDelay(100); - uapi_gpio_set_val(ZTW523_RESET_GPIO, GPIO_LEVEL_HIGH); + uapi_gpio_set_val(FT6X46_RESET_GPIO, GPIO_LEVEL_HIGH); /* reset high delay 200ms */ osDelay(200); return EXT_ERR_SUCCESS; } -void ztw523_resume_reset(void) +void ft6x46_resume_reset(void) { - uapi_gpio_set_dir(ZTW523_RESET_GPIO, GPIO_DIRECTION_OUTPUT); + 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(ZTW523_RESET_GPIO, GPIO_LEVEL_HIGH); + uapi_gpio_set_val(FT6X46_RESET_GPIO, GPIO_LEVEL_HIGH); osDelay(1); - uapi_gpio_set_val(ZTW523_RESET_GPIO, GPIO_LEVEL_LOW); + uapi_gpio_set_val(FT6X46_RESET_GPIO, GPIO_LEVEL_LOW); /* delay 10ms */ osDelay(10); - uapi_gpio_set_val(ZTW523_RESET_GPIO, GPIO_LEVEL_HIGH); + uapi_gpio_set_val(FT6X46_RESET_GPIO, GPIO_LEVEL_HIGH); /* delay 100ms */ - osDelay(100); - uapi_gpio_set_dir(ZTW523_RESET_GPIO, GPIO_DIRECTION_INPUT); -} -#else -ext_errno ztw523_reset(void) -{ - /* Config Gpio For Reset Pin */ - writel(ZTW523_RST_REG, ZTW523_RST_HIGH); - /* reset high delay 20ms */ - osDelay(20); - writel(ZTW523_RST_REG, ZTW523_RST_LOW); - /* reset low delay 100ms */ - osDelay(100); - writel(ZTW523_RST_REG, ZTW523_RST_HIGH); - /* reset high delay 200ms */ osDelay(200); - /* Record Status For Reset */ - - return EXT_ERR_SUCCESS; + uapi_gpio_set_dir(FT6X46_RESET_GPIO, GPIO_DIRECTION_INPUT); } -void ztw523_resume_reset(void) -{ - /* drvdata is global variable point and no need to handle null */ - writel(ZTW523_RST_REG, ZTW523_RST_HIGH); - osDelay(1); - writel(ZTW523_RST_REG, ZTW523_RST_LOW); - /* delay 10ms */ - osDelay(10); - writel(ZTW523_RST_REG, ZTW523_RST_HIGH); - /* delay 100ms */ - osDelay(100); -} -#endif diff --git a/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_ctrl.h b/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_ctrl.h index 5d994b8ba..ac23c5fce 100644 --- a/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_ctrl.h +++ b/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_ctrl.h @@ -18,48 +18,48 @@ /* host peripheral definitions */ -// #define ZTW523_I2C_ADDR 0x20 +//#define FT6X46_I2C_ADDR 0x20 #define FT6X46_I2C_ADDR 0x38 -#define ZTW523_I2C_SPEED I2C_SPEED_MODE_SS -#define ZTW523_REG_BYTE_LEN 2 +#define FT6X46_I2C_SPEED I2C_SPEED_MODE_SS +#define FT6X46_REG_BYTE_LEN 2 #define OFFSET_8_BITS 8 -#define ZTW523_REG_WRITE_LEN 4 +#define FT6X46_REG_WRITE_LEN 4 -#define ZTW523_CMD_SEND_LEN 2 -#define FT6X46_CMD_SEND_LEN 1 +#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_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 -#define ZTW523_REG_DATA_LEN 2 -#define ZTW523_I2C_TIME_MAX 3 -#define ZTW523_I2C_SEND_INDEX0 0 -#define ZTW523_I2C_SEND_INDEX1 1 -#define ZTW523_I2C_SEND_INDEX2 2 -#define ZTW523_I2C_SEND_INDEX3 3 typedef struct { uint32_t int_gpio; + uint32_t reset_gpio; i2c_bus_t i2c_id; uint32_t i2c_speed; -} ztw523_ctrl_attr; +} ft6x46_ctrl_attr; -typedef ext_errno (*ztw523_bus_init)(ztw523_ctrl_attr *attr); +typedef ext_errno (*ft6x46_bus_init)(ft6x46_ctrl_attr *attr); typedef struct { - ztw523_ctrl_attr attr; - ztw523_bus_init bus_init; -} ztw523_ctrl_ops; - -ext_errno ztw523_host_peripheral_init(ztw523_ctrl_attr *attr); -ext_errno ztw523_register_handle(const ztw523_ctrl_ops *peri_data, touch_callback func); -ext_errno ztw523_unregister_handle(const ztw523_ctrl_ops *peri_data); -ext_errno ztw523_reset(void); -void ztw523_resume_reset(void); -void ztw523_delay(uint32_t ms); - -ext_errno tp_i2c_data_read(uint16_t reg_addr, uint8_t *data_buf, uint32_t data_len); -ext_errno tp_i2c_cmd_write(uint16_t cmd); -ext_errno tp_i2c_reg_write(uint16_t reg_addr, uint16_t reg_cfg); -ext_errno tp_i2c_data_write(uint16_t reg_addr, uint8_t *data_buf, uint32_t data_len); + 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); diff --git a/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_drv1.c b/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_drv1.c index f453033bc..928c58eac 100644 --- a/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_drv1.c +++ b/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_drv1.c @@ -12,10 +12,10 @@ #include "debug_print.h" #include "hal_i2c.h" -static ext_errno ztw523_drv_init(ztw523_ctrl_ops *config) +static ext_errno ft6x46_drv_init(ft6x46_ctrl_ops *config) { ext_errno ret; - ztw523_ctrl_ops *ops = config; + ft6x46_ctrl_ops *ops = config; tp_err("ft6x46_drv_init!11111"); @@ -35,7 +35,7 @@ static ext_errno ztw523_drv_init(ztw523_ctrl_ops *config) return ret; } - ret = ztw523_init(); + ret = ft6x46_init(); if (ret != EXT_ERR_SUCCESS) { tp_err("ZTW523 init fail! ret = 0x%x", ret); return ret; @@ -44,61 +44,61 @@ static ext_errno ztw523_drv_init(ztw523_ctrl_ops *config) return EXT_ERR_SUCCESS; } -static ext_errno ztw523_drv_deinit(void) +static ext_errno ft6x46_drv_deinit(void) { return EXT_ERR_SUCCESS; } -static ext_errno ztw523_drv_get_info(uint8_t *data, uint8_t data_len) +static ext_errno ft6x46_drv_get_info(uint8_t *data, uint8_t data_len) { - return ztw523_irq_callback(data, data_len); + return ft6x46_irq_callback(data, data_len); } -static ext_errno ztw523_drv_suspend(void) +static ext_errno ft6x46_drv_suspend(void) { - //return ztw523_set_power_mode(MC_TP_SUSPEND_SCAN); + //return ft6x46_set_power_mode(MC_TP_SUSPEND_SCAN); return EXT_ERR_SUCCESS; } -static ext_errno ztw523_drv_resume(void) +static ext_errno ft6x46_drv_resume(void) { - //return ztw523_set_power_mode(MC_TP_RESUME_SCAN); + //return ft6x46_set_power_mode(MC_TP_RESUME_SCAN); return EXT_ERR_SUCCESS; } -static ext_errno ztw523_drv_sleep(void) +static ext_errno ft6x46_drv_sleep(void) { - //return ztw523_set_power_mode(MC_TP_SLEEP_WORK_MODE); + //return ft6x46_set_power_mode(MC_TP_SLEEP_WORK_MODE); return EXT_ERR_SUCCESS; } -touch_peripheral_api g_ztw523_api = { - .touch_init = ztw523_drv_init, - .touch_deinit = ztw523_drv_deinit, - .touch_get_tpinfo = ztw523_drv_get_info, - .touch_suspend = ztw523_drv_suspend, - .touch_resume = ztw523_drv_resume, - .touch_sleep = ztw523_drv_sleep, - .touch_bus_init = ztw523_host_peripheral_init, - .register_callback = ztw523_register_handle, - .unregister_callback = ztw523_unregister_handle, +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, }; -ztw523_ctrl_ops g_ztw523_ctrl = { +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 = (ztw523_bus_init)ztw523_host_peripheral_init, + .bus_init = (ft6x46_bus_init)ft6x46_host_peripheral_init, }; void *touch_screen_get_api(void) { - return ((void *)&g_ztw523_api); + return ((void *)&g_ft6x46_api); } void *touch_screen_get_peri_attr(void) { - return ((void *)&g_ztw523_ctrl); + return ((void *)&g_ft6x46_ctrl); } \ No newline at end of file diff --git a/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_touch1.c b/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_touch1.c index 455eb599e..0d2f4c780 100644 --- a/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_touch1.c +++ b/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_touch1.c @@ -1,6 +1,6 @@ /* * Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved. - * Description: ztw523 touch driver. + * Description: ft6x46 touch driver. * Author: @CompanyNameTag * Create: 2021-05-29 */ @@ -22,19 +22,19 @@ extern "C" { #endif #endif -ztw523_drv_data g_ztw523_drv = { - .chip_status = ZTW523_NOT_READY, +ft6x46_drv_data g_ft6x46_drv = { + .chip_status = FT6X46_NOT_READY, .ops_mux = {0}, - .int_mask = ZTW523_INT_MASK, - .work_status = ZTW523_WORK_INVALID, + .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 = ZTW523_DEVICE_INFO, + .chip_info = FT6X46_DEVICE_INFO, .p_void = NULL, }; - -static void ztw523_set_irq_mode(ztw523_irq_status irq_status, uint16_t irq_mask) +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; @@ -43,24 +43,24 @@ static void ztw523_set_irq_mode(ztw523_irq_status irq_status, uint16_t irq_mask) tp_print("TOUCH:set irq mode %d", irq_status); switch (irq_status) { - case ZTW523_IRQ_DISABLE: + case FT6X46_IRQ_DISABLE: /* Write Int Register */ - reg_write = ZTW523_INT_NONE; - ret = tp_i2c_reg_write(ZTW523_INT_ENABLE_FLAG, reg_write); - if (ret != EXT_ERR_SUCCESS) { - tp_err("TOUCH:set irq mode disable 0x%x", ret); - return; - } + 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 ZTW523_IRQ_ENABLE: + case FT6X46_IRQ_ENABLE: /* Write Int Register */ - reg_write = ZTW523_INT_MASK; - ret = tp_i2c_reg_write(ZTW523_INT_ENABLE_FLAG, reg_write); - if (ret != EXT_ERR_SUCCESS) { - tp_err("TOUCH:set irq mode enable 0x%x", ret); - return; - } + 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: @@ -71,7 +71,7 @@ static void ztw523_set_irq_mode(ztw523_irq_status irq_status, uint16_t irq_mask) return; } -static ext_errno ztw523_parse_gesture_input(void) +static ext_errno ft6x46_parse_gesture_input(void) { ext_errno ret; uint16_t gesture_val; @@ -79,33 +79,33 @@ static ext_errno ztw523_parse_gesture_input(void) uint16_t reg_write; reg_read = 0; - ret = tp_i2c_data_read(ZTW523_GESTURE_WAKEUP_REG, (uint8_t *)®_read, ZTW523_DATA_LEN); - if (ret != EXT_ERR_SUCCESS) { - tp_err("TOUCH:parse gesture input read fail 0x%x", ret); - return EXT_ERR_FAILURE; - } + // 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(ZTW523_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; - } + // 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 ZTW523_GESTURE_SIGNAL_CLICK: - g_ztw523_drv.touch_msg.tp_event = MC_TP_SHORT_CLICK; + case FT6X46_GESTURE_SIGNAL_CLICK: + g_ft6x46_drv.touch_msg.tp_event = MC_TP_SHORT_CLICK; break; - case ZTW523_GESTURE_DOUBLE_CLICK: - g_ztw523_drv.touch_msg.tp_event = MC_TP_DOUBLE_CLICK; + case FT6X46_GESTURE_DOUBLE_CLICK: + g_ft6x46_drv.touch_msg.tp_event = MC_TP_DOUBLE_CLICK; break; - case ZTW523_GESTURE_SLIDE_UP: - g_ztw523_drv.touch_msg.tp_event = MC_TP_SLIDE_UP; + case FT6X46_GESTURE_SLIDE_UP: + g_ft6x46_drv.touch_msg.tp_event = MC_TP_SLIDE_UP; break; - case ZTW523_GESTURE_SLIDE_DOWN: - g_ztw523_drv.touch_msg.tp_event = MC_TP_SLIDE_DOWN; + 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); @@ -115,55 +115,55 @@ static ext_errno ztw523_parse_gesture_input(void) return EXT_ERR_SUCCESS; } -static ext_errno ztw523_parse_touch_input(void) +static ext_errno ft6x46_parse_touch_input(void) { - static uint8_t touch_input[ZTW523_TOUCHINFO_LEN] = { 0 }; + 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(ZTW523_POINT_STATUS_REG, touch_input, ZTW523_TOUCHINFO_LEN); + 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[ZTW523_STATUSH_OFFSET] << ZTW523_REGDATA_SHIFT) | - (touch_input[ZTW523_STATUSL_OFFSET]); - if ((touch_status & ZTW523_PALM_MASK) != 0) { - g_ztw523_drv.touch_msg.tp_event = MC_TP_COVER; + 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[ZTW523_SUBSTATUS_OFFSET] & ZTW523_TOUCHINFO_MASK; - x_axis = ((uint16_t)touch_input[ZTW523_XH_OFFSET] << ZTW523_REGDATA_SHIFT) | (touch_input[ZTW523_XL_OFFSET]); - y_axis = ((uint16_t)touch_input[ZTW523_YH_OFFSET] << ZTW523_REGDATA_SHIFT) | (touch_input[ZTW523_YL_OFFSET]); + 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 ZTW523_TOUCH_DOWN: - g_ztw523_drv.touch_msg.tp_event = MC_TP_PRESS; + case FT6X46_TOUCH_DOWN: + g_ft6x46_drv.touch_msg.tp_event = MC_TP_PRESS; break; /* Need To Modify For UI */ - case ZTW523_TOUCH_EXIST: - case ZTW523_TOUCH_MOVE: - case ZTW523_TOUCH_NONE: - g_ztw523_drv.touch_msg.tp_event = MC_TP_MOVE; + case FT6X46_TOUCH_EXIST: + case FT6X46_TOUCH_MOVE: + case FT6X46_TOUCH_NONE: + g_ft6x46_drv.touch_msg.tp_event = MC_TP_MOVE; break; - case ZTW523_TOUCH_UP: - g_ztw523_drv.touch_msg.tp_event = MC_TP_RELEASE; + 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 << ZTW523_SHIFT_16_BIT) | (uint32_t)sub_status); + ((uint32_t)touch_status << FT6X46_SHIFT_16_BIT) | (uint32_t)sub_status); return EXT_ERR_FAILURE; } - g_ztw523_drv.touch_msg.tp_event_info.x_axis[0] = x_axis; - g_ztw523_drv.touch_msg.tp_event_info.y_axis[0] = y_axis; - g_ztw523_drv.touch_msg.tv_usec = (uint32_t)uapi_tcxo_get_ms(); + 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_ztw523_drv.touch_msg.tp_event = MC_TP_INVALID; + g_ft6x46_drv.touch_msg.tp_event = MC_TP_INVALID; tp_print("TOUCH:parse wrong touchstatus %d", touch_status); return EXT_ERR_SUCCESS; } @@ -235,6 +235,7 @@ static ext_errno fts_touch_process(void) 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; } @@ -276,53 +277,53 @@ static ext_errno fts_touch_process(void) #endif switch (events[i].type) { case 0: - g_ztw523_drv.touch_msg.tp_event = MC_TP_PRESS; + g_ft6x46_drv.touch_msg.tp_event = MC_TP_PRESS; break; /* Need To Modify For UI */ case 2: - g_ztw523_drv.touch_msg.tp_event = MC_TP_MOVE; + g_ft6x46_drv.touch_msg.tp_event = MC_TP_MOVE; break; case 1: - g_ztw523_drv.touch_msg.tp_event = MC_TP_RELEASE; + 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_ztw523_drv.touch_msg.tp_event_info.x_axis[0] = events[i].x; - g_ztw523_drv.touch_msg.tp_event_info.y_axis[0] = events[i].y; - g_ztw523_drv.touch_msg.tv_usec = (uint32_t)uapi_tcxo_get_ms(); + 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_ztw523_drv.touch_msg.tp_event, - g_ztw523_drv.touch_msg.tp_event_info.x_axis[0], - g_ztw523_drv.touch_msg.tp_event_info.y_axis[0], - g_ztw523_drv.touch_msg.tv_usec); + 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 ztw523_parse_input(void) +static ext_errno ft6x46_parse_input(void) { ext_errno ret = EXT_ERR_FAILURE; uint16_t reg_write; - if (g_ztw523_drv.gesture_wakeup == TD_TRUE) { - ret = ztw523_parse_gesture_input(); + 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 = ztw523_parse_touch_input(); + 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 = ZTW523_CLEAR_INT_STATUS_CMD; + 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); @@ -332,77 +333,22 @@ static ext_errno ztw523_parse_input(void) return EXT_ERR_SUCCESS; } -ext_errno ztw523_irq_callback(uint8_t *data_buf, uint8_t data_len) +ext_errno ft6x46_irq_callback(uint8_t *data_buf, uint8_t data_len) { unused(data_len); - #if 0 - ext_errno ret; - int32_t mem_ret; - uint16_t reg_write; - - if (g_ztw523_drv.work_status == ZTW523_WORK_GETCMCP) { - tp_warning("in getcmcp status: %d", ZTW523_WORK_GETCMCP); - return EXT_ERR_SUCCESS; - } - - g_ztw523_drv.touch_msg.tp_event = MC_TP_INVALID; - - if ((g_ztw523_drv.work_status == ZTW523_WORK_NORMAL) || (g_ztw523_drv.work_status == ZTW523_WORK_STANDBY)) { - g_ztw523_drv.irq_count++; - ret = ztw523_parse_input(); - if (ret != EXT_ERR_SUCCESS) { - ztw523_init(); - reg_write = ZTW523_CLEAR_INT_STATUS_CMD; - (void)tp_i2c_cmd_write(reg_write); - tp_err("touch parse input fail, ret = 0x%x", ret); - return EXT_ERR_FAILURE; - } - } - - mem_ret = memcpy_s(data_buf, sizeof(input_event_info), &(g_ztw523_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; - } - #endif - - - - /*ext_errno ret; - int32_t mem_ret; - uint16_t reg_write; - - if (g_ztw523_drv.work_status == ZTW523_WORK_GETCMCP) { - tp_warning("in getcmcp status: %d", ZTW523_WORK_GETCMCP); - return EXT_ERR_SUCCESS; - }*/ - - g_ztw523_drv.touch_msg.tp_event = MC_TP_INVALID; - - /*if ((g_ztw523_drv.work_status == ZTW523_WORK_NORMAL) || (g_ztw523_drv.work_status == ZTW523_WORK_STANDBY)) { - g_ztw523_drv.irq_count++; - ret = ztw523_parse_input(); - if (ret != EXT_ERR_SUCCESS) { - ztw523_init(); - reg_write = ZTW523_CLEAR_INT_STATUS_CMD; - (void)tp_i2c_cmd_write(reg_write); - tp_err("touch parse input fail, ret = 0x%x", ret); - return EXT_ERR_FAILURE; - } - }*/ + 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_ztw523_drv.touch_msg), sizeof(input_event_info)); + 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; } @@ -423,71 +369,10 @@ ext_errno ztw523_irq_callback(uint8_t *data_buf, uint8_t data_len) static ext_errno ft6x46_power_sequence(void) { ext_errno ret; - #if 0 - uint16_t reg_write; - uint16_t reg_read; - reg_write = ZTW523_ENABLE; - - ret = tp_i2c_reg_write(ZTW523_REG_CMD_ENABLE, reg_write); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_POWERUP_VENDOR_CMD_ENABLE; - } - osDelay(ZTW523_GENERAL_DELAY_1); - reg_read = 0; - ret = tp_i2c_data_read(ZTW523_REG_CHIP_ID, (uint8_t *)®_read, ZTW523_DATA_LEN); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_POWERUP_READ_CHIPID; - } - osDelay(ZTW523_GENERAL_DELAY_1); - - reg_write = ZTW523_REG_INTN_CLEAR; - ret = tp_i2c_cmd_write(reg_write); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_POWERUP_INTN_CLEAR; - } - osDelay(ZTW523_GENERAL_DELAY_1); - - reg_write = ZTW523_ENABLE; - ret = tp_i2c_reg_write(ZTW523_REG_NVM, reg_write); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_POWERUP_NVM_INIT; - } - osDelay(ZTW523_GENERAL_DELAY_5); - - reg_write = ZTW523_ENABLE; - ret = tp_i2c_reg_write(ZTW523_REG_PROGRAM_START, reg_write); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_POWERUP_PROGRAM_START; - } - - /* Delay 150ms, Refer Demo Code */ - osDelay(ZTW523_FIRMWAREON_DELAY); - - /* config report rate to 60Hz */ - reg_write = ZTW523_REPORT_RATE; - ret = tp_i2c_reg_write(ZTW523_REPORT_REG, reg_write); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_POWERUP_REPORT_RATE; - } - - /* sw reset */ - reg_write = ZTW523_SWRESET_CMD; - ret = tp_i2c_cmd_write(reg_write); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_POWERUP_SW_RESET; - } - /* Delay 10ms for sw reset */ - osDelay(ZTW523_GENERAL_DELAY_10); - - return EXT_ERR_SUCCESS; - #endif -#if 1 - uint8_t chip_id[2] = { 0 }; - /*delay 200ms,wait fw*/ - osDelay(ZTW523_GENERAL_DELAY_200); + osDelay(FT6X46_GENERAL_DELAY_200); /*get chip id*/ ret = tp_ft6x46_i2c_data_read(FTS_REG_CHIP_ID, &chip_id[0], 1); @@ -500,9 +385,9 @@ static ext_errno ft6x46_power_sequence(void) 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]); + // 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_err("get ic information, chip id = 0x%02x%02x", chip_id[0], chip_id[1]); + tp_warning("get ic information, chip id = 0x%02x%02x", chip_id[0], chip_id[1]); return EXT_ERR_SUCCESS; } @@ -524,12 +409,11 @@ static ext_errno ft6x46_power_sequence(void) } return ret; - #endif } -static void ztw523_clear_interrupt(uint8_t retry_times, uint16_t delay) +static void ft6x46_clear_interrupt(uint8_t retry_times, uint16_t delay) { - uint16_t reg_write = ZTW523_CLEAR_INT_STATUS_CMD; + uint16_t reg_write = FT6X46_CLEAR_INT_STATUS_CMD; ext_errno ret; uint8_t times; for (times = 1; times <= retry_times; times++) { @@ -545,76 +429,76 @@ static void ztw523_clear_interrupt(uint8_t retry_times, uint16_t delay) } } -static ext_errno ztw523_reg_config(void) +static ext_errno ft6x46_reg_config(void) { ext_errno ret; - uint16_t reg_write; - - /* Initial Touch Mode */ - reg_write = ZTW523_POINT_MODE; - ret = tp_i2c_reg_write(ZTW523_INITIAL_TOUCH_MODE, reg_write); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_CONFIG_INIT_TOUCHMODE; - } - - ret = tp_i2c_reg_write(ZTW523_TOUCH_MODE, reg_write); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_CONFIG_WRITE_TOUCHMODE; - } - - /* Set Finger Num */ - reg_write = ZTW523_MAX_SUPPORTED_FINGER_NUM; - ret = tp_i2c_reg_write(ZTW523_SUPPORTED_FINGER_NUM, reg_write); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_CONFIG_WRITE_FINGER_NUM; - } - - /* Set X Resolution */ - reg_write = ZTW523_RES_MAX_X; - ret = tp_i2c_reg_write(ZTW523_X_RESOLUTION, reg_write); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_CONFIG_WRITE_XRES; - } - - /* Set Y Resolution */ - reg_write = ZTW523_RES_MAX_Y; - ret = tp_i2c_reg_write(ZTW523_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(ZTW523_HOLD_POINT_TRESHHOLD, ZTW523_POINT_TRESHHOLD); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_CONFIG_WRITE_YRES; - } - - /* Write Calib Cmd */ - reg_write = ZTW523_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 = ZTW523_INT_MASK; - ret = tp_i2c_reg_write(ZTW523_INT_ENABLE_FLAG, reg_write); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_CONFIG_WRITE_INTMASK; - } -#ifdef ZTW523_GESTURE_WAKEUP - /* Write Gesture Register */ - reg_write = ZTW523_GESTURE_WAKEUP_INIT; - ret = tp_i2c_reg_write(ZTW523_GESTURE_WAKEUP_REG, reg_write); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_CONFIG_WRITE_GESWAKEUP; - } -#endif + // 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 ztw523_configuration(void) +static ext_errno ft6x46_configuration(void) { ext_errno ret; uint8_t retry_times = 0; @@ -622,393 +506,356 @@ static ext_errno ztw523_configuration(void) uint16_t reg_write; /* Software Reset */ - reg_write = ZTW523_SWRESET_CMD; - for (retry_times = 0; retry_times < ZTW523_RETRY_TIMES; retry_times++) { + 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(ZTW523_RESETHIGH_DELAY); + osDelay(FT6X46_RESETHIGH_DELAY); } - if (retry_times >= ZTW523_RETRY_TIMES) { + 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(ZTW523_FIRMWARE_VERSION, (uint8_t *)®_read, ZTW523_DATA_LEN); + 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_ztw523_drv.firmware_version = reg_read; + g_ft6x46_drv.firmware_version = reg_read; /* Read Minor Firmware Version */ reg_read = 0; - ret = tp_i2c_data_read(ZTW523_MINOR_FW_VERSION, (uint8_t *)®_read, ZTW523_DATA_LEN); + 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_ztw523_drv.minor_firmware_version = reg_read; + g_ft6x46_drv.minor_firmware_version = reg_read; /* Read Hw ID */ reg_read = 0; - ret = tp_i2c_data_read(ZTW523_HW_ID, (uint8_t *)®_read, ZTW523_DATA_LEN); + 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_ztw523_drv.chip_hw_id = reg_read; + g_ft6x46_drv.chip_hw_id = reg_read; /* Read Register Version */ reg_read = 0; - ret = tp_i2c_data_read(ZTW523_DATA_VERSION_REG, (uint8_t *)®_read, ZTW523_DATA_LEN); + 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_ztw523_drv.reg_version = reg_read; + g_ft6x46_drv.reg_version = reg_read; - ret = ztw523_reg_config(); + ret = ft6x46_reg_config(); if (ret != EXT_ERR_SUCCESS) { return ret; } /* Write Clear Int Cmd */ - ztw523_clear_interrupt(ZTW523_RETRY_TIMES, ZTW523_GENERAL_DELAY_1); + ft6x46_clear_interrupt(FT6X46_RETRY_TIMES, FT6X46_GENERAL_DELAY_1); return EXT_ERR_SUCCESS; } -static ext_errno ztw523_get_panel_info(void) +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(ZTW523_TOTAL_NUMBER_OF_X, (uint8_t *)®_read, ZTW523_DATA_LEN); + 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_ztw523_drv.panel_info.xchannel_num = reg_read; + g_ft6x46_drv.panel_info.xchannel_num = reg_read; /* Read Y Channel Num */ reg_read = 0; - ret = tp_i2c_data_read(ZTW523_TOTAL_NUMBER_OF_Y, (uint8_t *)®_read, ZTW523_DATA_LEN); + 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_ztw523_drv.panel_info.ychannel_num = reg_read; - g_ztw523_drv.panel_info.total_dnd_num = - g_ztw523_drv.panel_info.xchannel_num * g_ztw523_drv.panel_info.ychannel_num; - g_ztw523_drv.panel_info.total_self_dnd_num = - g_ztw523_drv.panel_info.xchannel_num + g_ztw523_drv.panel_info.ychannel_num; + 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 ztw523_standby(void) +static ext_errno ft6x46_standby(void) { ext_errno ret; uint16_t reg_write; uint8_t retry_times; - if ((g_ztw523_drv.work_status == ZTW523_WORK_STANDBY) || (g_ztw523_drv.work_status == ZTW523_WORK_SLEEP)) { + 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 */ - ztw523_set_irq_mode(ZTW523_IRQ_DISABLE, ZTW523_INT_NONE); + ft6x46_set_irq_mode(FT6X46_IRQ_DISABLE, FT6X46_INT_NONE); - reg_write = ZTW523_POWER_CTL_BEGIN; + reg_write = FT6X46_POWER_CTL_BEGIN; ret = tp_i2c_cmd_write(reg_write); if (ret != EXT_ERR_SUCCESS) { - ztw523_set_irq_mode(ZTW523_IRQ_ENABLE, ZTW523_INT_MASK); + 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(ZTW523_GENERAL_DELAY_10); + osDelay(FT6X46_GENERAL_DELAY_10); /* Send Clear Int Cmd */ - reg_write = ZTW523_CLEAR_INT_STATUS_CMD; - for (retry_times = 0; retry_times < ZTW523_INIT_RETRY_TIMERS; retry_times++) { + 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(ZTW523_GENERAL_DELAY_10); + osDelay(FT6X46_GENERAL_DELAY_10); } /* Send Idle Cmd */ - reg_write = ZTW523_IDLE_CMD; - for (retry_times = 0; retry_times < ZTW523_INIT_RETRY_TIMERS; retry_times++) { + 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(ZTW523_GENERAL_DELAY_10); + osDelay(FT6X46_GENERAL_DELAY_10); } - reg_write = ZTW523_POWER_CTL_END; + reg_write = FT6X46_POWER_CTL_END; ret = tp_i2c_cmd_write(reg_write); if (ret != EXT_ERR_SUCCESS) { - ztw523_set_irq_mode(ZTW523_IRQ_ENABLE, ZTW523_INT_MASK); + 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(ZTW523_GENERAL_DELAY_10); - ztw523_set_irq_mode(ZTW523_IRQ_ENABLE, ZTW523_INT_MASK); - g_ztw523_drv.work_status = ZTW523_WORK_STANDBY; + 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; } -static ext_errno ztw523_suspend(void) +ext_errno ft6x46_suspend(void) { ext_errno ret; - uint16_t reg_write; - uint8_t retry_times = 0; + // uint16_t reg_write; + // uint8_t retry_times = 0; - if (g_ztw523_drv.work_status == ZTW523_WORK_SLEEP) { + if (g_ft6x46_drv.work_status == FT6X46_WORK_SLEEP) { tp_print("TOUCH:alread suspend"); return EXT_ERR_SUCCESS; } - /* Disabel Irq */ - ztw523_set_irq_mode(ZTW523_IRQ_DISABLE, ZTW523_INT_NONE); - - reg_write = ZTW523_POWER_CTL_BEGIN; - ret = tp_i2c_cmd_write(reg_write); - if (ret != EXT_ERR_SUCCESS) { - tp_err("TOUCH:suspend begin 0x%x", ret); - goto suspend_exit; - } - - osDelay(ZTW523_GENERAL_DELAY_10); - /* Send Clear Int Cmd */ - reg_write = ZTW523_CLEAR_INT_STATUS_CMD; - for (retry_times = 0; retry_times < ZTW523_INIT_RETRY_TIMERS; retry_times++) { - ret = tp_i2c_cmd_write(reg_write); - if (ret == EXT_ERR_SUCCESS) { - break; - } - osDelay(ZTW523_GENERAL_DELAY_10); - } - - /* Send Sleep Cmd */ - reg_write = ZTW523_SLEEP_CMD; - for (retry_times = 0; retry_times < ZTW523_INIT_RETRY_TIMERS; retry_times++) { - ret = tp_i2c_cmd_write(reg_write); - if (ret == EXT_ERR_SUCCESS) { - break; - } - osDelay(ZTW523_GENERAL_DELAY_10); - } - - reg_write = ZTW523_POWER_CTL_END; - ret = tp_i2c_cmd_write(reg_write); - if (ret != EXT_ERR_SUCCESS) { - tp_err("TOUCH:suspend end 0x%x", ret); - goto suspend_exit; + /*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."); } - - osDelay(ZTW523_GENERAL_DELAY_10); - - g_ztw523_drv.work_status = ZTW523_WORK_SLEEP; + g_ft6x46_drv.work_status = FT6X46_WORK_SLEEP; return EXT_ERR_SUCCESS; - -suspend_exit: - /* Enable Irq */ - ztw523_set_irq_mode(ZTW523_IRQ_ENABLE, ZTW523_INT_MASK); - - tp_err("TOUCH:suspend failed 0x%x", ret); - - return EXT_ERR_FAILURE; } -static ext_errno ztw523_resume_post(void) +static ext_errno ft6x46_resume_post(void) { ext_errno ret; - uint16_t reg_write; - uint16_t cmd_write; - - reg_write = ZTW523_ENABLE; - ret = tp_i2c_reg_write(ZTW523_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(ZTW523_GENERAL_DELAY_1); - - cmd_write = ZTW523_REG_INTN_CLEAR; - ret = tp_i2c_cmd_write(cmd_write); - if (ret != EXT_ERR_SUCCESS) { - return EXT_ERR_TP_ZTW523_POWERUP_INTN_CLEAR; - } - osDelay(ZTW523_GENERAL_DELAY_1); - - reg_write = ZTW523_ENABLE; - ret = tp_i2c_reg_write(ZTW523_REG_NVM, reg_write); - if (ret != EXT_ERR_SUCCESS) { - tp_err("resume post reg nvm failed 0x%x", ret); - return EXT_ERR_FAILURE; - } - osDelay(ZTW523_GENERAL_DELAY_1); - - reg_write = ZTW523_ENABLE; - ret = tp_i2c_reg_write(ZTW523_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(ZTW523_GENERAL_DELAY_50); /* delay 50 ms */ + // 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 ztw523_resume(void) +ext_errno ft6x46_resume(void) { ext_errno ret; uint8_t retry_times = 0; - g_ztw523_drv.work_status = ZTW523_WORK_RESUME; + g_ft6x46_drv.work_status = FT6X46_WORK_RESUME; - ztw523_resume_reset(); + ft6x46_resume_reset(); - for (; retry_times < ZTW523_INIT_RETRY_TIMERS; retry_times++) { - ret = ztw523_resume_post(); - if (ret != EXT_ERR_SUCCESS) { - tp_err("resume: post err %d", ret); - /* retry delay 200ms */ - osDelay(ZTW523_GENERAL_DELAY_200); - } else { - break; - } - } + // 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 == ZTW523_INIT_RETRY_TIMERS) { - tp_err("resume: overtimes %d", retry_times); - goto resume_exit; - } - - ret = ztw523_configuration(); + // 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:resume config fail 0x%x", ret); - return EXT_ERR_TP_ZTW523_INIT_CONFIG; + 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_ztw523_drv.work_status = ZTW523_WORK_NORMAL; -#ifdef ZTW523_GESTURE_WAKEUP - g_ztw523_drv.gesture_wakeup = TD_FALSE; + g_ft6x46_drv.work_status = FT6X46_WORK_NORMAL; +#ifdef FT6X46_GESTURE_WAKEUP + g_ft6x46_drv.gesture_wakeup = TD_FALSE; #endif /* Enable Irq */ - ztw523_set_irq_mode(ZTW523_IRQ_ENABLE, ZTW523_INT_MASK); + ft6x46_set_irq_mode(FT6X46_IRQ_ENABLE, FT6X46_INT_MASK); return EXT_ERR_SUCCESS; resume_exit: /* Enable Irq */ - ztw523_set_irq_mode(ZTW523_IRQ_DISABLE, ZTW523_INT_MASK); + ft6x46_set_irq_mode(FT6X46_IRQ_DISABLE, FT6X46_INT_MASK); tp_err("resume failed 0x%x", ret); return EXT_ERR_FAILURE; } -ext_errno ztw523_get_power_mode(uint32_t *power_mode) +ext_errno ft6x46_get_power_mode(uint32_t *power_mode) { if (power_mode == NULL) { return EXT_ERR_FAILURE; } - *power_mode = (uint32_t)(g_ztw523_drv.work_status); + *power_mode = (uint32_t)(g_ft6x46_drv.work_status); return EXT_ERR_SUCCESS; } -static ext_errno ztw523_set_standby_mode(void) +static ext_errno ft6x46_set_standby_mode(void) { ext_errno ret; - ret = ztw523_standby(); + ret = ft6x46_standby(); if (ret != EXT_ERR_SUCCESS) { tp_err("TOUCH:ft6x46 set standby 0x%x", ret); return EXT_ERR_FAILURE; } -#ifdef ZTW523_GESTURE_WAKEUP - g_ztw523_drv.gesture_wakeup = TD_TRUE; +#ifdef FT6X46_GESTURE_WAKEUP + g_ft6x46_drv.gesture_wakeup = TD_TRUE; #endif return EXT_ERR_SUCCESS; } -static ext_errno ztw523_set_sleep_mode(void) +static ext_errno ft6x46_set_sleep_mode(void) { ext_errno ret; - ret = ztw523_suspend(); + ret = ft6x46_suspend(); if (ret != EXT_ERR_SUCCESS) { tp_err("TOUCH:ft6x46 set suspend fail 0x%x", ret); } -#ifdef ZTW523_GESTURE_WAKEUP - g_ztw523_drv.gesture_wakeup = TD_FALSE; +#ifdef FT6X46_GESTURE_WAKEUP + g_ft6x46_drv.gesture_wakeup = TD_FALSE; #endif - g_ztw523_drv.work_status = ZTW523_WORK_SLEEP; + g_ft6x46_drv.work_status = FT6X46_WORK_SLEEP; return EXT_ERR_SUCCESS; } -static ext_errno ztw523_set_normal_mode(void) +static ext_errno ft6x46_set_normal_mode(void) { ext_errno ret; uint16_t reg_write; - if (g_ztw523_drv.work_status == ZTW523_WORK_NORMAL) { + if (g_ft6x46_drv.work_status == FT6X46_WORK_NORMAL) { return EXT_ERR_SUCCESS; } - reg_write = ZTW523_SDRAM_RESET; + reg_write = FT6X46_SDRAM_RESET; ret = tp_i2c_cmd_write(reg_write); if (ret != EXT_ERR_SUCCESS) { return EXT_ERR_FAILURE; } /* delay 50ms */ - osDelay(ZTW523_GENERAL_DELAY_50); + osDelay(FT6X46_GENERAL_DELAY_50); ret = ft6x46_power_sequence(); if (ret != EXT_ERR_SUCCESS) { return EXT_ERR_FAILURE; } - ztw523_set_irq_mode(ZTW523_IRQ_ENABLE, ZTW523_INT_MASK); - g_ztw523_drv.work_status = ZTW523_WORK_NORMAL; -#ifdef ZTW523_GESTURE_WAKEUP - g_ztw523_drv.gesture_wakeup = TD_FALSE; + 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 ztw523_set_power_mode(tp_work_mode power_mode) +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 = ztw523_set_sleep_mode(); + ret = ft6x46_set_sleep_mode(); break; case MC_TP_NORMAL_WORK_MODE: case MC_TP_RESUME_SCAN: - ret = ztw523_set_normal_mode(); + ret = ft6x46_set_normal_mode(); break; case MC_TP_STANDBY_WORK_MODE: - ret = ztw523_set_standby_mode(); + ret = ft6x46_set_standby_mode(); break; default: - tp_err("TOUCH:ztw523 not support powermode 0x%x", power_mode); + tp_err("TOUCH:ft6x46 not support powermode 0x%x", power_mode); ret = EXT_ERR_FAILURE; break; } @@ -1016,12 +863,12 @@ ext_errno ztw523_set_power_mode(tp_work_mode power_mode) return ret; } -static ext_errno ztw523_config(void) +static ext_errno ft6x46_config(void) { ext_errno ret; /* Step 1 hardware reset */ - ret = ztw523_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; @@ -1036,14 +883,14 @@ static ext_errno ztw523_config(void) #if 0 /* Step 3 configuration */ - ret = ztw523_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 = ztw523_get_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; @@ -1051,70 +898,70 @@ static ext_errno ztw523_config(void) #endif /* Record Status For Init */ - g_ztw523_drv.chip_status = ZTW523_READY; - g_ztw523_drv.work_status = ZTW523_WORK_NORMAL; + g_ft6x46_drv.chip_status = FT6X46_READY; + g_ft6x46_drv.work_status = FT6X46_WORK_NORMAL; return EXT_ERR_SUCCESS; } -static ext_errno ztw523_resource_deinit(void) +static ext_errno ft6x46_resource_deinit(void) { - g_ztw523_drv.work_status = ZTW523_WORK_INVALID; - g_ztw523_drv.fw_upgrade_flag = TD_FALSE; - osal_mutex_destroy(&g_ztw523_drv.ops_mux); + 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 ztw523_init(void) +ext_errno ft6x46_init(void) { ext_errno ret = EXT_ERR_FAILURE; ext_errno err_ret; /* create tp operation mutex */ - if (g_ztw523_drv.ops_mux.mutex == NULL) { - ret = osal_mutex_init(&(g_ztw523_drv.ops_mux)); + 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:ztw523 init create mux lock fail 0x%x", ret); + 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_ztw523_drv.ops_mux, ZTW523_OPERATER_MUTEX_WAIT_TIME); + ret = osal_mutex_lock_timeout(&g_ft6x46_drv.ops_mux, FT6X46_OPERATER_MUTEX_WAIT_TIME); if (ret != EXT_ERR_SUCCESS) { - tp_err("TOUCH:ztw523 init wait mux lock fail 0x%x", ret); + tp_err("TOUCH:ft6x46 init wait mux lock fail 0x%x", ret); goto init_fail; } /* tp hardware reset and init */ - ret = ztw523_config(); + ret = ft6x46_config(); if (ret != EXT_ERR_SUCCESS) { - tp_err("TOUCH:ztw523 init fail 0x%x", ret); + tp_err("TOUCH:ft6x46 init fail 0x%x", ret); goto init_fail; } /* release tp operater mutex */ - osal_mutex_unlock(&g_ztw523_drv.ops_mux); + osal_mutex_unlock(&g_ft6x46_drv.ops_mux); - tp_print("TOUCH:ztw523 init succ!"); + tp_print("TOUCH:ft6x46 init succ!"); return EXT_ERR_SUCCESS; init_fail: /* release tp operater mutex */ - osal_mutex_unlock(&g_ztw523_drv.ops_mux); - err_ret = ztw523_resource_deinit(); + 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 ztw523_deinit(void) +ext_errno ft6x46_deinit(void) { - ext_errno ret = ztw523_resource_deinit(); + ext_errno ret = ft6x46_resource_deinit(); if (ret != EXT_ERR_SUCCESS) { - tp_err("TOUCH: ztw523 deinit fail! ret = 0x%x", ret); + tp_err("TOUCH: ft6x46 deinit fail! ret = 0x%x", ret); return ret; } diff --git a/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_touch1.h b/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_touch1.h index 7319d0c22..b0e57762f 100644 --- a/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_touch1.h +++ b/code/sdk/drivers/peripheral/touch/ft6x46_touch/ft6x46_touch1.h @@ -22,68 +22,68 @@ extern "C" { /* ztw523 definitions */ /* max wait time */ -#define ZTW523_OPERATER_MUTEX_WAIT_TIME 3000 /* operater tp mutex timeout ms */ -#define ZTW523_CMCP_WAIT_TIMEOUT 1000 +#define FT6X46_OPERATER_MUTEX_WAIT_TIME 3000 /* operater tp mutex timeout ms */ +#define FT6X46_CMCP_WAIT_TIMEOUT 1000 /* define some properties value */ -#define ZTW523_ENABLE 0x0001 -#define ZTW523_DISABLE 0x0000 -#define ZTW523_DATA_LEN 2 -#define ZTW523_POWERON_DELAY 100 -#define ZTW523_POWEROFF_DELAY 100 -#define ZTW523_RESETHIGH_DELAY 10 -#define ZTW523_CLEARINT_DELAY 10 -#define ZTW523_FIRMWAREON_DELAY 200 -#define ZTW523_INIT_RETRY_TIMERS 3 -#define ZTW523_SETMODE_RETRY_TIMERS 3 -#define ZTW523_SOFTRESET_RETRY_TIMES 10 -#define ZTW523_RETRY_TIMES 10 -#define ZTW523_DEVICE_INFO "zinitix,ztw523" -#define ZTW523_DEVICE_INFO_SIZE sizeof(ZTW523_DEVICE_INFO) -#define ZTW523_MAX_SUPPORTED_FINGER_NUM 1 -#define ZTW523_POINT_MODE 1 -#define ZTW523_CALIB_TOUCH_MODE 0x07 -#define ZTW523_REGDATA_SHIFT 8 -#define ZTW523_GENERAL_DELAY_1 1 -#define ZTW523_GENERAL_DELAY_5 5 -#define ZTW523_GENERAL_DELAY_10 10 -#define ZTW523_GENERAL_DELAY_20 20 -#define ZTW523_GENERAL_DELAY_25 25 -#define ZTW523_GENERAL_DELAY_30 30 -#define ZTW523_GENERAL_DELAY_50 50 -#define ZTW523_GENERAL_DELAY_100 100 -#define ZTW523_GENERAL_DELAY_200 200 -#define ZTW523_GENERAL_DELAY_500 500 -#define ZTW523_GENERAL_RETRY_1 1 -#define ZTW523_GENERAL_RETRY_2 2 -#define ZTW523_GENERAL_RETRY_3 3 -#define ZTW523_GENERAL_RETRY_4 4 -#define ZTW523_GENERAL_RETRY_10 10 -#define ZTW523_RAWDATA_DELAY_FOR_HOST 100 -#define ZTW523_FW_JUMP_CODE 0x0048 -#define ZTW523_REPORT_RATE 60 -#define ZTW523_PIXEL_THRESHOLD 5 - -#ifndef ZTW523_RES_MAX_X -#define ZTW523_RES_MAX_X 453 +#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 ZTW523_RES_MAX_Y -#define ZTW523_RES_MAX_Y 453 +#ifndef FT6X46_RES_MAX_Y +#define FT6X46_RES_MAX_Y 466 #endif -#ifndef ZTW523_POINT_TRESHHOLD -#define ZTW523_POINT_TRESHHOLD 0x19 +#ifndef FT6X46_POINT_TRESHHOLD +#define FT6X46_POINT_TRESHHOLD 0x19 #endif -#define ZTW523_TOUCHINFO_HEAD_LEN 4 -#define ZTW523_POINTINFO_LEN 6 -#define ZTW523_TOUCHINFO_LEN (ZTW523_TOUCHINFO_HEAD_LEN + ZTW523_POINTINFO_LEN * ZTW523_MAX_SUPPORTED_FINGER_NUM) +#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 ZTW523_INT_NONE 0x0000 -#define ZTW523_INT_MASK 0x081F -#define ZTW523_PALM_MASK 0x0010 -#define ZTW523_GESTURE_WAKEUP_INIT 0 -#define ZTW523_FIRMWARE_SIZE 48 +#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 @@ -94,173 +94,173 @@ extern "C" { #define ZTW_CHIPID_E538 0xE538 #define ZTW_CHIPID_E532 0xE532 #define ZTW_VENDOR_ID 0x5A49 -#define ZTW523_CHIP_ID 0xE628 +#define FT6X46_CHIP_ID 0xE628 /* define touch info offset */ -#define ZTW523_STATUSL_OFFSET 0 -#define ZTW523_STATUSH_OFFSET 1 -#define ZTW523_EVENTL_OFFSET 2 -#define ZTW523_EVENTH_OFFSET 3 -#define ZTW523_XL_OFFSET 4 -#define ZTW523_XH_OFFSET 5 -#define ZTW523_YL_OFFSET 6 -#define ZTW523_YH_OFFSET 7 -#define ZTW523_WIDTH_OFFSET 8 -#define ZTW523_SUBSTATUS_OFFSET 9 +#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 ZTW523_SHIFT_8_BIT 8 -#define ZTW523_SHIFT_16_BIT 16 -#define ZTW523_SHIFT_24_BIT 24 -#define ZTW523_MASK_BYTE 0xFF -/* define ZTW523_HIGH_SPEED_DMA rely on iic dma support */ -#ifdef ZTW523_HIGH_SPEED_DMA -#define ZTW523_TOUCH_POINT_MODE 0 +#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 ZTW523_TOUCH_POINT_MODE 1 +#define FT6X46_TOUCH_POINT_MODE 1 #endif -#define ZTW523_SEC_MODE 48 -#define ZTW523_NORMAL_MODE 5 -#define ZTW523_DND_MODE 11 /* mutual cap */ -#define ZTW523_SELF_DND_MODE 17 /* self cap */ -#define ZTW523_DNDSKIP_CNT 1 -#define ZTW523_SELFDNDSKIP_CNT 1 +#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 ZTW523_REG_CMD_ENABLE 0xC000 -#define ZTW523_REG_CHIP_ID 0xCC00 -#define ZTW523_REG_INTN_CLEAR 0xC004 -#define ZTW523_REG_NVM 0xC002 -#define ZTW523_REG_NVM_VPP 0xC003 -#define ZTW523_REG_NVM_WP 0xC104 -#define ZTW523_REG_PROGRAM_START 0xC001 -#define ZTW523_POWER_CTL_BEGIN 0x000A -#define ZTW523_POWER_CTL_END 0x000B -#define ZTW523_CALIB_CTL1 0xC003 -#define ZTW523_CALIB_CTL2 0xC104 -#define ZTW523_SDRAM_RESET 0x0FF8 -#define ZTW523_REPORT_REG 0x0186 /* 设置中断上报频率 */ -#define ZTW523_PIXEL_THRESHOLD_REG 0x00C3 +#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 ZTW523_SWRESET_CMD 0x0000 -#define ZTW523_WAKEUP_CMD 0x0001 -#define ZTW523_IDLE_CMD 0x0004 -#define ZTW523_SLEEP_CMD 0x0005 -#define ZTW523_CLEAR_INT_STATUS_CMD 0x0003 -#define ZTW523_CALIBRATE_CMD 0x0006 -#define ZTW523_SAVE_STATUS_CMD 0x0007 -#define ZTW523_SAVE_CALIBRATION_CMD 0x0008 -#define ZTW523_RECALL_FACTORY_CMD 0x000f -#define ZTW523_SENSITIVITY 0x0020 -#define ZTW523_I2C_CHECKSUM_WCNT 0x016a -#define ZTW523_I2C_CHECKSUM_RESULT 0x016c -#define ZTW523_DEBUG_REG 0x0115 /* 0~7 */ -#define ZTW523_TOUCH_MODE 0x0010 -#define ZTW523_CHIP_REVISION 0x0011 -#define ZTW523_FIRMWARE_VERSION 0x0012 -#define ZTW523_MINOR_FW_VERSION 0x0121 -#define ZTW523_DATA_VERSION_REG 0x0013 -#define ZTW523_HW_ID 0x0014 -#define ZTW523_SUPPORTED_FINGER_NUM 0x0015 -#define ZTW523_EEPROM_INFO 0x0018 -#define ZTW523_INITIAL_TOUCH_MODE 0x0019 -#define ZTW523_CHIP_HW_REVISION 0x001A -#define ZTW523_IC_VENDOR_ID 0x001C -#define ZTW523_TSM_MODULE_ID 0x001E -#define ZTW523_TOTAL_NUMBER_OF_X 0x0060 -#define ZTW523_TOTAL_NUMBER_OF_Y 0x0061 -#define ZTW523_DELAY_RAW_FOR_HOST 0x007f -#define ZTW523_BUTTON_SUPPORTED_NUM 0x00B0 -#define ZTW523_BUTTON_SENSITIVITY 0x00B2 -#define ZTW523_X_RESOLUTION 0x00C0 -#define ZTW523_Y_RESOLUTION 0x00C1 -#define ZTW523_HOLD_POINT_TRESHHOLD 0x00C3 -#define ZTW523_POINT_STATUS_REG 0x0080 -#define ZTW523_ICON_STATUS_REG 0x00AA -#define ZTW523_AFE_FREQUENCY 0x0100 -#define ZTW523_DND_N_COUNT 0x0122 -#define ZTW523_DND_U_COUNT 0x0135 -#define ZTW523_RAWDATA_REG 0x0200 -#define ZTW523_EEPROM_INFO_REG 0x0018 -#define ZTW523_INT_ENABLE_FLAG 0x00f0 -#define ZTW523_PERIODICAL_INTERRUPT_INTERVAL 0x00f1 -#define ZTW523_CHECKSUM_RESULT 0x012c -#define ZTW523_GESTURE_WAKEUP_REG 0x0126 - -#define ZTW523_TOUCHINFO_MASK 0x0F -#define ZTW523_TOUCH_EXIST 0x01 -#define ZTW523_TOUCH_DOWN 0x03 -#define ZTW523_TOUCH_MOVE 0x05 -#define ZTW523_TOUCH_UP 0x08 -#define ZTW523_TOUCH_NONE 0x07 - -#define ZTW523_SUB_BIT_EXIST 0 -#define ZTW523_SUB_BIT_DOWN 1 -#define ZTW523_SUB_BIT_MOVE 2 -#define ZTW523_SUB_BIT_UP 3 -#define ZTW523_SUB_BIT_UPDATE 4 -#define ZTW523_SUB_BIT_WAIT 5 - -#ifndef ZTW523_TSP_X_CHANNEL_NUM -#define ZTW523_TSP_X_CHANNEL_NUM 6 +#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 ZTW523_TSP_Y_CHANNEL_NUM -#define ZTW523_TSP_Y_CHANNEL_NUM 6 +#ifndef FT6X46_TSP_Y_CHANNEL_NUM +#define FT6X46_TSP_Y_CHANNEL_NUM 6 #endif -#define ZTW523_TSP_DND_NUM (ZTW523_TSP_X_CHANNEL_NUM * ZTW523_TSP_Y_CHANNEL_NUM) -#define ZTW523_TSP_SELFDND_NUM (ZTW523_TSP_X_CHANNEL_NUM + ZTW523_TSP_Y_CHANNEL_NUM) +#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 ZTW523_FIRMWARE_VERSION_L 0 -#define ZTW523_FIRMWARE_VERSION_H 1 -#define ZTW523_FIRMWARE_VERSION_OFFSET 52 -#define ZTW523_FIRMWARE_MINOR_VERSION_OFFSET 56 -#define ZTW523_FIRMWARE_DATA_VERSION_OFFSET 60 -#define ZTW523_FIRMWARE_OFFSET_ZERO 0 -#define ZTW523_FIRMWARE_CONVERT_DATA_STEP 2 -#define ZTW523_FIRMWARE_CONVERT_DATA_OFFSET 1 +#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 ZTW523_FILE_ERROR (-1) -#define ZTW523_FILE_OK 0 +#define FT6X46_FILE_ERROR (-1) +#define FT6X46_FILE_OK 0 /* upgrade info */ -#define ZTW523_FWGRADE_CMD_NUM 3 +#define FT6X46_FWGRADE_CMD_NUM 3 /* rawdata info */ -#define ZTW523_RAWDATA_CMD_NUM 2 +#define FT6X46_RAWDATA_CMD_NUM 2 /* define gesture macro */ -#define ZTW523_GESTURE_WAKEUP 1 +#define FT6X46_GESTURE_WAKEUP 1 /* self_dnd dnd parameter */ -#define ZTW523_SEC_SELF_DND_N_COUNT 15 -#define ZTW523_SEC_SELF_DND_U_COUNT 2 -#define ZTW523_SEC_SELF_DND_FREQUENCY 80 +#define FT6X46_SEC_SELF_DND_N_COUNT 15 +#define FT6X46_SEC_SELF_DND_U_COUNT 2 +#define FT6X46_SEC_SELF_DND_FREQUENCY 80 -#define ZTW523_SEC_DND_N_COUNT 27 -#define ZTW523_SEC_DND_U_COUNT 3 -#define ZTW523_SEC_DND_FREQUENCY 240 +#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 { - ZTW523_POWERDOWN = 0, - ZTW523_POWERUP, -} ztw523_sw_power_status; + FT6X46_POWERDOWN = 0, + FT6X46_POWERUP, +} ft6x46_sw_power_status; typedef enum { - ZTW523_WORK_NORMAL = 0, - ZTW523_WORK_STANDBY, - ZTW523_WORK_GETCMCP, - ZTW523_WORK_SLEEP, - ZTW523_WORK_SUSPEND, - ZTW523_WORK_RESUME, - ZTW523_WORK_INVALID, -} ztw523_work_status; + 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 { - ZTW523_NOT_READY = 0, - ZTW523_READY, -} ztw523_device_status; + FT6X46_NOT_READY = 0, + FT6X46_READY, +} ft6x46_device_status; typedef enum { MC_BUTTON_RELEASE = 0, /* button release */ @@ -275,17 +275,17 @@ typedef enum { } touch_key_event_type; typedef enum { - ZTW523_GESTURE_NONE = 0, - ZTW523_GESTURE_SIGNAL_CLICK = 1, - ZTW523_GESTURE_DOUBLE_CLICK = 2, - ZTW523_GESTURE_SLIDE_UP = 4, - ZTW523_GESTURE_SLIDE_DOWN = 5, -} ztw523_gesture_event; + 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 { - ZTW523_IRQ_DISABLE = 0, - ZTW523_IRQ_ENABLE, -} ztw523_irq_status; + FT6X46_IRQ_DISABLE = 0, + FT6X46_IRQ_ENABLE, +} ft6x46_irq_status; typedef enum { MC_TP_NORMAL_WORK_MODE = 0, /* tp normal mode */ @@ -320,13 +320,13 @@ typedef struct { uint16_t ychannel_num; uint16_t total_dnd_num; uint16_t total_self_dnd_num; -} ztw523_panel_data; +} ft6x46_panel_data; typedef struct { uint32_t skip_cnt; - int16_t dnd_data[ZTW523_TSP_DND_NUM]; - int16_t self_dnd_data[ZTW523_TSP_SELFDND_NUM]; -} ztw523_tsp_rawdata; + 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, @@ -374,7 +374,7 @@ typedef struct { uint16_t chip_id; uint16_t vendor_id; uint16_t chip_hw_id; - uint8_t chip_info[ZTW523_DEVICE_INFO_SIZE]; + uint8_t chip_info[FT6X46_DEVICE_INFO_SIZE]; uint16_t firmware_version; uint16_t minor_firmware_version; uint16_t reg_version; @@ -390,27 +390,28 @@ typedef struct { bool fw_upgrade_flag; bool gesture_wakeup; bool host_dev_init_flag; - ztw523_sw_power_status power_status; - ztw523_work_status work_status; - ztw523_sw_power_status chip_sw_power_status; - ztw523_device_status chip_status; + 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; - ztw523_panel_data panel_info; + ft6x46_panel_data panel_info; tp_peripheral_attr dev_attr; - ztw523_tsp_rawdata tsp_raw_data; + ft6x46_tsp_rawdata tsp_raw_data; void *p_void; uint32_t tp_event; - touch_drv_upgrade_proc upgrade_table[ZTW523_FWGRADE_CMD_NUM]; - touch_drv_rawdata_proc raw_data_table[ZTW523_RAWDATA_CMD_NUM]; -} ztw523_drv_data; - -ext_errno ztw523_init(void); -ext_errno ztw523_deinit(void); -ext_errno ztw523_set_power_mode(tp_work_mode power_mode); -ext_errno ztw523_get_power_mode(uint32_t *power_mode); -ext_errno ztw523_resume(void); -ext_errno ztw523_irq_callback(uint8_t *data_buf, uint8_t data_len); -ext_errno ztw523_host_init_sample(void); + 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 } diff --git a/code/sdk/drivers/peripheral/touch/touch_screen_drv.c b/code/sdk/drivers/peripheral/touch/touch_screen_drv.c index a34945c1f..660f2bb73 100644 --- a/code/sdk/drivers/peripheral/touch/touch_screen_drv.c +++ b/code/sdk/drivers/peripheral/touch/touch_screen_drv.c @@ -434,8 +434,15 @@ 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) @@ -450,8 +457,7 @@ void touch_screen_resume(void) #elif defined(TPTYPE_ZTW523) ztw523_resume(); #elif defined(TPTYPE_FT6X46) - ztw523_resume(); - // ft6x46_resume(); + ft6x46_resume(); #else ztw523_resume(); #endif @@ -477,8 +483,7 @@ void touch_screen_restart(void) #elif defined(TPTYPE_ZTW523) ztw523_resume(); #elif defined(TPTYPE_FT6X46) - // ft6x46_resume(); - ztw523_resume(); + ft6x46_resume(); #else ztw523_resume(); #endif