#elif defined(TPTYPE_ZTW523)\r
ztw523_host_init_sample();\r
#elif defined(TPTYPE_FT6X46)\r
- ztw523_host_init_sample();\r
+ ft6x46_host_init_sample();\r
#else\r
ztw523_host_init_sample();\r
#endif\r
#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;
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;
}
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;
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) {
}
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;
return EXT_ERR_SUCCESS;
}
-#endif
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[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) {
}
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;
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;
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;
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);
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;
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)
{
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);
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;
}
-ext_errno ztw523_host_peripheral_init(ztw523_ctrl_attr *attr)
+ext_errno ft6x46_host_peripheral_init(ft6x46_ctrl_attr *attr)
{
ext_errno ret;
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;
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;
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
/* 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);
#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");
return ret;
}
- ret = ztw523_init();
+ 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 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
/*
* Copyright (c) @CompanyNameMagicTag 2021-2022. All rights reserved.
- * Description: ztw523 touch driver.
+ * Description: ft6x46 touch driver.
* Author: @CompanyNameTag
* Create: 2021-05-29
*/
#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;
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:
return;
}
-static ext_errno ztw523_parse_gesture_input(void)
+static ext_errno ft6x46_parse_gesture_input(void)
{
ext_errno ret;
uint16_t gesture_val;
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);
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;
}
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;
}
#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);
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;
}
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);
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;
}
}
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++) {
}
}
-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;
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;
}
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;
#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;
#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;
}
/* 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
#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 */
} 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 */
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,
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;
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
}
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)
#elif defined(TPTYPE_ZTW523)
ztw523_resume();
#elif defined(TPTYPE_FT6X46)
- ztw523_resume();
- // ft6x46_resume();
+ ft6x46_resume();
#else
ztw523_resume();
#endif
#elif defined(TPTYPE_ZTW523)
ztw523_resume();
#elif defined(TPTYPE_FT6X46)
- // ft6x46_resume();
- ztw523_resume();
+ ft6x46_resume();
#else
ztw523_resume();
#endif
projects / mirrors / FD230.git / commitdiff