自学教程：C++ HS_DBG函数代码示例

static ssize_t headset_state_show(struct device *dev,		struct device_attribute *attr, char *buf){	int length = 0;	char *state;	HS_DBG();	switch (hi->hs_35mm_type) {	case HEADSET_UNPLUG:		state = "headset_unplug";		break;	case HEADSET_NO_MIC:		state = "headset_no_mic";		break;	case HEADSET_MIC:		state = "headset_mic";		break;	case HEADSET_METRICO:		state = "headset_metrico";		break;	case HEADSET_UNKNOWN_MIC:		state = "headset_unknown_mic";		break;	case HEADSET_TV_OUT:		state = "headset_tv_out";		break;	case HEADSET_UNSTABLE:		state = "headset_unstable";		break;	case HEADSET_BEATS:		state = "headset_beats";		break;	case HEADSET_BEATS_SOLO:		state = "headset_beats_solo";		break;	case HEADSET_INDICATOR:		state = "headset_indicator";		break;	default:		state = "error_state";	}	length = sprintf(buf, "%s/n", state);	return length;}

static void irq_init_work_func(struct work_struct *work){	HS_DBG();	if (hi->pdata.hpin_gpio) {		HS_LOG("Enable detect IRQ");		set_irq_type(hi->hpin_irq, IRQF_TRIGGER_LOW);		enable_irq(hi->hpin_irq);	}	if (hi->pdata.key_gpio) {		HS_LOG("Enable button IRQ");		hi->key_irq_type = IRQF_TRIGGER_LOW;		set_irq_type(hi->key_irq, hi->key_irq_type);		enable_irq(hi->key_irq);	}}

static void button_35mm_work_func(struct work_struct *work){	int key;	struct button_work *works;	wake_lock_timeout(&hi->hs_wake_lock, HS_WAKE_LOCK_TIMEOUT);	HS_DBG();	works = container_of(work, struct button_work, key_work.work);	hi->key_level_flag = works->key_code;	if (!hi->is_ext_insert && !hi->h2w_35mm_type) {		kfree(works);		HS_LOG("3.5mm headset is plugged out, skip report key event");		return;	}	if (hi->key_level_flag) {		switch (hi->key_level_flag) {		case 1:			HS_LOG("3.5mm RC: Play Pressed");			key = HS_MGR_KEYCODE_MEDIA;			break;		case 2:			HS_LOG("3.5mm RC: BACKWARD Pressed");			key = HS_MGR_KEYCODE_BACKWARD;			break;		case 3:			HS_LOG("3.5mm RC: FORWARD Pressed");			key = HS_MGR_KEYCODE_FORWARD;			break;		default:			HS_LOG("3.5mm RC: WRONG Button Pressed");			return;		}		headset_button_event(1, key);	} else { /* key release */		if (atomic_read(&hi->btn_state))			headset_button_event(0, atomic_read(&hi->btn_state));		else			HS_LOG("3.5mm RC: WRONG Button Release");	}	kfree(works);}

int switch_send_event(unsigned int bit, int on){	unsigned long state;	HS_DBG();	mutex_lock(&hi->mutex_lock);	state = switch_get_state(&hi->sdev_h2w);	state &= ~(bit);	if (on)		state |= bit;	switch_set_state(&hi->sdev_h2w, state);	mutex_unlock(&hi->mutex_lock);	return 0;}

static ssize_t debug_flag_show(struct device *dev,			       struct device_attribute *attr, char *buf){	int flag = hi->debug_flag;	int adc = -EINVAL;	int hpin_gpio = -EINVAL;	HS_DBG();	if (hs_mgr_notifier.hpin_gpio)		hpin_gpio = hs_mgr_notifier.hpin_gpio();	if (hs_mgr_notifier.remote_adc)		hs_mgr_notifier.remote_adc(&adc);	return sprintf(buf, "Debug Flag %d, HP_DET %d, ADC %d/n", flag,		       hpin_gpio, adc);}

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 (!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 int hs_pmic_remote_threshold(uint32_t adc){	int i = 0;	int ret = 0;	uint32_t status;	struct hs_pmic_rpc_request req;	struct hs_pmic_rpc_reply rep;	HS_DBG();	if (!(hi->pdata.driver_flag & DRIVER_HS_PMIC_DYNAMIC_THRESHOLD))		return 0;	req.hs_controller = cpu_to_be32(hi->pdata.hs_controller);	req.hs_switch = cpu_to_be32(hi->pdata.hs_switch);	req.current_uA = cpu_to_be32(HS_PMIC_HTC_CURRENT_THRESHOLD);	for (i = 0; i < ARRAY_SIZE(current_threshold_lut); i++) {		if (adc >= current_threshold_lut[i].adc_min &&		    adc <= current_threshold_lut[i].adc_max)			req.current_uA = cpu_to_be32(current_threshold_lut[i].						     current_uA);	}	ret = msm_rpc_call_reply(endpoint_current,				 HS_PMIC_RPC_CLIENT_PROC_THRESHOLD,				 &req, sizeof(req), &rep, sizeof(rep),				 HS_RPC_TIMEOUT);	if (ret < 0) {		HS_ERR("Failed to send remote threshold RPC");		return 0;	} else {		status = be32_to_cpu(rep.status);		if (status != HS_PMIC_RPC_ERR_SUCCESS) {			HS_ERR("Failed to set remote threshold");			return 0;		}	}	HS_LOG("Set remote threshold (%u, %u, %u)", hi->pdata.hs_controller,	       hi->pdata.hs_switch, be32_to_cpu(req.current_uA));	return 1;}

static void usb_headset_detect(int type){	int state_h2w = 0;	int state_usb = 0;	HS_DBG();	mutex_lock(&hi->mutex_lock);	state_h2w = switch_get_state(&hi->sdev_h2w);	switch (type) {	case USB_NO_HEADSET:		hi->usb_headset.type = USB_NO_HEADSET;		hi->usb_headset.status = STATUS_DISCONNECTED;		state_h2w &= ~MASK_USB_HEADSET;		state_usb = GOOGLE_USB_AUDIO_UNPLUG;		HS_LOG_TIME("Remove USB_HEADSET (state %d, %d)",			    state_h2w, state_usb);		break;	case USB_AUDIO_OUT:		hi->usb_headset.type = USB_AUDIO_OUT;		hi->usb_headset.status = STATUS_CONNECTED_ENABLED;		state_h2w |= BIT_USB_AUDIO_OUT;		state_usb = GOOGLE_USB_AUDIO_ANLG;		HS_LOG_TIME("Insert USB_AUDIO_OUT (state %d, %d)",			    state_h2w, state_usb);		break;#ifdef CONFIG_SUPPORT_USB_SPEAKER       case USB_AUDIO_OUT_DGTL:	       hi->usb_headset.type = USB_AUDIO_OUT;               hi->usb_headset.status = STATUS_CONNECTED_ENABLED;               state_h2w |= BIT_USB_AUDIO_OUT;               state_usb = GOOGLE_USB_AUDIO_DGTL;               HS_LOG_TIME("Insert USB_AUDIO_OUT DGTL (state %d, %d)",	                  state_h2w, state_usb);	       break;#endif	default:		HS_LOG("Unknown headset type");	}	switch_set_state(&hi->sdev_h2w, state_h2w);	switch_set_state(&hi->sdev_usb_audio, state_usb);	mutex_unlock(&hi->mutex_lock);}

static void htc_headset_mgr_late_resume(struct early_suspend *h){	int state = 0;	HS_DBG();	if (hi->quick_boot_status) {		mutex_lock(&hi->mutex_lock);		state = switch_get_state(&hi->sdev);		HS_LOG_TIME("Resend quick boot U-Event (state = %d)",			    state | BIT_UNDEFINED);		switch_set_state(&hi->sdev, state | BIT_UNDEFINED);		HS_LOG_TIME("Resend quick boot U-Event (state = %d)", state);		switch_set_state(&hi->sdev, state);		hi->quick_boot_status = 0;		mutex_unlock(&hi->mutex_lock);	}}

static irqreturn_t detect_irq_handler(int irq, void *data){	unsigned int irq_mask = IRQF_TRIGGER_HIGH | IRQF_TRIGGER_LOW;	hs_notify_hpin_irq();	HS_DBG();	if (!(hi->pdata.driver_flag & DRIVER_HS_PMIC_EDGE_IRQ)) {		hi->hpin_irq_type ^= irq_mask;		set_irq_type(hi->pdata.hpin_irq, hi->hpin_irq_type);	}	wake_lock_timeout(&hi->hs_wake_lock, HS_WAKE_LOCK_TIMEOUT);	queue_delayed_work(detect_wq, &detect_pmic_work, hi->hpin_debounce);	return IRQ_HANDLED;}

static int hs_gpio_request_irq(unsigned int gpio, unsigned int *irq,			       irq_handler_t handler, unsigned long flags,			       const char *name, unsigned int wake){	int ret = 0;	HS_DBG();	ret = gpio_request(gpio, name);	if (ret < 0)		return ret;	ret = gpio_direction_input(gpio);	if (ret < 0) {		gpio_free(gpio);		return ret;	}	if (!(*irq)) {		ret = gpio_to_irq(gpio);		if (ret < 0) {			gpio_free(gpio);			return ret;		}		HS_LOG("gpio_to_irq ret = %d", ret);		*irq = (unsigned int) ret;	}	HS_LOG("[HS] irq=%d", *irq);	ret = request_irq(*irq, handler, flags, name, NULL);	if (ret < 0) {		gpio_free(gpio);		return ret;	}	ret = set_irq_wake(*irq, wake);	if (ret < 0) {		free_irq(*irq, 0);		gpio_free(gpio);		return ret;	}	return 1;}

static void set_35mm_hw_state(int state){	HS_DBG();	if (hi->mic_bias_state != state && hs_mgr_notifier.mic_bias_enable) {		hs_mgr_notifier.mic_bias_enable(state);		hi->mic_bias_state = state;		if (state) /* Wait for MIC bias stable */			msleep(HS_DELAY_MIC_BIAS);	}	hs_set_mic_select(state);	if (hs_mgr_notifier.key_enable)		hs_mgr_notifier.key_enable(state);	if (hs_mgr_notifier.key_int_enable)		hs_mgr_notifier.key_int_enable(state);}

static int hs_gpio_request_output(unsigned int gpio, const char *name, int value){	int ret = 0;	HS_DBG();	ret = gpio_request(gpio, name);	if (ret < 0)		HS_LOG("GPIO Already Requested");	ret = gpio_direction_output(gpio, value);	if (ret < 0) {		HS_ERR("gpio_direction_output(gpio);");		gpio_free(gpio);		return ret;	}	return 1;}

static int hs_8x60_remote_adc(int *adc){	int ret = 0;	HS_DBG();	ret = pm8058_htc_config_mpp_and_adc_read(adc, 1, CHANNEL_ADC_HDSET,						 hi->pdata.adc_mpp,						 hi->pdata.adc_amux);	if (ret) {		*adc = -1;		HS_LOG("Failed to read remote ADC");		return 0;	}	HS_LOG("Remote ADC %d (0x%X)", *adc, *adc);	return 1;}

static void debug_work_func(struct work_struct *work){	int flag = 0;	int adc = -EINVAL;	int hpin_gpio = -EINVAL;	HS_DBG();	while (hi->debug_flag & DEBUG_FLAG_ADC) {		flag = hi->debug_flag;		if (hs_mgr_notifier.hpin_gpio)			hpin_gpio = hs_mgr_notifier.hpin_gpio();		if (hs_mgr_notifier.remote_adc)			hs_mgr_notifier.remote_adc(&adc);		HS_LOG("Debug Flag %d, HP_DET %d, ADC %d", flag,		       hpin_gpio, adc);		msleep(HS_DELAY_SEC);	}}

int hs_notify_key_event(int key_code){	struct button_work *work;	HS_DBG();	if (hi->hs_35mm_type == HEADSET_INDICATOR) {		HS_LOG("Not support remote control");		return 1;	}	if (hi->hs_35mm_type == HEADSET_UNKNOWN_MIC ||	    hi->hs_35mm_type == HEADSET_NO_MIC ||	    hi->h2w_35mm_type == HEADSET_NO_MIC)		update_mic_status(HS_DEF_MIC_DETECT_COUNT);	else if (hi->hs_35mm_type == HEADSET_UNSTABLE)		update_mic_status(0);	else if (!hs_hpin_stable()) {		HS_LOG("IGNORE key %d (Unstable HPIN)", key_code);		return 1;	} else if (hi->hs_35mm_type == HEADSET_UNPLUG && hi->is_ext_insert == 1) {		HS_LOG("MIC status is changed from float, re-polling to decide accessory type");		update_mic_status(HS_DEF_MIC_DETECT_COUNT);		return 1;	} else if (hi->hs_35mm_type == HEADSET_UNPLUG && hi->is_ext_insert == 1) {		HS_LOG("MIC status is changed from float, re-polling to decide accessory type");		update_mic_status(HS_DEF_MIC_DETECT_COUNT);		return 1;	} else {		work = kzalloc(sizeof(struct button_work), GFP_KERNEL);		if (!work) {			HS_ERR("Failed to allocate button memory");			return 1;		}		work->key_code = key_code;		INIT_DELAYED_WORK(&work->key_work, button_35mm_work_func);		queue_delayed_work(button_wq, &work->key_work,				   HS_JIFFIES_BUTTON);	}	return 1;}

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 (!is_press)		button_released(type);	else if (!atomic_read(&hi->btn_state))		button_pressed(type);}

static void enable_metrico_headset(int enable){	HS_DBG();	if (enable && !hi->metrico_status) {#if 0		enable_mos_test(1);#endif		hi->metrico_status = 1;		HS_LOG("Enable metrico headset");	}	if (!enable && hi->metrico_status) {#if 0		enable_mos_test(0);#endif		hi->metrico_status = 0;		HS_LOG("Disable metrico headset");	}}

static ssize_t fm_flag_show(struct device *dev,		struct device_attribute *attr, char *buf){	char *s = buf;	char *show_str = "disable";;	HS_DBG();	mutex_lock(&hi->mutex_lock);	if (hi->fm_flag == 0)		show_str = "disable";	if (hi->fm_flag == 1)		show_str = "fm_headset";	if (hi->fm_flag == 2)		show_str = "fm_speaker";	s += sprintf(s, "%s/n", show_str);	mutex_unlock(&hi->mutex_lock);	return (s - buf);}

int hs_notify_plug_event(int insert){	HS_DBG("Headset status %d", insert);	mutex_lock(&hi->mutex_lock);	hi->is_ext_insert = insert;	mutex_unlock(&hi->mutex_lock);	cancel_delayed_work_sync(&mic_detect_work);	cancel_delayed_work_sync(&insert_detect_work);	cancel_delayed_work_sync(&remove_detect_work);	if (hi->is_ext_insert)		queue_delayed_work(detect_wq, &insert_detect_work,				   HS_JIFFIES_INSERT);	else		queue_delayed_work(detect_wq, &remove_detect_work,				   HS_JIFFIES_REMOVE);	return 1;}

static int hs_pmic_remote_adc(int *adc){	int ret = 0;	struct rpc_request_hdr req;	struct hs_rpc_client_rep_adc rep;	HS_DBG();	ret = msm_rpc_call_reply(endpoint_adc, HS_RPC_CLIENT_PROC_ADC,				 &req, sizeof(req), &rep, sizeof(rep),				 HS_RPC_TIMEOUT);	if (ret < 0) {		HS_ERR("Failed to read remote ADC");		return 0;	}	*adc = (int) be32_to_cpu(rep.adc);	HS_LOG("Remote ADC %d (0x%X)", *adc, *adc);	return 1;}

static void button_35mm_work_func(struct work_struct *work){	int key;	struct button_work *works;	wake_lock_timeout(&hi->hs_wake_lock, HS_WAKE_LOCK_TIMEOUT);	HS_DBG();	works = container_of(work, struct button_work, key_work.work);	hi->key_level_flag = works->key_code;	if (hi->key_level_flag) {		switch (hi->key_level_flag) {		case 1:			key = HS_MGR_KEYCODE_MEDIA;			break;		case 2:			key = HS_MGR_KEYCODE_BACKWARD;			break;		case 3:			key = HS_MGR_KEYCODE_FORWARD;			break;		default:			HS_LOG("3.5mm RC: WRONG Button Pressed");			kfree(works);			pre_key_work = NULL;			return;		}		headset_button_event(1, key);	} else { /* key release */		if (atomic_read(&hi->btn_state))			headset_button_event(0, atomic_read(&hi->btn_state));		else			HS_LOG("3.5mm RC: WRONG Button Release");	}	kfree(works);	pre_key_work = NULL;}

static void irq_init_work_func(struct work_struct *work){	unsigned int irq_type = IRQF_TRIGGER_LOW;	HS_DBG();	if (hi->pdata.driver_flag & DRIVER_HS_PMIC_EDGE_IRQ)		irq_type = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;	if (hi->pdata.hpin_gpio) {		HS_LOG("Enable detect IRQ");		hi->hpin_irq_type = irq_type;		set_irq_type(hi->pdata.hpin_irq, hi->hpin_irq_type);		enable_irq(hi->pdata.hpin_irq);	}	if (hi->pdata.key_gpio) {		HS_LOG("Setup button IRQ type");		hi->key_irq_type = irq_type;		set_irq_type(hi->pdata.key_irq, hi->key_irq_type);	}}

static void cancel_button_work_func(struct work_struct *work){	int counter = 10, ret = 0;	HS_DBG();	ret = cancel_delayed_work(&button_gpio_work);	if (ret)            HS_LOG("cancel_delayed_work &button_gpio_work ok");	while(counter--)	{		if(queue_delayed_work(button_wq, &button_gpio_work, unstable_jiffies))		{		    HS_LOG("queue_delayed_work &button_gpio_work ok");		    break;		}		msleep(2);	}	queue_delayed_work(button_wq, &hs_key_irq_enable, irq_delay);}

static irqreturn_t button_irq_handler(int irq, void *dev_id){	unsigned int irq_mask = IRQF_TRIGGER_HIGH | IRQF_TRIGGER_LOW;	HS_DBG();	if(time_before_eq(jiffies, last_key_jiffies+unstable_jiffies) && last_key_jiffies != 0) {		queue_delayed_work(button_wq, &cancel_button_work, HS_JIFFIES_ZERO);		HS_LOG("The KEY event is unstable,remove debounce.");	}	disable_irq_nosync(hi->key_irq);	queue_delayed_work(button_wq, &hs_key_irq_enable, irq_delay);	hi->key_irq_type ^= irq_mask;	irq_set_irq_type(hi->key_irq, hi->key_irq_type);	wake_lock_timeout(&hi->hs_wake_lock, HS_WAKE_LOCK_TIMEOUT);	queue_delayed_work(button_wq, &button_gpio_work, unstable_jiffies);	last_key_jiffies = jiffies;	return IRQ_HANDLED;}

void headset_ext_detect(int type){	HS_DBG();	switch (type) {	case H2W_NO_HEADSET:		/* Release Key */	case H2W_HEADSET:	case H2W_35MM_HEADSET:	case H2W_REMOTE_CONTROL:	case H2W_USB_CRADLE:	case H2W_UART_DEBUG:	case H2W_TVOUT:		break;	case USB_NO_HEADSET:		/* Release Key */	case USB_AUDIO_OUT:		usb_headset_detect(type);		break;	default:		HS_LOG("Unknown headset type");	}}

static int hs_pmic_mic_status(void){	int ret = 0;	int adc = 0;	HS_DBG();	ret = hs_pmic_remote_adc(&adc);	if (hi->pdata.driver_flag & DRIVER_HS_PMIC_DYNAMIC_THRESHOLD)		hs_pmic_remote_threshold((unsigned int) adc);	if (adc >= hi->pdata.adc_mic_bias[0] &&	    adc <= hi->pdata.adc_mic_bias[1])		ret = HEADSET_MIC;	else if (adc < hi->pdata.adc_mic_bias[0])		ret = HEADSET_NO_MIC;	else		ret = HEADSET_UNKNOWN_MIC;	return ret;}

static ssize_t fm_flag_store(struct device *dev,		struct device_attribute *attr, const char *buf, size_t count){	int state;	HS_DBG();	mutex_lock(&hi->mutex_lock);	state = switch_get_state(&hi->sdev_h2w);	state &= ~(BIT_FM_HEADSET | BIT_FM_SPEAKER);	if (count == (strlen("fm_headset") + 1) &&	   strncmp(buf, "fm_headset", strlen("fm_headset")) == 0) {		hi->fm_flag = 1;		state |= BIT_FM_HEADSET;		HS_LOG("Enable FM HEADSET");	} else if (count == (strlen("fm_speaker") + 1) &&	   strncmp(buf, "fm_speaker", strlen("fm_speaker")) == 0) {		hi->fm_flag = 2;		state |= BIT_FM_SPEAKER;		HS_LOG("Enable FM SPEAKER");	} else if (count == (strlen("disable") + 1) &&	   strncmp(buf, "disable", strlen("disable")) == 0) {		hi->fm_flag = 0 ;		HS_LOG("Disable FM");	} else {		mutex_unlock(&hi->mutex_lock);		HS_LOG("Invalid FM argument");		return -EINVAL;	}	switch_set_state(&hi->sdev_h2w, state);	mutex_unlock(&hi->mutex_lock);	return count;}

static void insert_detect_work_func(struct work_struct *work){	int state,old_state;	int mic = HEADSET_NO_MIC;	wake_lock_timeout(&hi->hs_wake_lock, HS_WAKE_LOCK_TIMEOUT);	HS_DBG();	if (!hi->is_ext_insert) {		HS_LOG("Headset has been removed");		return;	}	hi->insert_jiffies = jiffies;	set_35mm_hw_state(1);	mutex_lock(&hi->mutex_lock);	mic = get_mic_status();	if (hi->pdata.driver_flag & DRIVER_HS_MGR_FLOAT_DET) {		HS_LOG("Headset float detect enable");		if (mic == HEADSET_UNPLUG) {			mutex_unlock(&hi->mutex_lock);			update_mic_status(HS_DEF_MIC_DETECT_COUNT);			return;		}	}	if (mic == HEADSET_NO_MIC)		mic = tv_out_detect();	if (mic == HEADSET_TV_OUT && hi->pdata.hptv_sel_gpio)		gpio_set_value(hi->pdata.hptv_sel_gpio, 1);	if (mic == HEADSET_METRICO && !hi->metrico_status)		enable_metrico_headset(1);	state = switch_get_state(&hi->sdev_h2w);	old_state = state;	state &= ~MASK_35MM_HEADSET;	state |= BIT_35MM_HEADSET;	switch (mic) {	case HEADSET_NO_MIC:		state |= BIT_HEADSET_NO_MIC;		HS_LOG_TIME("HEADSET_NO_MIC");		break;	case HEADSET_MIC:		state |= BIT_HEADSET;		HS_LOG_TIME("HEADSET_MIC");		break;	case HEADSET_METRICO:		mic = HEADSET_UNSTABLE;		HS_LOG_TIME("HEADSET_METRICO (UNSTABLE)");		break;	case HEADSET_UNKNOWN_MIC:		state |= BIT_HEADSET_NO_MIC;		HS_LOG_TIME("HEADSET_UNKNOWN_MIC");		break;	case HEADSET_TV_OUT:		state |= BIT_TV_OUT;		HS_LOG_TIME("HEADSET_TV_OUT");#if defined(CONFIG_FB_MSM_TVOUT) && defined(CONFIG_ARCH_MSM8X60)		tvout_enable_detection(1);#endif		break;	case HEADSET_BEATS:		state |= BIT_HEADSET;		HS_LOG_TIME("HEADSET_BEATS (UNSTABLE)");		break;	case HEADSET_BEATS_SOLO:		state |= BIT_HEADSET;		HS_LOG_TIME("HEADSET_BEATS_SOLO (UNSTABLE)");		break;	case HEADSET_INDICATOR:		HS_LOG_TIME("HEADSET_INDICATOR");		break;	}	if (old_state != state) {		if (old_state & state & MASK_35MM_HEADSET) {			if (hi->pdata.driver_flag & DRIVER_HS_MGR_OLD_AJ) {				state |= old_state;				HS_LOG("Old audio jack found, use workaround");			} else {				switch_set_state(&hi->sdev_h2w, old_state & ~MASK_35MM_HEADSET);				HS_LOG("Report fake remove event");			}		}		hi->hs_35mm_type = mic;		HS_LOG_TIME("Send uevent for state change, %d => %d", old_state, state);		switch_set_state(&hi->sdev_h2w, state);	} else		HS_LOG("No state change");	mutex_unlock(&hi->mutex_lock);#ifdef HTC_HEADSET_CONFIG_QUICK_BOOT//.........这里部分代码省略.........

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}