Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e9427a36 authored by Phani Kumar Uppalapati's avatar Phani Kumar Uppalapati
Browse files

ASoC: wcd-mbhc: Use micbias for accessory detection 



Currently micbias pull-up is used for headset accessory
detection. However this would cause failures in detection
during some scenarios of slow insertion of the plug. Use
micbias instead, to detect accessory type.

Change-Id: If15c7676aa2e46b0718fbea8938cc4f2cca0948d
Signed-off-by: default avatarPhani Kumar Uppalapati <phaniu@codeaurora.org>
parent 557f5ea8

sound/soc/codecs/wcd-mbhc-v2.c

+120 −25
Original line number Diff line number Diff line
@@ -191,6 +191,43 @@ static void wcd_enable_curr_micbias(const struct wcd_mbhc *mbhc, 
	pr_debug("%s: exit\n", __func__);

}



static const char *wcd_mbhc_get_event_string(int event)

{

	switch (event) {

	case WCD_EVENT_PRE_MICBIAS_2_OFF:

		return WCD_MBHC_STRINGIFY(WCD_EVENT_PRE_MICBIAS_2_OFF);

	case WCD_EVENT_POST_MICBIAS_2_OFF:

		return WCD_MBHC_STRINGIFY(WCD_EVENT_POST_MICBIAS_2_OFF);

	case WCD_EVENT_PRE_MICBIAS_2_ON:

		return WCD_MBHC_STRINGIFY(WCD_EVENT_PRE_MICBIAS_2_ON);

	case WCD_EVENT_POST_MICBIAS_2_ON:

		return WCD_MBHC_STRINGIFY(WCD_EVENT_POST_MICBIAS_2_ON);

	case WCD_EVENT_PRE_HPHL_PA_ON:

		return WCD_MBHC_STRINGIFY(WCD_EVENT_PRE_HPHL_PA_ON);

	case WCD_EVENT_POST_HPHL_PA_OFF:

		return WCD_MBHC_STRINGIFY(WCD_EVENT_POST_HPHL_PA_OFF);

	case WCD_EVENT_PRE_HPHR_PA_ON:

		return WCD_MBHC_STRINGIFY(WCD_EVENT_PRE_HPHR_PA_ON);

	case WCD_EVENT_POST_HPHR_PA_OFF:

		return WCD_MBHC_STRINGIFY(WCD_EVENT_POST_HPHR_PA_OFF);

	case WCD_EVENT_PRE_HPHR_PA_OFF:

		return WCD_MBHC_STRINGIFY(WCD_EVENT_PRE_HPHR_PA_OFF);

	case WCD_EVENT_PRE_HPHL_PA_OFF:

		return WCD_MBHC_STRINGIFY(WCD_EVENT_PRE_HPHL_PA_OFF);

	case WCD_EVENT_POST_DAPM_MICBIAS_2_ON:

		return WCD_MBHC_STRINGIFY(WCD_EVENT_POST_DAPM_MICBIAS_2_ON);

	case WCD_EVENT_PRE_DAPM_MICBIAS_2_ON:

		return WCD_MBHC_STRINGIFY(WCD_EVENT_PRE_DAPM_MICBIAS_2_ON);

	case WCD_EVENT_POST_DAPM_MICBIAS_2_OFF:

		return WCD_MBHC_STRINGIFY(WCD_EVENT_POST_DAPM_MICBIAS_2_OFF);

	case WCD_EVENT_PRE_DAPM_MICBIAS_2_OFF:

		return WCD_MBHC_STRINGIFY(WCD_EVENT_PRE_DAPM_MICBIAS_2_OFF);

	case WCD_EVENT_INVALID:

	default:

		return WCD_MBHC_STRINGIFY(WCD_EVENT_INVALID);

	}

}



static int wcd_event_notify(struct notifier_block *self, unsigned long val,

			    void *data)

{
@@ -201,7 +238,8 @@ static int wcd_event_notify(struct notifier_block *self, unsigned long val, 
	bool micbias1 = false;

	u8 fsm_en;



	pr_debug("%s: event %d\n", __func__, event);

	pr_debug("%s: event %s (%d)\n", __func__,

		 wcd_mbhc_get_event_string(event), event);

	if (mbhc->mbhc_cb->micbias_enable_status) {

		micbias2 = mbhc->mbhc_cb->micbias_enable_status(mbhc,

								MIC_BIAS_2);
@@ -210,6 +248,11 @@ static int wcd_event_notify(struct notifier_block *self, unsigned long val, 
	}

	switch (event) {

	/* MICBIAS usage change */

	case WCD_EVENT_POST_DAPM_MICBIAS_2_ON:

		mbhc->is_hs_recording = true;

		pr_debug("%s: is_capture: %d\n", __func__,

			  mbhc->is_hs_recording);

		break;

	case WCD_EVENT_POST_MICBIAS_2_ON:

		if (!mbhc->micbias_enable)

			goto out_micb_en;
@@ -233,7 +276,6 @@ static int wcd_event_notify(struct notifier_block *self, unsigned long val, 
					MBHC_COMMON_MICB_PRECHARGE,

					false);

out_micb_en:

		mbhc->is_hs_recording = true;

		/* Disable current source if micbias enabled */

		if (mbhc->mbhc_cb->mbhc_micbias_control) {

			WCD_MBHC_REG_READ(WCD_MBHC_FSM_EN, fsm_en);
@@ -241,18 +283,39 @@ out_micb_en: 
				WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_BTN_ISRC_CTL,

							 0);

		} else {

			mbhc->is_hs_recording = true;

			wcd_enable_curr_micbias(mbhc, WCD_MBHC_EN_MB);

		}

		/* configure cap settings properly when micbias is enabled */

		if (mbhc->mbhc_cb->set_cap_mode)

			mbhc->mbhc_cb->set_cap_mode(codec, micbias1, true);

		break;

	case WCD_EVENT_PRE_MICBIAS_2_OFF:

		/*

		 * Before MICBIAS_2 is turned off, if FSM is enabled,

		 * make sure current source is enabled so as to detect

		 * button press/release events

		 */

		if (mbhc->mbhc_cb->mbhc_micbias_control &&

		    !mbhc->micbias_enable) {

			WCD_MBHC_REG_READ(WCD_MBHC_FSM_EN, fsm_en);

			if (fsm_en)

				WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_BTN_ISRC_CTL,

							 3);

		}

		break;

	/* MICBIAS usage change */

	case WCD_EVENT_POST_DAPM_MICBIAS_2_OFF:

		mbhc->is_hs_recording = false;

		pr_debug("%s: is_capture: %d\n", __func__,

			  mbhc->is_hs_recording);

		break;

	case WCD_EVENT_POST_MICBIAS_2_OFF:

		if (mbhc->mbhc_cb->set_auto_zeroing)

			mbhc->mbhc_cb->set_auto_zeroing(codec, false);

		if (mbhc->mbhc_cb->set_micbias_value)

			mbhc->mbhc_cb->set_micbias_value(codec);

		if (!mbhc->mbhc_cb->mbhc_micbias_control)

			mbhc->is_hs_recording = false;

		/* Enable PULL UP if PA's are enabled */

		if ((test_bit(WCD_MBHC_EVENT_PA_HPHL, &mbhc->event_state)) ||
@@ -264,12 +327,6 @@ out_micb_en: 
			/* enable current source and disable mb, pullup*/

			wcd_enable_curr_micbias(mbhc, WCD_MBHC_EN_CS);



		if (mbhc->mbhc_cb->mbhc_micbias_control) {

			WCD_MBHC_REG_READ(WCD_MBHC_FSM_EN, fsm_en);

			if (fsm_en)

				WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_BTN_ISRC_CTL,

							 0);

		}

		/* configure cap settings properly when micbias is disabled */

		if (mbhc->mbhc_cb->set_cap_mode)

			mbhc->mbhc_cb->set_cap_mode(codec, micbias1, false);
@@ -480,8 +537,17 @@ static void wcd_mbhc_report_plug(struct wcd_mbhc *mbhc, int insertion, 
				~WCD_MBHC_JACK_BUTTON_MASK;

		}



		if (mbhc->micbias_enable)

		if (mbhc->micbias_enable) {

			if (mbhc->mbhc_cb->mbhc_micbias_control)

				mbhc->mbhc_cb->mbhc_micbias_control(

							mbhc->codec,

							MICB_DISABLE);

			if (mbhc->mbhc_cb->mbhc_micb_ctrl_thr_mic)

				mbhc->mbhc_cb->mbhc_micb_ctrl_thr_mic(

						mbhc->codec,

						MIC_BIAS_2, false);

			mbhc->micbias_enable = false;

		}



		mbhc->hph_type = WCD_MBHC_HPH_NONE;

		mbhc->zl = mbhc->zr = 0;
@@ -504,8 +570,17 @@ static void wcd_mbhc_report_plug(struct wcd_mbhc *mbhc, int insertion, 
		    jack_type == SND_JACK_LINEOUT) &&

		    (mbhc->hph_status && mbhc->hph_status != jack_type)) {



			if (mbhc->micbias_enable)

			if (mbhc->micbias_enable) {

				if (mbhc->mbhc_cb->mbhc_micbias_control)

					mbhc->mbhc_cb->mbhc_micbias_control(

							mbhc->codec,

							MICB_DISABLE);

				if (mbhc->mbhc_cb->mbhc_micb_ctrl_thr_mic)

					mbhc->mbhc_cb->mbhc_micb_ctrl_thr_mic(

							mbhc->codec,

							MIC_BIAS_2, false);

				mbhc->micbias_enable = false;

			}

			mbhc->hph_type = WCD_MBHC_HPH_NONE;

			mbhc->zl = mbhc->zr = 0;

			pr_debug("%s: Reporting removal (%x)\n",
@@ -679,17 +754,29 @@ static int wcd_check_cross_conn(struct wcd_mbhc *mbhc) 
static bool wcd_is_special_headset(struct wcd_mbhc *mbhc)

{

	struct snd_soc_codec *codec = mbhc->codec;

	int delay = 0;

	int delay = 0, rc;

	bool ret = false;

	bool hs_comp_res;



	/*

	 * Enable micbias if not already enabled

	 * and disable current source if using micbias

	 * Increase micbias to 2.7V to detect headsets with

	 * threshold on microphone

	 */

	if (mbhc->mbhc_cb->mbhc_micbias_control)

		mbhc->mbhc_cb->mbhc_micbias_control(codec, MICB_ENABLE);

	else

	if (mbhc->mbhc_cb->mbhc_micbias_control &&

	    !mbhc->mbhc_cb->mbhc_micb_ctrl_thr_mic) {

		pr_debug("%s: callback fn micb_ctrl_thr_mic not defined\n",

			 __func__);

		return false;

	} else if (mbhc->mbhc_cb->mbhc_micb_ctrl_thr_mic) {

		rc = mbhc->mbhc_cb->mbhc_micb_ctrl_thr_mic(codec,

							MIC_BIAS_2, true);

		if (rc) {

			pr_err("%s: Micbias control for thr mic failed, rc: %d\n",

				__func__, rc);

			return false;

		}

	}



	wcd_enable_curr_micbias(mbhc, WCD_MBHC_EN_MB);



	pr_debug("%s: special headset, start register writes\n", __func__);
@@ -740,22 +827,29 @@ static bool wcd_is_special_headset(struct wcd_mbhc *mbhc) 
	if (mbhc->mbhc_cb->set_auto_zeroing)

		mbhc->mbhc_cb->set_auto_zeroing(codec, false);



	if (mbhc->mbhc_cb->mbhc_micbias_control)

		mbhc->mbhc_cb->mbhc_micbias_control(codec, MICB_DISABLE);

	if (mbhc->mbhc_cb->mbhc_micb_ctrl_thr_mic &&

	    !mbhc->micbias_enable)

		mbhc->mbhc_cb->mbhc_micb_ctrl_thr_mic(codec, MIC_BIAS_2,

						      false);



	pr_debug("%s: leave\n", __func__);

	pr_debug("%s: leave, micb_enable: %d\n", __func__,

		  mbhc->micbias_enable);

	return ret;

}



static void wcd_mbhc_update_fsm_source(struct wcd_mbhc *mbhc,

				       enum wcd_mbhc_plug_type plug_type)

{

	bool micbias2;



	micbias2 = mbhc->mbhc_cb->micbias_enable_status(mbhc,

							MIC_BIAS_2);

	switch (plug_type) {

	case MBHC_PLUG_TYPE_HEADPHONE:

		WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_BTN_ISRC_CTL, 3);

		break;

	case MBHC_PLUG_TYPE_HEADSET:

		if (!mbhc->is_hs_recording)

		if (!mbhc->is_hs_recording && !micbias2)

			WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_BTN_ISRC_CTL, 3);

		break;

	default:
@@ -1031,9 +1125,10 @@ enable_supply: 
	else

		wcd_enable_mbhc_supply(mbhc, plug_type);

exit:

	if (mbhc->mbhc_cb->mbhc_micbias_control)

	if (mbhc->mbhc_cb->mbhc_micbias_control &&

	    !mbhc->micbias_enable)

		mbhc->mbhc_cb->mbhc_micbias_control(codec,

						    MICB_PULLUP_DISABLE);

						    MICB_DISABLE);

	if (mbhc->mbhc_cb->micbias_enable_status) {

		micbias1 = mbhc->mbhc_cb->micbias_enable_status(mbhc,

								MIC_BIAS_1);
@@ -1065,7 +1160,7 @@ static void wcd_mbhc_detect_plug_type(struct wcd_mbhc *mbhc) 
		mbhc->mbhc_cb->set_cap_mode(codec, micbias1, true);



	if (mbhc->mbhc_cb->mbhc_micbias_control)

		mbhc->mbhc_cb->mbhc_micbias_control(codec, MICB_PULLUP_ENABLE);

		mbhc->mbhc_cb->mbhc_micbias_control(codec, MICB_ENABLE);

	else

		wcd_enable_curr_micbias(mbhc, WCD_MBHC_EN_MB);

sound/soc/codecs/wcd-mbhc-v2.h

+8 −0
Original line number Diff line number Diff line
@@ -13,12 +13,15 @@ 
#define __WCD_MBHC_V2_H__



#include <linux/wait.h>

#include <linux/stringify.h>

#include "wcdcal-hwdep.h"



#define TOMBAK_MBHC_NC	0

#define TOMBAK_MBHC_NO	1

#define WCD_MBHC_DEF_BUTTONS 8

#define WCD_MBHC_USLEEP_RANGE_MARGIN_US 100

#define WCD_MBHC_THR_HS_MICB_MV  2700

#define WCD_MBHC_STRINGIFY(s)  __stringify(s)



struct wcd_mbhc;

enum wcd_mbhc_register_function {
@@ -104,6 +107,10 @@ enum wcd_notify_event { 
	WCD_EVENT_POST_MICBIAS_2_OFF,

	WCD_EVENT_PRE_MICBIAS_2_ON,

	WCD_EVENT_POST_MICBIAS_2_ON,

	WCD_EVENT_PRE_DAPM_MICBIAS_2_OFF,

	WCD_EVENT_POST_DAPM_MICBIAS_2_OFF,

	WCD_EVENT_PRE_DAPM_MICBIAS_2_ON,

	WCD_EVENT_POST_DAPM_MICBIAS_2_ON,

	/* events for PA ON and OFF */

	WCD_EVENT_PRE_HPHL_PA_ON,

	WCD_EVENT_POST_HPHL_PA_OFF,
@@ -300,6 +307,7 @@ struct wcd_mbhc_cb { 
	int (*mbhc_micbias_control)(struct snd_soc_codec *, int req);

	void (*mbhc_micb_ramp_control)(struct snd_soc_codec *, bool);

	bool (*extn_use_mb)(struct snd_soc_codec *);

	int (*mbhc_micb_ctrl_thr_mic)(struct snd_soc_codec *, int, bool);

};



struct wcd_mbhc {

sound/soc/codecs/wcd9335.c

+117 −10
Original line number Diff line number Diff line
@@ -93,6 +93,9 @@ 
#define CPE_FLL_CLK_150MHZ 150000000

#define WCD9335_REG_BITS 8



/* Convert from vout ctl to micbias voltage in mV */

#define WCD_VOUT_CTL_TO_MICB(v) (1000 + v * 50)



static int cpe_debug_mode = 1;

module_param(cpe_debug_mode, int,

	     S_IRUGO | S_IWUSR | S_IWGRP);
@@ -365,6 +368,7 @@ static const DECLARE_TLV_DB_SCALE(line_gain, 0, 7, 1); 
static const DECLARE_TLV_DB_SCALE(analog_gain, 0, 25, 1);



static struct snd_soc_dai_driver tasha_dai[];

static int wcd9335_get_micb_vout_ctl_val(u32 micb_mv);



/* Hold instance to soundwire platform device */

struct tasha_swr_ctrl_data {
@@ -746,7 +750,7 @@ static void tasha_mbhc_hph_l_pull_up_control(struct snd_soc_codec *codec, 
}



static int tasha_micbias_control(struct snd_soc_codec *codec,

				 int req)

				 int req, bool is_dapm)

{

	struct tasha_priv *tasha = snd_soc_codec_get_drvdata(codec);
@@ -774,6 +778,10 @@ static int tasha_micbias_control(struct snd_soc_codec *codec, 
					WCD_EVENT_POST_MICBIAS_2_ON,

					&tasha->mbhc);

		}

		if (is_dapm)

			blocking_notifier_call_chain(&tasha->notifier,

					WCD_EVENT_POST_DAPM_MICBIAS_2_ON,

					&tasha->mbhc);

		break;

	case MICB_DISABLE:

		tasha->micb_ref--;
@@ -781,12 +789,19 @@ static int tasha_micbias_control(struct snd_soc_codec *codec, 
			snd_soc_update_bits(codec, WCD9335_ANA_MICB2, 0xC0,

					    0x80);

		else if ((tasha->micb_ref == 0) && (tasha->pullup_ref == 0)) {

			blocking_notifier_call_chain(&tasha->notifier,

					WCD_EVENT_PRE_MICBIAS_2_OFF,

					&tasha->mbhc);

			snd_soc_update_bits(codec, WCD9335_ANA_MICB2, 0xC0,

					    0x00);

			blocking_notifier_call_chain(&tasha->notifier,

					WCD_EVENT_POST_MICBIAS_2_OFF,

					&tasha->mbhc);

		}

		if (is_dapm)

			blocking_notifier_call_chain(&tasha->notifier,

					WCD_EVENT_POST_DAPM_MICBIAS_2_OFF,

					&tasha->mbhc);

		break;

	};
@@ -801,25 +816,25 @@ static int tasha_micbias_control(struct snd_soc_codec *codec, 
static int tasha_mbhc_request_micbias(struct snd_soc_codec *codec,

				      int req)

{

	struct tasha_priv *tasha = snd_soc_codec_get_drvdata(codec);

	int ret;



	/*

	 * If micbias is requested, make sure that there

	 * is vote to enable master bias

	 * is vote to enable mclk

	 */

	if (req == MICB_ENABLE)

		wcd_resmgr_enable_master_bias(tasha->resmgr);

		tasha_cdc_mclk_enable(codec, true, false);



	tasha_micbias_control(codec, req);

	ret = tasha_micbias_control(codec, req, false);



	/*

	 * Release vote for master bias while requesting for

	 * Release vote for mclk while requesting for

	 * micbias disable

	 */

	if (req == MICB_DISABLE)

		wcd_resmgr_disable_master_bias(tasha->resmgr);

		tasha_cdc_mclk_enable(codec, false, false);



	return 0;

	return ret;

}



static void tasha_mbhc_micb_ramp_control(struct snd_soc_codec *codec,
@@ -857,6 +872,96 @@ static struct firmware_cal *tasha_get_hwdep_fw_cal(struct snd_soc_codec *codec, 
	return hwdep_cal;

}



static int tasha_mbhc_micb_adjust_voltage(struct snd_soc_codec *codec,

					  int req_volt,

					  int micb_num)

{

	int cur_vout_ctl, req_vout_ctl;

	int micb_reg, micb_val, micb_en;



	switch (micb_num) {

	case MIC_BIAS_1:

		micb_reg = WCD9335_ANA_MICB1;

		break;

	case MIC_BIAS_2:

		micb_reg = WCD9335_ANA_MICB2;

		break;

	case MIC_BIAS_3:

		micb_reg = WCD9335_ANA_MICB3;

		break;

	case MIC_BIAS_4:

		micb_reg = WCD9335_ANA_MICB4;

		break;

	default:

		return -EINVAL;

	}



	/*

	 * If requested micbias voltage is same as current micbias

	 * voltage, then just return. Otherwise, adjust voltage as

	 * per requested value. If micbias is already enabled, then

	 * to avoid slow micbias ramp-up or down enable pull-up

	 * momentarily, change the micbias value and then re-enable

	 * micbias.

	 */

	micb_val = snd_soc_read(codec, micb_reg);

	micb_en = (micb_val & 0xC0) >> 6;

	cur_vout_ctl = micb_val & 0x3F;



	req_vout_ctl = wcd9335_get_micb_vout_ctl_val(req_volt);

	if (IS_ERR_VALUE(req_vout_ctl))

		return -EINVAL;

	if (cur_vout_ctl == req_vout_ctl)

		return 0;



	dev_dbg(codec->dev, "%s: micb_num: %d, cur_mv: %d, req_mv: %d, micb_en: %d\n",

		 __func__, micb_num, WCD_VOUT_CTL_TO_MICB(cur_vout_ctl),

		 req_volt, micb_en);



	if (micb_en == 0x1)

		snd_soc_update_bits(codec, micb_reg, 0xC0, 0x80);



	snd_soc_update_bits(codec, micb_reg, 0x3F, req_vout_ctl);



	if (micb_en == 0x1) {

		snd_soc_update_bits(codec, micb_reg, 0xC0, 0x40);

		/*

		 * Add 2ms delay as per HW requirement after enabling

		 * micbias

		 */

		usleep_range(2000, 2100);

	}



	return 0;

}



static int tasha_mbhc_micb_ctrl_threshold_mic(struct snd_soc_codec *codec,

					      int micb_num, bool req_en)

{

	struct tasha_priv *tasha = snd_soc_codec_get_drvdata(codec);

	struct wcd9xxx_pdata *pdata = dev_get_platdata(codec->dev->parent);

	int rc, micb_mv;



	if (micb_num != MIC_BIAS_2)

		return -EINVAL;



	/*

	 * If device tree micbias level is already above the minimum

	 * voltage needed to detect threshold microphone, then do

	 * not change the micbias, just return.

	 */

	if (pdata->micbias.micb2_mv >= WCD_MBHC_THR_HS_MICB_MV)

		return 0;



	micb_mv = req_en ? WCD_MBHC_THR_HS_MICB_MV : pdata->micbias.micb2_mv;



	mutex_lock(&tasha->micb_lock);

	rc = tasha_mbhc_micb_adjust_voltage(codec, micb_mv, MIC_BIAS_2);

	mutex_unlock(&tasha->micb_lock);



	return rc;

}



static const struct wcd_mbhc_cb mbhc_cb = {

	.request_irq = tasha_mbhc_request_irq,

	.irq_control = tasha_mbhc_irq_control,
@@ -873,6 +978,7 @@ static const struct wcd_mbhc_cb mbhc_cb = { 
	.mbhc_micbias_control = tasha_mbhc_request_micbias,

	.mbhc_micb_ramp_control = tasha_mbhc_micb_ramp_control,

	.get_hwdep_fw_cal = tasha_get_hwdep_fw_cal,

	.mbhc_micb_ctrl_thr_mic = tasha_mbhc_micb_ctrl_threshold_mic,

};



static int tasha_get_iir_enable_audio_mixer(
@@ -2988,7 +3094,7 @@ static int tasha_codec_enable_micbias(struct snd_soc_dapm_widget *w, 
		 * and enable requests

		 */

		if (micb_reg == WCD9335_ANA_MICB2)

			tasha_micbias_control(codec, MICB_ENABLE);

			tasha_micbias_control(codec, MICB_ENABLE, true);

		else

			snd_soc_update_bits(codec, micb_reg, 0xC0, 0x40);

		break;
@@ -2998,7 +3104,7 @@ static int tasha_codec_enable_micbias(struct snd_soc_dapm_widget *w, 
		break;

	case SND_SOC_DAPM_POST_PMD:

		if (micb_reg == WCD9335_ANA_MICB2)

			tasha_micbias_control(codec, MICB_DISABLE);

			tasha_micbias_control(codec, MICB_DISABLE, true);

		else

			snd_soc_update_bits(codec, micb_reg, 0xC0, 0x00);

		break;
@@ -7269,6 +7375,7 @@ static const struct tasha_reg_mask_val tasha_codec_reg_init_val[] = { 
	{WCD9335_CDC_RX7_RX_PATH_MIX_CFG, 0x01, 0x01},

	{WCD9335_CDC_RX8_RX_PATH_MIX_CFG, 0x01, 0x01},

	{WCD9335_SOC_MAD_AUDIO_CTL_2, 0x03, 0x03},

	{WCD9335_MICB2_TEST_CTL_2, 0x07, 0x01},

};



static void tasha_update_reg_reset_values(struct snd_soc_codec *codec)