#include "includes.h" #include "asm/power/p11.h" #include "asm/power/p33.h" #include "asm/lp_touch_key_tool.h" #include "asm/lp_touch_key_alog.h" #include "device/key_driver.h" #include "key_event_deal.h" #include "app_config.h" #include "asm/lp_touch_key_api.h" #include "asm/charge.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 #define CTMU_CHECK_LONG_CLICK_BY_RES 1 /************************************************************************************************************************* lp_touch_key driver *************************************************************************************************************************/ #define LP_TOUCH_KEY_TIMER_MAGIC_NUM 0xFFFF struct ctmu_key _ctmu_key = { .slide_dir = TOUCH_KEY_EVENT_MAX, .click_cnt = {0, 0, 0, 0, 0}, .last_key = {CTMU_KEY_NULL, CTMU_KEY_NULL, CTMU_KEY_NULL, CTMU_KEY_NULL, CTMU_KEY_NULL}, .short_timer = {LP_TOUCH_KEY_TIMER_MAGIC_NUM, LP_TOUCH_KEY_TIMER_MAGIC_NUM, LP_TOUCH_KEY_TIMER_MAGIC_NUM, LP_TOUCH_KEY_TIMER_MAGIC_NUM, LP_TOUCH_KEY_TIMER_MAGIC_NUM}, }; #define __this (&_ctmu_key) static volatile u8 is_lpkey_active = 0; extern void lp_touch_key_send_cmd(enum CTMU_M2P_CMD cmd); //======================================================// // 内置触摸灵敏度表, 由内置触摸灵敏度调试工具生成 // // 请将该表替换sdk中lp_touch_key.c中同名的参数表 // //======================================================// const static struct ch_adjust_table ch_sensitivity_table[] = { /* cfg0 cfg1 cfg2 */ //ch0 PB0 { 109, 131, 4318}, // level 0 { 109, 131, 3982}, // level 1 { 109, 131, 3646}, // level 2 { 109, 131, 3310}, // level 3 { 109, 131, 2974}, // level 4 { 109, 131, 2638}, // level 5 { 109, 131, 2303}, // level 6 { 109, 131, 1967}, // level 7 { 109, 131, 1631}, // level 8 { 109, 131, 1295}, // level 9 //ch1 PB1 { 10, 15, 126}, // level 0 { 10, 15, 117}, // level 1 { 10, 15, 107}, // level 2 { 10, 15, 97}, // level 3 { 10, 15, 87}, // level 4 { 10, 15, 77}, // level 5 { 10, 15, 67}, // level 6 { 10, 15, 57}, // level 7 { 10, 15, 47}, // level 8 { 10, 15, 38}, // level 9 //ch2 PB2 { 10, 15, 152}, // level 0 { 10, 15, 140}, // level 1 { 10, 15, 128}, // level 2 { 10, 15, 116}, // level 3 { 10, 15, 104}, // level 4 { 10, 15, 92}, // level 5 { 10, 15, 81}, // level 6 { 10, 15, 69}, // level 7 { 10, 15, 57}, // level 8 { 10, 15, 45}, // level 9 //ch3 PB4 { 10, 15, 152}, // level 0 { 10, 15, 140}, // level 1 { 10, 15, 128}, // level 2 { 10, 15, 116}, // level 3 { 10, 15, 104}, // level 4 { 10, 15, 92}, // level 5 { 10, 15, 81}, // level 6 { 10, 15, 69}, // level 7 { 10, 15, 57}, // level 8 { 10, 15, 45}, // level 9 //ch4 PB5 { 109, 131, 4318}, // level 0 { 109, 131, 3982}, // level 1 { 109, 131, 3646}, // level 2 { 109, 131, 3310}, // level 3 { 109, 131, 2974}, // level 4 { 109, 131, 2638}, // level 5 { 109, 131, 2303}, // level 6 { 109, 131, 1967}, // level 7 { 109, 131, 1631}, // level 8 { 109, 131, 1295}, // level 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_036UA, LPCTMU_ISEL_072UA, LPCTMU_ISEL_108UA, LPCTMU_ISEL_144UA, LPCTMU_ISEL_180UA, LPCTMU_ISEL_216UA, LPCTMU_ISEL_252UA, LPCTMU_ISEL_288UA }; 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[5]; static u32 alog_sta_cnt[5]; static u8 ch_range_sensity[5] = {7, 7, 7, 7, 7}; static u16 save_alog_cfg_timeout[5] = {0, 0, 0, 0, 0}; static u16 ctmu_res_scan_time_add = 0; #define TOUCH_RANGE_MIN 50 #define TOUCH_RANGE_MAX 500 #define CTMU_RES_BUF_SIZE 15 static u16 ctmu_res_buf[5][CTMU_RES_BUF_SIZE]; static u16 ctmu_res_buf_in[5] = {0, 0, 0, 0, 0}; static u16 falling_res_avg[5] = {0, 0, 0, 0, 0}; static u16 long_event_res_avg[5] = {0, 0, 0, 0, 0}; static const u8 _ch_priv[5] = {0, 1, 2, 3, 4}; int __attribute__((weak)) lp_touch_key_event_remap(struct sys_event *e) { return true; } static void __ctmu_notify_key_event(struct sys_event *event, u8 ch) { #if CFG_DISABLE_KEY_EVENT return; #endif event->type = SYS_KEY_EVENT; event->u.key.type = KEY_DRIVER_TYPE_CTMU_TOUCH; //区分按键类型 event->arg = (void *)DEVICE_EVENT_FROM_KEY; if (__this->key_ch_msg_lock) {//锁住期间不能发消息 return; } #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE if (lp_touch_key_online_debug_key_event_handle(ch, 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 ch, u8 click_cnt, u8 event) { return event; } #if (TCFG_LP_SLIDE_KEY_ENABLE && (!TCFG_LP_SLIDE_KEY_SHORT_DISTANCE)) u8 __attribute__((weak)) ctmu_slide_direction_handle(u8 cur_ch, u8 pre_ch) { if ((cur_ch == 0xff) || (pre_ch == 0xff)) { return TOUCH_KEY_EVENT_MAX; } u8 dir_case = (pre_ch << 4) | (cur_ch & 0xf); log_debug("ctmu_touch_key_slide_direction = 0x%x : %x -> %x\n", dir_case, pre_ch, cur_ch); switch (dir_case) { case 0x12: //方向 1 -> 2 case 0x23: //方向 2 -> 3 case 0x13: //方向 1 -> 3 return TOUCH_KEY_EVENT_SLIDE_UP; break; case 0x32: //方向 3 -> 2 case 0x21: //方向 2 -> 1 case 0x31: //方向 3 -> 1 return TOUCH_KEY_EVENT_SLIDE_DOWN; break; } return TOUCH_KEY_EVENT_MAX; } #endif static void __ctmu_short_click_time_out_handle(void *priv) { u8 ch = *((u8 *)priv); struct sys_event e; switch (__this->click_cnt[ch]) { 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; case 4: e.u.key.event = KEY_EVENT_FOURTH_CLICK; break; case 5: e.u.key.event = KEY_EVENT_FIRTH_CLICK; break; default: e.u.key.event = KEY_EVENT_USER; break; } e.u.key.event = remap_ctmu_short_click_event(ch, __this->click_cnt[ch], e.u.key.event); e.u.key.value = __this->config->ch[ch].key_value; #if (TCFG_LP_SLIDE_KEY_ENABLE && (!TCFG_LP_SLIDE_KEY_SHORT_DISTANCE)) if (__this->slide_dir < TOUCH_KEY_EVENT_MAX) { e.u.key.event = __this->slide_dir; e.u.key.value = __this->config->slide_mode_key_value; __this->slide_dir = ctmu_slide_direction_handle(0xff, 0xff); } #endif log_debug("notify key%d short event, cnt: %d", ch, __this->click_cnt[ch]); __ctmu_notify_key_event(&e, ch); __this->short_timer[ch] = LP_TOUCH_KEY_TIMER_MAGIC_NUM; __this->last_key[ch] = CTMU_KEY_NULL; __this->click_cnt[ch] = 0; } static void ctmu_short_click_handle(u8 ch) { static u8 pre_ch = 0xff; __this->slide_dir = TOUCH_KEY_EVENT_MAX; __this->last_key[ch] = CTMU_KEY_SHORT_CLICK; if (__this->short_timer[ch] == LP_TOUCH_KEY_TIMER_MAGIC_NUM) { #if (TCFG_LP_SLIDE_KEY_ENABLE && (!TCFG_LP_SLIDE_KEY_SHORT_DISTANCE)) if (__this->config->slide_mode_en) { if ((pre_ch != 0xff) && (pre_ch != ch) && (__this->click_cnt[pre_ch] == 1)) { usr_timeout_del(__this->short_timer[pre_ch]); __this->short_timer[pre_ch] = LP_TOUCH_KEY_TIMER_MAGIC_NUM; __this->click_cnt[pre_ch] = 0; __this->last_key[pre_ch] = CTMU_KEY_NULL; __this->slide_dir = ctmu_slide_direction_handle(ch, pre_ch); } pre_ch = ch; } #endif __this->click_cnt[ch] = 1; #if (TCFG_LP_SLIDE_KEY_ENABLE && TCFG_LP_SLIDE_KEY_SHORT_DISTANCE) __this->short_timer[ch] = usr_timeout_add((void *)&_ch_priv[ch], __ctmu_short_click_time_out_handle, CTMU_SHORT_CLICK_DELAY_TIME + 150, 1); #else __this->short_timer[ch] = usr_timeout_add((void *)&_ch_priv[ch], __ctmu_short_click_time_out_handle, CTMU_SHORT_CLICK_DELAY_TIME, 1); #endif } else { __this->click_cnt[ch]++; usr_timer_modify(__this->short_timer[ch], CTMU_SHORT_CLICK_DELAY_TIME); } } static void ctmu_raise_click_handle(u8 ch) { struct sys_event e = {0}; if (__this->last_key[ch] >= CTMU_KEY_LONG_CLICK) { e.u.key.event = KEY_EVENT_UP; e.u.key.value = __this->config->ch[ch].key_value; __ctmu_notify_key_event(&e, ch); __this->last_key[ch] = CTMU_KEY_NULL; log_debug("notify key HOLD UP event"); } else { ctmu_short_click_handle(ch); } } static void ctmu_long_click_handle(u8 ch) { __this->last_key[ch] = CTMU_KEY_LONG_CLICK; struct sys_event e; e.u.key.event = KEY_EVENT_LONG; e.u.key.value = __this->config->ch[ch].key_value; __ctmu_notify_key_event(&e, ch); } static void ctmu_hold_click_handle(u8 ch) { __this->last_key[ch] = CTMU_KEY_HOLD_CLICK; struct sys_event e; e.u.key.event = KEY_EVENT_HOLD; e.u.key.value = __this->config->ch[ch].key_value; __ctmu_notify_key_event(&e, ch); } #if TCFG_LP_EARTCH_KEY_ENABLE __attribute__((weak)) void ear_lptouch_update_state(u8 state) { return; } static void __ctmu_ear_in_timeout_handle(void *priv) { #if CFG_DISABLE_INEAR_EVENT return; #endif if (__this->config->ch[__this->config->eartch_ch].key_value == 0xFF) { //使用外部自定义流程 if (__this->eartch_last_state == EAR_IN) { ear_lptouch_update_state(0); } else { ear_lptouch_update_state(1); } return; } #if TCFG_EARTCH_EVENT_HANDLE_ENABLE u8 state; if (__this->eartch_last_state == EAR_IN) { state = EARTCH_STATE_IN; } else if (__this->eartch_last_state == EAR_OUT) { state = EARTCH_STATE_OUT; } else { return; } eartch_state_update(state); #endif /* #if TCFG_EARTCH_EVENT_HANDLE_ENABLE */ } static void __ctmu_key_unlock_timeout_handle(void *priv) { __this->key_ch_msg_lock = false; __this->key_ch_msg_lock_timer = 0; } static void ctmu_eartch_event_handle(u8 eartch_state) { __this->eartch_last_state = eartch_state; #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE struct sys_event event; if (eartch_state == EAR_IN) { event.u.key.event = 10; } else if (eartch_state == EAR_OUT) { event.u.key.event = 11; } if (lp_touch_key_online_debug_key_event_handle(__this->config->eartch_ch, &event)) { return; } #endif /* #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE */ __this->key_ch_msg_lock = true; if (__this->key_ch_msg_lock_timer == 0) { __this->key_ch_msg_lock_timer = sys_hi_timeout_add(NULL, __ctmu_key_unlock_timeout_handle, ERATCH_KEY_MSG_LOCK_TIME); } else { sys_hi_timer_modify(__this->key_ch_msg_lock_timer, ERATCH_KEY_MSG_LOCK_TIME); } __ctmu_ear_in_timeout_handle(NULL); } #endif /************************************************************************************************************************* lp_touch_key driver *************************************************************************************************************************/ #if CTMU_CHECK_LONG_CLICK_BY_RES static void lp_touch_key_ctmu_res_buf_clear(u8 ch) { ctmu_res_buf_in[ch] = 0; for (u8 i = 0; i < CTMU_RES_BUF_SIZE; i ++) { ctmu_res_buf[ch][i] = 0; } } static void lp_touch_key_ctmu_res_all_buf_clear(void) { for (u8 ch = 0; ch < LP_CTMU_CHANNEL_SIZE; ch ++) { lp_touch_key_ctmu_res_buf_clear(ch); } } static u32 lp_touch_key_ctmu_res_buf_avg(u8 ch) { #if !TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE u32 res_sum = 0; u8 j = 0; u8 cnt = ctmu_res_buf_in[ch]; for (u8 i = 0; i < (CTMU_RES_BUF_SIZE - 5); i ++) { if (ctmu_res_buf[ch][cnt]) { res_sum += ctmu_res_buf[ch][cnt]; j ++; } else { return 0; } cnt ++; if (cnt >= CTMU_RES_BUF_SIZE) { cnt = 0; } } if (res_sum) { return (res_sum / j); } #endif return 0; } static u8 lp_touch_key_check_long_click_by_ctmu_res(u8 ch) { #if !TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE long_event_res_avg[ch] = lp_touch_key_ctmu_res_buf_avg(ch); log_debug("long_event_res_avg: %d\n", long_event_res_avg[ch]); if ((falling_res_avg[ch] < 2000) || \ (falling_res_avg[ch] > 20000) || \ (long_event_res_avg[ch] < 2000) || \ (long_event_res_avg[ch] > 20000)) { } else { u16 cfg2 = (M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG2H + ch * 8) << 8) | M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG2L + ch * 8); u16 diff = (falling_res_avg[ch] > long_event_res_avg[ch]) ? (falling_res_avg[ch] - long_event_res_avg[ch]) : (long_event_res_avg[ch] - falling_res_avg[ch]); if (diff < (cfg2 / 2)) { log_debug("long event return ! diff: %d < cfg2/2: %d\n", diff, (cfg2 / 2)); //复位算法 lp_touch_key_send_cmd(CTMU_M2P_RESET_ALGO); return 1; } } #endif return 0; } #endif u8 lp_touch_key_alog_range_display(u8 *display_buf) { if (__this->init == 0) { return 0; } u8 tmp_buf[32], i = 0; memset(tmp_buf, 0, sizeof(tmp_buf)); for (u8 ch = 0; ch < LP_CTMU_CHANNEL_SIZE; ch ++) { if (__this->config->ch[ch].enable) { u16 range = alog_cfg[ch].range % 1000; tmp_buf[0 + i * 4] = (range / 100) + '0'; tmp_buf[1 + i * 4] = ((range % 100) / 10) + '0'; tmp_buf[2 + i * 4] = (range % 10) + '0'; tmp_buf[3 + i * 4] = ' '; i ++; } } if (i) { display_buf[0] = i * 4 + 1; display_buf[1] = 0x01; memcpy((u8 *)&display_buf[2], tmp_buf, i * 4); printf_buf(display_buf, i * 4 + 2); return (display_buf[0] + 1); } return 0; } #if !TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE void lp_touch_key_save_alog_cfg(void *priv) { u8 ch = *((u8 *)priv); int ret = syscfg_write(VM_LP_TOUCH_KEY0_ALOG_CFG + ch, (void *)&alog_cfg[ch], 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_timeout[ch] = 0; } void lp_touch_key_ctmu_cfg2_check_update(u8 ch, u16 cfg2_new) { u16 cfg0 = (M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG0H + ch * 8) << 8) | M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG0L + ch * 8); u16 cfg2_old = (M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG2H + ch * 8) << 8) | M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG2L + ch * 8); if ((cfg2_old != cfg2_new) && (cfg2_new > (3 * cfg0))) { printf("ctmu ch%d cfg2_old = %d cfg2_new = %d\n", ch, cfg2_old, cfg2_new); M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG2L + ch * 8) = cfg2_new & 0xff; M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG2H + ch * 8) = (cfg2_new >> 8) & 0xff; u16 cfg1 = (M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG1H + ch * 8) << 8) | (M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG1L + ch * 8)); M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG0L + ch * 8) = cfg1 & 0xff; M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG0H + ch * 8) = (cfg1 >> 8) & 0xff; } } static void lp_touch_key_ctmu_res_scan(void *priv) { for (u8 ch = 0; ch < LP_CTMU_CHANNEL_SIZE; ch ++) { if (__this->config->ch[ch].enable) { if (__this->config->eartch_en && (__this->config->eartch_ch == ch)) { } else { u16 ctmu_res0; u16 ctmu_res1; __read_res: ctmu_res0 = (P2M_MESSAGE_ACCESS(P2M_MASSAGE_CTMU_CH0_H_RES + ch * 2) << 8) | P2M_MESSAGE_ACCESS(P2M_MASSAGE_CTMU_CH0_L_RES + ch * 2); delay(100); ctmu_res1 = (P2M_MESSAGE_ACCESS(P2M_MASSAGE_CTMU_CH0_H_RES + ch * 2) << 8) | P2M_MESSAGE_ACCESS(P2M_MASSAGE_CTMU_CH0_L_RES + ch * 2); if (ctmu_res0 != ctmu_res1) { goto __read_res; } #if 1 if ((ctmu_res0 < 2000) || (ctmu_res0 > 20000)) { continue; } #if CTMU_CHECK_LONG_CLICK_BY_RES ctmu_res_buf[ch][ctmu_res_buf_in[ch]] = ctmu_res0; ctmu_res_buf_in[ch] ++; if (ctmu_res_buf_in[ch] >= CTMU_RES_BUF_SIZE) { ctmu_res_buf_in[ch] = 0; } #endif if (alog_cfg[ch].ready_flag == 0) { continue; } if (alog_sta_cnt[ch] < 50) { alog_sta_cnt[ch] ++; continue; } TouchAlgo_Update(ch, ctmu_res0); u8 range_valid = 0; u16 touch_range = TouchAlgo_GetRange(ch, (u8 *)&range_valid); s32 touch_sigma = TouchAlgo_GetSigma(ch); /* printf("ch%d res:%d range:%d val:%d sigma:%d\n", ch, ctmu_res0, touch_range, range_valid, touch_sigma); */ if ((range_valid) && (touch_range > TOUCH_RANGE_MIN) && (touch_range < TOUCH_RANGE_MAX)) { if (touch_range != alog_cfg[ch].range) { u16 cfg2_new = touch_range * (10 - ch_range_sensity[ch]) / 10; lp_touch_key_ctmu_cfg2_check_update(ch, cfg2_new); alog_cfg[ch].range = touch_range; alog_cfg[ch].sigma = touch_sigma; if (save_alog_cfg_timeout[ch] == 0) { save_alog_cfg_timeout[ch] = sys_timeout_add((void *)&_ch_priv[ch], lp_touch_key_save_alog_cfg, 1); } } } else if ((range_valid) && (touch_range >= TOUCH_RANGE_MAX)) { TouchAlgo_SetRange(ch, alog_cfg[ch].range); } #endif } } } } void lp_touch_key_alog_ready_flag_check_and_set(void) { for (u8 ch = 0; ch < LP_CTMU_CHANNEL_SIZE; ch ++) { if (__this->config->ch[ch].enable) { if (__this->config->eartch_en && (__this->config->eartch_ch == ch)) { } else { alog_cfg[ch].ready_flag = 0; syscfg_read(VM_LP_TOUCH_KEY0_ALOG_CFG + ch, (void *)&alog_cfg[ch], sizeof(struct lp_touch_key_alog_cfg)); if (alog_cfg[ch].ready_flag == 0) { alog_cfg[ch].ready_flag = 1; lp_touch_key_save_alog_cfg((void *)&ch); } } } } } #endif 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); } u8 p11_wakeup_query(void) { return is_wakeup_source(PWR_WK_REASON_P11); }; void lp_touch_key_send_cmd(enum CTMU_M2P_CMD cmd) { M2P_CTMU_CMD = cmd; P11_M2P_INT_SET = BIT(M2P_CTMU_INDEX); } #define IO_RESET_PORTB_01 18 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; 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, 8, 0); P33_CON_SET(P3_PINR_CON1, 0, 8, 0x16); P33_CON_SET(P3_PINR_CON1, 0, 1, 1); log_info("reset pin change: old: %d, P3_PINR_CON1 = 0x%x", pinr_io, P33_CON_GET(P3_PINR_CON1)); } } u8 ch_enable = 0; u8 ch_wakeup_en = 0; u8 ch_debug = 0; for (u8 ch = 0; ch < LP_CTMU_CHANNEL_SIZE; ch ++) { if (__this->config->ch[ch].enable) { ch_enable |= BIT(ch); if (__this->config->ch[ch].wakeup_enable) { ch_wakeup_en |= BIT(ch); } if (CFG_CHx_DEBUG_ENABLE & BIT(ch)) { ch_debug |= BIT(ch); } } } if (p11_wakeup_query() == 0 || get_charge_online_flag() || (!(ch_wakeup_en)) || (is_ldo5v_wakeup())) { for (u32 m2p_addr = 0x18; m2p_addr < 0x56; m2p_addr ++) { M2P_MESSAGE_ACCESS(m2p_addr) = 0; } for (u32 p2m_addr = 0x10; p2m_addr < 0x24; p2m_addr ++) { P2M_MESSAGE_ACCESS(p2m_addr) = 0; } } M2P_CTMU_MSG = 0; M2P_CTMU_CH_CFG = 0; M2P_CTMU_TIME_BASE = CTMU_SAMPLE_RATE_PRD; M2P_CTMU_LONG_TIMEL = (CTMU_LONG_KEY_DELAY_TIME & 0xFF); M2P_CTMU_LONG_TIMEH = ((CTMU_LONG_KEY_DELAY_TIME >> 8) & 0xFF); M2P_CTMU_HOLD_TIMEL = (CTMU_HOLD_CLICK_DELAY_TIME & 0xFF); M2P_CTMU_HOLD_TIMEH = ((CTMU_HOLD_CLICK_DELAY_TIME >> 8) & 0xFF); M2P_CTMU_SOFTOFF_LONG_TIMEL = (CFG_M2P_CTMU_SOFTOFF_LONG_TIME & 0xFF); M2P_CTMU_SOFTOFF_LONG_TIMEH = ((CFG_M2P_CTMU_SOFTOFF_LONG_TIME >> 8) & 0xFF); #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE M2P_CTMU_LONG_PRESS_RESET_TIME_VALUE_L = 0; M2P_CTMU_LONG_PRESS_RESET_TIME_VALUE_H = 0; #else M2P_CTMU_LONG_PRESS_RESET_TIME_VALUE_L = (CTMU_RESET_TIME_CONFIG & 0xFF); M2P_CTMU_LONG_PRESS_RESET_TIME_VALUE_H = ((CTMU_RESET_TIME_CONFIG >> 8) & 0xFF); #endif log_info("M2P_CTMU_LONG_TIMEL = 0x%x", M2P_CTMU_LONG_TIMEL); log_info("M2P_CTMU_LONG_TIMEH = 0x%x", M2P_CTMU_LONG_TIMEH); log_info("M2P_CTMU_HOLD_TIMEL = 0x%x", M2P_CTMU_HOLD_TIMEL); log_info("M2P_CTMU_HOLD_TIMEH = 0x%x", M2P_CTMU_HOLD_TIMEH); log_info("M2P_CTMU_SOFTOFF_LONG_TIMEL = 0x%x", M2P_CTMU_SOFTOFF_LONG_TIMEL); log_info("M2P_CTMU_SOFTOFF_LONG_TIMEH = 0x%x", M2P_CTMU_SOFTOFF_LONG_TIMEH); log_info("M2P_CTMU_LONG_PRESS_RESET_TIME_VALUE_L = 0x%x", M2P_CTMU_LONG_PRESS_RESET_TIME_VALUE_L); log_info("M2P_CTMU_LONG_PRESS_RESET_TIME_VALUE_H = 0x%x", M2P_CTMU_LONG_PRESS_RESET_TIME_VALUE_H); M2P_CTMU_CH_ENABLE = ch_enable; M2P_CTMU_CH_WAKEUP_EN = ch_wakeup_en; M2P_CTMU_CH_DEBUG = ch_debug; for (u8 ch = 0; ch < LP_CTMU_CHANNEL_SIZE; ch ++) { if (__this->config->ch[ch].enable) { u8 ch_sensity = __this->config->ch[ch].sensitivity; M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG0L + ch * 8) = ((ch_sensitivity_table[ch_sensity + ch * 10].cfg0) & 0xFF); M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG0H + ch * 8) = (((ch_sensitivity_table[ch_sensity + ch * 10].cfg0) >> 8) & 0xFF); M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG1L + ch * 8) = ((ch_sensitivity_table[ch_sensity + ch * 10].cfg1) & 0xFF); M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG1H + ch * 8) = (((ch_sensitivity_table[ch_sensity + ch * 10].cfg1) >> 8) & 0xFF); M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG2L + ch * 8) = ((ch_sensitivity_table[ch_sensity + ch * 10].cfg2) & 0xFF); M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG2H + ch * 8) = (((ch_sensitivity_table[ch_sensity + ch * 10].cfg2) >> 8) & 0xFF); log_info("M2P_CTMU_CH%d_CFG0L = 0x%x", ch, M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG0L + ch * 8)); log_info("M2P_CTMU_CH%d_CFG0H = 0x%x", ch, M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG0H + ch * 8)); log_info("M2P_CTMU_CH%d_CFG1L = 0x%x", ch, M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG1L + ch * 8)); log_info("M2P_CTMU_CH%d_CFG1H = 0x%x", ch, M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG1H + ch * 8)); log_info("M2P_CTMU_CH%d_CFG2L = 0x%x", ch, M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG2L + ch * 8)); log_info("M2P_CTMU_CH%d_CFG2H = 0x%x", ch, M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG2H + ch * 8)); ctmu_port_init(__this->config->ch[ch].port); #if TCFG_LP_EARTCH_KEY_ENABLE if (__this->config->eartch_en && (__this->config->eartch_ch == ch)) { M2P_CTMU_CH_CFG |= BIT(1); M2P_CTMU_EARTCH_CH = (__this->config->eartch_ref_ch << 4) | (__this->config->eartch_ch & 0xf); #if (TCFG_EARTCH_EVENT_HANDLE_ENABLE && TCFG_LP_EARTCH_KEY_ENABLE) extern int eartch_event_deal_init(void); eartch_event_deal_init(); #endif u16 trim_value; int ret = syscfg_read(LP_KEY_EARTCH_TRIM_VALUE, &trim_value, sizeof(trim_value)); __this->eartch_trim_flag = 0; __this->eartch_inear_ok = 0; __this->eartch_trim_value = 0; if (ret > 0) { __this->eartch_inear_ok = 1; __this->eartch_trim_value = trim_value; log_info("eartch_trim_value = %d", __this->eartch_trim_value); M2P_CTMU_EARTCH_TRIM_VALUE_L = (__this->eartch_trim_value & 0xFF); M2P_CTMU_EARTCH_TRIM_VALUE_H = ((__this->eartch_trim_value >> 8) & 0xFF); } else { //没有trim的情况下用不了 M2P_CTMU_EARTCH_TRIM_VALUE_L = (10000 & 0xFF); M2P_CTMU_EARTCH_TRIM_VALUE_H = ((10000 >> 8) & 0xFF); } //软件触摸灵敏度调试 M2P_CTMU_INEAR_VALUE_L = __this->config->eartch_soft_inear_val & 0xFF; M2P_CTMU_INEAR_VALUE_H = __this->config->eartch_soft_inear_val >> 8; M2P_CTMU_OUTEAR_VALUE_L = __this->config->eartch_soft_outear_val & 0xFF; M2P_CTMU_OUTEAR_VALUE_H = __this->config->eartch_soft_outear_val >> 8; } else #endif { #if !TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE TouchAlgo_Init(ch, TOUCH_RANGE_MIN, TOUCH_RANGE_MAX); alog_sta_cnt[ch] = 0; ch_range_sensity[ch] = ch_sensity; log_info("read vm alog cfg\n"); int ret = syscfg_read(VM_LP_TOUCH_KEY0_ALOG_CFG + ch, (void *)&alog_cfg[ch], sizeof(struct lp_touch_key_alog_cfg)); if ((ret == (sizeof(struct lp_touch_key_alog_cfg))) && (alog_cfg[ch].range > TOUCH_RANGE_MIN) && (alog_cfg[ch].range < TOUCH_RANGE_MAX)) { log_info("vm read ch%d alog ready:%d sigma:%d range:%d\n", ch, alog_cfg[ch].ready_flag, alog_cfg[ch].sigma, alog_cfg[ch].range); u16 cfg0 = (M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG0H + ch * 8) << 8) | (M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG0L + ch * 8)); M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG1L + ch * 8) = (cfg0 + 5) & 0xff; M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG1H + ch * 8) = ((cfg0 + 5) >> 8) & 0xff; u16 cfg2_new = alog_cfg[ch].range * (10 - ch_range_sensity[ch]) / 10; M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG2L + ch * 8) = cfg2_new & 0xff; M2P_MESSAGE_ACCESS(M2P_MASSAGE_CTMU_CH0_CFG2H + ch * 8) = (cfg2_new >> 8) & 0xff; TouchAlgo_SetSigma(ch, alog_cfg[ch].sigma); TouchAlgo_SetRange(ch, alog_cfg[ch].range); } #endif } } } #if !TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE #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 (ctmu_res_scan_time_add == 0) { ctmu_res_scan_time_add = usr_timer_add(NULL, lp_touch_key_ctmu_res_scan, 20, 0); } #if CTMU_CHECK_LONG_CLICK_BY_RES lp_touch_key_ctmu_res_all_buf_clear(); #endif #endif //CTMU 初始化命令 if (p11_wakeup_query() == 0 || get_charge_online_flag() || (!(ch_wakeup_en)) || (is_ldo5v_wakeup())) { log_info("lp touch init by %d_%d_%d_%d\n", p11_wakeup_query(), get_charge_online_flag(), (!(ch_wakeup_en)), is_ldo5v_wakeup()); LPCTMU_ANA0_CONFIG(get_lpctmu_ana_level()); P2M_CTMU_WKUP_MSG &= (~(P2M_MESSAGE_INIT_MODE_FLAG)); } else { P2M_CTMU_WKUP_MSG |= (P2M_MESSAGE_INIT_MODE_FLAG); log_info("p11 wakeup, lp touch key continue work"); } __this->softoff_mode = LP_TOUCH_SOFTOFF_MODE_ADVANCE; log_info("M2P_CTMU_CH_ENABLE = 0x%x", M2P_CTMU_CH_ENABLE); log_info("M2P_CTMU_CH_WAKEUP_EN = 0x%x", M2P_CTMU_CH_WAKEUP_EN); log_info("M2P_CTMU_CH_CFG = 0x%x", M2P_CTMU_CH_CFG); log_info("M2P_CTMU_EARTCH_CH = 0x%x", M2P_CTMU_EARTCH_CH); lp_touch_key_send_cmd(CTMU_M2P_INIT); #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE lp_touch_key_online_debug_init(); #endif /* #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE */ __this->init = 1; } #if (TCFG_LP_SLIDE_KEY_ENABLE && TCFG_LP_SLIDE_KEY_SHORT_DISTANCE) /******************************双通道滑动触摸识别的基础原理*********************************** 1.单击，但如果超过设定的长按时间，那就为长按 chx __________________________________________ chx ___________ __________ |_______>180________| 2.单击，但如果超过设定的长按时间，那就为长按 chx ___________ __________ |_______>180________| chx _______ <30 <30 ______ |___________________________| 3.单击，但如果超过设定的长按时间，那就为长按 chx ___________ __________ |_______>180________| chx _______ <30 >30 __ |_______________________________| 4.单击，但如果超过设定的长按时间，那就为长按 chx ___________ __________ |_______>180________| chx ___ >30 <30 ______ |_______________________________| 5.单击，但如果超过设定的长按时间，那就为长按 chx ___________ __________ |_______>180________| chx ___ >30 >30 __ |___________________________________| 6.单击，但如果超过设定的长按时间，那就为长按 chx ___________ ______ |_______________________| chx _______ <30 >180 _<30______ |_______________________| 7.根据前后操作，有可能是滑动，也有可能是连击中的后单击，也有可能是无效操作 chx ___________ __________ |_______________| chx _______ <30 <180 _<30__________ |_______________| 8.滑动，t < 设定的长按的时间 chx ___________ __________ |_______________| chx ___ >30 t _<30__________ |___________________| 9.滑动，t < 设定的长按的时间 chx ___________ ______ |___________________| chx ___ >30 t __>30_________ |___________________| 10.滑动，t < 设定的长按的时间 chx ___________ ______ |___________________| chx _______ <30 t __>30_________ |_______________| *****************************************************************************/ enum falling_order_type { FALLING_NULL, FALLING_FIRST, FALLING_SECOND, }; enum raising_order_type { RAISING_NULL, RAISING_FIRST, RAISING_SECOND, }; enum time_interval_type { LONG_TIME, SHORT_TIME, }; enum slide_key_type { SHORT_CLICK = 1, DOUBLE_CLICK, TRIPLE_CLICK, FOURTH_CLICK, FIRTH_CLICK, LONG_CLICK = 8, LONG_HOLD_CLICK = 9, LONG_UP_CLICK = 10, SLIDE_UP = 0x12, SLIDE_DOWN = 0x21, }; static u8 falling_order[2] = {FALLING_NULL, FALLING_NULL}; static u8 raising_order[2] = {RAISING_NULL, RAISING_NULL}; static u8 falling_time_interval = 0; static u8 raising_time_interval = 0; static u8 last_key_type = 0; #define FALLING_TIMEOUT_TIME 30 //两个按下边沿的时间间隔的阈值 static int falling_timeout_add = 0; static void falling_timeout_handle(void *priv) { falling_timeout_add = 0; } #define RAISING_TIMEOUT_TIME 30 //两个抬起边沿的时间间隔的阈值 static int raising_timeout_add = 0; static void raising_timeout_handle(void *priv) { raising_timeout_add = 0; } #define CLICK_IDLE_TIMEOUT_TIME 500 //如果该时间内，没有单击，那么该时间之后的第一次单击，识别为首次单击 static int click_idle_timeout_add = 0; static void click_idle_timeout_handle(void *priv) { click_idle_timeout_add = 0; } #define FIRST_SHORT_CLICK_TIMEOUT_TIME 190 //只针对首次单击，要满足按够那么长时间。连击时，后面的单击没有该时间要求 static int first_short_click_timeout_add = 0; static void first_short_click_timeout_handle(void *priv) { first_short_click_timeout_add = 0; } void __attribute__((weak)) send_keytone_event(void) { //可以在此处发送按键音的消息 /* struct sys_event e; */ /* e.u.key.event = 5; */ /* e.u.key.value = 3; */ /* __ctmu_notify_key_event(&e, 0); */ } #define SEND_KEYTONE_TIMEOUT_TIME 250 //长按时的按键音，在按下后的多长时间要响 static u8 send_keytone_flag = 0; static int send_keytone_timeout_add = 0; static void send_keytone_timeout_handle(void *priv) { send_keytone_event(); send_keytone_timeout_add = 0; send_keytone_flag = 1; } #define SLIDE_CLICK_TIMEOUT_TIME 500 //识别为滑动之后，该时间内，如果有case7.也要识别为滑动 #define FAST_SLIDE_CNT_MAX 4 //一来就连续那么多次的case7.，就会识别为一次滑动。 static u8 fast_slide_cnt = 0; static u8 fast_slide_type = 0; static int slide_click_timeout_add = 0; void slide_click_timeout_handle(void *priv) { slide_click_timeout_add = 0; } static void check_channel_falling_info(u8 ch) { falling_order[ch] = FALLING_FIRST; if (falling_order[!ch] == FALLING_FIRST) { falling_order[ch] = FALLING_SECOND; } send_keytone_flag = 0; if (send_keytone_timeout_add == 0) { send_keytone_timeout_add = sys_hi_timeout_add(NULL, send_keytone_timeout_handle, SEND_KEYTONE_TIMEOUT_TIME); } else { sys_hi_timer_modify(send_keytone_timeout_add, SEND_KEYTONE_TIMEOUT_TIME); } if ((last_key_type != SHORT_CLICK) || (click_idle_timeout_add == 0)) { if (first_short_click_timeout_add == 0) { first_short_click_timeout_add = sys_hi_timeout_add(NULL, first_short_click_timeout_handle, FIRST_SHORT_CLICK_TIMEOUT_TIME); } else { sys_hi_timer_modify(first_short_click_timeout_add, FIRST_SHORT_CLICK_TIMEOUT_TIME); } } if (falling_order[ch] == FALLING_FIRST) { if (falling_timeout_add == 0) { falling_timeout_add = sys_hi_timeout_add(NULL, falling_timeout_handle, FALLING_TIMEOUT_TIME); } else { sys_hi_timer_modify(falling_timeout_add, FALLING_TIMEOUT_TIME); } falling_time_interval = SHORT_TIME; } else if (falling_order[ch] == FALLING_SECOND) { if (falling_timeout_add) { sys_hi_timeout_del(falling_timeout_add); falling_timeout_add = 0; falling_time_interval = SHORT_TIME; } else { falling_time_interval = LONG_TIME; } } } static u8 check_channel_raising_info_and_key_type(u8 ch) { u8 key_type = 0; fast_slide_type = 0; if (falling_order[ch] == FALLING_NULL) { return key_type; } raising_order[ch] = RAISING_FIRST; if (raising_order[!ch] == RAISING_FIRST) { raising_order[ch] = RAISING_SECOND; } if (falling_order[ch] > falling_order[!ch]) { if (raising_order[ch] == RAISING_FIRST) { key_type = SHORT_CLICK; //case 1~5. } else { if (falling_time_interval == SHORT_TIME) { if (raising_timeout_add) { sys_hi_timeout_del(raising_timeout_add); raising_timeout_add = 0; key_type = SHORT_CLICK; //case 6~7. if (ch == 0) { fast_slide_type = SLIDE_DOWN; } else { fast_slide_type = SLIDE_UP; } } else if (ch == 0) { key_type = SLIDE_DOWN; //case 10. } else { key_type = SLIDE_UP; //case 10. } } else if (ch == 0) { key_type = SLIDE_DOWN; //caee 8~9. } else { key_type = SLIDE_UP; //case 8~9. } } } else { if (raising_order[ch] == RAISING_FIRST) { if (falling_time_interval == SHORT_TIME) { if (raising_timeout_add == 0) { raising_timeout_add = sys_hi_timeout_add(NULL, raising_timeout_handle, RAISING_TIMEOUT_TIME); } else { sys_hi_timer_modify(raising_timeout_add, RAISING_TIMEOUT_TIME); } } else if (ch == 0) { key_type = SLIDE_UP; //case 8~9. } else { key_type = SLIDE_DOWN; //case 8~9. } } else { if (falling_time_interval == SHORT_TIME) { if (raising_timeout_add) { sys_hi_timeout_del(raising_timeout_add); raising_timeout_add = 0; key_type = SHORT_CLICK; //case 6~7 if (ch == 0) { fast_slide_type = SLIDE_UP; } else { fast_slide_type = SLIDE_DOWN; } } else if (ch == 0) { key_type = SLIDE_UP; //case 10. } else { key_type = SLIDE_DOWN; //case 10. } } else if (ch == 0) { key_type = SLIDE_UP; //case 8~9. } else { key_type = SLIDE_DOWN; //case 8~9. } } } return key_type; } static u8 get_slide_event_ch(void) { u8 event_ch = 1; for (u8 ch = 0; ch < LP_CTMU_CHANNEL_SIZE; ch ++) { if (__this->config->ch[ch].enable) { event_ch = ch; break; } } return event_ch; } static u8 check_slide_key_type(u8 event, u8 ch) { u8 key_type = 0; u8 event_ch = get_slide_event_ch(); if (event == (CTMU_P2M_CH0_FALLING_EVENT + ch * 8)) { if (ch == event_ch) { check_channel_falling_info(0); } else { check_channel_falling_info(1); } } else if (event == (CTMU_P2M_CH0_RAISING_EVENT + ch * 8)) { if (ch == event_ch) { if ((last_key_type == LONG_CLICK) || (last_key_type == LONG_HOLD_CLICK)) { key_type = LONG_UP_CLICK; //一定是长按抬起 } else { key_type = check_channel_raising_info_and_key_type(0); } } else { key_type = check_channel_raising_info_and_key_type(1); } } else if (event == (CTMU_P2M_CH0_LONG_KEY_EVENT + event_ch * 8)) {//长按只判断通道号小的那个按键 key_type = LONG_CLICK; } else if (event == (CTMU_P2M_CH0_HOLD_KEY_EVENT + event_ch * 8)) {//长按只判断通道号小的那个按键 key_type = LONG_HOLD_CLICK; } if (key_type) { falling_order[0] = FALLING_NULL; falling_order[1] = FALLING_NULL; raising_order[0] = RAISING_NULL; raising_order[1] = RAISING_NULL; falling_time_interval = 0; last_key_type = key_type; if (send_keytone_timeout_add) { sys_hi_timeout_del(send_keytone_timeout_add); send_keytone_timeout_add = 0; } if (key_type == SHORT_CLICK) { //case 6~7 的进一步处理 if (first_short_click_timeout_add) { sys_hi_timeout_del(first_short_click_timeout_add); first_short_click_timeout_add = 0; if (slide_click_timeout_add) { sys_hi_timeout_del(slide_click_timeout_add); slide_click_timeout_add = 0; if (fast_slide_type) { key_type = fast_slide_type; last_key_type = key_type; } else { key_type = 0xff; last_key_type = key_type; } fast_slide_cnt = 0; } else { if (fast_slide_type) { fast_slide_cnt ++; if (fast_slide_cnt >= FAST_SLIDE_CNT_MAX) { fast_slide_cnt = 0; key_type = fast_slide_type; last_key_type = key_type; } else { key_type = 0xff; last_key_type = key_type; } } else { fast_slide_cnt = 0; key_type = 0xff; last_key_type = key_type; } } } else { if (send_keytone_flag == 0) { send_keytone_event(); } if (slide_click_timeout_add) { sys_hi_timeout_del(slide_click_timeout_add); slide_click_timeout_add = 0; } fast_slide_cnt = 0; } if (click_idle_timeout_add == 0) { click_idle_timeout_add = sys_hi_timeout_add(NULL, click_idle_timeout_handle, CLICK_IDLE_TIMEOUT_TIME); } else { sys_hi_timer_modify(click_idle_timeout_add, CLICK_IDLE_TIMEOUT_TIME); } } else { fast_slide_cnt = 0; } if ((key_type == SLIDE_UP) || (key_type == SLIDE_DOWN)) { if (slide_click_timeout_add == 0) { slide_click_timeout_add = sys_hi_timeout_add(NULL, slide_click_timeout_handle, SLIDE_CLICK_TIMEOUT_TIME); } else { sys_hi_timer_modify(slide_click_timeout_add, SLIDE_CLICK_TIMEOUT_TIME); } } } return key_type; } static void ctmu_send_slide_key_type_event(u8 key_type) { struct sys_event e; u8 event_ch = get_slide_event_ch(); switch (key_type) { case SHORT_CLICK: //单击 ctmu_short_click_handle(event_ch); break; case LONG_CLICK: //长按 #if CTMU_CHECK_LONG_CLICK_BY_RES if (lp_touch_key_check_long_click_by_ctmu_res(event_ch)) { last_key_type = 0; return; } #endif ctmu_long_click_handle(event_ch); break; case LONG_HOLD_CLICK: //长按保持 #if CTMU_CHECK_LONG_CLICK_BY_RES if (lp_touch_key_check_long_click_by_ctmu_res(event_ch)) { last_key_type = 0; return; } #endif ctmu_hold_click_handle(event_ch); break; case LONG_UP_CLICK: //长按抬起 ctmu_raise_click_handle(event_ch); break; case SLIDE_UP: //向上滑动 e.u.key.event = TOUCH_KEY_EVENT_SLIDE_UP; e.u.key.value = __this->config->slide_mode_key_value; printf("key.event = TOUCH_KEY_EVENT_SLIDE_UP\n"); printf("key.value = %d\n", e.u.key.value); __ctmu_notify_key_event(&e, event_ch); break; case SLIDE_DOWN: //向下滑动 e.u.key.event = TOUCH_KEY_EVENT_SLIDE_DOWN; e.u.key.value = __this->config->slide_mode_key_value; printf("key.event = TOUCH_KEY_EVENT_SLIDE_DOWN\n"); printf("key.value = %d\n", e.u.key.value); __ctmu_notify_key_event(&e, event_ch); break; default: break; } } #endif u8 last_state = CTMU_P2M_EARTCH_OUT_EVENT; void p33_ctmu_key_event_irq_handler() { u8 ret = 0; u8 ctmu_event = P2M_CTMU_KEY_EVENT; u8 ch_num = P2M_CTMU_KEY_CNT; u16 ch_res = 0; u16 chx_res[LP_CTMU_CHANNEL_SIZE]; #if TCFG_LP_EARTCH_KEY_ENABLE if (testbox_get_key_action_test_flag(NULL)) { if (__this->config->eartch_en && (__this->config->eartch_ch == ch_num)) { ret = lp_touch_key_testbox_remote_test(ch_num, ctmu_event); if (ret == true) { return; } } } #endif /* printf("ctmu_event = 0x%x\n", ctmu_event); */ switch (ctmu_event) { case CTMU_P2M_CH0_RES_EVENT: case CTMU_P2M_CH1_RES_EVENT: case CTMU_P2M_CH2_RES_EVENT: case CTMU_P2M_CH3_RES_EVENT: case CTMU_P2M_CH4_RES_EVENT: chx_res[0] = (P2M_CTMU_CH0_H_RES << 8) | P2M_CTMU_CH0_L_RES; chx_res[1] = (P2M_CTMU_CH1_H_RES << 8) | P2M_CTMU_CH1_L_RES; chx_res[2] = (P2M_CTMU_CH2_H_RES << 8) | P2M_CTMU_CH2_L_RES; chx_res[3] = (P2M_CTMU_CH3_H_RES << 8) | P2M_CTMU_CH3_L_RES; chx_res[4] = (P2M_CTMU_CH4_H_RES << 8) | P2M_CTMU_CH4_L_RES; ch_res = chx_res[ch_num]; /* printf("ch%d_res: %d\n", ch_num, ch_res); */ #if TWS_BT_SEND_KEY_CH_RES_DATA_ENABLE if (tws_api_get_tws_state() & TWS_STA_SIBLING_CONNECTED) { lpctmu_tws_send_res_data(BT_KEY_CH_RES_MSG, chx_res[0], chx_res[1], chx_res[2], chx_res[3], chx_res[4]); } #endif #if TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE lp_touch_key_online_debug_send(ch_num, ch_res); #endif #if TCFG_LP_EARTCH_KEY_ENABLE if (__this->config->eartch_en && (__this->config->eartch_ch == ch_num)) { u16 eartch_ch_res = chx_res[ch_num]; u16 eartch_ref_ch_res = chx_res[__this->config->eartch_ref_ch]; u16 eartch_iir = (P2M_CTMU_EARTCH_H_IIR_VALUE << 8) | P2M_CTMU_EARTCH_L_IIR_VALUE; u16 eartch_trim = (P2M_CTMU_EARTCH_H_TRIM_VALUE << 8) | P2M_CTMU_EARTCH_L_TRIM_VALUE; u16 eartch_diff = (P2M_CTMU_EARTCH_H_DIFF_VALUE << 8) | P2M_CTMU_EARTCH_L_DIFF_VALUE; #if TWS_BT_SEND_EARTCH_RES_DATA_ENABLE if (tws_api_get_tws_state() & TWS_STA_SIBLING_CONNECTED) { lpctmu_tws_send_res_data(BT_EARTCH_RES_MSG, eartch_ch_res, eartch_ref_ch_res, eartch_iir, eartch_trim, eartch_diff); } #endif #if !TCFG_LP_TOUCH_KEY_BT_TOOL_ENABLE if (__this->eartch_trim_flag) { if (__this->eartch_trim_value == 0) { __this->eartch_trim_value = eartch_diff; } else { __this->eartch_trim_value = ((eartch_diff + __this->eartch_trim_value) >> 1); } if (__this->eartch_trim_flag++ > 20) { __this->eartch_trim_flag = 0; M2P_CTMU_CH_DEBUG &= ~BIT(ch_num); int ret = syscfg_write(LP_KEY_EARTCH_TRIM_VALUE, &(__this->eartch_trim_value), sizeof(__this->eartch_trim_value)); log_info("write ret = %d", ret); if (ret > 0) { M2P_CTMU_EARTCH_TRIM_VALUE_L = (__this->eartch_trim_value & 0xFF); M2P_CTMU_EARTCH_TRIM_VALUE_H = ((__this->eartch_trim_value >> 8) & 0xFF); __this->eartch_inear_ok = 1; #if TCFG_EARTCH_EVENT_HANDLE_ENABLE eartch_state_update(EARTCH_STATE_TRIM_OK); #endif log_info("trim: %d\n", __this->eartch_inear_ok); is_lpkey_active = 0; } else { __this->eartch_inear_ok = 0; #if TCFG_EARTCH_EVENT_HANDLE_ENABLE eartch_state_update(EARTCH_STATE_TRIM_ERR); #endif log_info("trim: %d\n", __this->eartch_inear_ok); is_lpkey_active = 0; } } log_debug("eartch ch trim value: %d, res = %d", __this->eartch_trim_value, eartch_diff); } #endif if (P2M_CTMU_EARTCH_EVENT != last_state) { last_state = P2M_CTMU_EARTCH_EVENT; if (last_state == CTMU_P2M_EARTCH_IN_EVENT) { printf("soft inear\n"); #if TWS_BT_SEND_EVENT_ENABLE lpctmu_tws_send_event_data(EAR_IN, BT_EVENT_SW_MSG); #endif if (__this->eartch_inear_ok) { ctmu_eartch_event_handle(EAR_IN); } } else if (last_state == CTMU_P2M_EARTCH_OUT_EVENT) { printf("soft outear"); #if TWS_BT_SEND_EVENT_ENABLE lpctmu_tws_send_event_data(EAR_OUT, BT_EVENT_SW_MSG); #endif if (__this->eartch_inear_ok) { ctmu_eartch_event_handle(EAR_OUT); } } } } #endif break; case CTMU_P2M_CH0_SHORT_KEY_EVENT: case CTMU_P2M_CH1_SHORT_KEY_EVENT: case CTMU_P2M_CH2_SHORT_KEY_EVENT: case CTMU_P2M_CH3_SHORT_KEY_EVENT: case CTMU_P2M_CH4_SHORT_KEY_EVENT: log_debug("CH%d: SHORT click", ch_num); #if (TCFG_LP_SLIDE_KEY_ENABLE && TCFG_LP_SLIDE_KEY_SHORT_DISTANCE) #else ctmu_short_click_handle(ch_num); #endif break; case CTMU_P2M_CH0_LONG_KEY_EVENT: case CTMU_P2M_CH1_LONG_KEY_EVENT: case CTMU_P2M_CH2_LONG_KEY_EVENT: case CTMU_P2M_CH3_LONG_KEY_EVENT: case CTMU_P2M_CH4_LONG_KEY_EVENT: log_debug("CH%d: LONG click", ch_num); is_lpkey_active = 0; #if (TCFG_LP_SLIDE_KEY_ENABLE && TCFG_LP_SLIDE_KEY_SHORT_DISTANCE) #else #if CTMU_CHECK_LONG_CLICK_BY_RES if (lp_touch_key_check_long_click_by_ctmu_res(ch_num)) { return; } #endif ctmu_long_click_handle(ch_num); #endif break; case CTMU_P2M_CH0_HOLD_KEY_EVENT: case CTMU_P2M_CH1_HOLD_KEY_EVENT: case CTMU_P2M_CH2_HOLD_KEY_EVENT: case CTMU_P2M_CH3_HOLD_KEY_EVENT: case CTMU_P2M_CH4_HOLD_KEY_EVENT: log_debug("CH%d: HOLD click", ch_num); is_lpkey_active = 0; #if (TCFG_LP_SLIDE_KEY_ENABLE && TCFG_LP_SLIDE_KEY_SHORT_DISTANCE) #else #if CTMU_CHECK_LONG_CLICK_BY_RES if (lp_touch_key_check_long_click_by_ctmu_res(ch_num)) { return; } #endif ctmu_hold_click_handle(ch_num); #endif break; case CTMU_P2M_CH0_FALLING_EVENT: case CTMU_P2M_CH1_FALLING_EVENT: case CTMU_P2M_CH2_FALLING_EVENT: case CTMU_P2M_CH3_FALLING_EVENT: case CTMU_P2M_CH4_FALLING_EVENT: log_debug("CH%d: FALLING", ch_num); is_lpkey_active = 1; #if CTMU_CHECK_LONG_CLICK_BY_RES falling_res_avg[ch_num] = lp_touch_key_ctmu_res_buf_avg(ch_num); log_debug("falling_res_avg: %d", falling_res_avg[ch_num]); #endif break; case CTMU_P2M_CH0_RAISING_EVENT: case CTMU_P2M_CH1_RAISING_EVENT: case CTMU_P2M_CH2_RAISING_EVENT: case CTMU_P2M_CH3_RAISING_EVENT: case CTMU_P2M_CH4_RAISING_EVENT: log_debug("CH%d: RAISING", ch_num); is_lpkey_active = 0; #if CTMU_CHECK_LONG_CLICK_BY_RES lp_touch_key_ctmu_res_buf_clear(ch_num); #endif #if (TCFG_LP_SLIDE_KEY_ENABLE && TCFG_LP_SLIDE_KEY_SHORT_DISTANCE) #else ctmu_raise_click_handle(ch_num); #endif break; case CTMU_P2M_EARTCH_IN_EVENT: log_debug("CH%d: IN", ch_num); break; case CTMU_P2M_EARTCH_OUT_EVENT: log_debug("CH%d: OUT", ch_num); break; default: break; } #if (TCFG_LP_SLIDE_KEY_ENABLE && TCFG_LP_SLIDE_KEY_SHORT_DISTANCE) u8 key_type = check_slide_key_type(ctmu_event, ch_num); if (key_type) { printf("CH%d: key_type = 0x%x\n", ch_num, key_type); ctmu_send_slide_key_type_event(key_type); } #endif } u8 lp_touch_key_power_on_status() { extern u8 power_reset_flag; u8 sfr = power_reset_flag; u8 ret = 0; log_debug("P3_RST_SRC = %x, P2M_CTMU_CTMU_WKUP_MSG = 0x%x", sfr, P2M_CTMU_WKUP_MSG); if (P2M_CTMU_WKUP_MSG & P2M_MESSAGE_POWER_ON_FLAG) { //长按开机查询 if (P2M_CTMU_WKUP_MSG & (P2M_MESSAGE_KEY_ACTIVE_FLAG)) { //按键释放查询, 0:释放, 1: 触摸保持 ret = 1; //key active } } return ret; } void lp_touch_key_disable(void) { log_debug("%s", __func__); P2M_CTMU_WKUP_MSG &= (~(P2M_MESSAGE_SYNC_FLAG)); lp_touch_key_send_cmd(CTMU_M2P_DISABLE); while (!(P2M_CTMU_WKUP_MSG & P2M_MESSAGE_SYNC_FLAG)); __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() { log_debug("%s", __func__); #if (!LP_TOUCH_KEY_CHARGE_MODE_SW_DISABLE) P2M_CTMU_WKUP_MSG &= (~(P2M_MESSAGE_SYNC_FLAG)); lp_touch_key_send_cmd(CTMU_M2P_CHARGE_ENTER_MODE); while (!(P2M_CTMU_WKUP_MSG & P2M_MESSAGE_SYNC_FLAG)); __this->softoff_mode = LP_TOUCH_SOFTOFF_MODE_LEGACY; #endif } void lp_touch_key_charge_mode_exit() { log_debug("%s", __func__); P2M_CTMU_WKUP_MSG &= (~(P2M_MESSAGE_RESET_ALGO_FLAG)); lp_touch_key_send_cmd(CTMU_M2P_RESET_ALGO); while (!(P2M_CTMU_WKUP_MSG & P2M_MESSAGE_RESET_ALGO_FLAG)); #if (!LP_TOUCH_KEY_CHARGE_MODE_SW_DISABLE) 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; } void set_lpkey_active(u8 set) { is_lpkey_active = set; } static u8 lpkey_idle_query(void) { return !is_lpkey_active; } REGISTER_LP_TARGET(key_lp_target) = { .name = "lpkey", .is_idle = lpkey_idle_query, }; #endif