#include "includes.h" #include "asm/power/p11.h" #include "asm/power/p33.h" #include "asm/lp_touch_key_api.h" #include "asm/lp_touch_key_alog.h" #include "asm/lp_touch_key_hw.h" #include "device/key_driver.h" #include "bt_tws.h" #include "classic/tws_api.h" #include "key_event_deal.h" #include "btstack/avctp_user.h" #include "app_config.h" #define LOG_TAG_CONST LP_KEY #define LOG_TAG "[LP_KEY]" /* #define LOG_ERROR_ENABLE */ /* #define LOG_DEBUG_ENABLE */ #define LOG_INFO_ENABLE #define LOG_DUMP_ENABLE #define LOG_CLI_ENABLE #include "debug.h" #if (TCFG_LP_TOUCH_KEY_ENABLE || TCFG_LP_EARTCH_KEY_ENABLE) //需要开debug的情况 //1.内置触摸调试工具 //2.入耳检测 #define CTMU_CH0_MODULE_DEBUG 1 #define CTMU_CH1_MODULE_DEBUG 0 #define TWS_FUNC_ID_VOL_LP_KEY TWS_FUNC_ID('L', 'K', 'E', 'Y') #define TWS_BT_SEND_CH0_RES_DATA_ENABLE 0 #define TWS_BT_SEND_CH1_RES_DATA_ENABLE 0 #define TWS_BT_SEND_EVENT_ENABLE 0 #define LP_TOUCH_KEY_TIMER_MAGIC_NUM 0xFFFF #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE #ifdef CTMU_RESET_TIME_CONFIG #undef CTMU_RESET_TIME_CONFIG #define CTMU_RESET_TIME_CONFIG 0 #endif /* #ifdef CTMU_RESET_TIME_CONFIG */ #endif /* #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE */ struct ctmu_key { u8 init; u8 ch_init; u8 click_cnt; u8 last_key; u8 last_ear_in_state; u8 ch0_msg_lock; u8 softoff_mode; u16 ch0_msg_lock_timer; u16 short_timer; u16 long_timer; u16 ear_in_timer; u32 lrc_hz; u8 ch1_inear_ok; u16 ch1_trim_value; u16 ch1_trim_flag; const struct lp_touch_key_platform_data *config; }; enum ctmu_key_event { CTMU_KEY_NULL, CTMU_KEY_SHORT_CLICK, CTMU_KEY_LONG_CLICK, CTMU_KEY_HOLD_CLICK, }; enum ch1_event_list { CH1_EAR_IN, CH1_EAR_OUT, }; enum LP_TOUCH_SOFTOFF_MODE { LP_TOUCH_SOFTOFF_MODE_LEGACY = 0, //普通关机 LP_TOUCH_SOFTOFF_MODE_ADVANCE = 1, //带触摸关机 }; static struct ctmu_key _ctmu_key = { .click_cnt = 0, .last_ear_in_state = CH1_EAR_OUT, .short_timer = LP_TOUCH_KEY_TIMER_MAGIC_NUM, .long_timer = LP_TOUCH_KEY_TIMER_MAGIC_NUM, .ear_in_timer = LP_TOUCH_KEY_TIMER_MAGIC_NUM, .last_key = CTMU_KEY_NULL, }; struct ch_ana_cfg { u8 isel; u8 vhsel; u8 vlsel; }; struct ch_adjust_table { u16 cfg0; u16 cfg1; u16 cfg2; }; //cap(电容)检测灵敏度级数配置 //模具厚度, 触摸片面积有关 //模具越厚, 触摸片面积越大, 触摸时电容变化量 //cap检测灵敏度级数配置建议从级数0开始调, 选取合适的灵敏度; const static struct ch_adjust_table ch0_sensitivity_table[] = { /* cfg0 cfg1 cfg2 */ {20, 30, 550}, //cap检测灵敏度级数0 {15, 20, 270}, //cap检测灵敏度级数1 {15, 20, 240}, //cap检测灵敏度级数2 {15, 20, 210}, //cap检测灵敏度级数3 {15, 20, 180}, //cap检测灵敏度级数4 {15, 20, 150}, //cap检测灵敏度级数5 {15, 20, 120}, //cap检测灵敏度级数6 {15, 20, 90}, //cap检测灵敏度级数7 {10, 15, 60}, //cap检测灵敏度级数8 {10, 15, 30}, //cap检测灵敏度级数9 }; const static struct ch_adjust_table ch1_sensitivity_table[] = { /* cfg0 cfg1 cfg2 */ {15, 20, 230}, //cap检测灵敏度级数0 {15, 20, 210}, //cap检测灵敏度级数1 {15, 20, 190}, //cap检测灵敏度级数2 {15, 20, 170}, //cap检测灵敏度级数3 {15, 20, 150}, //cap检测灵敏度级数4 {15, 20, 130}, //cap检测灵敏度级数5 {15, 20, 110}, //cap检测灵敏度级数6 {15, 20, 80}, //cap检测灵敏度级数7 {10, 15, 70}, //cap检测灵敏度级数8 {10, 15, 50}, //cap检测灵敏度级数9 }; #define LPCTMU_VH_LEVEL 3 // 上限电压档位 #define LPCTMU_VL_LEVEL 0 // 下限电压档位 #define LPCTMU_CUR_LEVEL 7 // 充放电电流档位 static const u8 lpctmu_ana_vh_table[4] = { LPCTMU_VH_065V, LPCTMU_VH_070V, LPCTMU_VH_075V, LPCTMU_VH_080V, }; static const u8 lpctmu_ana_vl_table[4] = { LPCTMU_VL_020V, LPCTMU_VL_025V, LPCTMU_VL_030V, LPCTMU_VL_035V, }; static const u8 lpctmu_ana_cur_table[8] = { LPCTMU_ISEL_008UA, LPCTMU_ISEL_024UA, LPCTMU_ISEL_040UA, LPCTMU_ISEL_056UA, LPCTMU_ISEL_072UA, LPCTMU_ISEL_088UA, LPCTMU_ISEL_104UA, LPCTMU_ISEL_120UA }; u8 get_lpctmu_ana_level(void) { return ((lpctmu_ana_vh_table[LPCTMU_VH_LEVEL]) | \ (lpctmu_ana_vl_table[LPCTMU_VL_LEVEL]) | \ (lpctmu_ana_cur_table[LPCTMU_CUR_LEVEL])); } struct lp_touch_key_alog_cfg { u16 ready_flag; u16 range; s32 sigma; }; static struct lp_touch_key_alog_cfg alog_cfg = { .ready_flag = 0, .range = 0, .sigma = 0, }; static u16 res_stable_cnt = 0; static u8 ch0_range_sensity = 7; static u16 ctmu_ch0_res_scan_time_add = 0; static u16 save_alog_cfg_time_out = 0; #define TOUCH_RANGE_MIN 50 #define TOUCH_RANGE_MAX 500 #define CH1_SOFT_INEAR_VAL 180 #define CH1_SOFT_OUTEAR_VAL 120 int eartch_event_deal_init(void); #define __this (&_ctmu_key) #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE static int lp_touch_key_online_debug_init(void); static int lp_touch_key_online_debug_send(u8 ch, u16 val); static int lp_touch_key_online_debug_key_event_handle(u8 ch_index, struct sys_event *event); #endif /* #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE */ static volatile u8 is_lpkey_active = 0; //init io HZ static void ctmu_port_init(u8 port) { gpio_set_die(port, 0); gpio_set_dieh(port, 0); gpio_set_direction(port, 1); gpio_set_pull_down(port, 0); gpio_set_pull_up(port, 0); } static void lp_touch_key_send_cmd(enum CTMU_M2P_CMD cmd) { M2P_CTMU_CMD = cmd; P11_M2P_INT_SET = BIT(M2P_CTMU_INDEX); } static u32 lp_touch_key_get_lrc_hz(void) { ASSERT(__this->lrc_hz, "lrc_hz is ZERO"); return __this->lrc_hz; } #if TCFG_LP_EARTCH_KEY_ENABLE void eartch_hardware_recover(void) { lp_touch_key_send_cmd(CTMU_M2P_CH1_ENABLE); } void eartch_hardware_suspend(void) { __this->ch_init &= ~BIT(1); lp_touch_key_send_cmd(CTMU_M2P_CH1_DISABLE); } #endif /* #if TCFG_LP_EARTCH_KEY_ENABLE */ //=========================================// //模块配置顺序: Select ctmu clk --> Enable --> Reset --> 配置参数 --> Run static void __lpctmu_reset(u8 para_reset) { LP_CTMU_CLK_SEL(LP_CTMU_CLK_SEL_P11_SYS_CLK); //sel sys_clk 12M, 加快配置速度 LP_CTMU_MODULE_EN(1); //lctm en LP_CTMU_RUN(0); //lctm run (内部状态机复位) if (para_reset) { LP_CTMU_CFG_RESET(0); //lctm 配置参数reset } delay(100); LP_CTMU_CFG_RESET(1); //lctm reset } //=========================================// #if !TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE void lp_touch_key_save_alog_cfg(void *priv) { int ret = syscfg_write(VM_LP_TOUCH_KEY_ALOG_CFG, (void *)&alog_cfg, sizeof(struct lp_touch_key_alog_cfg)); if (ret != sizeof(struct lp_touch_key_alog_cfg)) { log_info("write vm alog cfg ready flag error !\n"); } save_alog_cfg_time_out = 0; } void lp_touch_key_ctmu_ch0_cfg2_check_update(u16 cfg2_new) { u16 cfg2_old = (M2P_CTMU_CH0_CFG2H << 8) | M2P_CTMU_CH0_CFG2L; if (cfg2_old != cfg2_new) { printf("ctmu ch0 cfg2_old = %d cfg_new = %d\n", cfg2_old, cfg2_new); printf("change ctmu ch0 cfg2 !\n"); M2P_CTMU_CH0_CFG2H = (cfg2_new >> 8) & 0xff; M2P_CTMU_CH0_CFG2L = (cfg2_new >> 0) & 0xff; } } static void lp_touch_key_ctmu_ch0_res_scan(void *priv) { if (M2P_CTMU_CH0_RES_SEND) { return; } u16 ctmu_ch0_res0; u16 ctmu_ch0_res1; __read_res: ctmu_ch0_res0 = (P2M_CTMU_CH0_H_RES << 8) | P2M_CTMU_CH0_L_RES; delay(100); ctmu_ch0_res1 = (P2M_CTMU_CH0_H_RES << 8) | P2M_CTMU_CH0_L_RES; if (ctmu_ch0_res0 != ctmu_ch0_res1) { goto __read_res; } #if 1 if ((ctmu_ch0_res0 < 2000) || (ctmu_ch0_res0 > 20000)) { return; } if (res_stable_cnt < 50) { res_stable_cnt ++; return; } TouchAlgo_Update(0, ctmu_ch0_res0); u8 range_valid = 0; u16 touch_range = TouchAlgo_GetRange(0, (u8 *)&range_valid); s32 touch_sigma = TouchAlgo_GetSigma(0); /* printf("res:%d range:%d val:%d sigma:%d\n", ctmu_ch0_res0, touch_range, range_valid, touch_sigma); */ if ((range_valid) && (touch_range > TOUCH_RANGE_MIN) && (touch_range < TOUCH_RANGE_MAX)) { u16 cfg2_new = touch_range * (10 - ch0_range_sensity) / 10; lp_touch_key_ctmu_ch0_cfg2_check_update(cfg2_new); if (touch_range != alog_cfg.range) { alog_cfg.range = touch_range; alog_cfg.sigma = touch_sigma; if (save_alog_cfg_time_out == 0) { save_alog_cfg_time_out = sys_timeout_add(NULL, lp_touch_key_save_alog_cfg, 1); } } } else if ((range_valid) && (touch_range > TOUCH_RANGE_MAX)) { TouchAlgo_SetRange(0, alog_cfg.range); } #endif } void lp_touch_key_alog_ready_flag_check_and_set(void) { alog_cfg.ready_flag = 0; syscfg_read(VM_LP_TOUCH_KEY_ALOG_CFG, (void *)&alog_cfg, sizeof(struct lp_touch_key_alog_cfg)); if (alog_cfg.ready_flag == 0) { alog_cfg.ready_flag = 1; lp_touch_key_save_alog_cfg(NULL); } } void lp_touch_key_alog_init(u8 cfg2_sensity) { TouchAlgo_Init(0, TOUCH_RANGE_MIN, TOUCH_RANGE_MAX); res_stable_cnt = 0; ch0_range_sensity = cfg2_sensity; int ret = syscfg_read(VM_LP_TOUCH_KEY_ALOG_CFG, (void *)&alog_cfg, sizeof(struct lp_touch_key_alog_cfg)); if ((ret == (sizeof(struct lp_touch_key_alog_cfg))) && (alog_cfg.range > TOUCH_RANGE_MIN) && (alog_cfg.range < TOUCH_RANGE_MAX) && (alog_cfg.ready_flag)) { log_info("vm read alog ready_flag:%d sigma:%d range:%d\n", alog_cfg.ready_flag, alog_cfg.sigma, alog_cfg.range); TouchAlgo_SetSigma(0, alog_cfg.sigma); TouchAlgo_SetRange(0, alog_cfg.range); u16 new_cfg2 = alog_cfg.range * (10 - ch0_range_sensity) / 10; LP_CTMU_CH0_EDGE_TH(new_cfg2); } #if 1 //触摸算法要尽可能的在装完整机之后开始跑，而这里是耳机生产流程中获取它第一次在舱内开机的时候，在vm标记一个变量，从此开始跑算法。 if (get_charge_online_flag()) { log_info("check charge online !\n"); lp_touch_key_alog_ready_flag_check_and_set();//如果有其他好的位置，请将该函数移到那个位置执行。 } #endif if ((alog_cfg.ready_flag) && (ctmu_ch0_res_scan_time_add == 0)) { ctmu_ch0_res_scan_time_add = usr_timer_add(NULL, lp_touch_key_ctmu_ch0_res_scan, 20, 0); } } #endif #define IO_PORT_RESET_PORT_LDOIN LINDT_IN//IO编号 #define IO_RESET_PORTB_01 11 void lp_touch_key_init(const struct lp_touch_key_platform_data *config) { log_info("%s >>>>", __func__); ASSERT(config && (__this->init == 0)); __this->config = config; M2P_CTMU_MSG = 0; //长按复位检测 u8 pinr_io; if (P33_CON_GET(P3_PINR_CON) & BIT(0)) { pinr_io = P33_CON_GET(P3_PORT_SEL0); if (pinr_io == IO_RESET_PORTB_01) { P33_CON_SET(P3_PINR_CON, 0, 1, 0); p33_tx_1byte(P3_PORT_SEL0, IO_PORT_RESET_PORT_LDOIN); P33_CON_SET(P3_PINR_CON, 2, 1, 1); P33_CON_SET(P3_PINR_CON, 0, 1, 1); log_info("reset pin change: old: %d, new: %d, P33_PINR_CON = 0x%x", pinr_io, P33_CON_GET(P3_PORT_SEL0), P33_CON_GET(P3_PINR_CON)); } } u8 ch0_sensity = __this->config->ch0.sensitivity; u8 ch1_sensity = __this->config->ch1.sensitivity; LP_TOUCH_KEY_CONFIG tool_cfg; int ret = syscfg_read(CFG_LP_TOUCH_KEY_ID, &tool_cfg, sizeof(LP_TOUCH_KEY_CONFIG)); if (ret > 0) { log_info("cfg_en: %d, ch0_sensity_cfg: %d, ch1_sensity_cfg: %d", tool_cfg.cfg_en, tool_cfg.touch_key_sensity_class, tool_cfg.earin_key_sensity_class); if (tool_cfg.cfg_en) { ch0_sensity = tool_cfg.touch_key_sensity_class; ch1_sensity = tool_cfg.earin_key_sensity_class; } } else { log_error("touch key cfg not exist"); } log_info("ch0_sensity: %d, ch1_sensity: %d", ch0_sensity, ch1_sensity); //==============================================================// // CH0 初始化 // //==============================================================// __lpctmu_reset(1); //模块复位 LP_CTMU_SWITCH_STABLE_TIME_SET(); //CTMU 时基配置: u16 time_prd = 0; if (__this->lrc_hz) { time_prd = (__this->lrc_hz * CTMU_TIME_BASE) / 1000 - 1; } else { time_prd = CFG_M2P_CTMU_BASE_TIME_PRD; } LP_CTMU_TIMER_BASE_CONFIG(time_prd); log_info("LRC_HZ = %d, time_prd = %d", __this->lrc_hz, time_prd); if (__this->config->ch0.enable) { //PB1和PB2通道互换IO: if (__this->config->ch0.port == IO_PORTB_02) { LP_CTMU_IO_INV(1); } else { LP_CTMU_IO_INV(0); ASSERT(__this->config->ch0.port == IO_PORTB_01); } M2P_CTMU_MSG |= CTMU_INIT_CH0_ENABLE; ctmu_port_init(__this->config->ch0.port); //模拟参数配置: LP_CTMU_CH0_ANA_CFG(get_lpctmu_ana_level()); //通用配置: LP_CTMU_CH0_ENABLE(1); //通道0使能 LP_CTMU_CH0_FILTER_LEVEL(1); //通道0滤波级数 LP_CTMU_CH0_FILTER_EN(1); //通道0滤波使能 LP_CTMU_CH0_EDGE_EN(1); //通道0边沿检测使能 LP_CTMU_CH0_EDGE_TEMP_EN(1); //fixed LP_CTMU_CH0_FIRST_RISE_MASK(0); //屏蔽第一个上升沿 //上升沿中断: LP_CTMU_CH0_FALL_PENDING_CLR(); LP_CTMU_CH0_FALL_PENDING_IE(1); LP_CTMU_CH0_FALL_PENDING_SEL(0); //下升沿中断: LP_CTMU_CH0_RISE_PENDING_CLR(); LP_CTMU_CH0_RISE_PENDING_IE(1); LP_CTMU_CH0_RISE_PENDING_SEL(0); //多击模式: LP_CTMU_CH0_SHORT_KEY_MODE(1); #if CTMU_CH0_MODULE_DEBUG LP_CTMU_CH0_RES_PENDING_IE(1); M2P_CTMU_MSG |= CTMU_INIT_CH0_DEBUG; #endif /* #if CTMU_CH0_MODULE_DEBUG */ LP_CTMU_CH0_SHORT_KEY_TRIGGER(0); LP_CTMU_CH0_SHORT_PENDING_CLR(); LP_CTMU_CH0_SHORT_PENDING_IE(0); LP_CTMU_CH0_LONG_PENDING_CLR(); LP_CTMU_CH0_LONG_PENDING_IE(1); LP_CTMU_CH0_HOLD_PENDING_CLR(); LP_CTMU_CH0_HOLD_PENDING_IE(1); LP_CTMU_CH0_HOLD_EN(1); LP_CTMU_CH0_KEY_MODE_ENABLE(1); //快速 & 低速扫描周期 LP_CTMU_CH0_HIGH_SPEED_PRD(CFG_CTMU_CH0_HS_PERIOD_VALUE); LP_CTMU_CH0_LOW_SPEED_PRD(CFG_CTMU_CH0_LS_PERIOD_VALUE); //采样窗口时间 LP_CTMU_CH0_DET_TIME(CFG_CTMU_CH0_WINDOW_TIME_VALUE); ASSERT(ch0_sensity < ARRAY_SIZE(ch0_sensitivity_table)); //CH0阈值: LP_CTMU_CH0_TEMP_TH(ch0_sensitivity_table[ch0_sensity].cfg0); LP_CTMU_CH0_STABLE_TH(ch0_sensitivity_table[ch0_sensity].cfg0 + 5); LP_CTMU_CH0_EDGE_TH(ch0_sensitivity_table[ch0_sensity].cfg2); M2P_CTMU_CH0_CFG2H = (ch0_sensitivity_table[ch0_sensity].cfg2 >> 8) & 0xff; M2P_CTMU_CH0_CFG2L = (ch0_sensitivity_table[ch0_sensity].cfg2 >> 0) & 0xff; //CH0 按键时间: LP_CTMU_CH0_SHORT_KEY_TIME(CFG_M2P_CTMU_CH0_SHORT_TIME_VALUE); LP_CTMU_CH0_LONG_KEY_TIME(CFG_M2P_CTMU_CH0_LONG_TIME_VALUE); LP_CTMU_CH0_HOLD_KEY_TIME(CFG_M2P_CTMU_CH0_HOLD_TIME_VALUE); LP_CTMU_CH0_IE(1); //长按开机时间配置 M2P_CTMU_CH0_SOFTOFF_LONG_TIMEL = (CFG_M2P_CTMU_CH0_SOFTOFF_LONG_TIME & 0xFF); M2P_CTMU_CH0_SOFTOFF_LONG_TIMEH = ((CFG_M2P_CTMU_CH0_SOFTOFF_LONG_TIME >> 8) & 0xFF); log_info("P11_LCTM_CON = 0x%x", P11_LCTM_CON); log_info("LCTM_MOD = 0x%x", LCTM_MOD); log_info("LCTM_TMR = 0x%x", LCTM_TMR); log_info("LCTM_TIME_BASE_H = 0x%x", LCTM_TIME_BASE_H); log_info("LCTM_TIME_BASE_L = 0x%x", LCTM_TIME_BASE_L); log_info("LCTM_CHL0_ANA = 0x%x", LCTM_CHL0_ANA); log_info("LCTM_CHL0_CON0 = 0x%x", LCTM_CHL0_CON0); log_info("LCTM_CHL0_CON1 = 0x%x", LCTM_CHL0_CON1); log_info("LCTM_CHL0_CON2 = 0x%x", LCTM_CHL0_CON2); log_info("LCTM_CHL0_CON3 = 0x%x", LCTM_CHL0_CON3); log_info("LCTM_CHL0_HS_PRD = 0x%x", LCTM_CHL0_HS_PRD); log_info("LCTM_CHL0_LS_PRD = 0x%x", LCTM_CHL0_LS_PRD); log_info("LCTM_CHL0_DET_TIME_H = 0x%x", LCTM_CHL0_DET_TIME_H); log_info("LCTM_CHL0_DET_TIME_L = 0x%x", LCTM_CHL0_DET_TIME_L); log_info("LCTM_CHL0_TEMP_H = 0x%x", LCTM_CHL0_TEMP_H); log_info("LCTM_CHL0_TEMP_L = 0x%x", LCTM_CHL0_TEMP_L); log_info("LCTM_CHL0_STA_H = 0x%x", LCTM_CHL0_STA_H); log_info("LCTM_CHL0_STA_L = 0x%x", LCTM_CHL0_STA_L); log_info("LCTM_CHL0_EDGE_H = 0x%x", LCTM_CHL0_EDGE_H); log_info("LCTM_CHL0_EDGE_L = 0x%x", LCTM_CHL0_EDGE_L); log_info("LCTM_CHL0_SHORT_H = 0x%x", LCTM_CHL0_SHORT_H); log_info("LCTM_CHL0_SHORT_L = 0x%x", LCTM_CHL0_SHORT_L); log_info("LCTM_CHL0_LONG_H = 0x%x", LCTM_CHL0_LONG_H); log_info("LCTM_CHL0_LONG_L = 0x%x", LCTM_CHL0_LONG_L); log_info("LCTM_CHL0_HOLD_H = 0x%x", LCTM_CHL0_HOLD_H); log_info("LCTM_CHL0_HOLD_L = 0x%x", LCTM_CHL0_HOLD_L); #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE M2P_CTMU_CH0_RES_SEND = 1; #else M2P_CTMU_CH0_RES_SEND = 0; #endif #if CTMU_CH0_MODULE_DEBUG #if !TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE if (!M2P_CTMU_CH0_RES_SEND) { lp_touch_key_alog_init(ch0_sensity); } #endif #endif } //==============================================================// // CH1 初始化 // //==============================================================// if (__this->config->ch1.enable) { if (__this->config->ch1.port == IO_PORTB_01) { LP_CTMU_IO_INV(1); } else { LP_CTMU_IO_INV(0); ASSERT(__this->config->ch1.port == IO_PORTB_02); } M2P_CTMU_MSG |= CTMU_INIT_CH1_ENABLE; ctmu_port_init(__this->config->ch1.port); //模拟参数配置: LP_CTMU_CH1_ANA_CFG(get_lpctmu_ana_level()); //通用配置: LP_CTMU_CH1_ENABLE(1); //通道0使能 LP_CTMU_CH1_FILTER_LEVEL(1); //通道0滤波级数 LP_CTMU_CH1_FILTER_EN(1); //通道0滤波使能 LP_CTMU_CH1_EDGE_EN(1); //通道0边沿检测使能 LP_CTMU_CH1_EDGE_TEMP_EN(1); //fixed LP_CTMU_CH1_FIRST_RISE_MASK(0); //屏蔽第一个上升沿 //上升沿中断: LP_CTMU_CH1_FALL_PENDING_CLR(); LP_CTMU_CH1_FALL_PENDING_IE(1); LP_CTMU_CH1_FALL_PENDING_SEL(0); //下升沿中断: LP_CTMU_CH1_RISE_PENDING_CLR(); LP_CTMU_CH1_RISE_PENDING_IE(1); LP_CTMU_CH1_RISE_PENDING_SEL(0); #if CTMU_CH1_MODULE_DEBUG LP_CTMU_CH1_RES_PENDING_IE(1); M2P_CTMU_MSG |= CTMU_INIT_CH1_DEBUG; #endif /* #if CTMU_CH1_MODULE_DEBUG */ //快速 & 低速扫描周期 LP_CTMU_CH1_HIGH_SPEED_PRD(CFG_CTMU_CH1_HS_PERIOD_VALUE); LP_CTMU_CH1_LOW_SPEED_PRD(CFG_CTMU_CH1_LS_PERIOD_VALUE); //采样窗口时间 LP_CTMU_CH1_DET_TIME(CFG_CTMU_CH1_WINDOW_TIME_VALUE); ASSERT(ch1_sensity < ARRAY_SIZE(ch1_sensitivity_table)); //CH1阈值: LP_CTMU_CH1_TEMP_TH(ch1_sensitivity_table[ch1_sensity].cfg0); LP_CTMU_CH1_STABLE_TH(ch1_sensitivity_table[ch1_sensity].cfg0 + 5); LP_CTMU_CH1_EDGE_TH(ch1_sensitivity_table[ch1_sensity].cfg2); LP_CTMU_CH1_IE(1); log_info("P11_LCTM_CON = 0x%x", P11_LCTM_CON); log_info("LCTM_MOD = 0x%x", LCTM_MOD); log_info("LCTM_TMR = 0x%x", LCTM_TMR); log_info("LCTM_TIME_BASE_H = 0x%x", LCTM_TIME_BASE_H); log_info("LCTM_TIME_BASE_L = 0x%x", LCTM_TIME_BASE_L); log_info("LCTM_CHL1_ANA = 0x%x", LCTM_CHL1_ANA); log_info("LCTM_CHL1_CON0 = 0x%x", LCTM_CHL1_CON0); log_info("LCTM_CHL1_CON1 = 0x%x", LCTM_CHL1_CON1); log_info("LCTM_CHL1_CON2 = 0x%x", LCTM_CHL1_CON2); log_info("LCTM_CHL1_HS_PRD = 0x%x", LCTM_CHL1_HS_PRD); log_info("LCTM_CHL1_LS_PRD = 0x%x", LCTM_CHL1_LS_PRD); log_info("LCTM_CHL1_DET_TIME_H = 0x%x", LCTM_CHL1_DET_TIME_H); log_info("LCTM_CHL1_DET_TIME_L = 0x%x", LCTM_CHL1_DET_TIME_L); log_info("LCTM_CHL1_TEMP_H = 0x%x", LCTM_CHL1_TEMP_H); log_info("LCTM_CHL1_TEMP_L = 0x%x", LCTM_CHL1_TEMP_L); log_info("LCTM_CHL1_STA_H = 0x%x", LCTM_CHL1_STA_H); log_info("LCTM_CHL1_STA_L = 0x%x", LCTM_CHL1_STA_L); log_info("LCTM_CHL1_EDGE_H = 0x%x", LCTM_CHL1_EDGE_H); log_info("LCTM_CHL1_EDGE_L = 0x%x", LCTM_CHL1_EDGE_L); #if (TCFG_EARTCH_EVENT_HANDLE_ENABLE && TCFG_LP_EARTCH_KEY_ENABLE) if (eartch_event_deal_init() == 0) { sys_timeout_add(NULL, eartch_hardware_suspend, 500); } #endif /* #if (TCFG_EARTCH_EVENT_HANDLE_ENABLE && TCFG_LP_EARTCH_KEY_ENABLE) */ #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE M2P_CTMU_CH1_RES_SEND = 1; #else M2P_CTMU_CH1_RES_SEND = 0; #endif u16 trim_value; int ret = syscfg_read(LP_KEY_EARTCH_TRIM_VALUE, &trim_value, sizeof(trim_value)); __this->ch1_trim_flag = 0; __this->ch1_inear_ok = 0; if (ret > 0) { __this->ch1_trim_value = trim_value; M2P_CTMU_CH1_TRIM_VALUE_L = (__this->ch1_trim_value & 0xFF); M2P_CTMU_CH1_TRIM_VALUE_H = ((__this->ch1_trim_value >> 8) & 0xFF); __this->ch1_inear_ok = 1; log_info("ch1_trim_value = %d", __this->ch1_trim_value); } else { __this->ch1_trim_value = 0; //没有trim的情况下用不了 M2P_CTMU_CH1_TRIM_VALUE_L = (10000 & 0xFF); M2P_CTMU_CH1_TRIM_VALUE_H = ((10000 >> 8) & 0xFF); } //软件触摸灵敏度调试 M2P_CTM_INEAR_VALUE_L = CH1_SOFT_INEAR_VAL & 0xFF; M2P_CTM_INEAR_VALUE_H = CH1_SOFT_INEAR_VAL >> 8; M2P_CTM_OUTEAR_VALUE_L = CH1_SOFT_OUTEAR_VAL & 0xFF; M2P_CTM_OUTEAR_VALUE_H = CH1_SOFT_OUTEAR_VAL >> 8; } //CTMU 初始化命令 lp_touch_key_send_cmd(CTMU_M2P_INIT); __this->softoff_mode = LP_TOUCH_SOFTOFF_MODE_ADVANCE; __this->init = 1; #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE lp_touch_key_online_debug_init(); #endif /* #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE */ } int __attribute__((weak)) lp_touch_key_event_remap(struct sys_event *e) { return true; } static void __ctmu_notify_key_event(struct sys_event *event) { event->type = SYS_KEY_EVENT; event->u.key.type = KEY_DRIVER_TYPE_CTMU_TOUCH; //区分按键类型 event->arg = (void *)DEVICE_EVENT_FROM_KEY; if ((event->u.key.value == __this->config->ch0.key_value) && (__this->ch0_msg_lock) #if ((defined CFG_EAROUT_NOTIFY_CH0_ONE_CLICK_EVNET) && (CFG_EAROUT_NOTIFY_CH0_ONE_CLICK_EVNET == 0)) && (event->u.key.event == KEY_EVENT_CLICK) #endif /* #if (CFG_EAROUT_NOTIFY_CH0_ONE_CLICK_EVNET == 0) */ ) { return; } if (__this->config->ch1.enable) { #if (CFG_EAROUT_NOTIFY_CH0_EVENT_SEL == CFG_EAROUT_NO_NOTIFY_CH0_ALL_EVENT) if ((event->u.key.value == __this->config->ch0.key_value) && (__this->last_ear_in_state == CH1_EAR_OUT)) { return; } #elif (CFG_EAROUT_NOTIFY_CH0_EVENT_SEL == CFG_EAROUT_NO_NOTIFY_CH0_CLICK_EVENT) if ((event->u.key.value == __this->config->ch0.key_value) && (__this->last_ear_in_state == CH1_EAR_OUT) && ((event->u.key.event == KEY_EVENT_CLICK) || (event->u.key.event == KEY_EVENT_DOUBLE_CLICK) || (event->u.key.event == KEY_EVENT_TRIPLE_CLICK) )) { return; } #else //TODO: #endif } #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE if (lp_touch_key_online_debug_key_event_handle(0, event)) { return; } #endif /* #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE */ if (lp_touch_key_event_remap(event)) { sys_event_notify(event); } } __attribute__((weak)) u8 remap_ctmu_short_click_event(u8 click_cnt, u8 event) { return event; } static void __ctmu_short_click_time_out_handle(void *priv) { struct sys_event e; switch (__this->click_cnt) { case 0: return; break; case 1: e.u.key.event = KEY_EVENT_CLICK; break; case 2: e.u.key.event = KEY_EVENT_DOUBLE_CLICK; break; case 3: e.u.key.event = KEY_EVENT_TRIPLE_CLICK; break; default: e.u.key.event = KEY_EVENT_TRIPLE_CLICK; break; } e.u.key.event = remap_ctmu_short_click_event(__this->click_cnt, e.u.key.event); e.u.key.value = __this->config->ch0.key_value; __this->short_timer = LP_TOUCH_KEY_TIMER_MAGIC_NUM; __this->last_key = CTMU_KEY_NULL; log_debug("notify key short event, cnt: %d", __this->click_cnt); __ctmu_notify_key_event(&e); } static void __ctmu_short_click_time_test(void *priv) { return; } static void __ctmu_short_click_handle(void) { __this->last_key = CTMU_KEY_SHORT_CLICK; u8 click_cnt = LP_CTMU_CH0_SHORT_KEY_CNT_GET(); __this->click_cnt = click_cnt; log_debug("click_cnt = %d", click_cnt); __ctmu_short_click_time_out_handle(NULL); } static void ctmu_short_click_handle(void) { __this->last_key = CTMU_KEY_SHORT_CLICK; if (__this->short_timer == LP_TOUCH_KEY_TIMER_MAGIC_NUM) { __this->click_cnt = 1; __this->short_timer = usr_timeout_add(NULL, __ctmu_short_click_time_out_handle, CTMU_SHORT_CLICK_DELAY_TIME, 1); } else { __this->click_cnt++; usr_timer_modify(__this->short_timer, CTMU_SHORT_CLICK_DELAY_TIME); } } static void ctmu_raise_click_handle(void) { struct sys_event e = {0}; if (__this->last_key >= CTMU_KEY_LONG_CLICK) { #if 0 if (__this->long_timer != LP_TOUCH_KEY_TIMER_MAGIC_NUM) { usr_timer_del(__this->long_timer); __this->long_timer = LP_TOUCH_KEY_TIMER_MAGIC_NUM; } #endif e.u.key.event = KEY_EVENT_UP; e.u.key.value = __this->config->ch0.key_value; __ctmu_notify_key_event(&e); __this->last_key = CTMU_KEY_NULL; log_debug("notify key HOLD UP event"); } else { ctmu_short_click_handle(); } } static void ctmu_long_click_handle(void) { __this->last_key = CTMU_KEY_LONG_CLICK; struct sys_event e; e.u.key.event = KEY_EVENT_LONG; e.u.key.value = __this->config->ch0.key_value; __ctmu_notify_key_event(&e); } static void ctmu_hold_click_handle(void) { __this->last_key = CTMU_KEY_HOLD_CLICK; struct sys_event e; e.u.key.event = KEY_EVENT_HOLD; e.u.key.value = __this->config->ch0.key_value; __ctmu_notify_key_event(&e); } __attribute__((weak)) void ear_lptouch_update_state(u8 state) { return; } extern void ear_lptouch_update_state(u8 state); extern void eartch_state_update(u8 state); static void __ctmu_ear_in_timeout_handle(void *priv) { u8 state; __this->ear_in_timer = 0xFFFF; if (__this->config->ch1.key_value == 0xFF) { //使用外部自定义流程 if (__this->last_ear_in_state == CH1_EAR_IN) { ear_lptouch_update_state(0); } else { ear_lptouch_update_state(1); } return; } #if TCFG_EARTCH_EVENT_HANDLE_ENABLE if (__this->last_ear_in_state == CH1_EAR_IN) { state = EARTCH_STATE_IN; } else if (__this->last_ear_in_state == CH1_EAR_OUT) { state = EARTCH_STATE_OUT; } else { return; } eartch_state_update(state); #endif /* #if TCFG_EARTCH_EVENT_HANDLE_ENABLE */ } static void __ctmu_ch0_unlock_timeout_handle(void *priv) { __this->ch0_msg_lock = false; __this->ch0_msg_lock_timer = 0; } static void ctmu_ch1_event_handle(u8 ch1_event) { __this->last_ear_in_state = ch1_event; #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE struct sys_event event; if (ch1_event == CH1_EAR_IN) { event.u.key.event = 10; } else if (ch1_event == CH1_EAR_OUT) { event.u.key.event = 11; } if (lp_touch_key_online_debug_key_event_handle(1, &event)) { return; } #endif /* #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE */ __this->ch0_msg_lock = true; if (__this->ch0_msg_lock_timer == 0) { __this->ch0_msg_lock_timer = sys_hi_timeout_add(NULL, __ctmu_ch0_unlock_timeout_handle, 3000); } else { sys_hi_timer_modify(__this->ch0_msg_lock_timer, 3000); } __ctmu_ear_in_timeout_handle(NULL); } static int tws_api_send_data_test(void *data, int len, u32 func_id); static void tws_send_event_data(int msg, int type) { u32 event_data[4]; if (tws_api_get_tws_state() & TWS_STA_SIBLING_CONNECTED) { event_data[0] = type; event_data[1] = jiffies_to_msecs(jiffies); event_data[2] = msg; tws_api_send_data_test(event_data, 3 * sizeof(int), TWS_FUNC_ID_VOL_LP_KEY); } } void tws_send_vddio_data(u8 data) { tws_send_event_data(data, BT_EVENT_VDDIO); } static void tws_send_res_data(int data1, int data2, int data3, int type) { u32 event_data[4]; if (tws_api_get_tws_state() & TWS_STA_SIBLING_CONNECTED) { event_data[0] = type; event_data[1] = data1; event_data[2] = data2; event_data[3] = data3; tws_api_send_data_test(event_data, 4 * sizeof(int), TWS_FUNC_ID_VOL_LP_KEY); } } __attribute__((weak)) u32 user_send_cmd_prepare(USER_CMD_TYPE cmd, u16 param_len, u8 *param) { return 0; } static u8 lp_touch_key_testbox_remote_test(u8 event) { u8 ret = true; u8 key_report = 0; switch (event) { case CTMU_P2M_CH0_FALLING_EVENT: key_report = 0xF1; log_info("Notify testbox CH0 Down"); break; case CTMU_P2M_CH0_RAISING_EVENT: key_report = 0xF2; log_info("Notify testbox CH0 Up"); break; case CTMU_P2M_CH0_LONG_KEY_EVENT: case CTMU_P2M_CH0_SHORT_KEY_EVENT: case CTMU_P2M_CH0_HOLD_KEY_EVENT: break; default: ret = false; break; } if (key_report) { user_send_cmd_prepare(USER_CTRL_TEST_KEY, 1, &key_report); //音量加 } return ret; } void lp_touch_key_testbox_inear_trim(u8 flag) { #if (!TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE) if (flag == 1) { __this->ch1_trim_flag = 1; __this->ch1_inear_ok = 0; __this->ch1_trim_value == 0; M2P_CTMU_CH1_RES_SEND = 1; log_info("__this->ch1_trim_flag = %d", __this->ch1_trim_flag); is_lpkey_active = 1; } else { __this->ch1_trim_flag = 0; M2P_CTMU_CH1_RES_SEND = 0; log_info("__this->ch1_trim_flag = %d", __this->ch1_trim_flag); } #endif } //======================================================// // 测试盒测试标志接口 // //======================================================// extern u8 testbox_get_key_action_test_flag(void *priv); u8 last_state = CTMU_P2M_CH1_OUT_EVENT; //extern void spp_printf(const char *format, ...); void p33_ctmu_key_event_irq_handler() { u8 ctmu_event = P2M_CTMU_KEY_EVENT; int res = 0; static u32 cnt0 = 0; static u32 cnt1 = 0; u8 ret = 0; u16 ch0_res = 0, ch1_res = 0, ch0_iir = 0, ch1_diff = 0, ch1_trim = 0; if (testbox_get_key_action_test_flag(NULL)) { ret = lp_touch_key_testbox_remote_test(ctmu_event); if (ret == true) { return; } } //log_debug("ctmu msg: 0x%x", ctmu_event); switch (ctmu_event) { case CTMU_P2M_CH0_RES_EVENT: ch0_res = LP_CTMU_CH0_RES_GET(); ch0_iir = ((P2M_CTMU_CH0_H_IIR_VALUE << 8) | P2M_CTMU_CH0_L_IIR_VALUE); /*printf("ch0_res: %d, ch0_iir: %d\n", ch0_res, ch0_iir);*/ //log_debug("CH0: debug, RES = %08d", res); //log_debug("CH0: debug %08d, RES = %08d", cnt0++, res); #if TWS_BT_SEND_CH0_RES_DATA_ENABLE tws_send_res_data(((ch0_res << 16) | ch0_iir), 0, 0, BT_CH0_RES_MSG); #endif /* #if TWS_BT_SEND_CH0_RES_DATA_ENABLE */ #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE lp_touch_key_online_debug_send(0, ch0_res); #endif /* #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE */ break; case CTMU_P2M_CH1_RES_EVENT: ch1_res = LP_CTMU_CH1_RES_GET(); ch1_diff = ((P2M_CTMU_CH1_H_DIFF_VALUE << 8) | P2M_CTMU_CH1_L_DIFF_VALUE); ch1_trim = ((P2M_CTMU_CH1_H_TRIM_VALUE << 8) | P2M_CTMU_CH1_L_TRIM_VALUE); ch0_res = ((P2M_CTMU_CH0_H_RES << 8) | P2M_CTMU_CH0_L_RES); ch0_iir = (P2M_CTMU_CH0_H_IIR_VALUE << 8 | P2M_CTMU_CH0_L_IIR_VALUE); /*printf("ch1_diff: %d, ch1_trim: %d, ch0_res: %d, ch1_res: %d, ch0_iir: %d\n", ch1_diff, ch1_trim, ch0_res, ch1_res, ch0_iir);*/ //////////////////////////////////////////////////////////////////////////////////////////////////////// #if!TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE if (__this->ch1_trim_flag) { if (__this->ch1_trim_value == 0) { __this->ch1_trim_value = ch1_diff; } else { __this->ch1_trim_value = ((ch1_diff + __this->ch1_trim_value) >> 1); } if (__this->ch1_trim_flag++ > 20) { __this->ch1_trim_flag = 0; M2P_CTMU_CH1_RES_SEND = 0; int ret = syscfg_write(LP_KEY_EARTCH_TRIM_VALUE, &(__this->ch1_trim_value), sizeof(__this->ch1_trim_value)); log_info("write ret = %d", ret); if (ret > 0) { M2P_CTMU_CH1_TRIM_VALUE_L = (__this->ch1_trim_value & 0xFF); M2P_CTMU_CH1_TRIM_VALUE_H = ((__this->ch1_trim_value >> 8) & 0xFF); __this->ch1_inear_ok = 1; #if TCFG_EARTCH_EVENT_HANDLE_ENABLE eartch_state_update(EARTCH_STATE_TRIM_OK); #endif log_info("trim: %d\n", __this->ch1_inear_ok); is_lpkey_active = 0; } else { __this->ch1_inear_ok = 0; #if TCFG_EARTCH_EVENT_HANDLE_ENABLE eartch_state_update(EARTCH_STATE_TRIM_ERR); #endif log_info("trim: %d\n", __this->ch1_inear_ok); is_lpkey_active = 0; } } log_debug("ch1 trim value: %d, res = %d", __this->ch1_trim_value, ch1_diff); } #endif /////////////////////////////////////////////////////////////////////////////////////////////////////////// #if TWS_BT_SEND_CH1_RES_DATA_ENABLE tws_send_res_data(((ch1_trim << 16) | ch0_res), ((ch0_iir << 16) | ch1_res), ch1_diff, BT_CH1_RES_MSG); #endif /* #if TWS_BT_SEND_CH1_RES_DATA_ENABLE */ ////////////////////////////////////////////////////////////////////////////////////////////////////////// #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE lp_touch_key_online_debug_send(1, ch1_res); #endif /* #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE */ ///////////////////////////////////////////////////////////////////////////////////////////////////////// if (P2M_CTMU_CTMU_KEY_CNT != last_state) { last_state = P2M_CTMU_CTMU_KEY_CNT; if (last_state == CTMU_P2M_CH1_IN_EVENT) { #if TWS_BT_SEND_EVENT_ENABLE tws_send_event_data(CH1_EAR_IN, BT_EVENT_SW_MSG); #endif /* #if TWS_BT_SEND_EVENT_ENABLE */ if (__this->ch1_inear_ok) { ctmu_ch1_event_handle(CH1_EAR_IN); } } else if (last_state == CTMU_P2M_CH1_OUT_EVENT) { #if TWS_BT_SEND_EVENT_ENABLE tws_send_event_data(CH1_EAR_OUT, BT_EVENT_SW_MSG); #endif /* #if TWS_BT_SEND_EVENT_ENABLE */ if (__this->ch1_inear_ok) { ctmu_ch1_event_handle(CH1_EAR_OUT); } } } ///////////////////////////////////////////////////////////////////////////////////////////////////////// break; case CTMU_P2M_CH0_SHORT_KEY_EVENT: log_debug("CH0: SHORT click"); //__ctmu_short_click_handle(); break; case CTMU_P2M_CH0_LONG_KEY_EVENT: log_debug("CH0: LONG click"); ctmu_long_click_handle(); break; case CTMU_P2M_CH0_HOLD_KEY_EVENT: log_debug("CH0: HOLD click"); ctmu_hold_click_handle(); break; case CTMU_P2M_CH0_FALLING_EVENT: log_debug("CH0: FALLING"); break; case CTMU_P2M_CH0_RAISING_EVENT: if (!(__this->ch_init & BIT(0))) { __this->ch_init |= BIT(0); load_p11_bank_code2ram(1, 1); return; } log_debug("CH0: RAISING"); ctmu_raise_click_handle(); break; case CTMU_P2M_CH1_IN_EVENT: #if TWS_BT_SEND_EVENT_ENABLE tws_send_event_data(CH1_EAR_IN, BT_EVENT_HW_MSG); #endif /* #if TWS_BT_SEND_EVENT_ENABLE */ log_debug("CH1 HW: IN"); break; case CTMU_P2M_CH1_OUT_EVENT: if (!(__this->ch_init & BIT(1))) { __this->ch_init |= BIT(1); return; } #if TWS_BT_SEND_EVENT_ENABLE tws_send_event_data(CH1_EAR_OUT, BT_EVENT_HW_MSG); #endif /* #if TWS_BT_SEND_EVENT_ENABLE */ log_debug("CH1 HW: OUT"); break; default: break; } } void lp_touch_key_trace_lrc_hook(u32 lrc_hz) { static u8 first_time = 0; if (first_time) { return; } first_time = 1; log_debug("%s", __func__); __this->lrc_hz = lrc_hz; u16 cnt = (CTMU_RESET_TIMER_PRD_VALUE * lrc_hz) / (1000L * 64); #if CTMU_RESET_TIME_CONFIG M2P_LCTM_RESET_PCNT_PRD1 = cnt >> 8; M2P_LCTM_RESET_PCNT_PRD0 = cnt & 0xff; M2P_LCTM_RESET_PCNT_VALUE = (CTMU_RESET_TIME_CONFIG - CTMU_LONG_KEY_DELAY_TIME) / CTMU_RESET_TIMER_PRD_VALUE; #else M2P_LCTM_RESET_PCNT_VALUE = 0; #endif /* #if CTMU_RESET_TIME_CONFIG */ log_debug("lp timer cnt = %d, lrc_hz = %d, RESET_PCNT = %d", cnt, lrc_hz, M2P_LCTM_RESET_PCNT_VALUE); #if 0 if (__this->init) { u16 time_prd = 0; time_prd = (__this->lrc_hz * CTMU_TIME_BASE) / 1000 - 1; M2P_CTMU_BASE_TIME_PRD_L = (time_prd & 0xFF); M2P_CTMU_BASE_TIME_PRD_H = ((time_prd >> 8) & 0xFF); lp_touch_key_send_cmd(CTMU_M2P_UPDATE_BASE_TIME); } #endif } u8 lp_touch_key_power_on_status() { extern u8 power_reset_flag; u8 sfr = power_reset_flag; static u8 power_on_flag = 0; log_debug("P3_RST_SRC = %x, P2M_CTMU_CTMU_WKUP_MSG = 0x%x", sfr, P2M_CTMU_CTMU_WKUP_MSG); if ((sfr & BIT(0)) || (sfr & BIT(1))) { return 0; } if (P2M_CTMU_CTMU_WKUP_MSG & BIT(0)) { power_on_flag = 1; P2M_CTMU_CTMU_WKUP_MSG &= (~(BIT(0))); } return power_on_flag; } void lp_touch_key_disable(void) { log_debug("%s", __func__); while (!__this->ch_init & BIT(0)) { asm volatile("nop"); } P2M_CTMU_CTMU_WKUP_MSG &= (~(BIT(1))); lp_touch_key_send_cmd(CTMU_M2P_DISABLE); while (!(P2M_CTMU_CTMU_WKUP_MSG & BIT(1))); __this->softoff_mode = LP_TOUCH_SOFTOFF_MODE_LEGACY; } void lp_touch_key_enable(void) { log_debug("%s", __func__); lp_touch_key_send_cmd(CTMU_M2P_ENABLE); __this->softoff_mode = LP_TOUCH_SOFTOFF_MODE_ADVANCE; } void lp_touch_key_charge_mode_enter() { #if (!LP_TOUCH_KEY_CHARGE_MODE_SW_DISABLE) while (!__this->ch_init & BIT(0)) { asm volatile("nop"); } log_debug("%s", __func__); P2M_CTMU_CTMU_WKUP_MSG &= (~(BIT(1))); lp_touch_key_send_cmd(CTMU_M2P_CHARGE_ENTER_MODE); while (!(P2M_CTMU_CTMU_WKUP_MSG & BIT(1))); __this->softoff_mode = LP_TOUCH_SOFTOFF_MODE_LEGACY; #endif } void lp_touch_key_charge_mode_exit() { #if (!LP_TOUCH_KEY_CHARGE_MODE_SW_DISABLE) log_debug("%s", __func__); lp_touch_key_send_cmd(CTMU_M2P_CHARGE_EXIT_MODE); __this->softoff_mode = LP_TOUCH_SOFTOFF_MODE_ADVANCE; #endif } //=============================================// //NOTE: 该函数为进关机时被库里面回调 //在板级配置struct low_power_param power_param中变量lpctmu_en配置为TCFG_LP_TOUCH_KEY_ENABLE时: //该函数在决定softoff进触摸模式还是普通模式: // return 1: 进触摸模式关机(LP_TOUCH_SOFTOFF_MODE_ADVANCE); // return 0: 进普通模式关机(触摸关闭)(LP_TOUCH_SOFTOFF_MODE_LEGACY); //使用场景: // 1)在充电舱外关机, 需要触摸开机, 进带触摸关机模式; // 2)在充电舱内关机，可以关闭触摸模块, 进普通关机模式, 关机功耗进一步降低. //=============================================// u8 lp_touch_key_softoff_mode_query(void) { return __this->softoff_mode; } //================ bt tws debug ====================// int tws_api_send_data_to_sibling(void *data, u16 len, u32 func_id); static int tws_api_send_data_test(void *data, int len, u32 func_id) { int ret = -EINVAL; local_irq_disable(); ret = tws_api_send_data_to_sibling(data, len, func_id); local_irq_enable(); return ret; } static void res_receive_handle(void *_data, u16 len, bool rx) { static u32 cnt0 = 0; static u32 cnt1 = 0; u32 *data = _data; if (rx) { if (data[0] == BT_CH0_RES_MSG) { /*log_debug("len = %d, RES0 = %08d", len, data[1]);*/ log_debug("cnt: %08d, ch0: %08d, iir: %08d\n", cnt1++, (data[1] >> 16), (data[1] & 0xffff)); } else if (data[0] == BT_CH1_RES_MSG) { /*log_debug("RES1 ORIGIN = %08d", data[1] & 0xFFFF);*/ log_debug("cnt: %08d, trim: %08d, ch0: %08d, ch0_iir: %08d, ch1: %08d, ch0-ch1 %08d", cnt1++, (data[1] >> 16), data[1] & 0xFFFF, (data[2] >> 16), data[2] & 0xFFFF, (data[3] & 0xFFFF)); } else if (data[0] == BT_EVENT_SW_MSG) { log_debug("len = %d, %d ms", len, data[1]); if (data[2] == EPD_IN) { log_debug("SW: IN"); } else if (data[2] == EPD_OUT) { log_debug("SW: OUT"); } } else if (data[0] == BT_EVENT_HW_MSG) { log_debug("len = %d, %d ms", len, data[1]); if (data[2] == CH1_EAR_IN) { log_debug("HW: IN"); } else if (data[2] == CH1_EAR_OUT) { log_debug("HW: OUT"); } } else if (data[0] == BT_EVENT_VDDIO) { log_debug("BT_EVENT_VDDIO: %d", data[2]); } } } REGISTER_TWS_FUNC_STUB(lp_touch_res_sync_stub) = { .func_id = TWS_FUNC_ID_VOL_LP_KEY, .func = res_receive_handle, //handle }; //==================================================// //============== 在线调节灵敏度参数表 ==========// //==================================================// #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE #include "online_db_deal.h" //LP KEY在线调试工具版本号管理 const u8 lp_key_sdk_name[16] = "AC698N"; const u8 lp_key_bt_ver[4] = {0, 0, 1, 0}; struct lp_key_ver_info { char sdkname[16]; u8 lp_key_ver[4]; }; #if TCFG_LP_EARTCH_KEY_ENABLE //版本号 按键事件个数 按键事件个数 const char ch_content[] = {0x01, 'c', 'h', '0', '\0', 6, 0, 1, 2, 3, 4, 5, 'c', 'h', '1', '\0', 2, 10, 11}; //ch0 & ch1 #else const char ch_content[] = {0x01, 'c', 'h', '0', '\0', 6, 0, 1, 2, 3, 4, 5}; //only ch0 #endif /* #if TCFG_LP_EARTCH_KEY_ENABLE */ enum { TOUCH_RECORD_GET_VERSION = 0x05, TOUCH_RECORD_GET_CH_SIZE = 0x0B, TOUCH_RECORD_GET_CH_CONTENT = 0x0C, TOUCH_RECORD_CHANGE_MODE = 0x0E, TOUCH_RECORD_COUNT = 0x200, TOUCH_RECORD_START, TOUCH_RECORD_STOP, ONLINE_OP_QUERY_RECORD_PACKAGE_LENGTH, TOUCH_CH_CFG_UPDATE = 0x3000, TOUCH_CH_VOL_CFG_UPDATE = 0x3001, TOUCH_CH_CFG_CONFIRM = 0x3100, }; enum { LP_KEY_ONLINE_ST_INIT, LP_KEY_ONLINE_ST_READY, LP_KEY_ONLINE_ST_CH_RES_DEBUG_START, LP_KEY_ONLINE_ST_CH_RES_DEBUG_STOP, LP_KEY_ONLINE_ST_CH_KEY_DEBUG_START, LP_KEY_ONLINE_ST_CH_KEY_DEBUG_CONFIRM, }; //小机接收命令包格式, 使用DB_PKT_TYPE_TOUCH通道接收 typedef struct { int cmd_id; int mode; int data[]; } touch_receive_cmd_t; //小机发送按键消息格式, 使用DB_PKT_TYPE_TOUCH通道发送 typedef struct { u32 cmd_id; u32 mode; u32 key_event; } lp_touch_online_key_event_t; typedef struct { u8 state; u8 current_record_ch; u16 res_packet; struct ch_adjust_table ch0_debug_cfg; struct ch_adjust_table ch1_debug_cfg; lp_touch_online_key_event_t online_key_event; struct ch_ana_cfg ch0_ana; struct ch_ana_cfg ch1_ana; } lp_touch_key_online; static lp_touch_key_online lp_key_online = {0}; static int lp_touch_key_online_debug_key_event_handle(u8 ch_index, struct sys_event *event) { int err = 0; if ((lp_key_online.state == LP_KEY_ONLINE_ST_CH_KEY_DEBUG_START) && (lp_key_online.current_record_ch == ch_index)) { lp_key_online.online_key_event.cmd_id = 0x3100; lp_key_online.online_key_event.mode = 0; lp_key_online.online_key_event.key_event = event->u.key.event; log_debug("send %d event to PC", lp_key_online.online_key_event.key_event); err = app_online_db_send(DB_PKT_TYPE_TOUCH, (u8 *)(&(lp_key_online.online_key_event)), sizeof(lp_touch_online_key_event_t)); } if ((lp_key_online.state == LP_KEY_ONLINE_ST_CH_KEY_DEBUG_CONFIRM) || (lp_key_online.state <= LP_KEY_ONLINE_ST_READY)) { return 0; } return 1; } static int lp_touch_key_debug_reinit_config(void) { //==============================================================// // CH0 初始化 // //==============================================================// __lpctmu_reset(1); //模块复位 LP_CTMU_SWITCH_STABLE_TIME_SET(); //CTMU 时基配置: u16 time_prd = 0; if (__this->lrc_hz) { time_prd = (__this->lrc_hz * CTMU_TIME_BASE) / 1000 - 1; } else { time_prd = CFG_M2P_CTMU_BASE_TIME_PRD; } LP_CTMU_TIMER_BASE_CONFIG(time_prd); log_info("LRC_HZ = %d, time_prd = %d", __this->lrc_hz, time_prd); if (__this->config->ch0.enable) { //PB1和PB2通道互换IO: if (__this->config->ch0.port == IO_PORTB_02) { LP_CTMU_IO_INV(1); } else { LP_CTMU_IO_INV(0); ASSERT(__this->config->ch0.port == IO_PORTB_01); } M2P_CTMU_MSG |= CTMU_INIT_CH0_ENABLE; ctmu_port_init(__this->config->ch0.port); //模拟参数配置: if (lp_key_online.ch0_ana.isel) { LP_CTMU_CH0_ANA_CFG(((lp_key_online.ch0_ana.vlsel << 5) | (lp_key_online.ch0_ana.vhsel << 3) | (lp_key_online.ch0_ana.isel << 0))); } else { LP_CTMU_CH0_ANA_CFG(get_lpctmu_ana_level()); } //通用配置: LP_CTMU_CH0_ENABLE(1); //通道0使能 LP_CTMU_CH0_FILTER_LEVEL(1); //通道0滤波级数 LP_CTMU_CH0_FILTER_EN(1); //通道0滤波使能 LP_CTMU_CH0_EDGE_EN(1); //通道0边沿检测使能 LP_CTMU_CH0_EDGE_TEMP_EN(1); //fixed LP_CTMU_CH0_FIRST_RISE_MASK(0); //屏蔽第一个上升沿 //上升沿中断: LP_CTMU_CH0_FALL_PENDING_CLR(); LP_CTMU_CH0_FALL_PENDING_IE(1); LP_CTMU_CH0_FALL_PENDING_SEL(0); //下升沿中断: LP_CTMU_CH0_RISE_PENDING_CLR(); LP_CTMU_CH0_RISE_PENDING_IE(1); LP_CTMU_CH0_RISE_PENDING_SEL(0); //多击模式: LP_CTMU_CH0_SHORT_KEY_MODE(1); if (M2P_CTMU_MSG & CTMU_INIT_CH0_DEBUG) { LP_CTMU_CH0_RES_PENDING_IE(1); } LP_CTMU_CH0_SHORT_KEY_TRIGGER(0); LP_CTMU_CH0_SHORT_PENDING_CLR(); LP_CTMU_CH0_SHORT_PENDING_IE(0); LP_CTMU_CH0_LONG_PENDING_CLR(); LP_CTMU_CH0_LONG_PENDING_IE(1); LP_CTMU_CH0_HOLD_PENDING_CLR(); LP_CTMU_CH0_HOLD_PENDING_IE(1); LP_CTMU_CH0_HOLD_EN(1); LP_CTMU_CH0_KEY_MODE_ENABLE(1); //快速 & 低速扫描周期 LP_CTMU_CH0_HIGH_SPEED_PRD(CFG_CTMU_CH0_HS_PERIOD_VALUE); LP_CTMU_CH0_LOW_SPEED_PRD(CFG_CTMU_CH0_LS_PERIOD_VALUE); //采样窗口时间 LP_CTMU_CH0_DET_TIME(CFG_CTMU_CH0_WINDOW_TIME_VALUE); //CH0阈值: LP_CTMU_CH0_TEMP_TH(lp_key_online.ch0_debug_cfg.cfg0); LP_CTMU_CH0_STABLE_TH(lp_key_online.ch0_debug_cfg.cfg0 + 5); LP_CTMU_CH0_EDGE_TH(lp_key_online.ch0_debug_cfg.cfg2); M2P_CTMU_CH0_CFG2H = (lp_key_online.ch0_debug_cfg.cfg2 >> 8) & 0xff; M2P_CTMU_CH0_CFG2L = (lp_key_online.ch0_debug_cfg.cfg2 >> 0) & 0xff; //CH0 按键时间: LP_CTMU_CH0_SHORT_KEY_TIME(CFG_M2P_CTMU_CH0_SHORT_TIME_VALUE); LP_CTMU_CH0_LONG_KEY_TIME(CFG_M2P_CTMU_CH0_LONG_TIME_VALUE); LP_CTMU_CH0_HOLD_KEY_TIME(CFG_M2P_CTMU_CH0_HOLD_TIME_VALUE); LP_CTMU_CH0_IE(1); //长按开机时间配置 M2P_CTMU_CH0_SOFTOFF_LONG_TIMEL = (CFG_M2P_CTMU_CH0_SOFTOFF_LONG_TIME & 0xFF); M2P_CTMU_CH0_SOFTOFF_LONG_TIMEH = ((CFG_M2P_CTMU_CH0_SOFTOFF_LONG_TIME >> 8) & 0xFF); #if 0 log_info("P11_LCTM_CON = 0x%x", P11_LCTM_CON); log_info("LCTM_MOD = 0x%x", LCTM_MOD); log_info("LCTM_TMR = 0x%x", LCTM_TMR); log_info("LCTM_TIME_BASE_H = 0x%x", LCTM_TIME_BASE_H); log_info("LCTM_TIME_BASE_L = 0x%x", LCTM_TIME_BASE_L); log_info("LCTM_CHL0_ANA = 0x%x", LCTM_CHL0_ANA); log_info("LCTM_CHL0_CON0 = 0x%x", LCTM_CHL0_CON0); log_info("LCTM_CHL0_CON1 = 0x%x", LCTM_CHL0_CON1); log_info("LCTM_CHL0_CON2 = 0x%x", LCTM_CHL0_CON2); log_info("LCTM_CHL0_CON3 = 0x%x", LCTM_CHL0_CON3); log_info("LCTM_CHL0_HS_PRD = 0x%x", LCTM_CHL0_HS_PRD); log_info("LCTM_CHL0_LS_PRD = 0x%x", LCTM_CHL0_LS_PRD); log_info("LCTM_CHL0_DET_TIME_H = 0x%x", LCTM_CHL0_DET_TIME_H); log_info("LCTM_CHL0_DET_TIME_L = 0x%x", LCTM_CHL0_DET_TIME_L); log_info("LCTM_CHL0_TEMP_H = 0x%x", LCTM_CHL0_TEMP_H); log_info("LCTM_CHL0_TEMP_L = 0x%x", LCTM_CHL0_TEMP_L); log_info("LCTM_CHL0_STA_H = 0x%x", LCTM_CHL0_STA_H); log_info("LCTM_CHL0_STA_L = 0x%x", LCTM_CHL0_STA_L); log_info("LCTM_CHL0_EDGE_H = 0x%x", LCTM_CHL0_EDGE_H); log_info("LCTM_CHL0_EDGE_L = 0x%x", LCTM_CHL0_EDGE_L); log_info("LCTM_CHL0_SHORT_H = 0x%x", LCTM_CHL0_SHORT_H); log_info("LCTM_CHL0_SHORT_L = 0x%x", LCTM_CHL0_SHORT_L); log_info("LCTM_CHL0_LONG_H = 0x%x", LCTM_CHL0_LONG_H); log_info("LCTM_CHL0_LONG_L = 0x%x", LCTM_CHL0_LONG_L); log_info("LCTM_CHL0_HOLD_H = 0x%x", LCTM_CHL0_HOLD_H); log_info("LCTM_CHL0_HOLD_L = 0x%x", LCTM_CHL0_HOLD_L); #endif } //==============================================================// // CH1 初始化 // //==============================================================// if (__this->config->ch1.enable) { if (__this->config->ch1.port == IO_PORTB_01) { LP_CTMU_IO_INV(1); } else { LP_CTMU_IO_INV(0); ASSERT(__this->config->ch1.port == IO_PORTB_02); } M2P_CTMU_MSG |= CTMU_INIT_CH1_ENABLE; ctmu_port_init(__this->config->ch1.port); //模拟参数配置: if (lp_key_online.ch1_ana.isel) { LP_CTMU_CH1_ANA_CFG(((lp_key_online.ch1_ana.vlsel << 5) | (lp_key_online.ch1_ana.vhsel << 3) | (lp_key_online.ch1_ana.isel << 0))); } else { LP_CTMU_CH1_ANA_CFG(get_lpctmu_ana_level()); } //通用配置: LP_CTMU_CH1_ENABLE(1); //通道0使能 LP_CTMU_CH1_FILTER_LEVEL(1); //通道0滤波级数 LP_CTMU_CH1_FILTER_EN(1); //通道0滤波使能 LP_CTMU_CH1_EDGE_EN(1); //通道0边沿检测使能 LP_CTMU_CH1_EDGE_TEMP_EN(1); //fixed LP_CTMU_CH1_FIRST_RISE_MASK(0); //屏蔽第一个上升沿 //上升沿中断: LP_CTMU_CH1_FALL_PENDING_CLR(); LP_CTMU_CH1_FALL_PENDING_IE(1); LP_CTMU_CH1_FALL_PENDING_SEL(0); //下升沿中断: LP_CTMU_CH1_RISE_PENDING_CLR(); LP_CTMU_CH1_RISE_PENDING_IE(1); LP_CTMU_CH1_RISE_PENDING_SEL(0); if (M2P_CTMU_MSG & CTMU_INIT_CH1_DEBUG) { LP_CTMU_CH1_RES_PENDING_IE(1); } //快速 & 低速扫描周期 LP_CTMU_CH1_HIGH_SPEED_PRD(CFG_CTMU_CH1_HS_PERIOD_VALUE); LP_CTMU_CH1_LOW_SPEED_PRD(CFG_CTMU_CH1_LS_PERIOD_VALUE); //采样窗口时间 LP_CTMU_CH1_DET_TIME(CFG_CTMU_CH1_WINDOW_TIME_VALUE); //CH1阈值: LP_CTMU_CH1_TEMP_TH(lp_key_online.ch1_debug_cfg.cfg0); LP_CTMU_CH1_STABLE_TH(lp_key_online.ch1_debug_cfg.cfg0 + 5); LP_CTMU_CH1_EDGE_TH(lp_key_online.ch1_debug_cfg.cfg2); LP_CTMU_CH1_IE(1); #if 0 log_info("P11_LCTM_CON = 0x%x", P11_LCTM_CON); log_info("LCTM_MOD = 0x%x", LCTM_MOD); log_info("LCTM_TMR = 0x%x", LCTM_TMR); log_info("LCTM_TIME_BASE_H = 0x%x", LCTM_TIME_BASE_H); log_info("LCTM_TIME_BASE_L = 0x%x", LCTM_TIME_BASE_L); log_info("LCTM_CHL1_ANA = 0x%x", LCTM_CHL1_ANA); log_info("LCTM_CHL1_CON0 = 0x%x", LCTM_CHL1_CON0); log_info("LCTM_CHL1_CON1 = 0x%x", LCTM_CHL1_CON1); log_info("LCTM_CHL1_CON2 = 0x%x", LCTM_CHL1_CON2); log_info("LCTM_CHL1_HS_PRD = 0x%x", LCTM_CHL1_HS_PRD); log_info("LCTM_CHL1_LS_PRD = 0x%x", LCTM_CHL1_LS_PRD); log_info("LCTM_CHL1_DET_TIME_H = 0x%x", LCTM_CHL1_DET_TIME_H); log_info("LCTM_CHL1_DET_TIME_L = 0x%x", LCTM_CHL1_DET_TIME_L); log_info("LCTM_CHL1_TEMP_H = 0x%x", LCTM_CHL1_TEMP_H); log_info("LCTM_CHL1_TEMP_L = 0x%x", LCTM_CHL1_TEMP_L); log_info("LCTM_CHL1_STA_H = 0x%x", LCTM_CHL1_STA_H); log_info("LCTM_CHL1_STA_L = 0x%x", LCTM_CHL1_STA_L); log_info("LCTM_CHL1_EDGE_H = 0x%x", LCTM_CHL1_EDGE_H); log_info("LCTM_CHL1_EDGE_L = 0x%x", LCTM_CHL1_EDGE_L); #endif } load_p11_bank_code2ram(1, 0); //CTMU 初始化命令 lp_touch_key_send_cmd(CTMU_M2P_INIT); return 0; } static int lp_touch_key_debug_reinit(u8 update_state) { log_debug("%s, current_record_ch = %d", __func__, lp_key_online.current_record_ch); switch (update_state) { case LP_KEY_ONLINE_ST_CH_RES_DEBUG_START: if (lp_key_online.current_record_ch == 0) { M2P_CTMU_MSG &= ~(CTMU_INIT_CH1_DEBUG); M2P_CTMU_MSG |= CTMU_INIT_CH0_DEBUG; } else if (lp_key_online.current_record_ch == 1) { M2P_CTMU_MSG &= ~(CTMU_INIT_CH0_DEBUG); M2P_CTMU_MSG |= CTMU_INIT_CH1_DEBUG; } break; case LP_KEY_ONLINE_ST_CH_RES_DEBUG_STOP: M2P_CTMU_MSG &= ~(CTMU_INIT_CH0_DEBUG); M2P_CTMU_MSG &= ~(CTMU_INIT_CH1_DEBUG); break; case LP_KEY_ONLINE_ST_CH_KEY_DEBUG_START: M2P_CTMU_MSG &= ~(CTMU_INIT_CH0_DEBUG); M2P_CTMU_MSG &= ~(CTMU_INIT_CH1_DEBUG); break; case LP_KEY_ONLINE_ST_CH_KEY_DEBUG_CONFIRM: M2P_CTMU_MSG &= ~(CTMU_INIT_CH0_DEBUG); M2P_CTMU_MSG &= ~(CTMU_INIT_CH1_DEBUG); break; default: break; } if (__this->short_timer != 0xFFFF) { usr_timer_del(__this->short_timer); __this->short_timer = 0xFFFF; } /* if (__this->long_timer != 0xFFFF) { */ /* usr_timer_del(__this->long_timer); */ /* __this->long_timer = 0xFFFF; */ /* } */ __this->last_key = CTMU_KEY_NULL; lp_touch_key_debug_reinit_config(); return 0; } static int lp_touch_key_online_debug_parse(u8 *packet, u8 size, u8 *ext_data, u16 ext_size) { int res_data = 0; touch_receive_cmd_t *touch_cmd; int err = 0; u8 parse_seq = ext_data[1]; struct ch_adjust_table *receive_cfg; struct ch_ana_cfg *ana_cfg; struct lp_key_ver_info ver_info = {0}; res_data = 4; log_debug("%s", __func__); put_buf(packet, size); put_buf(ext_data, ext_size); //memcpy(&touch_cmd, packet, sizeof(touch_receive_cmd_t)); touch_cmd = (touch_receive_cmd_t *)packet; switch (touch_cmd->cmd_id) { /* case TOUCH_RECORD_COUNT: */ /* log_debug("TOUCH_RECORD_COUNT"); */ /* err = app_online_db_ack(parse_seq, (u8 *)&res_data, 4); */ /* break; */ case TOUCH_RECORD_START: log_debug("TOUCH_RECORD_START"); err = app_online_db_ack(parse_seq, (u8 *)&res_data, 1); //该命令随便ack一个byte即可 lp_key_online.state = LP_KEY_ONLINE_ST_CH_RES_DEBUG_START; lp_touch_key_debug_reinit(lp_key_online.state); break; case TOUCH_RECORD_STOP: log_debug("TOUCH_RECORD_STOP"); app_online_db_ack(parse_seq, (u8 *)&res_data, 1); //该命令随便ack一个byte即可 lp_key_online.state = LP_KEY_ONLINE_ST_CH_RES_DEBUG_STOP; lp_touch_key_debug_reinit(lp_key_online.state); break; /* case ONLINE_OP_QUERY_RECORD_PACKAGE_LENGTH: */ /* log_debug("ONLINE_OP_QUERY_RECORD_PACKAGE_LENGTH"); */ /* err = app_online_db_ack(parse_seq, (u8 *)&res_data, 4); //回复对应的通道数据长度 */ /* break; */ case TOUCH_CH_CFG_UPDATE: log_debug("TOUCH_CH_CFG_UPDATE"); app_online_db_ack(parse_seq, (u8 *)"OK", 2); //该命令随便ack "OK"字符串 lp_key_online.state = LP_KEY_ONLINE_ST_CH_KEY_DEBUG_START; receive_cfg = (struct ch_adjust_table *)(touch_cmd->data); if (lp_key_online.current_record_ch == 0) { lp_key_online.ch0_debug_cfg.cfg0 = receive_cfg->cfg0; lp_key_online.ch0_debug_cfg.cfg1 = receive_cfg->cfg1; lp_key_online.ch0_debug_cfg.cfg2 = receive_cfg->cfg2; } else if (lp_key_online.current_record_ch == 1) { lp_key_online.ch1_debug_cfg.cfg0 = receive_cfg->cfg0; lp_key_online.ch1_debug_cfg.cfg1 = receive_cfg->cfg1; lp_key_online.ch1_debug_cfg.cfg2 = receive_cfg->cfg2; } log_debug("update CH %d, cfg0 = %d, cfg1 = %d, cfg2 = %d", lp_key_online.current_record_ch, receive_cfg->cfg0, receive_cfg->cfg1, receive_cfg->cfg2); lp_touch_key_debug_reinit(lp_key_online.state); break; case TOUCH_CH_VOL_CFG_UPDATE: log_debug("TOUCH_CH_VOL_CFG_UPDATE"); app_online_db_ack(parse_seq, (u8 *)"OK", 2); //回"OK"字符串 ana_cfg = (struct ch_ana_cfg *)(touch_cmd->data); if (lp_key_online.current_record_ch == 0) { lp_key_online.ch0_ana.isel = ana_cfg->isel; lp_key_online.ch0_ana.vhsel = ana_cfg->vhsel; lp_key_online.ch0_ana.vlsel = ana_cfg->vlsel; } else if (lp_key_online.current_record_ch == 1) { lp_key_online.ch1_ana.isel = ana_cfg->isel; lp_key_online.ch1_ana.vhsel = ana_cfg->vhsel; lp_key_online.ch1_ana.vlsel = ana_cfg->vlsel; } log_debug("update, isel = %d, vhsel = %d, vlsel = %d", lp_key_online.ch_ana.isel, lp_key_online.ch_ana.vhsel, lp_key_online.ch_ana.vlsel); break; case TOUCH_CH_CFG_CONFIRM: log_debug("TOUCH_CH_CFG_CONFIRM"); app_online_db_ack(parse_seq, (u8 *)"OK", 2); //回"OK"字符串 lp_key_online.state = LP_KEY_ONLINE_ST_CH_KEY_DEBUG_CONFIRM; break; case TOUCH_RECORD_GET_VERSION: log_debug("TOUCH_RECORD_GET_VERSION"); memcpy(ver_info.sdkname, lp_key_sdk_name, sizeof(lp_key_sdk_name)); memcpy(ver_info.lp_key_ver, lp_key_bt_ver, sizeof(lp_key_bt_ver)); app_online_db_ack(parse_seq, (u8 *)(&ver_info), sizeof(ver_info)); //回复版本号数据结构 break; case TOUCH_RECORD_GET_CH_SIZE: log_debug("TOUCH_RECORD_GET_CH_SIZE"); res_data = sizeof(ch_content); err = app_online_db_ack(parse_seq, (u8 *)&res_data, 4); //回复对应的通道数据长度 break; case TOUCH_RECORD_GET_CH_CONTENT: log_debug("TOUCH_RECORD_GET_CH_CONTENT"); app_online_db_ack(parse_seq, (u8 *)(&ch_content), sizeof(ch_content)); break; case TOUCH_RECORD_CHANGE_MODE: log_debug("TOUCH_RECORD_CHANGE_MODE, cmd_mode = %d", touch_cmd->mode); lp_key_online.current_record_ch = touch_cmd->mode; if (lp_key_online.current_record_ch == 0) { lp_key_online.ch0_ana.isel = 0; } else if (lp_key_online.current_record_ch == 1) { lp_key_online.ch1_ana.isel = 0; } app_online_db_ack(parse_seq, (u8 *)"OK", 2); //回"OK"字符串 break; default: break; } return 0; } static int lp_touch_key_online_debug_send(u8 ch, u16 val) { int err = 0; putchar('s'); if (lp_key_online.state == LP_KEY_ONLINE_ST_CH_RES_DEBUG_START) { lp_key_online.res_packet = val; err = app_online_db_send(DB_PKT_TYPE_DAT_CH0, (u8 *)(&(lp_key_online.res_packet)), 2); } return err; } static int lp_touch_key_online_debug_init(void) { log_debug("%s", __func__); app_online_db_register_handle(DB_PKT_TYPE_TOUCH, lp_touch_key_online_debug_parse); lp_key_online.state = LP_KEY_ONLINE_ST_READY; u8 ch0_sensity = __this->config->ch0.sensitivity; u8 ch1_sensity = __this->config->ch1.sensitivity; if (__this->config->ch0.enable) { lp_key_online.ch0_debug_cfg.cfg0 = ch0_sensitivity_table[ch0_sensity].cfg0; lp_key_online.ch0_debug_cfg.cfg1 = ch0_sensitivity_table[ch0_sensity].cfg1; lp_key_online.ch0_debug_cfg.cfg2 = ch0_sensitivity_table[ch0_sensity].cfg2; } if (__this->config->ch1.enable) { lp_key_online.ch1_debug_cfg.cfg0 = ch1_sensitivity_table[ch1_sensity].cfg0; lp_key_online.ch1_debug_cfg.cfg1 = ch1_sensitivity_table[ch1_sensity].cfg1; lp_key_online.ch1_debug_cfg.cfg2 = ch1_sensitivity_table[ch1_sensity].cfg2; } return 0; } int lp_touch_key_online_debug_exit(void) { return 0; } #endif /* #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE */ #endif