static enum hrtimer_restart button_event_timer_func(struct hrtimer *data) { H2W_DBG(""); if (switch_get_state(&hi->sdev) == HEADSET) { if (gpio_get_value(hi->cable_in2) == BTN_STATE_RELEASED) { /* FIH-SW2-MM-AY-TAP_headset_00 */ if (hi->ignore_btn) hi->ignore_btn = 0; else { if (bn_state) button_released(); else { if (!hi->ignore_btn) { /* FIH-SW2-MM-AY-TAP_headset_01 */ button_pressed(); button_released(); } /* FIH-SW2-MM-AY-TAP_headset_01 */ } } } else { if (!hi->ignore_btn) button_pressed(); } } return HRTIMER_NORESTART; }
static void remove_headset(void) { unsigned long irq_flags; H2W_DBG(""); /*Report Headset State*/ input_report_switch(hi->input, SW_HEADPHONE_INSERT, 0); switch_set_state(&hi->sdev, BIT_NO_DEVICE); input_sync(hi->input); /* Disable button */ if(hi->enable_btn_irq) { local_irq_save(irq_flags); disable_irq_nosync(hi->irq_btn); irq_set_irq_wake(hi->irq_btn, 0); hi->enable_btn_irq = 0; local_irq_restore(irq_flags); } /*Check Button State*/ if (atomic_read(&hi->btn_state)) button_released(); //bc gpio_set_value(hi->gpio_mic_mode, 0); /* LGE_CHANGE_S: 2012-04-03, [email protected] Description: 500ms -> 250ms */ hi->debounce_time = ktime_set(0, 250000000); /* 500ms */ /* LGE_CHANGE_E: 500ms -> 250ms */ }
static void remove_headset(void) { #ifdef FEATURE_AUD_HOOK_BTN unsigned long irq_flags; #endif H2W_DBG(""); hi->ignore_btn = 1; /* FIH-SW2-MM-AY-TAP_Tapioca-00746_00 */ pmic_hsed_enable(PM_HSED_CONTROLLER_0, PM_HSED_ENABLE_OFF); /* FIH-SW2-MM-AY-TAP-ControlHSED_BIAS1-01 */ switch_set_state(&hi->sdev, NO_DEVICE); input_sync(hi->hs_input); #ifdef FEATURE_AUD_HOOK_BTN mHeadphone = false; if (bn_irq_enable) { local_irq_save(irq_flags); disable_irq(hi->irq_btn); local_irq_restore(irq_flags); bn_irq_enable=0; irq_set_irq_wake(hi->irq_btn, 0); } if (atomic_read(&hi->btn_state)) button_released(); #endif }
static void remove_headset(struct hsd_info *hi) { HSD_DBG("remove_headset"); gpio_set_value_cansleep(hi->gpio_mic_en, 0); if (hi->set_headset_mic_bias) hi->set_headset_mic_bias(FALSE); atomic_set(&hi->is_3_pole_or_not, 1); mutex_lock(&hi->mutex_lock); switch_set_state(&hi->sdev, NO_DEVICE); mutex_unlock(&hi->mutex_lock); if (atomic_read(&hi->irq_key_enabled)) { unsigned long irq_flags; local_irq_save(irq_flags); disable_irq(hi->irq_key); local_irq_restore(irq_flags); atomic_set(&hi->irq_key_enabled, FALSE); } if (atomic_read(&hi->btn_state)) button_released(hi); }
void headset_button_event(int is_press, int type) { HS_DBG(); if (hi->hs_35mm_type == HEADSET_UNPLUG && hi->h2w_35mm_type == HEADSET_UNPLUG) { HS_LOG("IGNORE key %d (HEADSET_UNPLUG)", type); return; } if (!hs_hpin_stable()) { HS_LOG("IGNORE key %d (Unstable HPIN)", type); return; } if (!get_mic_state()) { HS_LOG("IGNORE key %d (Not support MIC)", type); return; } if (!is_press) button_released(type); else if (!atomic_read(&hi->btn_state)) button_pressed(type); }
static void remove_35mm_do_work(struct work_struct *work) { int state; if (hi->is_wake_lock_ready) wake_lock_timeout(&hi->headset_wake_lock, 2.5*HZ); H2W_DBG(""); /*To solve the insert, remove, insert headset problem*/ if (time_before_eq(jiffies, hi->insert_jiffies)) msleep(800); if (hi->is_ext_insert) { H2WI("Skip 3.5mm headset plug out!!!"); return; } printk(KERN_INFO "3.5mm_headset plug out\n"); mutex_lock(&hi->mutex_lock); state = switch_get_state(&hi->sdev); if (hi->mic_bias_state) { turn_mic_bias_on(0); hi->mic_bias_state = 0; } /* For HW Metrico lab test */ if (hi->metrico_status) enable_metrico_headset(0); microp_notify_unplug_mic(); if (atomic_read(&hi->btn_state)) button_released(atomic_read(&hi->btn_state)); hi->ext_35mm_status = HTC_35MM_UNPLUG; if (hi->key_int_shutdown_gpio) gpio_set_value(hi->key_int_shutdown_gpio, 0); if (hi->ext_mic_sel) gpio_direction_output(hi->ext_mic_sel, 0); if (hi->h2w_dev_type == H2W_TVOUT) { state &= ~(BIT_HEADSET | BIT_35MM_HEADSET); state |= BIT_HEADSET_NO_MIC; switch_set_state(&hi->sdev, state); } else if (hi->cable_in1 && !gpio_get_value(hi->cable_in1)) { state &= ~BIT_35MM_HEADSET; switch_set_state(&hi->sdev, state); queue_delayed_work(detect_wq, &detect_h2w_work, H2W_NO_DELAY); } else { state &= ~(BIT_HEADSET | BIT_HEADSET_NO_MIC | BIT_35MM_HEADSET); switch_set_state(&hi->sdev, state); } mutex_unlock(&hi->mutex_lock); }
static void remove_h2w_35mm(void) { HS_LOG_TIME("Remove H2W 3.5mm headset"); set_35mm_hw_state(0); if (atomic_read(&hi->btn_state)) button_released(atomic_read(&hi->btn_state)); hi->h2w_35mm_type = HEADSET_UNPLUG; }
static void remove_detect_work_func(struct work_struct *work) { int state; wake_lock_timeout(&hi->hs_wake_lock, HS_WAKE_LOCK_TIMEOUT); HS_DBG(); if (time_before_eq(jiffies, hi->insert_jiffies + HZ)) { HS_LOG("Waiting for HPIN stable"); msleep(HS_DELAY_SEC - HS_DELAY_REMOVE); } if (hi->is_ext_insert) { HS_LOG("Headset has been inserted"); return; } set_35mm_hw_state(0); if (hi->metrico_status) enable_metrico_headset(0); if (atomic_read(&hi->btn_state)) button_released(atomic_read(&hi->btn_state)); hi->ext_35mm_status = HTC_35MM_UNPLUG; mutex_lock(&hi->mutex_lock); state = switch_get_state(&hi->sdev); if (!(state & MASK_35MM_HEADSET)) { HS_LOG("Headset has been removed"); mutex_unlock(&hi->mutex_lock); return; } #if 0 if (hi->cable_in1 && !gpio_get_value(hi->cable_in1)) { state &= ~BIT_35MM_HEADSET; switch_set_state(&hi->sdev, state); queue_delayed_work(detect_wq, &detect_h2w_work, HS_DELAY_ZERO_JIFFIES); } else { state &= ~(MASK_35MM_HEADSET | MASK_FM_ATTRIBUTE); switch_set_state(&hi->sdev, state); } #else state &= ~(MASK_35MM_HEADSET | MASK_FM_ATTRIBUTE); switch_set_state(&hi->sdev, state); #endif HS_LOG_TIME("Remove 3.5mm headset"); mutex_unlock(&hi->mutex_lock); }
static irqreturn_t button_irq_handler(int irq, void *dev_id) { struct hsd_info *hi = (struct hsd_info *) dev_id; int value = 0; int fp = read_file(EARJACK_FILENAME); if(fp < 0) { HSD_DBG("button_irq_handler"); value = gpio_get_value_cansleep(hi->gpio_key); if (value) button_pressed(hi); else button_released(hi); return IRQ_HANDLED; } else { if(fp) { HSD_DBG("button_irq_handler"); value = gpio_get_value_cansleep(hi->gpio_key); if (value) button_pressed(hi); else button_released(hi); return IRQ_HANDLED; } else { return IRQ_NONE; } } return IRQ_NONE; }
void check_hook_key_state_work_func(struct work_struct *work) { int hook_key_status = 0; int rc = 0; unsigned long irq_flags; HEADSET_DBG(""); if ( HSD_HEADSET != g_headset_type ) { HEADSET_INFO("Headset remove!! or may ear phone noise !!"); return; } hook_key_status = gpio_get_value(headset_data.hook_gpio); if ( 1 == hook_key_status ) { button_pressed(); atomic_set(&headset_data.is_button_press, 1); rc = set_irq_type(headset_data.hook_irq, IRQF_TRIGGER_LOW); if (rc) HEADSET_ERR( "change hook key detection type as low fail!!"); } else { if ( 1 == atomic_read(&headset_data.is_button_press)) { button_released(); atomic_set(&headset_data.is_button_press, 0); rc = set_irq_type(headset_data.hook_irq, IRQF_TRIGGER_HIGH); HEADSET_DBG("Hook Key release change hook key detection type as high"); if (rc) HEADSET_ERR("change hook key detection type as high fail!!"); } } if ( HSD_IRQ_DISABLE == headset_data.hook_irq_status) { local_irq_save(irq_flags); enable_irq(headset_data.hook_irq); headset_data.hook_irq_status = HSD_IRQ_ENABLE; set_irq_wake(headset_data.hook_irq, 1); local_irq_restore(irq_flags); } }
static enum hrtimer_restart button_35mm_event_timer_func(struct hrtimer *data) { printk(KERN_INFO "%s\n", __func__); if (gpio_get_value(hi->gpio_headset_mic)) { button_pressed(); hi->btn35mm_debounce_time = ktime_set(0, 200 * 1000 * 1000); } else { button_released(); hi->btn35mm_debounce_time = ktime_set(0, 500 * 1000 * 1000); } return HRTIMER_NORESTART; }
void headset_button_event(int is_press, int type) { HS_DBG(); if (!hs_hpin_stable()) { HS_LOG("The HPIN is unstable, SKIP THE BUTTON EVENT."); return; } if (!is_press) button_released(type); else if (!atomic_read(&hi->btn_state)) button_pressed(type); }
static void remove_11pin_35mm(void) { if (hi->mic_bias_state) { turn_mic_bias_on(0); hi->mic_bias_state = 0; msleep(300); } microp_notify_unplug_mic(); if (atomic_read(&hi->btn_state)) button_released(atomic_read(&hi->btn_state)); hi->h2w_35mm_status = HTC_35MM_UNPLUG; if (hi->key_int_shutdown_gpio) gpio_set_value(hi->key_int_shutdown_gpio, 0); printk(KERN_INFO "remove 11pin 3.5mm headset\n"); }
static void remove_headset(void) { int rc = 0; unsigned long irq_flags; if (HSD_HEADSET == g_headset_type) { gpio_set_value(AUDIO_HEADSET_MIC_SHTDWN_N, 1); HEADSET_INFO("Turn off mic en"); PM_LOG_EVENT(PM_LOG_OFF, PM_LOG_AUTIO_MIC); if ( 1 == atomic_read(&headset_data.is_button_press)) { button_released(); atomic_set(&headset_data.is_button_press, 0); } if ( HSD_IRQ_ENABLE == headset_data.hook_irq_status) { local_irq_save(irq_flags); disable_irq_nosync(headset_data.hook_irq); headset_data.hook_irq_status = HSD_IRQ_DISABLE; set_irq_wake(headset_data.hook_irq, 0); local_irq_restore(irq_flags); } } g_headset_type = HSD_NONE; rc = set_irq_type(headset_data.jack_irq, IRQF_TRIGGER_LOW); if (rc) HEADSET_ERR("change IRQ detection type as low fail!!"); headset_data.recover_chk_times = RECOVER_CHK_HEADSET_TYPE_TIMES; HEADSET_INFO("Headset remove, jack_irq active LOW"); }
static enum hrtimer_restart button_event_timer_func(struct hrtimer *data) { H2W_DBG(""); if (switch_get_state(&hi->sdev) == HTC_HEADSET) { if (gpio_get_value(SAPPHIRE_GPIO_CABLE_IN2)) { if (hi->ignore_btn) hi->ignore_btn = 0; else if (atomic_read(&hi->btn_state)) button_released(); } else { if (!hi->ignore_btn && !atomic_read(&hi->btn_state)) button_pressed(); } } return HRTIMER_NORESTART; }
static void remove_headset(void) { unsigned long irq_flags; H2W_DBG(""); switch_set_state(&hi->sdev, NO_DEVICE); configure_cpld(UART3); /* */ local_irq_save(irq_flags); disable_irq(hi->irq_btn); local_irq_restore(irq_flags); if (atomic_read(&hi->btn_state)) button_released(); hi->debounce_time = ktime_set(0, 100000000); /* */ }
static void remove_headset(void) { HDS_DBG(""); mutex_lock(&hi->mutex_lock); switch_set_state(&hi->sdev, switch_get_state(&hi->sdev) & ~(BIT_HEADSET | BIT_HEADSET_NO_MIC)); mutex_unlock(&hi->mutex_lock); if (hi->btn_11pin_35mm_flag) { disable_irq(hi->irq_btn_35mm); //turn_mic_bias_on(0); hi->btn_11pin_35mm_flag = 0; if (atomic_read(&hi->btn_state)) button_released(); } HDS_DBG("removed 3.5mm headset\n"); hi->debounce_time = ktime_set(0, 100000000); /* 100 ms */ }
void headset_button_event(int is_press, int type) { HS_DBG(); if (hi->hs_35mm_type == HEADSET_UNPLUG && hi->h2w_35mm_type == HEADSET_UNPLUG) { HS_LOG("IGNORE key %d (HEADSET_UNPLUG)", type); return; } if (!hs_hpin_stable()) { HS_LOG("The HPIN is unstable, SKIP THE BUTTON EVENT."); return; } if (!is_press) button_released(type); else if (!atomic_read(&hi->btn_state)) button_pressed(type); }
void simulate_hs_report(struct snd_soc_jack *jack, int status, int mask) { struct snd_soc_codec *codec; int oldstatus; if (!jack) return; pr_info("%s: id=[%s]; name=[%s]\n", __func__, jack->jack->id, jack->jack->name); codec = jack->codec; /* delet by youjin to avaid deadlock 2012-11-19 mutex_lock(&codec->mutex); */ oldstatus = jack->status; jack->status &= ~mask; jack->status |= status & mask; if (mask && (jack->status == oldstatus)) return; if (!strncmp("Headset Jack", jack->jack->id, sizeof("Headset Jack"))) { pr_debug("[%s] oldstatus:%d, newstatus:%d\n", jack->jack->id, oldstatus, jack->status); if (jack->status) insert_headset(); else remove_headset(); } else if (!strncmp("Button Jack", jack->jack->id, sizeof("Button Jack"))) { pr_debug("[%s] oldstatus:%d, newstatus:%d\n", jack->jack->id, oldstatus, jack->status); if (jack->status) button_pressed(); else button_released(); } /*delet by youjin to avaid deadlock 2012-11-19 out: mutex_unlock(&codec->mutex); */ }
static enum hrtimer_restart button_event_timer_func(struct hrtimer *data) { H2W_DBG(""); if (switch_get_state(&hi->sdev) == LGE_HEADSET //kiwone, 2009.12.24, to fix bug // 4 pole headset eject->button key is detected && (0 == gpio_get_value(hi->gpio_detect)) ) { if (!gpio_get_value(hi->gpio_button_detect)) { if (hi->ignore_btn) hi->ignore_btn = 0; else if (atomic_read(&hi->btn_state)) button_released(); } else { if (!hi->ignore_btn && !atomic_read(&hi->btn_state)) button_pressed(); } } return HRTIMER_NORESTART; }
static void remove_headset(void) { unsigned long irq_flags; H2W_DBG(""); input_report_switch(hi->input, SW_HEADPHONE_INSERT, 0); switch_set_state(&hi->sdev, NO_DEVICE); input_sync(hi->input); /* Disable button */ local_irq_save(irq_flags); disable_irq_nosync(hi->irq_btn); set_irq_wake(hi->irq_btn, 0); local_irq_restore(irq_flags); if (atomic_read(&hi->btn_state)) button_released(); #ifdef CONFIG_LGE_AUDIO_HEADSET_PROTECT gpio_set_value(hi->gpio_mic_bias_en, 0); #endif hi->debounce_time = ktime_set(0, 500000000); /* VS760 100 ms -> 300ms */ }
static enum hrtimer_restart button_event_timer_func(struct hrtimer *data) { int headset_in =0; int btn_down =0; H2W_DBG(""); /* Low Detect, Fast Check*/ /* "button timer < headset detach timer" makes abnormal operation*/ headset_in = gpio_get_value(hi->gpio_detect)?0: 1; /*Headset button - High Detect*/ //btn_down = gpio_get_value(hi->gpio_button_detect)?1 :0; /*Headset button - LOW Detect*/ btn_down = gpio_get_value(hi->gpio_button_detect)?0 :1; if(hi->ignore_btn){ H2W_DBG("ignore_btn"); return HRTIMER_NORESTART; } if ((switch_get_state(&hi->sdev) == BIT_HEADSET) && headset_in){ H2W_DBG(" headset in %d btn down %d",headset_in,btn_down); if (btn_down){ if (!atomic_read(&hi->btn_state)) button_pressed(); } else { if (atomic_read(&hi->btn_state)) button_released(); } } H2W_DBG(" No button event"); return HRTIMER_NORESTART; }
static void remove_detect_work_func(struct work_struct *work) { int state; wake_lock_timeout(&hi->hs_wake_lock, HS_WAKE_LOCK_TIMEOUT); HS_DBG(); /*remove one-wire detection setting if the project support one-wire detection*/ if(hi->detect_type == HEADSET_1WIRE && hi->pdata.enable_1wire){ HS_LOG("Disable one-wire detection."); closeFile(fp); disable_1wire(); hi->detect_type = HEADSET_ADC; } if (time_before_eq(jiffies, hi->insert_jiffies + HZ)) { HS_LOG("Waiting for HPIN stable"); msleep(HS_DELAY_SEC - HS_DELAY_REMOVE); } if (hi->is_ext_insert) { HS_LOG("Headset has been inserted"); return; } if (hi->hs_35mm_type == HEADSET_INDICATOR && hs_mgr_notifier.indicator_enable) hs_mgr_notifier.indicator_enable(0); set_35mm_hw_state(0); #if defined(CONFIG_FB_MSM_TVOUT) && defined(CONFIG_ARCH_MSM8X60) if (hi->hs_35mm_type == HEADSET_TV_OUT && hi->pdata.hptv_sel_gpio) { HS_LOG_TIME("Remove 3.5mm TVOUT cable"); tvout_enable_detection(0); gpio_set_value(hi->pdata.hptv_sel_gpio, 0); } #endif if (hi->metrico_status) enable_metrico_headset(0); if (atomic_read(&hi->btn_state)) button_released(atomic_read(&hi->btn_state)); mutex_lock(&hi->mutex_lock); state = switch_get_state(&hi->sdev); if (!(state & MASK_35MM_HEADSET)||hi->hs_35mm_type == HEADSET_UNPLUG) { HS_LOG("Headset has been removed"); mutex_unlock(&hi->mutex_lock); return; } hi->hs_35mm_type = HEADSET_UNPLUG; #if 0 if (hi->cable_in1 && !gpio_get_value(hi->cable_in1)) { state &= ~BIT_35MM_HEADSET; switch_set_state(&hi->sdev, state); queue_delayed_work(detect_wq, &detect_h2w_work, HS_DELAY_ZERO_JIFFIES); } else { state &= ~(MASK_35MM_HEADSET | MASK_FM_ATTRIBUTE); switch_set_state(&hi->sdev, state); } #else state &= ~(MASK_35MM_HEADSET | MASK_FM_ATTRIBUTE); switch_set_state(&hi->sdev, state); #endif hpin_report++; HS_LOG_TIME("Remove 3.5mm accessory"); mutex_unlock(&hi->mutex_lock); if ((hi->pdata.eng_cfg == HS_EDE_U) || (hi->pdata.eng_cfg == HS_EDE_TD) || (hi->pdata.eng_cfg == HS_BLE)) { aic3008_set_mic_bias(0); } if ((hi->pdata.eng_cfg == HS_QUO_F_U)) { regulator = regulator_get(NULL, "v_aud_2v85"); if (IS_ERR_OR_NULL(regulator)) { pr_err("htc_headset_gpio_probe:Couldn't get regulator v_aud_2v85\n"); regulator = NULL; return; } regulator_disable(regulator); } /* FIXME */ /* if (gpio_event_get_quickboot_status()) HS_LOG("quick_boot_status = 1"); */ }
static void remove_detect_work_func(struct work_struct *work) { int state; wake_lock_timeout(&hi->hs_wake_lock, HS_WAKE_LOCK_TIMEOUT); HS_DBG(); if (time_before_eq(jiffies, hi->insert_jiffies + HZ)) { HS_LOG("Waiting for HPIN stable"); if (hi->pdata.driver_flag & DRIVER_HS_MGR_OLD_AJ) msleep(HS_DELAY_SEC - HS_DELAY_REMOVE_LONG); else msleep(HS_DELAY_SEC - HS_DELAY_REMOVE_SHORT); } if (hi->is_ext_insert) { HS_LOG("Headset has been reinserted during debounce time"); return; } if (hi->hs_35mm_type == HEADSET_INDICATOR && hs_mgr_notifier.indicator_enable) hs_mgr_notifier.indicator_enable(0); set_35mm_hw_state(0); #if defined(CONFIG_FB_MSM_TVOUT) && defined(CONFIG_ARCH_MSM8X60) if (hi->hs_35mm_type == HEADSET_TV_OUT && hi->pdata.hptv_sel_gpio) { HS_LOG_TIME("Remove 3.5mm TVOUT cable"); tvout_enable_detection(0); gpio_set_value(hi->pdata.hptv_sel_gpio, 0); } #endif if (hi->metrico_status) enable_metrico_headset(0); if (atomic_read(&hi->btn_state)) button_released(atomic_read(&hi->btn_state)); hi->hs_35mm_type = HEADSET_UNPLUG; mutex_lock(&hi->mutex_lock); state = switch_get_state(&hi->sdev_h2w); if (!(state & MASK_35MM_HEADSET)) { HS_LOG("Headset has been removed"); mutex_unlock(&hi->mutex_lock); return; } #if 0 if (hi->cable_in1 && !gpio_get_value(hi->cable_in1)) { state &= ~BIT_35MM_HEADSET; switch_set_state(&hi->sdev_h2w, state); queue_delayed_work(detect_wq, &detect_h2w_work, HS_DELAY_ZERO_JIFFIES); } else { state &= ~(MASK_35MM_HEADSET | MASK_FM_ATTRIBUTE); switch_set_state(&hi->sdev_h2w, state); } #else state &= ~(MASK_35MM_HEADSET | MASK_FM_ATTRIBUTE); switch_set_state(&hi->sdev_h2w, state); #endif HS_LOG_TIME("Remove 3.5mm accessory"); mutex_unlock(&hi->mutex_lock); #ifdef HTC_HEADSET_CONFIG_QUICK_BOOT if (gpio_event_get_quickboot_status()) HS_LOG("quick_boot_status = 1"); #endif }
PROCESS_THREAD(hexapush_process, ev, data) { static struct etimer debounce_timer; static uint8_t button_state[8]; static uint8_t longclick_counter[8]; PROCESS_BEGIN(); int i; for(i=0;i<8;i++) { button_state[i]=0; longclick_counter[i]=0; } hexapush_init(); etimer_set(&debounce_timer, CLOCK_SECOND * HP_DEBOUNCE_TIME / 1000); PRINTF("Hexapush process ready!\n"); while(1) { etimer_restart(&debounce_timer); int i; for(i=0; i<8; i++) { if(button_state[i]==HEXAPUSH_NOTPRESSED_STATE) { //PRINTF("Hexapush: %d is in state 0\n",i); if(((~HEXAPUSH_IN&button_vector)&(1<<i))!=0) { button_state[i]=HEXAPUSH_DEBOUNCE_STATE; } } else if (button_state[i]==HEXAPUSH_DEBOUNCE_STATE) { //PRINTF("Hexapush: %d is in state 1\n",i); if(((~HEXAPUSH_IN&button_vector)&(1<<i))!=0) { #if HEXAPUSH_CLICK_ENABLE button_state[i]=HEXAPUSH_CLICK_STATE; #elif HEXAPUSH_PRESS_RELEASE_ENABLE button_pressed(i); button_state[i]=HEXAPUSH_PRESSED_STATE; #else button_state[i]=HEXAPUSH_NOTPRESSED_STATE; #endif } else { button_state[i]=HEXAPUSH_NOTPRESSED_STATE; } } else if (button_state[i]==HEXAPUSH_CLICK_STATE) { //PRINTF("Hexapush: %d is in state 2\n",i); #if HEXAPUSH_PRESS_RELEASE_ENABLE if(((~HEXAPUSH_IN&button_vector)&(1<<i))!=0) { if(longclick_counter[i]<HEXAPUSH_PRESS_DELAY) { longclick_counter[i]++; } else { button_pressed(i); longclick_counter[i]=0; button_state[i]=HEXAPUSH_PRESSED_STATE; } } else { button_clicked(i); longclick_counter[i]=0; button_state[i]=HEXAPUSH_NOTPRESSED_STATE; } #else button_clicked(i); button_state[i] = HEXAPUSH_PRESSED_STATE; #endif } else if (button_state[i]==HEXAPUSH_PRESSED_STATE) { //Long click state //PRINTF("Hexapush: %d is in state 3\n",i); if(((~HEXAPUSH_IN&button_vector)&(1<<i))==0) { #if HEXAPUSH_PRESS_RELEASE_ENABLE button_released(i); #endif button_state[i]=HEXAPUSH_NOTPRESSED_STATE; } } else { PRINTF("Hexapush error: Unknown state\n"); } } PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&debounce_timer)); } PROCESS_END(); }