void cable_ins_det_work_func(struct work_struct *work) { unsigned long irq_flags; headset_data.jack_status = gpio_get_value(headset_data.jack_gpio); if( 0 == headset_data.jack_status) { HEADSET_INFO("lock headset wakelock when doing headset insert detection"); wake_lock_timeout(&headset_data.headset_det_wakelock, (2*HZ) ); insert_headset(); } else { HEADSET_INFO("lock headset wakelock when doing headset remove detection"); wake_lock_timeout(&headset_data.headset_det_wakelock, HZ ); remove_headset(); } if ( HSD_IRQ_DISABLE == headset_data.jack_irq_status) { local_irq_save(irq_flags); enable_irq(headset_data.jack_irq); headset_data.jack_irq_status = HSD_IRQ_ENABLE; local_irq_restore(irq_flags); } switch_set_state(&headset_data.sdev, g_headset_type); }
/********************************************************** ** Function: Jack detection-in gpio configuration function ** Parameter: none ** Return value: if sucess, then returns 0 ** ************************************************************/ static int jack_config_gpio() { int ret; printk("HEADSET: Config Jack-in detection gpio\n"); hs_micbias_power(ON); tegra_gpio_enable(JACK_GPIO); ret = gpio_request(JACK_GPIO, "h2w_detect"); ret = gpio_direction_input(JACK_GPIO); hs_data->irq = gpio_to_irq(JACK_GPIO); ret = request_irq(hs_data->irq, detect_irq_handler, IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "h2w_detect", NULL); ret = irq_set_irq_wake(hs_data->irq, 1); msleep(1); if (gpio_get_value(JACK_GPIO) == 0){ insert_headset(); }else { hs_micbias_power(OFF); headset_alive = false; remove_headset(); } return 0; }
static void detect_work(struct work_struct *work) { int state; unsigned long irq_flags; local_irq_save(irq_flags); disable_irq(hi->irq); local_irq_restore(irq_flags); state = gpio_get_value(hi->gpio); HSD_DBG("hs:%d\n", state); local_irq_save(irq_flags); enable_irq(hi->irq); local_irq_restore(irq_flags); if (state != 1) { if (switch_get_state(&hi->sdev) == LGE_HEADSET) { HSD_DBG("==== LGE headset removing\n"); remove_headset(); } return; } if (state == 1) { if (switch_get_state(&hi->sdev) == NO_DEVICE) { HSD_DBG("==== LGE headset inserting\n"); insert_headset(); } } else { HSD_ERR("Invalid state\n"); } }
static void detection_work(struct work_struct *work) { int cable_in; H2W_DBG(""); H2W_DBG("%d %d", gpio_get_value(hi->cable_in1), HS_PLUG_IN); /* FIH-SW2-MM-AY-TAP_headset_00 */ if (gpio_get_value(hi->cable_in1) != HS_PLUG_IN) { /* FIH-SW2-MM-AY-TAP_headset_00 */ /* Headset plugged out */ if ( (switch_get_state(&hi->sdev) == HEADSET) || (switch_get_state(&hi->sdev) == NOMIC_HEADSET) || (switch_get_state(&hi->sdev) == NOT_SUPPORT) || (switch_get_state(&hi->sdev) == UNKNOWN_DEVICE)) { /* FIH-SW2-MM-AY-hsed_type-02 */ H2W_DBG("Headset is plugged out.\n"); remove_headset(); } return; } /* Something plugged in, lets make sure its a headset */ cable_in = gpio_get_value(hi->cable_in1); /* FIH-SW2-MM-AY-TAP_headset_00 */ if (cable_in == HS_PLUG_IN ) { if (switch_get_state(&hi->sdev) == NO_DEVICE) { H2W_DBG("Headset is plugged in.\n"); insert_headset(); } } else { H2W_DBG("WARN: AUD_PIN_HEADSET_DET be triggered, but not a headset "); } }
static void detection_work(struct work_struct *work) { unsigned long irq_flags; int cable_in1; /* Disable headset interrupt while detecting.*/ local_irq_save(irq_flags); disable_irq(hs_data->irq); local_irq_restore(irq_flags); /* Delay 500ms for pin stable. */ msleep(500); /* Restore IRQs */ local_irq_save(irq_flags); enable_irq(hs_data->irq); local_irq_restore(irq_flags); if (gpio_get_value(JACK_GPIO) != 0) { /* Headset not plugged in */ if (switch_get_state(&hs_data->sdev) == HEADSET) remove_headset(); return; } cable_in1 = gpio_get_value(JACK_GPIO); if (cable_in1 == 0) { if(switch_get_state(&hs_data->sdev) == NO_DEVICE) insert_headset(); } else{ printk("HEADSET: Jack-in GPIO is low, but not a headset \n"); } }
static void detection_work(struct work_struct *work) { int cable_in1; H2W_DBG(""); if (gpio_get_value(hi->gpio_detect) == 1) { /* Headset not plugged in */ if (switch_get_state(&hi->sdev) == LGE_HEADSET || switch_get_state(&hi->sdev) == LGE_NO_MIC_HEADSET ) remove_headset(); H2W_DBG("detection_work-remove_headset \n"); wake_unlock(&hi->wake_lock); return; } cable_in1 = gpio_get_value(hi->gpio_detect); if (cable_in1 == 0) { if (switch_get_state(&hi->sdev) == NO_DEVICE) { H2W_DBG("detection_work-insert_headset \n"); insert_headset(); } } wake_unlock(&hi->wake_lock); }
static void detect_work(struct work_struct *work) { int state; struct hsd_info *hi = container_of(work, struct hsd_info, work); HSD_DBG("detect_work\n"); state = hi->gpio_get_value_func(hi->gpio_detect); if (state == 1) { if (switch_get_state(&hi->sdev) != NO_DEVICE) { HSD_DBG("LGE headset removing\n"); remove_headset(hi); } else { HSD_DBG("err_invalid_state remove state = %d\n", state); } } else { if (switch_get_state(&hi->sdev) == NO_DEVICE) { HSD_DBG("LGE headset inserting\n"); insert_headset(hi); } else { HSD_DBG("err_invalid_state insert state = %d\n", state); } } }
int htc_35mm_remote_notify_microp_ready(void) { if (hi) { if (hi->is_ext_insert) queue_work(detect_wq, &insert_35mm_work); if (hi->h2w_35mm_status) insert_headset(NORMAL_HEARPHONE); } return 1; }
static void detection_work(struct work_struct *work) { unsigned long irq_flags; int cable_in1; int mic_in = 0; wake_lock(&hp_detect_wakelock); hs_micbias_power(ON); isHpDetecting = true; /* Disable headset interrupt while detecting.*/ local_irq_save(irq_flags); disable_irq(hs_data->irq); local_irq_restore(irq_flags); /* Delay 1000ms for pin stable. */ msleep(1000); /* Restore IRQs */ local_irq_save(irq_flags); enable_irq(hs_data->irq); local_irq_restore(irq_flags); if (gpio_get_value(JACK_GPIO) != 0) { /* Headset not plugged in */ if (switch_get_state(&hs_data->sdev) == HEADSET_WITH_MIC || switch_get_state(&hs_data->sdev) == HEADSET_WITHOUT_MIC) remove_headset(); goto closed_micbias; } cable_in1 = gpio_get_value(JACK_GPIO); mic_in = gpio_get_value(HOOK_GPIO); if (cable_in1 == 0) { printk("HOOK_GPIO value: %d\n", mic_in); if(switch_get_state(&hs_data->sdev) == NO_DEVICE) insert_headset(); else if ( mic_in == 1) goto closed_micbias; } else{ printk("HEADSET: Jack-in GPIO is low, but not a headset \n"); goto closed_micbias; } isHpDetecting = false; wake_unlock(&hp_detect_wakelock); return; closed_micbias: isHpDetecting = false; hs_micbias_power(OFF); wake_unlock(&hp_detect_wakelock); return; }
static void detection_work(struct work_struct *work) { unsigned long irq_flags; int cable_in1; int mic_in = 0; /* Disable headset interrupt while detecting.*/ local_irq_save(irq_flags); disable_irq(hs_data->hp_det_irq); local_irq_restore(irq_flags); irq_set_irq_type(hs_data->hook_det_irq, IRQF_TRIGGER_NONE); set_hs_micbias(ON); if (switch_get_state(&hs_data->sdev) != NO_DEVICE) { /* Delay for pin stable when being removed. */ msleep(110); } else { /* Delay for pin stable when plugged. */ msleep(1000); } /* Restore IRQs */ local_irq_save(irq_flags); enable_irq(hs_data->hp_det_irq); local_irq_restore(irq_flags); if (gpio_get_value(JACK_GPIO) != 0) { /* Headset not plugged in */ remove_headset(); goto closed_micbias; } cable_in1 = gpio_get_value(JACK_GPIO); mic_in = gpio_get_value(HS_HOOK_DET); if (cable_in1 == 0) { printk(KERN_INFO "HOOK_GPIO value: %d\n", mic_in); if (switch_get_state(&hs_data->sdev) == NO_DEVICE) insert_headset(); else if (mic_in == 1) goto closed_micbias; } else{ printk(KERN_INFO "HEADSET: Jack-in GPIO is low, but not a headset\n"); goto closed_micbias; } return; closed_micbias: set_hs_micbias(OFF); return; }
static ssize_t reselect_jack_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { int value = 0; sscanf(buf, "%d", &value); pr_err("%s: User selection : 0X%x", __func__, value); if (value == 1) { recheck_jack = true; insert_headset(); } return size; }
/********************************************************** ** Function: Jack detection-in gpio configuration function ** Parameter: none ** Return value: if sucess, then returns 0 ** ************************************************************/ static int jack_config_gpio() { int ret; printk("HEADSET: Config Jack-in detection gpio\n"); hs_micbias_power(ON); ret = gpio_request(JACK_GPIO, "h2w_detect"); ret = gpio_direction_input(JACK_GPIO); hs_data->irq = gpio_to_irq(JACK_GPIO); ret = request_irq(hs_data->irq, detect_irq_handler, IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "h2w_detect", NULL); ret = irq_set_irq_wake(hs_data->irq, 1); switch (project_info) { case TEGRA3_PROJECT_TF201: case TEGRA3_PROJECT_TF300T: case TEGRA3_PROJECT_TF300TG: case TEGRA3_PROJECT_TF300TL: case TEGRA3_PROJECT_TF500T: case TEGRA3_PROJECT_TF700T: case TEGRA3_PROJECT_ME301T: case TEGRA3_PROJECT_ME301TL: /* delay 100ms to wait hook_det stable */ msleep(100); break; case TEGRA3_PROJECT_P1801: /* delay 230ms to wait hook_det stable */ msleep(230); break; default: /* delay 100ms to wait hook_det stable */ msleep(100); break; } if (gpio_get_value(JACK_GPIO) == 0){ insert_headset(); }else { hs_micbias_power(OFF); headset_alive = false; switch_set_state(&hs_data->sdev, NO_DEVICE); remove_headset(); } return 0; }
static void detection_work(struct work_struct *work) { unsigned long irq_flags; int clk, cable_in1; H2W_DBG(""); if (gpio_get_value(SAPPHIRE_GPIO_CABLE_IN1) != 0) { /* */ if (switch_get_state(&hi->sdev) == HTC_HEADSET) remove_headset(); return; } /* */ /* */ configure_cpld(GPIO); /* */ local_irq_save(irq_flags); disable_irq(hi->irq); local_irq_restore(irq_flags); /* */ gpio_direction_output(SAPPHIRE_GPIO_CABLE_IN1, 1); /* */ msleep(10); /* */ clk = gpio_get_value(SAPPHIRE_GPIO_H2W_CLK_GPI); /* */ gpio_direction_input(SAPPHIRE_GPIO_CABLE_IN1); /* */ local_irq_save(irq_flags); enable_irq(hi->irq); local_irq_restore(irq_flags); cable_in1 = gpio_get_value(SAPPHIRE_GPIO_CABLE_IN1); if (cable_in1 == 0 && clk == 0) { if (switch_get_state(&hi->sdev) == NO_DEVICE) insert_headset(); } else { configure_cpld(UART3); H2W_DBG("CABLE_IN1 was low, but not a headset " "(recent cable_in1 = %d, clk = %d)", cable_in1, clk); } }
static ssize_t select_jack_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { int value = 0; sscanf(buf, "%d", &value); pr_err("%s: User selection : 0X%x", __func__, value); if (value == BIT_HEADSET) { gpio_set_value(MSM_GPIO_EAR_MICBIAS_EN, 1); msleep(100); } insert_headset(); return size; }
static void detect_work(struct work_struct *work) { int state; #if 0 unsigned long irq_flags; #endif struct delayed_work *dwork = container_of(work, struct delayed_work, work); struct hsd_info *hi = container_of(dwork, struct hsd_info, work); HSD_DBG("detect_work"); #if 0 local_irq_save(irq_flags); disable_irq(hi->irq_detect); local_irq_restore(irq_flags); #endif printk(KERN_INFO " dev=0x%x\n",(unsigned int)hi); state = gpio_get_value_cansleep(hi->gpio_detect); if (state == 1) { if (switch_get_state(&hi->sdev) != NO_DEVICE) { HSD_DBG("==== LGE headset removing\n"); remove_headset(hi); } else { HSD_DBG("err_invalid_state state = %d\n", state); } } else { if (switch_get_state(&hi->sdev) == NO_DEVICE) { HSD_DBG("==== LGE headset inserting\n"); insert_headset(hi); } else { HSD_DBG("err_invalid_state state = %d\n", state); } } #if 0 local_irq_save(irq_flags); enable_irq(hi->irq_detect); local_irq_restore(irq_flags); #endif }
static void detection_work(struct work_struct *work) { /*Headset detach*/ H2W_DBG(""); if (gpio_get_value(hi->gpio_detect) == 1) { if (switch_get_state(&hi->sdev) == BIT_HEADSET || switch_get_state(&hi->sdev) == BIT_HEADSET_SPEAKER_ONLY ){ remove_headset(); } } /*Headset attach*/ else{ if (switch_get_state(&hi->sdev) == BIT_NO_DEVICE){ insert_headset(); } } }
static irqreturn_t button_irq_handler(int irq, void *dev_id) { struct hsd_info *hi = (struct hsd_info *) dev_id; int value; wake_lock_timeout(&ear_hook_wake_lock, 2 * HZ); HSD_DBG("button_irq_handler\n"); value = hi->gpio_get_value_func(hi->gpio_key); HSD_DBG("hi->gpio_get_value_func(hi->gpio_key) : %d\n", value); #ifdef CONFIG_SWITCH_MAX1462X_WA HSD_DBG("hi->gpio_get_value_func(hi->gpio_key) %d hi->hook_disable : %d\n", value, hook_disable); #endif if(atomic_read(&hi->is_3_pole_or_not) == 0) { #ifdef CONFIG_SWITCH_MAX1462X_WA if (hook_disable) return IRQ_HANDLED; #endif if (value) queue_delayed_work(local_max1462x_workqueue, &(hi->work_for_key_released), hi->latency_for_key ); else queue_delayed_work(local_max1462x_workqueue, &(hi->work_for_key_pressed), hi->latency_for_key ); } #ifdef CONFIG_SWITCH_MAX1462X_WA else { msleep(10); HSD_DBG("3 pole wrong detection -> 4 pole"); if (value && hi->gpio_get_value_func(hi->gpio_detect) == 0) { remove_headset(hi); insert_headset(hi); } } #endif return IRQ_HANDLED; }
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 void detect_work(struct work_struct *work) { int state = 0; struct delayed_work *dwork = container_of(work, struct delayed_work, work); struct hsd_info *hi = container_of(dwork, struct hsd_info, work); HSD_DBG("detect_work"); if( gpio_cansleep(hi->gpio_det) ) state = gpio_get_value_cansleep(hi->gpio_det); else state = gpio_get_value(hi->gpio_det); if( state == 1 ) { // gpio_det high - jack out if( switch_get_state(&hi->sdev) != HEADSET_NO_DEVICE ) { HSD_DBG("======= LGE headset removing ======="); remove_headset(hi); #ifdef CONFIG_LGE_BROADCAST_ONESEG isdbt_hw_antenna_switch(0); ear_state = 0; #endif } else { HSD_DBG("err_invalid_state state = %d\n", state); } } else { // gpio_det low - jack in if( switch_get_state(&hi->sdev) == HEADSET_NO_DEVICE ) { HSD_DBG("********** LGE headset inserting **********"); insert_headset(hi); #ifdef CONFIG_LGE_BROADCAST_ONESEG isdbt_hw_antenna_switch(1); ear_state = 1; #endif } else { HSD_DBG("err_invalid_state state = %d\n", state); } } }
/********************************************************** ** Function: Jack detection-in gpio configuration function ** Parameter: none ** Return value: if sucess, then returns 0 ** ************************************************************/ static int jack_config_gpio() { int ret; ret = gpio_request(DB_DET_GPIO, "DB_DET"); if (ret) { pr_err("%s: Error requesting GPIO %d\n", __func__, DB_DET_GPIO); gpio_free(DB_DET_GPIO); } else gpio_direction_input(DB_DET_GPIO); ret = gpio_request(JACK_GPIO, "JACK_IN_DET"); if (ret) { pr_err("%s: Error requesting GPIO %d\n", __func__, JACK_GPIO); gpio_free(JACK_GPIO); } else gpio_direction_input(JACK_GPIO); hs_data->hp_det_irq = MSM_GPIO_TO_INT(JACK_GPIO); ret = request_irq(hs_data->hp_det_irq, detect_irq_handler, IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "h2w_detect", NULL); ret = irq_set_irq_wake(hs_data->hp_det_irq, 1); set_hs_micbias(ON); msleep(50); if (gpio_get_value(JACK_GPIO) == 0) { insert_headset(); } else { switch_set_state(&hs_data->sdev, NO_DEVICE); remove_headset(); } return 0; }
static void detection_work(struct work_struct *work) { unsigned long irq_flags; HDS_DBG(); if (gpio_get_value(hi->gpio_detect) != hi->jack_inverted) { /* Headset not plugged in */ if (switch_get_state(&hi->sdev) != HDS_NO_DEVICE) remove_headset(); return; } /* Disable headset interrupt while detecting.*/ local_irq_save(irq_flags); disable_irq(hi->irq); local_irq_restore(irq_flags); /* Restore IRQs */ local_irq_save(irq_flags); enable_irq(hi->irq); local_irq_restore(irq_flags); insert_headset(); }
static irqreturn_t detect_irq_handler(int irq, void *dev_id) { int value_det = 0; int retry_limit = 10; printk(KERN_INFO"%s\n", __func__); irq_set_irq_type(hi->irq_btn, IRQF_TRIGGER_RISING); while (retry_limit-- > 0) { value_det = gpio_get_value(MSM_GPIO_EAR_DET); if (value_det != detect_type) { if ((switch_get_state(&hi->sdev) == H2W_NO_DEVICE) ^ (value_det ^ detect_type)) remove_headset(); return IRQ_HANDLED; } usleep(10000); } if ((switch_get_state(&hi->sdev) == H2W_NO_DEVICE) ^ (value_det ^ detect_type)) { msleep(100); insert_headset(); } return IRQ_HANDLED; }