add support for p1

Signed-off-by: Chirayu Desai <cdesai@cyanogenmod.org>
Signed-off-by: Humberto Borba <humberos@gmail.com>
Signed-off-by: Koudai Aono <koxudaxi@gmail.com>
Change-Id: I2dcbaee7f17852ed3ea4a5db2d103704027fe259

10 files changed, 6419 insertions, 2797 deletions

diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig
index 9d2b5b8..8e32533 100644
--- a/sound/soc/codecs/Kconfig
+++ b/sound/soc/codecs/Kconfig
@@ -89,7 +89,7 @@ config SND_SOC_ALL_CODECS
 	select SND_SOC_WM8990 if I2C
 	select SND_SOC_WM8991 if I2C
 	select SND_SOC_WM8993 if I2C
-	select SND_SOC_WM8994 if MFD_WM8994
+	select SND_SOC_WM8994 if I2C && MACH_P1
 	select SND_SOC_WM8995 if SND_SOC_I2C_AND_SPI
 	select SND_SOC_WM9081 if I2C
 	select SND_SOC_WM9090 if I2C
@@ -130,7 +130,7 @@ config SND_SOC_AD1980
 
 config SND_SOC_AD73311
 	tristate
-	
+
 config SND_SOC_ADS117X
 	tristate
 
@@ -392,7 +392,7 @@ config SND_SOC_WM9090
 
 menuconfig SND_WM8994_EXTENSIONS
 	bool "WM8994 Extensions"
-	depends on SND_SOC_SAMSUNG_HERRING_WM8994
+	depends on SND_SOC_SAMSUNG_HERRING_WM8994 || SND_SOC_SAMSUNG_P1_WM8994
 	default y
 	help
 	  With this option enabled, the kernel compile an additional driver
@@ -409,7 +409,7 @@ config SND_WM8994_EXTENSIONS_HP_LEVEL_CONTROL
 config SND_WM8994_EXTENSIONS_HP_LEVEL
 	int "default level at boot 0-62"
 	depends on SND_WM8994_EXTENSIONS_HP_LEVEL_CONTROL
-	default 54 if MACH_HERRING=y || M110S=y
+	default 54 if MACH_HERRING=y || MACH_P1=y || M110S=y
 	default 47
 	range 0 62
 	help
diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile
index 3416290..dac6d79 100644
--- a/sound/soc/codecs/Makefile
+++ b/sound/soc/codecs/Makefile
@@ -73,12 +73,23 @@ snd-soc-wm8988-objs := wm8988.o
 snd-soc-wm8990-objs := wm8990.o
 snd-soc-wm8991-objs := wm8991.o
 snd-soc-wm8993-objs := wm8993.o
-snd-soc-wm8994-objs := wm8994.o wm8994-tables.o wm8958-dsp2.o
+
+ifdef CONFIG_MACH_P1
+ifeq ($(CONFIG_SND_WM8994_EXTENSIONS),y)
+snd-soc-wm8994-objs := wm8994.o wm8994_p1.o wm8994_extensions.o
+else
+snd-soc-wm8994-objs := wm8994.o wm8994_p1.o
+endif
+endif
+
+ifdef CONFIG_MACH_ARIES
 ifeq ($(CONFIG_SND_WM8994_EXTENSIONS),y)
 snd-soc-wm8994-samsung-objs := wm8994_samsung.o wm8994_herring.o wm8994_extensions.o
 else
 snd-soc-wm8994-samsung-objs := wm8994_samsung.o wm8994_herring.o
 endif
+endif
+
 snd-soc-wm8995-objs := wm8995.o
 snd-soc-wm9081-objs := wm9081.o
 snd-soc-wm9705-objs := wm9705.o
diff --git a/sound/soc/codecs/wm8994.c b/sound/soc/codecs/wm8994.c
index 1f7616d..13eb15b 100644
--- a/sound/soc/codecs/wm8994.c
+++ b/sound/soc/codecs/wm8994.c
@@ -1,1969 +1,1046 @@
-/*
- * wm8994.c  --  WM8994 ALSA SoC Audio driver
+/*
+ * wm8994.c  --  WM8994 ALSA Soc Audio driver
  *
- * Copyright 2009 Wolfson Microelectronics plc
+ * Copyright 2010 Wolfson Microelectronics PLC.
  *
- * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
  *
+ * Notes:
+ *  The WM8994 is a multichannel codec with S/PDIF support, featuring six
+ *  DAC channels and two ADC channels.
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
+ *  Currently only the primary audio interface is supported - S/PDIF and
+ *  the secondary audio interfaces are not.
  */
 
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
-#include <linux/platform_device.h>
-#include <linux/pm_runtime.h>
-#include <linux/regulator/consumer.h>
 #include <linux/slab.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
 #include <sound/core.h>
-#include <sound/jack.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
-#include <sound/initval.h>
+#include <sound/soc-dapm.h>
 #include <sound/tlv.h>
-#include <trace/events/asoc.h>
-
-#include <linux/mfd/wm8994/core.h>
-#include <linux/mfd/wm8994/registers.h>
-#include <linux/mfd/wm8994/pdata.h>
-#include <linux/mfd/wm8994/gpio.h>
-
+#include <sound/initval.h>
+#include <asm/div64.h>
+#include <asm/io.h>
+#include <plat/map-base.h>
+#include <mach/regs-clock.h>
 #include "wm8994.h"
-#include "wm_hubs.h"
 
-#define WM8994_NUM_DRC 3
-#define WM8994_NUM_EQ  3
+#ifdef CONFIG_SND_WM8994_EXTENSIONS
+#include "wm8994_extensions.h"
+#endif
 
-static int wm8994_drc_base[] = {
-	WM8994_AIF1_DRC1_1,
-	WM8994_AIF1_DRC2_1,
-	WM8994_AIF2_DRC_1,
-};
+#define WM8994_VERSION "0.1"
+#define SUBJECT "wm8994.c"
 
-static int wm8994_retune_mobile_base[] = {
-	WM8994_AIF1_DAC1_EQ_GAINS_1,
-	WM8994_AIF1_DAC2_EQ_GAINS_1,
-	WM8994_AIF2_EQ_GAINS_1,
-};
+#if defined(CONFIG_VIDEO_TV20) && defined(CONFIG_SND_S5P_WM8994_MASTER)
+#define HDMI_USE_AUDIO
+#endif
 
-static int wm8994_readable(struct snd_soc_codec *codec, unsigned int reg)
-{
-	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	struct wm8994 *control = codec->control_data;
-
-	switch (reg) {
-	case WM8994_GPIO_1:
-	case WM8994_GPIO_2:
-	case WM8994_GPIO_3:
-	case WM8994_GPIO_4:
-	case WM8994_GPIO_5:
-	case WM8994_GPIO_6:
-	case WM8994_GPIO_7:
-	case WM8994_GPIO_8:
-	case WM8994_GPIO_9:
-	case WM8994_GPIO_10:
-	case WM8994_GPIO_11:
-	case WM8994_INTERRUPT_STATUS_1:
-	case WM8994_INTERRUPT_STATUS_2:
-	case WM8994_INTERRUPT_RAW_STATUS_2:
-		return 1;
-
-	case WM8958_DSP2_PROGRAM:
-	case WM8958_DSP2_CONFIG:
-	case WM8958_DSP2_EXECCONTROL:
-		if (control->type == WM8958)
-			return 1;
-		else
-			return 0;
+/*
+ *Definitions of clock related.
+*/
 
-	default:
-		break;
-	}
+static struct {
+	int ratio;
+	int clk_sys_rate;
+} clk_sys_rates[] = {
+	{ 64,   0 },
+	{ 128,  1 },
+	{ 192,  2 },
+	{ 256,  3 },
+	{ 384,  4 },
+	{ 512,  5 },
+	{ 768,  6 },
+	{ 1024, 7 },
+	{ 1408, 8 },
+	{ 1536, 9 },
+};
 
-	if (reg >= WM8994_CACHE_SIZE)
-		return 0;
-	return wm8994_access_masks[reg].readable != 0;
-}
+static struct {
+	int rate;
+	int sample_rate;
+} sample_rates[] = {
+	{ 8000,  0  },
+	{ 11025, 1  },
+	{ 12000, 2  },
+	{ 16000, 3  },
+	{ 22050, 4  },
+	{ 24000, 5  },
+	{ 32000, 6  },
+	{ 44100, 7  },
+	{ 48000, 8  },
+	{ 88200, 9  },
+	{ 96000, 10  },
+};
 
-static int wm8994_volatile(struct snd_soc_codec *codec, unsigned int reg)
-{
-	if (reg >= WM8994_CACHE_SIZE)
-		return 1;
-
-	switch (reg) {
-	case WM8994_SOFTWARE_RESET:
-	case WM8994_CHIP_REVISION:
-	case WM8994_DC_SERVO_1:
-	case WM8994_DC_SERVO_READBACK:
-	case WM8994_RATE_STATUS:
-	case WM8994_LDO_1:
-	case WM8994_LDO_2:
-	case WM8958_DSP2_EXECCONTROL:
-	case WM8958_MIC_DETECT_3:
-		return 1;
-	default:
-		return 0;
-	}
-}
+static struct {
+	int div;
+	int bclk_div;
+} bclk_divs[] = {
+	{ 1,   0  },
+	{ 2,   1  },
+	{ 4,   2  },
+	{ 6,   3  },
+	{ 8,   4  },
+	{ 12,  5  },
+	{ 16,  6  },
+	{ 24,  7  },
+	{ 32,  8  },
+	{ 48,  9  },
+};
 
-static int wm8994_write(struct snd_soc_codec *codec, unsigned int reg,
-	unsigned int value)
-{
-	int ret;
+/*
+ * Definitions of sound path
+ */
+select_route universal_wm8994_playback_paths[] = {
+	wm8994_set_off, wm8994_set_playback_receiver,
+	wm8994_set_playback_speaker, wm8994_set_playback_headset,
+	wm8994_set_playback_headset, wm8994_set_playback_bluetooth,
+	wm8994_set_playback_speaker_headset, wm8994_set_playback_extra_dock_speaker,
+	wm8994_set_playback_hdmi_tvout,
+	wm8994_set_playback_speaker_hdmitvout,
+	wm8994_set_playback_speakerheadset_hdmitvout
+};
 
-	BUG_ON(reg > WM8994_MAX_REGISTER);
+select_route universal_wm8994_voicecall_paths[] = {
+	wm8994_set_off, wm8994_set_voicecall_receiver,
+	wm8994_set_voicecall_speaker, wm8994_set_voicecall_headset,
+	wm8994_set_voicecall_headphone, wm8994_set_voicecall_bluetooth,
+};
 
-	if (!wm8994_volatile(codec, reg)) {
-		ret = snd_soc_cache_write(codec, reg, value);
-		if (ret != 0)
-			dev_err(codec->dev, "Cache write to %x failed: %d\n",
-				reg, ret);
-	}
+select_mic_route universal_wm8994_mic_paths[] = {
+	wm8994_record_main_mic,
+	wm8994_record_headset_mic,
+	wm8994_record_bluetooth,
+};
 
-	return wm8994_reg_write(codec->control_data, reg, value);
-}
 
-static unsigned int wm8994_read(struct snd_soc_codec *codec,
-				unsigned int reg)
+/*
+ * Implementation of I2C functions
+ */
+static unsigned int wm8994_read_hw(struct snd_soc_codec *codec, u16 reg)
 {
-	unsigned int val;
+	struct i2c_msg xfer[2];
+	u16 data;
 	int ret;
-
-	BUG_ON(reg > WM8994_MAX_REGISTER);
-
-	if (!wm8994_volatile(codec, reg) && wm8994_readable(codec, reg) &&
-	    reg < codec->driver->reg_cache_size) {
-		ret = snd_soc_cache_read(codec, reg, &val);
-		if (ret >= 0)
-			return val;
-		else
-			dev_err(codec->dev, "Cache read from %x failed: %d\n",
-				reg, ret);
-	}
-
-	return wm8994_reg_read(codec->control_data, reg);
-}
-
-static int configure_aif_clock(struct snd_soc_codec *codec, int aif)
-{
-	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	int rate;
-	int reg1 = 0;
-	int offset;
-
-	if (aif)
-		offset = 4;
-	else
-		offset = 0;
-
-	switch (wm8994->sysclk[aif]) {
-	case WM8994_SYSCLK_MCLK1:
-		rate = wm8994->mclk[0];
-		break;
-
-	case WM8994_SYSCLK_MCLK2:
-		reg1 |= 0x8;
-		rate = wm8994->mclk[1];
-		break;
-
-	case WM8994_SYSCLK_FLL1:
-		reg1 |= 0x10;
-		rate = wm8994->fll[0].out;
-		break;
-
-	case WM8994_SYSCLK_FLL2:
-		reg1 |= 0x18;
-		rate = wm8994->fll[1].out;
-		break;
-
-	default:
-		return -EINVAL;
-	}
-
-	if (rate >= 13500000) {
-		rate /= 2;
-		reg1 |= WM8994_AIF1CLK_DIV;
-
-		dev_dbg(codec->dev, "Dividing AIF%d clock to %dHz\n",
-			aif + 1, rate);
+	struct i2c_client *i2c = codec->control_data;
+
+	data = ((reg & 0xff00) >> 8) | ((reg & 0xff) << 8);
+
+	xfer[0].addr = i2c->addr;
+	xfer[0].flags = 0;
+	xfer[0].len = 2;
+	xfer[0].buf = (void *)&data;
+
+	xfer[1].addr = i2c->addr;
+	xfer[1].flags = I2C_M_RD;
+	xfer[1].len = 2;
+	xfer[1].buf = (u8 *)&data;
+	ret = i2c_transfer(i2c->adapter, xfer, 2);
+	if (ret != 2) {
+		dev_err(codec->dev, "Failed to read 0x%x: %d\n", reg, ret);
+		return 0;
 	}
 
-	if (rate && rate < 3000000)
-		dev_warn(codec->dev, "AIF%dCLK is %dHz, should be >=3MHz for optimal performance\n",
-			 aif + 1, rate);
-
-	wm8994->aifclk[aif] = rate;
-
-	snd_soc_update_bits(codec, WM8994_AIF1_CLOCKING_1 + offset,
-			    WM8994_AIF1CLK_SRC_MASK | WM8994_AIF1CLK_DIV,
-			    reg1);
-
-	return 0;
+	return (data >> 8) | ((data & 0xff) << 8);
 }
 
-static int configure_clock(struct snd_soc_codec *codec)
+int wm8994_write(struct snd_soc_codec *codec, unsigned int reg,
+		 unsigned int value)
 {
-	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	int old, new;
+	u8 data[4];
+	int ret;
 
-	/* Bring up the AIF clocks first */
-	configure_aif_clock(codec, 0);
-	configure_aif_clock(codec, 1);
+#ifdef CONFIG_SND_WM8994_EXTENSIONS
+	value = wm8994_extensions_write(codec, reg, value);
+#endif
 
-	/* Then switch CLK_SYS over to the higher of them; a change
-	 * can only happen as a result of a clocking change which can
-	 * only be made outside of DAPM so we can safely redo the
-	 * clocking.
+	/* data is
+	 * D15..D9 WM8993 register offset
+	 * D8...D0 register data
 	 */
+	data[0] = (reg & 0xff00) >> 8;
+	data[1] = reg & 0x00ff;
+	data[2] = value >> 8;
+	data[3] = value & 0x00ff;
+	ret = codec->hw_write(codec->control_data, data, 4);
 
-	/* If they're equal it doesn't matter which is used */
-	if (wm8994->aifclk[0] == wm8994->aifclk[1])
+	if (ret == 4)
 		return 0;
-
-	if (wm8994->aifclk[0] < wm8994->aifclk[1])
-		new = WM8994_SYSCLK_SRC;
-	else
-		new = 0;
-
-	old = snd_soc_read(codec, WM8994_CLOCKING_1) & WM8994_SYSCLK_SRC;
-
-	/* If there's no change then we're done. */
-	if (old == new)
-		return 0;
-
-	snd_soc_update_bits(codec, WM8994_CLOCKING_1, WM8994_SYSCLK_SRC, new);
-
-	snd_soc_dapm_sync(&codec->dapm);
-
-	return 0;
+	else {
+		pr_err("i2c write problem occured\n");
+		return ret;
+	}
 }
 
-static int check_clk_sys(struct snd_soc_dapm_widget *source,
-			 struct snd_soc_dapm_widget *sink)
+inline unsigned int wm8994_read(struct snd_soc_codec *codec, unsigned int reg)
 {
-	int reg = snd_soc_read(source->codec, WM8994_CLOCKING_1);
-	const char *clk;
-
-	/* Check what we're currently using for CLK_SYS */
-	if (reg & WM8994_SYSCLK_SRC)
-		clk = "AIF2CLK";
-	else
-		clk = "AIF1CLK";
-
-	return strcmp(source->name, clk) == 0;
+	return wm8994_read_hw(codec, reg);
 }
 
-static const char *sidetone_hpf_text[] = {
-	"2.7kHz", "1.35kHz", "675Hz", "370Hz", "180Hz", "90Hz", "45Hz"
-};
-
-static const struct soc_enum sidetone_hpf =
-	SOC_ENUM_SINGLE(WM8994_SIDETONE, 7, 7, sidetone_hpf_text);
+/*
+ * Functions related volume.
+ */
+static const DECLARE_TLV_DB_SCALE(dac_tlv, -12750, 50, 1);
 
-static const char *adc_hpf_text[] = {
-	"HiFi", "Voice 1", "Voice 2", "Voice 3"
-};
+static int wm899x_outpga_put_volsw_vu(struct snd_kcontrol *kcontrol,
+				      struct snd_ctl_elem_value *ucontrol)
+{
+	int ret;
+	u16 val;
 
-static const struct soc_enum aif1adc1_hpf =
-	SOC_ENUM_SINGLE(WM8994_AIF1_ADC1_FILTERS, 13, 4, adc_hpf_text);
+	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+	struct soc_mixer_control *mc =
+	    (struct soc_mixer_control *)kcontrol->private_value;
+	int reg = mc->reg;
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
 
-static const struct soc_enum aif1adc2_hpf =
-	SOC_ENUM_SINGLE(WM8994_AIF1_ADC2_FILTERS, 13, 4, adc_hpf_text);
+	DEBUG_LOG("");
 
-static const struct soc_enum aif2adc_hpf =
-	SOC_ENUM_SINGLE(WM8994_AIF2_ADC_FILTERS, 13, 4, adc_hpf_text);
+	ret = snd_soc_put_volsw_2r(kcontrol, ucontrol);
+	if (ret < 0)
+		return ret;
 
-static const DECLARE_TLV_DB_SCALE(aif_tlv, 0, 600, 0);
-static const DECLARE_TLV_DB_SCALE(digital_tlv, -7200, 75, 1);
-static const DECLARE_TLV_DB_SCALE(st_tlv, -3600, 300, 0);
-static const DECLARE_TLV_DB_SCALE(wm8994_3d_tlv, -1600, 183, 0);
-static const DECLARE_TLV_DB_SCALE(eq_tlv, -1200, 100, 0);
+	val = wm8994_read(codec, reg);
 
-#define WM8994_DRC_SWITCH(xname, reg, shift) \
-{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
-	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
-	.put = wm8994_put_drc_sw, \
-	.private_value =  SOC_SINGLE_VALUE(reg, shift, 1, 0) }
+	return wm8994_write(codec, reg, val | 0x0100);
+}
 
-static int wm8994_put_drc_sw(struct snd_kcontrol *kcontrol,
-			     struct snd_ctl_elem_value *ucontrol)
+static int wm899x_inpga_put_volsw_vu(struct snd_kcontrol *kcontrol,
+				     struct snd_ctl_elem_value *ucontrol)
 {
-	struct soc_mixer_control *mc =
-		(struct soc_mixer_control *)kcontrol->private_value;
 	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
-	int mask, ret;
+	struct soc_mixer_control *mc =
+	    (struct soc_mixer_control *)kcontrol->private_value;
+	int reg = mc->reg;
+	int ret;
+	u16 val;
 
-	/* Can't enable both ADC and DAC paths simultaneously */
-	if (mc->shift == WM8994_AIF1DAC1_DRC_ENA_SHIFT)
-		mask = WM8994_AIF1ADC1L_DRC_ENA_MASK |
-			WM8994_AIF1ADC1R_DRC_ENA_MASK;
-	else
-		mask = WM8994_AIF1DAC1_DRC_ENA_MASK;
+	ret = snd_soc_put_volsw(kcontrol, ucontrol);
 
-	ret = snd_soc_read(codec, mc->reg);
 	if (ret < 0)
 		return ret;
-	if (ret & mask)
-		return -EINVAL;
 
-	return snd_soc_put_volsw(kcontrol, ucontrol);
-}
+	val = wm8994_read(codec, reg);
 
-static void wm8994_set_drc(struct snd_soc_codec *codec, int drc)
-{
-	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	struct wm8994_pdata *pdata = wm8994->pdata;
-	int base = wm8994_drc_base[drc];
-	int cfg = wm8994->drc_cfg[drc];
-	int save, i;
-
-	/* Save any enables; the configuration should clear them. */
-	save = snd_soc_read(codec, base);
-	save &= WM8994_AIF1DAC1_DRC_ENA | WM8994_AIF1ADC1L_DRC_ENA |
-		WM8994_AIF1ADC1R_DRC_ENA;
-
-	for (i = 0; i < WM8994_DRC_REGS; i++)
-		snd_soc_update_bits(codec, base + i, 0xffff,
-				    pdata->drc_cfgs[cfg].regs[i]);
-
-	snd_soc_update_bits(codec, base, WM8994_AIF1DAC1_DRC_ENA |
-			     WM8994_AIF1ADC1L_DRC_ENA |
-			     WM8994_AIF1ADC1R_DRC_ENA, save);
-}
+	return wm8994_write(codec, reg, val | 0x0100);
 
-/* Icky as hell but saves code duplication */
-static int wm8994_get_drc(const char *name)
-{
-	if (strcmp(name, "AIF1DRC1 Mode") == 0)
-		return 0;
-	if (strcmp(name, "AIF1DRC2 Mode") == 0)
-		return 1;
-	if (strcmp(name, "AIF2DRC Mode") == 0)
-		return 2;
-	return -EINVAL;
 }
 
-static int wm8994_put_drc_enum(struct snd_kcontrol *kcontrol,
-			       struct snd_ctl_elem_value *ucontrol)
-{
-	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
-	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	struct wm8994_pdata *pdata = wm8994->pdata;
-	int drc = wm8994_get_drc(kcontrol->id.name);
-	int value = ucontrol->value.integer.value[0];
-
-	if (drc < 0)
-		return drc;
-
-	if (value >= pdata->num_drc_cfgs)
-		return -EINVAL;
-
-	wm8994->drc_cfg[drc] = value;
+/*
+ * Implementation of sound path
+ */
+static const char *playback_path[] = { "OFF", "RCV", "SPK", "HP", "HP_NO_MIC",  "BT", "SPK_HP", "RING_SPK", "RING_HP", "RING_NO_MIC", "RING_SPK_HP", "EXTRA_DOCK_SPEAKER", "TV_OUT", "HDMI_TV_OUT", "HDMI_SPK", "HDMI_DUAL" };
+static const char *voicecall_path[] = { "OFF", "RCV", "SPK", "HP", "HP_NO_MIC",  "BT", };
+static const char *mic_path[] = {"Main Mic", "Hands Free Mic", "BT Sco Mic", "MIC OFF" };
+static const char *fmradio_path[]   = { "FMR_OFF", "FMR_SPK", "FMR_HP", "FMR_SPK_MIX", "FMR_HP_MIX", "FMR_DUAL_MIX"};
+static const char *codec_tuning_control[] = {"OFF", "ON"};
+static const char *codec_status_control[] = {"FMR_VOL_0", "FMR_VOL_1", "FMR_OFF", "REC_OFF", "REC_ON"};
+static const char * voice_record_path[] = {"CALL_RECORDING_OFF", "CALL_RECORDING_MAIN", "CALL_RECORDING_SUB"};
+static const char * call_recording_channel[] ={"CH_OFF"," CH_UPLINK","CH_DOWNLINK","CH_UDLINK"};
 
-	wm8994_set_drc(codec, drc);
 
-	return 0;
-}
 
-static int wm8994_get_drc_enum(struct snd_kcontrol *kcontrol,
+static int wm8994_get_mic_path(struct snd_kcontrol *kcontrol,
 			       struct snd_ctl_elem_value *ucontrol)
 {
 	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	int drc = wm8994_get_drc(kcontrol->id.name);
 
-	ucontrol->value.enumerated.item[0] = wm8994->drc_cfg[drc];
+	ucontrol->value.integer.value[0] = wm8994->rec_path;
 
 	return 0;
 }
 
-static void wm8994_set_retune_mobile(struct snd_soc_codec *codec, int block)
+static int wm8994_set_mic_path(struct snd_kcontrol *kcontrol,
+			       struct snd_ctl_elem_value *ucontrol)
 {
+	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	struct wm8994_pdata *pdata = wm8994->pdata;
-	int base = wm8994_retune_mobile_base[block];
-	int iface, best, best_val, save, i, cfg;
 
-	if (!pdata || !wm8994->num_retune_mobile_texts)
-		return;
+	DEBUG_LOG("");
 
-	switch (block) {
+	wm8994->codec_state |= CAPTURE_ACTIVE;
+
+	switch (ucontrol->value.integer.value[0]) {
 	case 0:
+		wm8994->rec_path = MAIN;
+		break;
 	case 1:
-		iface = 0;
+		wm8994->rec_path = SUB;
 		break;
 	case 2:
-		iface = 1;
+		wm8994->rec_path = BT_REC;
+		wm8994->universal_mic_path[wm8994->rec_path](codec);
 		break;
+	case 3:
+		wm8994_disable_rec_path(codec);
+		return 0;
 	default:
-		return;
+		return -EINVAL;
 	}
 
-	/* Find the version of the currently selected configuration
-	 * with the nearest sample rate. */
-	cfg = wm8994->retune_mobile_cfg[block];
-	best = 0;
-	best_val = INT_MAX;
-	for (i = 0; i < pdata->num_retune_mobile_cfgs; i++) {
-		if (strcmp(pdata->retune_mobile_cfgs[i].name,
-			   wm8994->retune_mobile_texts[cfg]) == 0 &&
-		    abs(pdata->retune_mobile_cfgs[i].rate
-			- wm8994->dac_rates[iface]) < best_val) {
-			best = i;
-			best_val = abs(pdata->retune_mobile_cfgs[i].rate
-				       - wm8994->dac_rates[iface]);
-		}
+	if(wm8994->rec_path == MAIN)
+		audio_ctrl_mic_bias_gpio(1);
+	else { //SUB
+		audio_ctrl_mic_bias_gpio(0);
+		audio_ctrl_earmic_bias_gpio(1);
 	}
 
-	dev_dbg(codec->dev, "ReTune Mobile %d %s/%dHz for %dHz sample rate\n",
-		block,
-		pdata->retune_mobile_cfgs[best].name,
-		pdata->retune_mobile_cfgs[best].rate,
-		wm8994->dac_rates[iface]);
-
-	/* The EQ will be disabled while reconfiguring it, remember the
-	 * current configuration. 
-	 */
-	save = snd_soc_read(codec, base);
-	save &= WM8994_AIF1DAC1_EQ_ENA;
-
-	for (i = 0; i < WM8994_EQ_REGS; i++)
-		snd_soc_update_bits(codec, base + i, 0xffff,
-				pdata->retune_mobile_cfgs[best].regs[i]);
+	wm8994->universal_mic_path[wm8994->rec_path] (codec);
 
-	snd_soc_update_bits(codec, base, WM8994_AIF1DAC1_EQ_ENA, save);
-}
-
-/* Icky as hell but saves code duplication */
-static int wm8994_get_retune_mobile_block(const char *name)
-{
-	if (strcmp(name, "AIF1.1 EQ Mode") == 0)
-		return 0;
-	if (strcmp(name, "AIF1.2 EQ Mode") == 0)
-		return 1;
-	if (strcmp(name, "AIF2 EQ Mode") == 0)
-		return 2;
-	return -EINVAL;
+	return 0;
 }
 
-static int wm8994_put_retune_mobile_enum(struct snd_kcontrol *kcontrol,
-					 struct snd_ctl_elem_value *ucontrol)
+static int wm8994_get_path(struct snd_kcontrol *kcontrol,
+			   struct snd_ctl_elem_value *ucontrol)
 {
 	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	struct wm8994_pdata *pdata = wm8994->pdata;
-	int block = wm8994_get_retune_mobile_block(kcontrol->id.name);
-	int value = ucontrol->value.integer.value[0];
-
-	if (block < 0)
-		return block;
 
-	if (value >= pdata->num_retune_mobile_cfgs)
-		return -EINVAL;
-
-	wm8994->retune_mobile_cfg[block] = value;
-
-	wm8994_set_retune_mobile(codec, block);
+	ucontrol->value.integer.value[0] = wm8994->cur_path;
 
 	return 0;
 }
 
-static int wm8994_get_retune_mobile_enum(struct snd_kcontrol *kcontrol,
-					 struct snd_ctl_elem_value *ucontrol)
+static int wm8994_set_path(struct snd_kcontrol *kcontrol,
+			   struct snd_ctl_elem_value *ucontrol)
 {
 	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	int block = wm8994_get_retune_mobile_block(kcontrol->id.name);
-
-	ucontrol->value.enumerated.item[0] = wm8994->retune_mobile_cfg[block];
+	int val;
+	int path_num = ucontrol->value.integer.value[0];
+
+	switch (path_num) {
+	case PLAYBACK_OFF:
+		DEBUG_LOG("Switching off output path\n");
+		break;
+	case RCV:
+	case SPK:
+	case HP:
+	case HP_NO_MIC:
+	case BT:
+	case SPK_HP:
+		DEBUG_LOG("routing to %s\n", mc->texts[path_num]);
+		wm8994->ringtone_active = OFF;
+		break;
+	case RING_SPK:
+	case RING_HP:
+	case RING_NO_MIC:
+		DEBUG_LOG("routing to %s\n", mc->texts[path_num]);
+		wm8994->ringtone_active = ON;
+		path_num -= 5;
+		break;
+	case RING_SPK_HP:
+		DEBUG_LOG("routing to %s\n", mc->texts[path_num]);
+		wm8994->ringtone_active = ON;
+		path_num -= 4;
+		break;
+	case EXTRA_DOCK_SPEAKER:
+	case TV_OUT:
+		DEBUG_LOG("routing to %s\n", mc->texts[path_num]);
+		wm8994->ringtone_active = OFF;
+		path_num -= 4;
+		break;
+	case HDMI_TV_OUT:
+	case HDMI_SPK:
+	case HDMI_DUAL:
+		DEBUG_LOG("routing to %s\n", mc->texts[path_num]);
+		wm8994->ringtone_active = OFF;
+		path_num -= 5;
+		break;
+	default:
+		DEBUG_LOG_ERR("audio path[%d] does not exists!!\n", path_num);
+		return -ENODEV;
+		break;
+	}
 
-	return 0;
-}
+	wm8994->codec_state |= PLAYBACK_ACTIVE;
 
-static const char *aif_chan_src_text[] = {
-	"Left", "Right"
-};
+	if (wm8994->codec_state & FMRADIO_ACTIVE) {
+		wm8994->codec_state &= ~(FMRADIO_ACTIVE);
+		wm8994->fmr_mix_path = FMR_MIX_OFF;
+		wm8994->fmradio_path = FMR_OFF;
+	}
 
-static const struct soc_enum aif1adcl_src =
-	SOC_ENUM_SINGLE(WM8994_AIF1_CONTROL_1, 15, 2, aif_chan_src_text);
+	if (wm8994->codec_state & CALL_ACTIVE) {
+		wm8994->codec_state &= ~(CALL_ACTIVE);
 
-static const struct soc_enum aif1adcr_src =
-	SOC_ENUM_SINGLE(WM8994_AIF1_CONTROL_1, 14, 2, aif_chan_src_text);
+		val = wm8994_read(codec, WM8994_CLOCKING_1);
+		val &= ~(WM8994_DSP_FS2CLK_ENA_MASK | WM8994_SYSCLK_SRC_MASK);
+		wm8994_write(codec, WM8994_CLOCKING_1, val);
+	}
 
-static const struct soc_enum aif2adcl_src =
-	SOC_ENUM_SINGLE(WM8994_AIF2_CONTROL_1, 15, 2, aif_chan_src_text);
 
-static const struct soc_enum aif2adcr_src =
-	SOC_ENUM_SINGLE(WM8994_AIF2_CONTROL_1, 14, 2, aif_chan_src_text);
+	if (wm8994->testmode_config_flag == SEC_TEST_PBA_DUAL_SPK &&
+		(path_num == HP || path_num == HP_NO_MIC)) {
+		DEBUG_LOG("SEC_TEST_PBA_DUAL_SPK : forced set path to SPK");
+		path_num = SPK;
+	}
 
-static const struct soc_enum aif1dacl_src =
-	SOC_ENUM_SINGLE(WM8994_AIF1_CONTROL_2, 15, 2, aif_chan_src_text);
+	wm8994->cur_path = path_num;
+	wm8994->universal_playback_path[wm8994->cur_path] (codec);
 
-static const struct soc_enum aif1dacr_src =
-	SOC_ENUM_SINGLE(WM8994_AIF1_CONTROL_2, 14, 2, aif_chan_src_text);
+	return 0;
+}
 
-static const struct soc_enum aif2dacl_src =
-	SOC_ENUM_SINGLE(WM8994_AIF2_CONTROL_2, 15, 2, aif_chan_src_text);
+static int wm8994_get_call_path(struct snd_kcontrol *kcontrol,
+	struct snd_ctl_elem_value *ucontrol)
+{
+	return 0;
+}
 
-static const struct soc_enum aif2dacr_src =
-	SOC_ENUM_SINGLE(WM8994_AIF2_CONTROL_2, 14, 2, aif_chan_src_text);
+static int wm8994_set_call_path(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+    struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+	struct soc_enum *mc = (struct soc_enum *)kcontrol->private_value;
 
-static const char *osr_text[] = {
-	"Low Power", "High Performance",
-};
+	// Get path value
+	int path_num = ucontrol->value.integer.value[0];
 
-static const struct soc_enum dac_osr =
-	SOC_ENUM_SINGLE(WM8994_OVERSAMPLING, 0, 2, osr_text);
+	if(strcmp( mc->texts[path_num], voicecall_path[path_num]) )
+	{
+		DEBUG_LOG_ERR("Unknown path %s", mc->texts[path_num] );
+		return -ENODEV;
+	}
 
-static const struct soc_enum adc_osr =
-	SOC_ENUM_SINGLE(WM8994_OVERSAMPLING, 1, 2, osr_text);
+	switch(path_num)
+	{
+		case PLAYBACK_OFF :
+			DEBUG_LOG("Switching off output path");
+			break;
 
-static const struct snd_kcontrol_new wm8994_snd_controls[] = {
-SOC_DOUBLE_R_TLV("AIF1ADC1 Volume", WM8994_AIF1_ADC1_LEFT_VOLUME,
-		 WM8994_AIF1_ADC1_RIGHT_VOLUME,
-		 1, 119, 0, digital_tlv),
-SOC_DOUBLE_R_TLV("AIF1ADC2 Volume", WM8994_AIF1_ADC2_LEFT_VOLUME,
-		 WM8994_AIF1_ADC2_RIGHT_VOLUME,
-		 1, 119, 0, digital_tlv),
-SOC_DOUBLE_R_TLV("AIF2ADC Volume", WM8994_AIF2_ADC_LEFT_VOLUME,
-		 WM8994_AIF2_ADC_RIGHT_VOLUME,
-		 1, 119, 0, digital_tlv),
-
-SOC_ENUM("AIF1ADCL Source", aif1adcl_src),
-SOC_ENUM("AIF1ADCR Source", aif1adcr_src),
-SOC_ENUM("AIF2ADCL Source", aif2adcl_src),
-SOC_ENUM("AIF2ADCR Source", aif2adcr_src),
-
-SOC_ENUM("AIF1DACL Source", aif1dacl_src),
-SOC_ENUM("AIF1DACR Source", aif1dacr_src),
-SOC_ENUM("AIF2DACL Source", aif2dacl_src),
-SOC_ENUM("AIF2DACR Source", aif2dacr_src),
-
-SOC_DOUBLE_R_TLV("AIF1DAC1 Volume", WM8994_AIF1_DAC1_LEFT_VOLUME,
-		 WM8994_AIF1_DAC1_RIGHT_VOLUME, 1, 96, 0, digital_tlv),
-SOC_DOUBLE_R_TLV("AIF1DAC2 Volume", WM8994_AIF1_DAC2_LEFT_VOLUME,
-		 WM8994_AIF1_DAC2_RIGHT_VOLUME, 1, 96, 0, digital_tlv),
-SOC_DOUBLE_R_TLV("AIF2DAC Volume", WM8994_AIF2_DAC_LEFT_VOLUME,
-		 WM8994_AIF2_DAC_RIGHT_VOLUME, 1, 96, 0, digital_tlv),
-
-SOC_SINGLE_TLV("AIF1 Boost Volume", WM8994_AIF1_CONTROL_2, 10, 3, 0, aif_tlv),
-SOC_SINGLE_TLV("AIF2 Boost Volume", WM8994_AIF2_CONTROL_2, 10, 3, 0, aif_tlv),
-
-SOC_SINGLE("AIF1DAC1 EQ Switch", WM8994_AIF1_DAC1_EQ_GAINS_1, 0, 1, 0),
-SOC_SINGLE("AIF1DAC2 EQ Switch", WM8994_AIF1_DAC2_EQ_GAINS_1, 0, 1, 0),
-SOC_SINGLE("AIF2 EQ Switch", WM8994_AIF2_EQ_GAINS_1, 0, 1, 0),
-
-WM8994_DRC_SWITCH("AIF1DAC1 DRC Switch", WM8994_AIF1_DRC1_1, 2),
-WM8994_DRC_SWITCH("AIF1ADC1L DRC Switch", WM8994_AIF1_DRC1_1, 1),
-WM8994_DRC_SWITCH("AIF1ADC1R DRC Switch", WM8994_AIF1_DRC1_1, 0),
-
-WM8994_DRC_SWITCH("AIF1DAC2 DRC Switch", WM8994_AIF1_DRC2_1, 2),
-WM8994_DRC_SWITCH("AIF1ADC2L DRC Switch", WM8994_AIF1_DRC2_1, 1),
-WM8994_DRC_SWITCH("AIF1ADC2R DRC Switch", WM8994_AIF1_DRC2_1, 0),
-
-WM8994_DRC_SWITCH("AIF2DAC DRC Switch", WM8994_AIF2_DRC_1, 2),
-WM8994_DRC_SWITCH("AIF2ADCL DRC Switch", WM8994_AIF2_DRC_1, 1),
-WM8994_DRC_SWITCH("AIF2ADCR DRC Switch", WM8994_AIF2_DRC_1, 0),
-
-SOC_SINGLE_TLV("DAC1 Right Sidetone Volume", WM8994_DAC1_MIXER_VOLUMES,
-	       5, 12, 0, st_tlv),
-SOC_SINGLE_TLV("DAC1 Left Sidetone Volume", WM8994_DAC1_MIXER_VOLUMES,
-	       0, 12, 0, st_tlv),
-SOC_SINGLE_TLV("DAC2 Right Sidetone Volume", WM8994_DAC2_MIXER_VOLUMES,
-	       5, 12, 0, st_tlv),
-SOC_SINGLE_TLV("DAC2 Left Sidetone Volume", WM8994_DAC2_MIXER_VOLUMES,
-	       0, 12, 0, st_tlv),
-SOC_ENUM("Sidetone HPF Mux", sidetone_hpf),
-SOC_SINGLE("Sidetone HPF Switch", WM8994_SIDETONE, 6, 1, 0),
-
-SOC_ENUM("AIF1ADC1 HPF Mode", aif1adc1_hpf),
-SOC_DOUBLE("AIF1ADC1 HPF Switch", WM8994_AIF1_ADC1_FILTERS, 12, 11, 1, 0),
-
-SOC_ENUM("AIF1ADC2 HPF Mode", aif1adc2_hpf),
-SOC_DOUBLE("AIF1ADC2 HPF Switch", WM8994_AIF1_ADC2_FILTERS, 12, 11, 1, 0),
-
-SOC_ENUM("AIF2ADC HPF Mode", aif2adc_hpf),
-SOC_DOUBLE("AIF2ADC HPF Switch", WM8994_AIF2_ADC_FILTERS, 12, 11, 1, 0),
-
-SOC_ENUM("ADC OSR", adc_osr),
-SOC_ENUM("DAC OSR", dac_osr),
-
-SOC_DOUBLE_R_TLV("DAC1 Volume", WM8994_DAC1_LEFT_VOLUME,
-		 WM8994_DAC1_RIGHT_VOLUME, 1, 96, 0, digital_tlv),
-SOC_DOUBLE_R("DAC1 Switch", WM8994_DAC1_LEFT_VOLUME,
-	     WM8994_DAC1_RIGHT_VOLUME, 9, 1, 1),
-
-SOC_DOUBLE_R_TLV("DAC2 Volume", WM8994_DAC2_LEFT_VOLUME,
-		 WM8994_DAC2_RIGHT_VOLUME, 1, 96, 0, digital_tlv),
-SOC_DOUBLE_R("DAC2 Switch", WM8994_DAC2_LEFT_VOLUME,
-	     WM8994_DAC2_RIGHT_VOLUME, 9, 1, 1),
-
-SOC_SINGLE_TLV("SPKL DAC2 Volume", WM8994_SPKMIXL_ATTENUATION,
-	       6, 1, 1, wm_hubs_spkmix_tlv),
-SOC_SINGLE_TLV("SPKL DAC1 Volume", WM8994_SPKMIXL_ATTENUATION,
-	       2, 1, 1, wm_hubs_spkmix_tlv),
-
-SOC_SINGLE_TLV("SPKR DAC2 Volume", WM8994_SPKMIXR_ATTENUATION,
-	       6, 1, 1, wm_hubs_spkmix_tlv),
-SOC_SINGLE_TLV("SPKR DAC1 Volume", WM8994_SPKMIXR_ATTENUATION,
-	       2, 1, 1, wm_hubs_spkmix_tlv),
-
-SOC_SINGLE_TLV("AIF1DAC1 3D Stereo Volume", WM8994_AIF1_DAC1_FILTERS_2,
-	       10, 15, 0, wm8994_3d_tlv),
-SOC_SINGLE("AIF1DAC1 3D Stereo Switch", WM8994_AIF1_DAC1_FILTERS_2,
-	   8, 1, 0),
-SOC_SINGLE_TLV("AIF1DAC2 3D Stereo Volume", WM8994_AIF1_DAC2_FILTERS_2,
-	       10, 15, 0, wm8994_3d_tlv),
-SOC_SINGLE("AIF1DAC2 3D Stereo Switch", WM8994_AIF1_DAC2_FILTERS_2,
-	   8, 1, 0),
-SOC_SINGLE_TLV("AIF2DAC 3D Stereo Volume", WM8994_AIF2_DAC_FILTERS_2,
-	       10, 15, 0, wm8994_3d_tlv),
-SOC_SINGLE("AIF2DAC 3D Stereo Switch", WM8994_AIF2_DAC_FILTERS_2,
-	   8, 1, 0),
-};
+		case SPK :
+		case RCV :
+		case HP:
+		case HP_NO_MIC:
+		case BT :
+			DEBUG_LOG("routing  voice path to %s", mc->texts[path_num] );
+			break;
 
-static const struct snd_kcontrol_new wm8994_eq_controls[] = {
-SOC_SINGLE_TLV("AIF1DAC1 EQ1 Volume", WM8994_AIF1_DAC1_EQ_GAINS_1, 11, 31, 0,
-	       eq_tlv),
-SOC_SINGLE_TLV("AIF1DAC1 EQ2 Volume", WM8994_AIF1_DAC1_EQ_GAINS_1, 6, 31, 0,
-	       eq_tlv),
-SOC_SINGLE_TLV("AIF1DAC1 EQ3 Volume", WM8994_AIF1_DAC1_EQ_GAINS_1, 1, 31, 0,
-	       eq_tlv),
-SOC_SINGLE_TLV("AIF1DAC1 EQ4 Volume", WM8994_AIF1_DAC1_EQ_GAINS_2, 11, 31, 0,
-	       eq_tlv),
-SOC_SINGLE_TLV("AIF1DAC1 EQ5 Volume", WM8994_AIF1_DAC1_EQ_GAINS_2, 6, 31, 0,
-	       eq_tlv),
-
-SOC_SINGLE_TLV("AIF1DAC2 EQ1 Volume", WM8994_AIF1_DAC2_EQ_GAINS_1, 11, 31, 0,
-	       eq_tlv),
-SOC_SINGLE_TLV("AIF1DAC2 EQ2 Volume", WM8994_AIF1_DAC2_EQ_GAINS_1, 6, 31, 0,
-	       eq_tlv),
-SOC_SINGLE_TLV("AIF1DAC2 EQ3 Volume", WM8994_AIF1_DAC2_EQ_GAINS_1, 1, 31, 0,
-	       eq_tlv),
-SOC_SINGLE_TLV("AIF1DAC2 EQ4 Volume", WM8994_AIF1_DAC2_EQ_GAINS_2, 11, 31, 0,
-	       eq_tlv),
-SOC_SINGLE_TLV("AIF1DAC2 EQ5 Volume", WM8994_AIF1_DAC2_EQ_GAINS_2, 6, 31, 0,
-	       eq_tlv),
-
-SOC_SINGLE_TLV("AIF2 EQ1 Volume", WM8994_AIF2_EQ_GAINS_1, 11, 31, 0,
-	       eq_tlv),
-SOC_SINGLE_TLV("AIF2 EQ2 Volume", WM8994_AIF2_EQ_GAINS_1, 6, 31, 0,
-	       eq_tlv),
-SOC_SINGLE_TLV("AIF2 EQ3 Volume", WM8994_AIF2_EQ_GAINS_1, 1, 31, 0,
-	       eq_tlv),
-SOC_SINGLE_TLV("AIF2 EQ4 Volume", WM8994_AIF2_EQ_GAINS_2, 11, 31, 0,
-	       eq_tlv),
-SOC_SINGLE_TLV("AIF2 EQ5 Volume", WM8994_AIF2_EQ_GAINS_2, 6, 31, 0,
-	       eq_tlv),
-};
+		default:
+			DEBUG_LOG_ERR("The audio path[%d] does not exists!!", path_num);
+			return -ENODEV;
+			break;
+	}
 
-static const struct snd_kcontrol_new wm8958_snd_controls[] = {
-SOC_SINGLE_TLV("AIF3 Boost Volume", WM8958_AIF3_CONTROL_2, 10, 3, 0, aif_tlv),
-};
+	if(wm8994->cur_path != path_num || !(wm8994->codec_state & CALL_ACTIVE))
+	{
+		wm8994->codec_state |= CALL_ACTIVE;
+		wm8994->cur_path = path_num;
+		wm8994->universal_voicecall_path[wm8994->cur_path](codec);
+	}
+	else
+	{
+		int val;
 
-static int clk_sys_event(struct snd_soc_dapm_widget *w,
-			 struct snd_kcontrol *kcontrol, int event)
-{
-	struct snd_soc_codec *codec = w->codec;
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_FILTERS_1);
+		val &= ~(WM8994_AIF1DAC1_MUTE_MASK);
+		val |= (WM8994_AIF1DAC1_UNMUTE);
+		wm8994_write(codec, WM8994_AIF1_DAC1_FILTERS_1, val);
+	}
 
-	switch (event) {
-	case SND_SOC_DAPM_PRE_PMU:
-		return configure_clock(codec);
+	return 0;
+}
 
-	case SND_SOC_DAPM_POST_PMD:
-		configure_clock(codec);
-		break;
-	}
 
+static int wm8994_get_fmradio_path(struct snd_kcontrol *kcontrol,
+	struct snd_ctl_elem_value *ucontrol)
+{
 	return 0;
 }
 
-static void wm8994_update_class_w(struct snd_soc_codec *codec)
+static int wm8994_set_fmradio_path(struct snd_kcontrol *kcontrol,
+	struct snd_ctl_elem_value *ucontrol)
 {
+	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+	struct soc_enum *mc = (struct soc_enum *)kcontrol->private_value;
 	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	int enable = 1;
-	int source = 0;  /* GCC flow analysis can't track enable */
-	int reg, reg_r;
-
-	/* Only support direct DAC->headphone paths */
-	reg = snd_soc_read(codec, WM8994_OUTPUT_MIXER_1);
-	if (!(reg & WM8994_DAC1L_TO_HPOUT1L)) {
-		dev_vdbg(codec->dev, "HPL connected to output mixer\n");
-		enable = 0;
-	}
 
-	reg = snd_soc_read(codec, WM8994_OUTPUT_MIXER_2);
-	if (!(reg & WM8994_DAC1R_TO_HPOUT1R)) {
-		dev_vdbg(codec->dev, "HPR connected to output mixer\n");
-		enable = 0;
+	int path_num = ucontrol->value.integer.value[0];
+
+	if (strcmp(mc->texts[path_num], fmradio_path[path_num]))
+		DEBUG_LOG("Unknown path %s\n", mc->texts[path_num]);
+
+	if (path_num == wm8994->fmradio_path) {
+		int val;
+
+		DEBUG_LOG("%s is already set. skip to set path..\n",
+			mc->texts[path_num]);
+
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_FILTERS_1);
+		val &= ~(WM8994_AIF1DAC1_MUTE_MASK);
+		val |= (WM8994_AIF1DAC1_UNMUTE);
+		wm8994_write(codec, WM8994_AIF1_DAC1_FILTERS_1, val);
+
+		return 0;
 	}
 
-	/* We also need the same setting for L/R and only one path */
-	reg = snd_soc_read(codec, WM8994_DAC1_LEFT_MIXER_ROUTING);
-	switch (reg) {
-	case WM8994_AIF2DACL_TO_DAC1L:
-		dev_vdbg(codec->dev, "Class W source AIF2DAC\n");
-		source = 2 << WM8994_CP_DYN_SRC_SEL_SHIFT;
-		break;
-	case WM8994_AIF1DAC2L_TO_DAC1L:
-		dev_vdbg(codec->dev, "Class W source AIF1DAC2\n");
-		source = 1 << WM8994_CP_DYN_SRC_SEL_SHIFT;
+	wm8994->codec_state |= FMRADIO_ACTIVE;
+
+	switch (path_num) {
+	case FMR_OFF:
+		DEBUG_LOG("Switching off output path");
+		wm8994_disable_fmradio_path(codec);
 		break;
-	case WM8994_AIF1DAC1L_TO_DAC1L:
-		dev_vdbg(codec->dev, "Class W source AIF1DAC1\n");
-		source = 0 << WM8994_CP_DYN_SRC_SEL_SHIFT;
+	case FMR_SPK:
+		DEBUG_LOG("routing  fmradio path to %s", mc->texts[path_num] );
+		wm8994->fmr_mix_path = FMR_MIX_OFF;
+		wm8994_set_fmradio_speaker(codec);
 		break;
-	default:
-		dev_vdbg(codec->dev, "DAC mixer setting: %x\n", reg);
-		enable = 0;
+	case FMR_HP:
+		DEBUG_LOG("routing fmradio path to %s\n", mc->texts[path_num]);
+		wm8994->fmr_mix_path = FMR_MIX_OFF;
+		wm8994_set_fmradio_headset(codec);
 		break;
-	}
 
-	reg_r = snd_soc_read(codec, WM8994_DAC1_RIGHT_MIXER_ROUTING);
-	if (reg_r != reg) {
-		dev_vdbg(codec->dev, "Left and right DAC mixers different\n");
-		enable = 0;
-	}
+	case FMR_SPK_MIX:
+		DEBUG_LOG("routing  fmradio path to %s", mc->texts[path_num]);
 
-	if (enable) {
-		dev_dbg(codec->dev, "Class W enabled\n");
-		snd_soc_update_bits(codec, WM8994_CLASS_W_1,
-				    WM8994_CP_DYN_PWR |
-				    WM8994_CP_DYN_SRC_SEL_MASK,
-				    source | WM8994_CP_DYN_PWR);
-		wm8994->hubs.class_w = true;
-		
-	} else {
-		dev_dbg(codec->dev, "Class W disabled\n");
-		snd_soc_update_bits(codec, WM8994_CLASS_W_1,
-				    WM8994_CP_DYN_PWR, 0);
-		wm8994->hubs.class_w = false;
-	}
-}
-
-static int late_enable_ev(struct snd_soc_dapm_widget *w,
-			  struct snd_kcontrol *kcontrol, int event)
-{
-	struct snd_soc_codec *codec = w->codec;
-	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-
-	switch (event) {
-	case SND_SOC_DAPM_PRE_PMU:
-		if (wm8994->aif1clk_enable) {
-			snd_soc_update_bits(codec, WM8994_AIF1_CLOCKING_1,
-					    WM8994_AIF1CLK_ENA_MASK,
-					    WM8994_AIF1CLK_ENA);
-			wm8994->aif1clk_enable = 0;
-		}
-		if (wm8994->aif2clk_enable) {
-			snd_soc_update_bits(codec, WM8994_AIF2_CLOCKING_1,
-					    WM8994_AIF2CLK_ENA_MASK,
-					    WM8994_AIF2CLK_ENA);
-			wm8994->aif2clk_enable = 0;
+		if (wm8994->fmr_mix_path != FMR_MIX_SPK) {
+			wm8994->fmr_mix_path = FMR_MIX_SPK;
+			wm8994_set_fmradio_speaker_mix(codec);
+		} else {
+			wm8994_write(codec,WM8994_AIF1_DAC1_FILTERS_1, WM8994_AIF1DAC1_UNMUTE);
+			DEBUG_LOG("FMR_MIX_SPK is already set!!! Skip path!!");
 		}
 		break;
-	}
 
-	/* We may also have postponed startup of DSP, handle that. */
-	wm8958_aif_ev(w, kcontrol, event);
+	case FMR_HP_MIX:
+		DEBUG_LOG("routing  fmradio path to %s", mc->texts[path_num]);
 
-	return 0;
-}
+		if (wm8994->fmr_mix_path != FMR_MIX_HP) {
+			wm8994->fmr_mix_path = FMR_MIX_HP;
+			wm8994_set_fmradio_headset_mix(codec);
+		} else {
+			wm8994_write(codec,WM8994_AIF1_DAC1_FILTERS_1, WM8994_AIF1DAC1_UNMUTE);
+			DEBUG_LOG("FMR_MIX_HP is already set!!! Skip path!!");
+		}
+		break;
 
-static int late_disable_ev(struct snd_soc_dapm_widget *w,
-			   struct snd_kcontrol *kcontrol, int event)
-{
-	struct snd_soc_codec *codec = w->codec;
-	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+	case FMR_DUAL_MIX :
+		DEBUG_LOG("routing  fmradio path to  %s\n", mc->texts[path_num]);
+		wm8994->fmr_mix_path = FMR_DUAL_MIX;
+		wm8994_set_fmradio_speaker_headset_mix(codec);
+		break;
 
-	switch (event) {
-	case SND_SOC_DAPM_POST_PMD:
-		if (wm8994->aif1clk_disable) {
-			snd_soc_update_bits(codec, WM8994_AIF1_CLOCKING_1,
-					    WM8994_AIF1CLK_ENA_MASK, 0);
-			wm8994->aif1clk_disable = 0;
-		}
-		if (wm8994->aif2clk_disable) {
-			snd_soc_update_bits(codec, WM8994_AIF2_CLOCKING_1,
-					    WM8994_AIF2CLK_ENA_MASK, 0);
-			wm8994->aif2clk_disable = 0;
-		}
+	default:
+		DEBUG_LOG("The audio path[%d] does not exists!!\n",path_num);
+		return -ENODEV;
 		break;
 	}
 
 	return 0;
 }
 
-static int aif1clk_ev(struct snd_soc_dapm_widget *w,
-		      struct snd_kcontrol *kcontrol, int event)
+static int wm8994_get_codec_tuning(struct snd_kcontrol *kcontrol,
+	struct snd_ctl_elem_value *ucontrol)
 {
-	struct snd_soc_codec *codec = w->codec;
+	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
 
-	switch (event) {
-	case SND_SOC_DAPM_PRE_PMU:
-		wm8994->aif1clk_enable = 1;
-		break;
-	case SND_SOC_DAPM_POST_PMD:
-		wm8994->aif1clk_disable = 1;
-		break;
-	}
+	DEBUG_LOG("Get testmode_config_flag = [%d]", wm8994->testmode_config_flag);
+	ucontrol->value.integer.value[0] = wm8994->testmode_config_flag;
 
 	return 0;
 }
 
-static int aif2clk_ev(struct snd_soc_dapm_widget *w,
-		      struct snd_kcontrol *kcontrol, int event)
+static int wm8994_set_codec_tuning(struct snd_kcontrol *kcontrol,
+	struct snd_ctl_elem_value *ucontrol)
 {
-	struct snd_soc_codec *codec = w->codec;
+	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
 
-	switch (event) {
-	case SND_SOC_DAPM_PRE_PMU:
-		wm8994->aif2clk_enable = 1;
-		break;
-	case SND_SOC_DAPM_POST_PMD:
-		wm8994->aif2clk_disable = 1;
-		break;
-	}
+	int control_flag = ucontrol->value.integer.value[0];
 
-	return 0;
-}
+	DEBUG_LOG("Set testmode_config_flag =[%d]", control_flag);
 
-static int adc_mux_ev(struct snd_soc_dapm_widget *w,
-		      struct snd_kcontrol *kcontrol, int event)
-{
-	late_enable_ev(w, kcontrol, event);
-	return 0;
-}
+	wm8994->testmode_config_flag = control_flag;
 
-static int micbias_ev(struct snd_soc_dapm_widget *w,
-		      struct snd_kcontrol *kcontrol, int event)
-{
-	late_enable_ev(w, kcontrol, event);
 	return 0;
 }
 
-static int dac_ev(struct snd_soc_dapm_widget *w,
-		  struct snd_kcontrol *kcontrol, int event)
+static int wm8994_get_codec_status(struct snd_kcontrol *kcontrol,
+	struct snd_ctl_elem_value *ucontrol)
 {
-	struct snd_soc_codec *codec = w->codec;
-	unsigned int mask = 1 << w->shift;
-
-	snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_5,
-			    mask, mask);
 	return 0;
 }
 
-static const char *hp_mux_text[] = {
-	"Mixer",
-	"DAC",
-};
-
-#define WM8994_HP_ENUM(xname, xenum) \
-{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
-	.info = snd_soc_info_enum_double, \
- 	.get = snd_soc_dapm_get_enum_double, \
- 	.put = wm8994_put_hp_enum, \
-  	.private_value = (unsigned long)&xenum }
+static void wm8994_shutdown_codec(struct snd_pcm_substream *substream, struct snd_soc_codec *codec);
 
-static int wm8994_put_hp_enum(struct snd_kcontrol *kcontrol,
-			      struct snd_ctl_elem_value *ucontrol)
+static int wm8994_set_codec_status(struct snd_kcontrol *kcontrol,
+	struct snd_ctl_elem_value *ucontrol)
 {
-	struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
-	struct snd_soc_dapm_widget *w = wlist->widgets[0];
-	struct snd_soc_codec *codec = w->codec;
-	int ret;
-
-	ret = snd_soc_dapm_put_enum_double(kcontrol, ucontrol);
-
-	wm8994_update_class_w(codec);
-
-	return ret;
-}
+	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+	struct snd_pcm_substream tempstream;
 
-static const struct soc_enum hpl_enum =
-	SOC_ENUM_SINGLE(WM8994_OUTPUT_MIXER_1, 8, 2, hp_mux_text);
+	int control_data = ucontrol->value.integer.value[0];
 
-static const struct snd_kcontrol_new hpl_mux =
-	WM8994_HP_ENUM("Left Headphone Mux", hpl_enum);
+	DEBUG_LOG("Received control_data = [0x%X]", control_data);
 
-static const struct soc_enum hpr_enum =
-	SOC_ENUM_SINGLE(WM8994_OUTPUT_MIXER_2, 8, 2, hp_mux_text);
+	switch (control_data) {
+	/* FM Radio Volume zero control */
+	case CMD_FMR_INPUT_DEACTIVE:
+	case CMD_FMR_INPUT_ACTIVE:
+		if(wm8994->codec_state & FMRADIO_ACTIVE)
+			wm8994_set_fmradio_common(codec, control_data);
+		break;
 
-static const struct snd_kcontrol_new hpr_mux =
-	WM8994_HP_ENUM("Right Headphone Mux", hpr_enum);
+	/* To remove pop up noise for FM radio */
+	case CMD_FMR_FLAG_CLEAR:
+		DEBUG_LOG("FM Radio Flag is clear!!");
+		wm8994->codec_state &= ~(FMRADIO_ACTIVE);
+		break;
 
-static const char *adc_mux_text[] = {
-	"ADC",
-	"DMIC",
-};
+	case CMD_FMR_END:
+		DEBUG_LOG("Call shutdown function forcely for FM radio!!");
+		wm8994->codec_state &= ~(FMRADIO_ACTIVE);
+		tempstream.stream = SNDRV_PCM_STREAM_PLAYBACK;
+		wm8994_shutdown_codec(&tempstream, codec);
+		break;
 
-static const struct soc_enum adc_enum =
-	SOC_ENUM_SINGLE(0, 0, 2, adc_mux_text);
+	/* For voice recognition. */
+	case CMD_RECOGNITION_DEACTIVE :
+		DEBUG_LOG("Recognition Gain is deactivated!!");
+		wm8994->recognition_active = REC_OFF;
+		break;
 
-static const struct snd_kcontrol_new adcl_mux =
-	SOC_DAPM_ENUM_VIRT("ADCL Mux", adc_enum);
+	case CMD_RECOGNITION_ACTIVE :
+		DEBUG_LOG("Recognition Gain is activated!!");
+		wm8994->recognition_active = REC_ON;
+		break;
 
-static const struct snd_kcontrol_new adcr_mux =
-	SOC_DAPM_ENUM_VIRT("ADCR Mux", adc_enum);
+	/* To remove pop up noise for Call. */
+	case CMD_CALL_FLAG_CLEAR:
+		DEBUG_LOG("Call Flag is clear!!");
+		wm8994->codec_state &= ~(CALL_ACTIVE);
+		break;
 
-static const struct snd_kcontrol_new left_speaker_mixer[] = {
-SOC_DAPM_SINGLE("DAC2 Switch", WM8994_SPEAKER_MIXER, 9, 1, 0),
-SOC_DAPM_SINGLE("Input Switch", WM8994_SPEAKER_MIXER, 7, 1, 0),
-SOC_DAPM_SINGLE("IN1LP Switch", WM8994_SPEAKER_MIXER, 5, 1, 0),
-SOC_DAPM_SINGLE("Output Switch", WM8994_SPEAKER_MIXER, 3, 1, 0),
-SOC_DAPM_SINGLE("DAC1 Switch", WM8994_SPEAKER_MIXER, 1, 1, 0),
-};
+	case CMD_CALL_END:
+		DEBUG_LOG("Call shutdown function forcely for call!!");
+		wm8994->codec_state &= ~(CALL_ACTIVE);
+		tempstream.stream = SNDRV_PCM_STREAM_PLAYBACK;
+		wm8994_shutdown_codec(&tempstream, codec);
+		break;
 
-static const struct snd_kcontrol_new right_speaker_mixer[] = {
-SOC_DAPM_SINGLE("DAC2 Switch", WM8994_SPEAKER_MIXER, 8, 1, 0),
-SOC_DAPM_SINGLE("Input Switch", WM8994_SPEAKER_MIXER, 6, 1, 0),
-SOC_DAPM_SINGLE("IN1RP Switch", WM8994_SPEAKER_MIXER, 4, 1, 0),
-SOC_DAPM_SINGLE("Output Switch", WM8994_SPEAKER_MIXER, 2, 1, 0),
-SOC_DAPM_SINGLE("DAC1 Switch", WM8994_SPEAKER_MIXER, 0, 1, 0),
-};
+	default:
+		break;
+	}
 
-/* Debugging; dump chip status after DAPM transitions */
-static int post_ev(struct snd_soc_dapm_widget *w,
-	    struct snd_kcontrol *kcontrol, int event)
-{
-	struct snd_soc_codec *codec = w->codec;
-	dev_dbg(codec->dev, "SRC status: %x\n",
-		snd_soc_read(codec,
-			     WM8994_RATE_STATUS));
 	return 0;
 }
 
-static const struct snd_kcontrol_new aif1adc1l_mix[] = {
-SOC_DAPM_SINGLE("ADC/DMIC Switch", WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING,
-		1, 1, 0),
-SOC_DAPM_SINGLE("AIF2 Switch", WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING,
-		0, 1, 0),
-};
-
-static const struct snd_kcontrol_new aif1adc1r_mix[] = {
-SOC_DAPM_SINGLE("ADC/DMIC Switch", WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING,
-		1, 1, 0),
-SOC_DAPM_SINGLE("AIF2 Switch", WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING,
-		0, 1, 0),
-};
-
-static const struct snd_kcontrol_new aif1adc2l_mix[] = {
-SOC_DAPM_SINGLE("DMIC Switch", WM8994_AIF1_ADC2_LEFT_MIXER_ROUTING,
-		1, 1, 0),
-SOC_DAPM_SINGLE("AIF2 Switch", WM8994_AIF1_ADC2_LEFT_MIXER_ROUTING,
-		0, 1, 0),
-};
-
-static const struct snd_kcontrol_new aif1adc2r_mix[] = {
-SOC_DAPM_SINGLE("DMIC Switch", WM8994_AIF1_ADC2_RIGHT_MIXER_ROUTING,
-		1, 1, 0),
-SOC_DAPM_SINGLE("AIF2 Switch", WM8994_AIF1_ADC2_RIGHT_MIXER_ROUTING,
-		0, 1, 0),
-};
-
-static const struct snd_kcontrol_new aif2dac2l_mix[] = {
-SOC_DAPM_SINGLE("Right Sidetone Switch", WM8994_DAC2_LEFT_MIXER_ROUTING,
-		5, 1, 0),
-SOC_DAPM_SINGLE("Left Sidetone Switch", WM8994_DAC2_LEFT_MIXER_ROUTING,
-		4, 1, 0),
-SOC_DAPM_SINGLE("AIF2 Switch", WM8994_DAC2_LEFT_MIXER_ROUTING,
-		2, 1, 0),
-SOC_DAPM_SINGLE("AIF1.2 Switch", WM8994_DAC2_LEFT_MIXER_ROUTING,
-		1, 1, 0),
-SOC_DAPM_SINGLE("AIF1.1 Switch", WM8994_DAC2_LEFT_MIXER_ROUTING,
-		0, 1, 0),
-};
-
-static const struct snd_kcontrol_new aif2dac2r_mix[] = {
-SOC_DAPM_SINGLE("Right Sidetone Switch", WM8994_DAC2_RIGHT_MIXER_ROUTING,
-		5, 1, 0),
-SOC_DAPM_SINGLE("Left Sidetone Switch", WM8994_DAC2_RIGHT_MIXER_ROUTING,
-		4, 1, 0),
-SOC_DAPM_SINGLE("AIF2 Switch", WM8994_DAC2_RIGHT_MIXER_ROUTING,
-		2, 1, 0),
-SOC_DAPM_SINGLE("AIF1.2 Switch", WM8994_DAC2_RIGHT_MIXER_ROUTING,
-		1, 1, 0),
-SOC_DAPM_SINGLE("AIF1.1 Switch", WM8994_DAC2_RIGHT_MIXER_ROUTING,
-		0, 1, 0),
-};
-
-#define WM8994_CLASS_W_SWITCH(xname, reg, shift, max, invert) \
-{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
-	.info = snd_soc_info_volsw, \
-	.get = snd_soc_dapm_get_volsw, .put = wm8994_put_class_w, \
-	.private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }
-
-static int wm8994_put_class_w(struct snd_kcontrol *kcontrol,
-			      struct snd_ctl_elem_value *ucontrol)
+static int wm8994_get_voice_recording_ch(struct snd_kcontrol *kcontrol,
+	struct snd_ctl_elem_value *ucontrol)
 {
-	struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
-	struct snd_soc_dapm_widget *w = wlist->widgets[0];
-	struct snd_soc_codec *codec = w->codec;
-	int ret;
-
-	ret = snd_soc_dapm_put_volsw(kcontrol, ucontrol);
-
-	wm8994_update_class_w(codec);
-
-	return ret;
+	return 0;
 }
 
-static const struct snd_kcontrol_new dac1l_mix[] = {
-WM8994_CLASS_W_SWITCH("Right Sidetone Switch", WM8994_DAC1_LEFT_MIXER_ROUTING,
-		      5, 1, 0),
-WM8994_CLASS_W_SWITCH("Left Sidetone Switch", WM8994_DAC1_LEFT_MIXER_ROUTING,
-		      4, 1, 0),
-WM8994_CLASS_W_SWITCH("AIF2 Switch", WM8994_DAC1_LEFT_MIXER_ROUTING,
-		      2, 1, 0),
-WM8994_CLASS_W_SWITCH("AIF1.2 Switch", WM8994_DAC1_LEFT_MIXER_ROUTING,
-		      1, 1, 0),
-WM8994_CLASS_W_SWITCH("AIF1.1 Switch", WM8994_DAC1_LEFT_MIXER_ROUTING,
-		      0, 1, 0),
-};
-
-static const struct snd_kcontrol_new dac1r_mix[] = {
-WM8994_CLASS_W_SWITCH("Right Sidetone Switch", WM8994_DAC1_RIGHT_MIXER_ROUTING,
-		      5, 1, 0),
-WM8994_CLASS_W_SWITCH("Left Sidetone Switch", WM8994_DAC1_RIGHT_MIXER_ROUTING,
-		      4, 1, 0),
-WM8994_CLASS_W_SWITCH("AIF2 Switch", WM8994_DAC1_RIGHT_MIXER_ROUTING,
-		      2, 1, 0),
-WM8994_CLASS_W_SWITCH("AIF1.2 Switch", WM8994_DAC1_RIGHT_MIXER_ROUTING,
-		      1, 1, 0),
-WM8994_CLASS_W_SWITCH("AIF1.1 Switch", WM8994_DAC1_RIGHT_MIXER_ROUTING,
-		      0, 1, 0),
-};
-
-static const char *sidetone_text[] = {
-	"ADC/DMIC1", "DMIC2",
-};
-
-static const struct soc_enum sidetone1_enum =
-	SOC_ENUM_SINGLE(WM8994_SIDETONE, 0, 2, sidetone_text);
-
-static const struct snd_kcontrol_new sidetone1_mux =
-	SOC_DAPM_ENUM("Left Sidetone Mux", sidetone1_enum);
-
-static const struct soc_enum sidetone2_enum =
-	SOC_ENUM_SINGLE(WM8994_SIDETONE, 1, 2, sidetone_text);
-
-static const struct snd_kcontrol_new sidetone2_mux =
-	SOC_DAPM_ENUM("Right Sidetone Mux", sidetone2_enum);
-
-static const char *aif1dac_text[] = {
-	"AIF1DACDAT", "AIF3DACDAT",
-};
-
-static const struct soc_enum aif1dac_enum =
-	SOC_ENUM_SINGLE(WM8994_POWER_MANAGEMENT_6, 0, 2, aif1dac_text);
-
-static const struct snd_kcontrol_new aif1dac_mux =
-	SOC_DAPM_ENUM("AIF1DAC Mux", aif1dac_enum);
-
-static const char *aif2dac_text[] = {
-	"AIF2DACDAT", "AIF3DACDAT",
-};
-
-static const struct soc_enum aif2dac_enum =
-	SOC_ENUM_SINGLE(WM8994_POWER_MANAGEMENT_6, 1, 2, aif2dac_text);
-
-static const struct snd_kcontrol_new aif2dac_mux =
-	SOC_DAPM_ENUM("AIF2DAC Mux", aif2dac_enum);
-
-static const char *aif2adc_text[] = {
-	"AIF2ADCDAT", "AIF3DACDAT",
-};
-
-static const struct soc_enum aif2adc_enum =
-	SOC_ENUM_SINGLE(WM8994_POWER_MANAGEMENT_6, 2, 2, aif2adc_text);
-
-static const struct snd_kcontrol_new aif2adc_mux =
-	SOC_DAPM_ENUM("AIF2ADC Mux", aif2adc_enum);
-
-static const char *aif3adc_text[] = {
-	"AIF1ADCDAT", "AIF2ADCDAT", "AIF2DACDAT", "Mono PCM",
-};
-
-static const struct soc_enum wm8994_aif3adc_enum =
-	SOC_ENUM_SINGLE(WM8994_POWER_MANAGEMENT_6, 3, 3, aif3adc_text);
+static int wm8994_set_voice_recording_ch(struct snd_kcontrol *kcontrol,
+	struct snd_ctl_elem_value *ucontrol)
+{
+	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
 
-static const struct snd_kcontrol_new wm8994_aif3adc_mux =
-	SOC_DAPM_ENUM("AIF3ADC Mux", wm8994_aif3adc_enum);
 
-static const struct soc_enum wm8958_aif3adc_enum =
-	SOC_ENUM_SINGLE(WM8994_POWER_MANAGEMENT_6, 3, 4, aif3adc_text);
+	int channel = ucontrol->value.integer.value[0];
 
-static const struct snd_kcontrol_new wm8958_aif3adc_mux =
-	SOC_DAPM_ENUM("AIF3ADC Mux", wm8958_aif3adc_enum);
+	wm8994 ->call_record_ch = channel;
 
-static const char *mono_pcm_out_text[] = {
-	"None", "AIF2ADCL", "AIF2ADCR", 
-};
+	DEBUG_LOG("control_data = [0x%X]", channel);
 
-static const struct soc_enum mono_pcm_out_enum =
-	SOC_ENUM_SINGLE(WM8994_POWER_MANAGEMENT_6, 9, 3, mono_pcm_out_text);
 
-static const struct snd_kcontrol_new mono_pcm_out_mux =
-	SOC_DAPM_ENUM("Mono PCM Out Mux", mono_pcm_out_enum);
+	switch (channel) {
+	case CH_OFF:
+		wm8994 ->call_record_path = CALL_RECORDING_OFF;
+		wm8994_set_voicecall_record_off(codec);
+		break;
+	case CH_UPLINK:
+	case CH_DOWNLINK:
+	case CH_UDLINK:
+		break;
 
-static const char *aif2dac_src_text[] = {
-	"AIF2", "AIF3",
-};
+	default :
+		break;
+	}
 
-/* Note that these two control shouldn't be simultaneously switched to AIF3 */
-static const struct soc_enum aif2dacl_src_enum =
-	SOC_ENUM_SINGLE(WM8994_POWER_MANAGEMENT_6, 7, 2, aif2dac_src_text);
+	return 0;
+}
 
-static const struct snd_kcontrol_new aif2dacl_src_mux =
-	SOC_DAPM_ENUM("AIF2DACL Mux", aif2dacl_src_enum);
+static int wm8994_get_voice_call_recording(struct snd_kcontrol *kcontrol,
+				 struct snd_ctl_elem_value *ucontrol)
+{
+	return 0;
+}
 
-static const struct soc_enum aif2dacr_src_enum =
-	SOC_ENUM_SINGLE(WM8994_POWER_MANAGEMENT_6, 8, 2, aif2dac_src_text);
+static int wm8994_set_voice_call_recording(struct snd_kcontrol *kcontrol,
+				 struct snd_ctl_elem_value *ucontrol)
+{
+	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
 
-static const struct snd_kcontrol_new aif2dacr_src_mux =
-	SOC_DAPM_ENUM("AIF2DACR Mux", aif2dacr_src_enum);
+	int path_num = ucontrol->value.integer.value[0];
 
-static const struct snd_soc_dapm_widget wm8994_lateclk_revd_widgets[] = {
-SND_SOC_DAPM_SUPPLY("AIF1CLK", SND_SOC_NOPM, 0, 0, aif1clk_ev,
-	SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
-SND_SOC_DAPM_SUPPLY("AIF2CLK", SND_SOC_NOPM, 0, 0, aif2clk_ev,
-	SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
+	DEBUG_LOG("control_data = [0x%X]", path_num);
 
-SND_SOC_DAPM_PGA_E("Late DAC1L Enable PGA", SND_SOC_NOPM, 0, 0, NULL, 0,
-	late_enable_ev, SND_SOC_DAPM_PRE_PMU),
-SND_SOC_DAPM_PGA_E("Late DAC1R Enable PGA", SND_SOC_NOPM, 0, 0, NULL, 0,
-	late_enable_ev, SND_SOC_DAPM_PRE_PMU),
-SND_SOC_DAPM_PGA_E("Late DAC2L Enable PGA", SND_SOC_NOPM, 0, 0, NULL, 0,
-	late_enable_ev, SND_SOC_DAPM_PRE_PMU),
-SND_SOC_DAPM_PGA_E("Late DAC2R Enable PGA", SND_SOC_NOPM, 0, 0, NULL, 0,
-	late_enable_ev, SND_SOC_DAPM_PRE_PMU),
+	wm8994 ->call_record_path = path_num;
 
-SND_SOC_DAPM_POST("Late Disable PGA", late_disable_ev)
-};
+	switch (path_num) {
+	case CALL_RECORDING_OFF :
+		break;
+	case CALL_RECORDING_MAIN :
+	case CALL_RECORDING_SUB :
+		wm8994_set_voicecall_record(codec, (int)wm8994 ->call_record_ch);
+		break;
+	default :
+		break;
+	}
 
-static const struct snd_soc_dapm_widget wm8994_lateclk_widgets[] = {
-SND_SOC_DAPM_SUPPLY("AIF1CLK", WM8994_AIF1_CLOCKING_1, 0, 0, NULL, 0),
-SND_SOC_DAPM_SUPPLY("AIF2CLK", WM8994_AIF2_CLOCKING_1, 0, 0, NULL, 0)
-};
+	return 0;
+}
 
-static const struct snd_soc_dapm_widget wm8994_dac_revd_widgets[] = {
-SND_SOC_DAPM_DAC_E("DAC2L", NULL, SND_SOC_NOPM, 3, 0,
-	dac_ev, SND_SOC_DAPM_PRE_PMU),
-SND_SOC_DAPM_DAC_E("DAC2R", NULL, SND_SOC_NOPM, 2, 0,
-	dac_ev, SND_SOC_DAPM_PRE_PMU),
-SND_SOC_DAPM_DAC_E("DAC1L", NULL, SND_SOC_NOPM, 1, 0,
-	dac_ev, SND_SOC_DAPM_PRE_PMU),
-SND_SOC_DAPM_DAC_E("DAC1R", NULL, SND_SOC_NOPM, 0, 0,
-	dac_ev, SND_SOC_DAPM_PRE_PMU),
-};
+void wm8994_set_off(struct snd_soc_codec *codec)
+{
+	DEBUG_LOG("");
+	audio_power(0);
+}
 
-static const struct snd_soc_dapm_widget wm8994_dac_widgets[] = {
-SND_SOC_DAPM_DAC("DAC2L", NULL, WM8994_POWER_MANAGEMENT_5, 3, 0),
-SND_SOC_DAPM_DAC("DAC2R", NULL, WM8994_POWER_MANAGEMENT_5, 2, 0),
-SND_SOC_DAPM_DAC("DAC1L", NULL, WM8994_POWER_MANAGEMENT_5, 1, 0),
-SND_SOC_DAPM_DAC("DAC1R", NULL, WM8994_POWER_MANAGEMENT_5, 0, 0),
+#define  SOC_WM899X_OUTPGA_DOUBLE_R_TLV(xname, reg_left, reg_right,\
+		xshift, xmax, xinvert, tlv_array) \
+{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
+	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
+		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
+	.tlv.p = (tlv_array), \
+	.info = snd_soc_info_volsw_2r, \
+	.get = snd_soc_get_volsw_2r, .put = wm899x_outpga_put_volsw_vu, \
+	.private_value = (unsigned long)&(struct soc_mixer_control) \
+		{.reg = reg_left, .rreg = reg_right, .shift = xshift, \
+		.max = xmax, .invert = xinvert} }
+
+#define SOC_WM899X_OUTPGA_SINGLE_R_TLV(xname, reg, shift, max, invert,\
+		tlv_array) {\
+		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
+		.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
+				SNDRV_CTL_ELEM_ACCESS_READWRITE,\
+		.tlv.p = (tlv_array), \
+		.info = snd_soc_info_volsw, \
+		.get = snd_soc_get_volsw, .put = wm899x_inpga_put_volsw_vu, \
+		.private_value = SOC_SINGLE_VALUE(reg, shift, max, invert) }
+
+static const DECLARE_TLV_DB_SCALE(digital_tlv, -7162, 37, 1);
+static const DECLARE_TLV_DB_LINEAR(digital_tlv_spkr, -5700, 600);
+static const DECLARE_TLV_DB_LINEAR(digital_tlv_rcv, -5700, 600);
+static const DECLARE_TLV_DB_LINEAR(digital_tlv_headphone, -5700, 600);
+static const DECLARE_TLV_DB_LINEAR(digital_tlv_mic, -7162, 7162);
+
+static const struct soc_enum path_control_enum[] = {
+	SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(playback_path), playback_path),
+	SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(voicecall_path), voicecall_path),
+	SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(mic_path), mic_path),
+	SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(fmradio_path),fmradio_path),
+	SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(codec_tuning_control), codec_tuning_control),
+	SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(codec_status_control), codec_status_control),
+	SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(voice_record_path), voice_record_path),
+	SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(call_recording_channel), call_recording_channel),
 };
 
-static const struct snd_soc_dapm_widget wm8994_adc_revd_widgets[] = {
-SND_SOC_DAPM_MUX_E("ADCL Mux", WM8994_POWER_MANAGEMENT_4, 1, 0, &adcl_mux,
-		   adc_mux_ev, SND_SOC_DAPM_PRE_PMU),
-SND_SOC_DAPM_MUX_E("ADCR Mux", WM8994_POWER_MANAGEMENT_4, 0, 0, &adcr_mux,
-		   adc_mux_ev, SND_SOC_DAPM_PRE_PMU),
-};
+static const struct snd_kcontrol_new wm8994_snd_controls[] = {
+	SOC_WM899X_OUTPGA_DOUBLE_R_TLV("Playback Volume",
+				       WM8994_LEFT_OPGA_VOLUME,
+				       WM8994_RIGHT_OPGA_VOLUME, 0, 0x3F, 0,
+				       digital_tlv_rcv),
+	SOC_WM899X_OUTPGA_DOUBLE_R_TLV("Playback Spkr Volume",
+				       WM8994_SPEAKER_VOLUME_LEFT,
+				       WM8994_SPEAKER_VOLUME_RIGHT, 1, 0x3F, 0,
+				       digital_tlv_spkr),
+	SOC_WM899X_OUTPGA_DOUBLE_R_TLV("Playback Headset Volume",
+				       WM8994_LEFT_OUTPUT_VOLUME,
+				       WM8994_RIGHT_OUTPUT_VOLUME, 1, 0x3F, 0,
+				       digital_tlv_headphone),
+	SOC_WM899X_OUTPGA_SINGLE_R_TLV("Capture Volume",
+				       WM8994_AIF1_ADC1_LEFT_VOLUME,
+				       0, 0xEF, 0, digital_tlv_mic),
+	/* Path Control */
+	SOC_ENUM_EXT("Playback Path", path_control_enum[0],
+		     wm8994_get_path, wm8994_set_path),
+
+	SOC_ENUM_EXT("Voice Call Path", path_control_enum[1],
+		     wm8994_get_call_path, wm8994_set_call_path),
+
+	SOC_ENUM_EXT("Capture MIC Path", path_control_enum[2],
+		     wm8994_get_mic_path, wm8994_set_mic_path),
+
+	SOC_ENUM_EXT("FM Radio Path", path_control_enum[3],
+		     wm8994_get_fmradio_path, wm8994_set_fmradio_path),
+
+	SOC_ENUM_EXT("Codec Tuning", path_control_enum[4],
+			wm8994_get_codec_tuning, wm8994_set_codec_tuning),
+
+	SOC_ENUM_EXT("Codec Status", path_control_enum[5],
+			wm8994_get_codec_status, wm8994_set_codec_status),
+
+	SOC_ENUM_EXT("Voice Call Recording", path_control_enum[6],
+			wm8994_get_voice_call_recording, wm8994_set_voice_call_recording),
+
+	SOC_ENUM_EXT("Recording Channel", path_control_enum[7],
+			wm8994_get_voice_recording_ch, wm8994_set_voice_recording_ch),
 
-static const struct snd_soc_dapm_widget wm8994_adc_widgets[] = {
-SND_SOC_DAPM_MUX("ADCL Mux", WM8994_POWER_MANAGEMENT_4, 1, 0, &adcl_mux),
-SND_SOC_DAPM_MUX("ADCR Mux", WM8994_POWER_MANAGEMENT_4, 0, 0, &adcr_mux),
 };
 
+/* Add non-DAPM controls */
+static int wm8994_add_controls(struct snd_soc_codec *codec)
+{
+	return snd_soc_add_controls(codec, wm8994_snd_controls,
+				    ARRAY_SIZE(wm8994_snd_controls));
+}
 static const struct snd_soc_dapm_widget wm8994_dapm_widgets[] = {
-SND_SOC_DAPM_INPUT("DMIC1DAT"),
-SND_SOC_DAPM_INPUT("DMIC2DAT"),
-SND_SOC_DAPM_INPUT("Clock"),
-
-SND_SOC_DAPM_SUPPLY_S("MICBIAS Supply", 1, SND_SOC_NOPM, 0, 0, micbias_ev,
-		      SND_SOC_DAPM_PRE_PMU),
-
-SND_SOC_DAPM_SUPPLY("CLK_SYS", SND_SOC_NOPM, 0, 0, clk_sys_event,
-		    SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
-
-SND_SOC_DAPM_SUPPLY("DSP1CLK", WM8994_CLOCKING_1, 3, 0, NULL, 0),
-SND_SOC_DAPM_SUPPLY("DSP2CLK", WM8994_CLOCKING_1, 2, 0, NULL, 0),
-SND_SOC_DAPM_SUPPLY("DSPINTCLK", WM8994_CLOCKING_1, 1, 0, NULL, 0),
-
-SND_SOC_DAPM_AIF_OUT("AIF1ADC1L", NULL,
-		     0, WM8994_POWER_MANAGEMENT_4, 9, 0),
-SND_SOC_DAPM_AIF_OUT("AIF1ADC1R", NULL,
-		     0, WM8994_POWER_MANAGEMENT_4, 8, 0),
-SND_SOC_DAPM_AIF_IN_E("AIF1DAC1L", NULL, 0,
-		      WM8994_POWER_MANAGEMENT_5, 9, 0, wm8958_aif_ev,
-		      SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
-SND_SOC_DAPM_AIF_IN_E("AIF1DAC1R", NULL, 0,
-		      WM8994_POWER_MANAGEMENT_5, 8, 0, wm8958_aif_ev,
-		      SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
-
-SND_SOC_DAPM_AIF_OUT("AIF1ADC2L", NULL,
-		     0, WM8994_POWER_MANAGEMENT_4, 11, 0),
-SND_SOC_DAPM_AIF_OUT("AIF1ADC2R", NULL,
-		     0, WM8994_POWER_MANAGEMENT_4, 10, 0),
-SND_SOC_DAPM_AIF_IN_E("AIF1DAC2L", NULL, 0,
-		      WM8994_POWER_MANAGEMENT_5, 11, 0, wm8958_aif_ev,
-		      SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
-SND_SOC_DAPM_AIF_IN_E("AIF1DAC2R", NULL, 0,
-		      WM8994_POWER_MANAGEMENT_5, 10, 0, wm8958_aif_ev,
-		      SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
-
-SND_SOC_DAPM_MIXER("AIF1ADC1L Mixer", SND_SOC_NOPM, 0, 0,
-		   aif1adc1l_mix, ARRAY_SIZE(aif1adc1l_mix)),
-SND_SOC_DAPM_MIXER("AIF1ADC1R Mixer", SND_SOC_NOPM, 0, 0,
-		   aif1adc1r_mix, ARRAY_SIZE(aif1adc1r_mix)),
-
-SND_SOC_DAPM_MIXER("AIF1ADC2L Mixer", SND_SOC_NOPM, 0, 0,
-		   aif1adc2l_mix, ARRAY_SIZE(aif1adc2l_mix)),
-SND_SOC_DAPM_MIXER("AIF1ADC2R Mixer", SND_SOC_NOPM, 0, 0,
-		   aif1adc2r_mix, ARRAY_SIZE(aif1adc2r_mix)),
-
-SND_SOC_DAPM_MIXER("AIF2DAC2L Mixer", SND_SOC_NOPM, 0, 0,
-		   aif2dac2l_mix, ARRAY_SIZE(aif2dac2l_mix)),
-SND_SOC_DAPM_MIXER("AIF2DAC2R Mixer", SND_SOC_NOPM, 0, 0,
-		   aif2dac2r_mix, ARRAY_SIZE(aif2dac2r_mix)),
-
-SND_SOC_DAPM_MUX("Left Sidetone", SND_SOC_NOPM, 0, 0, &sidetone1_mux),
-SND_SOC_DAPM_MUX("Right Sidetone", SND_SOC_NOPM, 0, 0, &sidetone2_mux),
-
-SND_SOC_DAPM_MIXER("DAC1L Mixer", SND_SOC_NOPM, 0, 0,
-		   dac1l_mix, ARRAY_SIZE(dac1l_mix)),
-SND_SOC_DAPM_MIXER("DAC1R Mixer", SND_SOC_NOPM, 0, 0,
-		   dac1r_mix, ARRAY_SIZE(dac1r_mix)),
-
-SND_SOC_DAPM_AIF_OUT("AIF2ADCL", NULL, 0,
-		     WM8994_POWER_MANAGEMENT_4, 13, 0),
-SND_SOC_DAPM_AIF_OUT("AIF2ADCR", NULL, 0,
-		     WM8994_POWER_MANAGEMENT_4, 12, 0),
-SND_SOC_DAPM_AIF_IN_E("AIF2DACL", NULL, 0,
-		      WM8994_POWER_MANAGEMENT_5, 13, 0, wm8958_aif_ev,
-		      SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
-SND_SOC_DAPM_AIF_IN_E("AIF2DACR", NULL, 0,
-		      WM8994_POWER_MANAGEMENT_5, 12, 0, wm8958_aif_ev,
-		      SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
-
-SND_SOC_DAPM_AIF_IN("AIF1DACDAT", "AIF1 Playback", 0, SND_SOC_NOPM, 0, 0),
-SND_SOC_DAPM_AIF_IN("AIF2DACDAT", "AIF2 Playback", 0, SND_SOC_NOPM, 0, 0),
-SND_SOC_DAPM_AIF_OUT("AIF1ADCDAT", "AIF1 Capture", 0, SND_SOC_NOPM, 0, 0),
-SND_SOC_DAPM_AIF_OUT("AIF2ADCDAT", "AIF2 Capture", 0, SND_SOC_NOPM, 0, 0),
-
-SND_SOC_DAPM_MUX("AIF1DAC Mux", SND_SOC_NOPM, 0, 0, &aif1dac_mux),
-SND_SOC_DAPM_MUX("AIF2DAC Mux", SND_SOC_NOPM, 0, 0, &aif2dac_mux),
-SND_SOC_DAPM_MUX("AIF2ADC Mux", SND_SOC_NOPM, 0, 0, &aif2adc_mux),
-
-SND_SOC_DAPM_AIF_IN("AIF3DACDAT", "AIF3 Playback", 0, SND_SOC_NOPM, 0, 0),
-SND_SOC_DAPM_AIF_OUT("AIF3ADCDAT", "AIF3 Capture", 0, SND_SOC_NOPM, 0, 0),
-
-SND_SOC_DAPM_SUPPLY("TOCLK", WM8994_CLOCKING_1, 4, 0, NULL, 0),
-
-SND_SOC_DAPM_ADC("DMIC2L", NULL, WM8994_POWER_MANAGEMENT_4, 5, 0),
-SND_SOC_DAPM_ADC("DMIC2R", NULL, WM8994_POWER_MANAGEMENT_4, 4, 0),
-SND_SOC_DAPM_ADC("DMIC1L", NULL, WM8994_POWER_MANAGEMENT_4, 3, 0),
-SND_SOC_DAPM_ADC("DMIC1R", NULL, WM8994_POWER_MANAGEMENT_4, 2, 0),
-
-/* Power is done with the muxes since the ADC power also controls the
- * downsampling chain, the chip will automatically manage the analogue
- * specific portions.
- */
-SND_SOC_DAPM_ADC("ADCL", NULL, SND_SOC_NOPM, 1, 0),
-SND_SOC_DAPM_ADC("ADCR", NULL, SND_SOC_NOPM, 0, 0),
-
-SND_SOC_DAPM_MUX("Left Headphone Mux", SND_SOC_NOPM, 0, 0, &hpl_mux),
-SND_SOC_DAPM_MUX("Right Headphone Mux", SND_SOC_NOPM, 0, 0, &hpr_mux),
-
-SND_SOC_DAPM_MIXER("SPKL", WM8994_POWER_MANAGEMENT_3, 8, 0,
-		   left_speaker_mixer, ARRAY_SIZE(left_speaker_mixer)),
-SND_SOC_DAPM_MIXER("SPKR", WM8994_POWER_MANAGEMENT_3, 9, 0,
-		   right_speaker_mixer, ARRAY_SIZE(right_speaker_mixer)),
-
-SND_SOC_DAPM_POST("Debug log", post_ev),
-};
-
-static const struct snd_soc_dapm_widget wm8994_specific_dapm_widgets[] = {
-SND_SOC_DAPM_MUX("AIF3ADC Mux", SND_SOC_NOPM, 0, 0, &wm8994_aif3adc_mux),
-};
-
-static const struct snd_soc_dapm_widget wm8958_dapm_widgets[] = {
-SND_SOC_DAPM_MUX("Mono PCM Out Mux", SND_SOC_NOPM, 0, 0, &mono_pcm_out_mux),
-SND_SOC_DAPM_MUX("AIF2DACL Mux", SND_SOC_NOPM, 0, 0, &aif2dacl_src_mux),
-SND_SOC_DAPM_MUX("AIF2DACR Mux", SND_SOC_NOPM, 0, 0, &aif2dacr_src_mux),
-SND_SOC_DAPM_MUX("AIF3ADC Mux", SND_SOC_NOPM, 0, 0, &wm8958_aif3adc_mux),
-};
-
-static const struct snd_soc_dapm_route intercon[] = {
-	{ "CLK_SYS", NULL, "AIF1CLK", check_clk_sys },
-	{ "CLK_SYS", NULL, "AIF2CLK", check_clk_sys },
-
-	{ "DSP1CLK", NULL, "CLK_SYS" },
-	{ "DSP2CLK", NULL, "CLK_SYS" },
-	{ "DSPINTCLK", NULL, "CLK_SYS" },
-
-	{ "AIF1ADC1L", NULL, "AIF1CLK" },
-	{ "AIF1ADC1L", NULL, "DSP1CLK" },
-	{ "AIF1ADC1R", NULL, "AIF1CLK" },
-	{ "AIF1ADC1R", NULL, "DSP1CLK" },
-	{ "AIF1ADC1R", NULL, "DSPINTCLK" },
-
-	{ "AIF1DAC1L", NULL, "AIF1CLK" },
-	{ "AIF1DAC1L", NULL, "DSP1CLK" },
-	{ "AIF1DAC1R", NULL, "AIF1CLK" },
-	{ "AIF1DAC1R", NULL, "DSP1CLK" },
-	{ "AIF1DAC1R", NULL, "DSPINTCLK" },
-
-	{ "AIF1ADC2L", NULL, "AIF1CLK" },
-	{ "AIF1ADC2L", NULL, "DSP1CLK" },
-	{ "AIF1ADC2R", NULL, "AIF1CLK" },
-	{ "AIF1ADC2R", NULL, "DSP1CLK" },
-	{ "AIF1ADC2R", NULL, "DSPINTCLK" },
-
-	{ "AIF1DAC2L", NULL, "AIF1CLK" },
-	{ "AIF1DAC2L", NULL, "DSP1CLK" },
-	{ "AIF1DAC2R", NULL, "AIF1CLK" },
-	{ "AIF1DAC2R", NULL, "DSP1CLK" },
-	{ "AIF1DAC2R", NULL, "DSPINTCLK" },
-
-	{ "AIF2ADCL", NULL, "AIF2CLK" },
-	{ "AIF2ADCL", NULL, "DSP2CLK" },
-	{ "AIF2ADCR", NULL, "AIF2CLK" },
-	{ "AIF2ADCR", NULL, "DSP2CLK" },
-	{ "AIF2ADCR", NULL, "DSPINTCLK" },
-
-	{ "AIF2DACL", NULL, "AIF2CLK" },
-	{ "AIF2DACL", NULL, "DSP2CLK" },
-	{ "AIF2DACR", NULL, "AIF2CLK" },
-	{ "AIF2DACR", NULL, "DSP2CLK" },
-	{ "AIF2DACR", NULL, "DSPINTCLK" },
-
-	{ "DMIC1L", NULL, "DMIC1DAT" },
-	{ "DMIC1L", NULL, "CLK_SYS" },
-	{ "DMIC1R", NULL, "DMIC1DAT" },
-	{ "DMIC1R", NULL, "CLK_SYS" },
-	{ "DMIC2L", NULL, "DMIC2DAT" },
-	{ "DMIC2L", NULL, "CLK_SYS" },
-	{ "DMIC2R", NULL, "DMIC2DAT" },
-	{ "DMIC2R", NULL, "CLK_SYS" },
-
-	{ "ADCL", NULL, "AIF1CLK" },
-	{ "ADCL", NULL, "DSP1CLK" },
-	{ "ADCL", NULL, "DSPINTCLK" },
-
-	{ "ADCR", NULL, "AIF1CLK" },
-	{ "ADCR", NULL, "DSP1CLK" },
-	{ "ADCR", NULL, "DSPINTCLK" },
-
-	{ "ADCL Mux", "ADC", "ADCL" },
-	{ "ADCL Mux", "DMIC", "DMIC1L" },
-	{ "ADCR Mux", "ADC", "ADCR" },
-	{ "ADCR Mux", "DMIC", "DMIC1R" },
-
-	{ "DAC1L", NULL, "AIF1CLK" },
-	{ "DAC1L", NULL, "DSP1CLK" },
-	{ "DAC1L", NULL, "DSPINTCLK" },
-
-	{ "DAC1R", NULL, "AIF1CLK" },
-	{ "DAC1R", NULL, "DSP1CLK" },
-	{ "DAC1R", NULL, "DSPINTCLK" },
-
-	{ "DAC2L", NULL, "AIF2CLK" },
-	{ "DAC2L", NULL, "DSP2CLK" },
-	{ "DAC2L", NULL, "DSPINTCLK" },
-
-	{ "DAC2R", NULL, "AIF2DACR" },
-	{ "DAC2R", NULL, "AIF2CLK" },
-	{ "DAC2R", NULL, "DSP2CLK" },
-	{ "DAC2R", NULL, "DSPINTCLK" },
-
-	{ "TOCLK", NULL, "CLK_SYS" },
-
-	/* AIF1 outputs */
-	{ "AIF1ADC1L", NULL, "AIF1ADC1L Mixer" },
-	{ "AIF1ADC1L Mixer", "ADC/DMIC Switch", "ADCL Mux" },
-	{ "AIF1ADC1L Mixer", "AIF2 Switch", "AIF2DACL" },
-
-	{ "AIF1ADC1R", NULL, "AIF1ADC1R Mixer" },
-	{ "AIF1ADC1R Mixer", "ADC/DMIC Switch", "ADCR Mux" },
-	{ "AIF1ADC1R Mixer", "AIF2 Switch", "AIF2DACR" },
-
-	{ "AIF1ADC2L", NULL, "AIF1ADC2L Mixer" },
-	{ "AIF1ADC2L Mixer", "DMIC Switch", "DMIC2L" },
-	{ "AIF1ADC2L Mixer", "AIF2 Switch", "AIF2DACL" },
-
-	{ "AIF1ADC2R", NULL, "AIF1ADC2R Mixer" },
-	{ "AIF1ADC2R Mixer", "DMIC Switch", "DMIC2R" },
-	{ "AIF1ADC2R Mixer", "AIF2 Switch", "AIF2DACR" },
-
-	/* Pin level routing for AIF3 */
-	{ "AIF1DAC1L", NULL, "AIF1DAC Mux" },
-	{ "AIF1DAC1R", NULL, "AIF1DAC Mux" },
-	{ "AIF1DAC2L", NULL, "AIF1DAC Mux" },
-	{ "AIF1DAC2R", NULL, "AIF1DAC Mux" },
-
-	{ "AIF1DAC Mux", "AIF1DACDAT", "AIF1DACDAT" },
-	{ "AIF1DAC Mux", "AIF3DACDAT", "AIF3DACDAT" },
-	{ "AIF2DAC Mux", "AIF2DACDAT", "AIF2DACDAT" },
-	{ "AIF2DAC Mux", "AIF3DACDAT", "AIF3DACDAT" },
-	{ "AIF2ADC Mux", "AIF2ADCDAT", "AIF2ADCL" },
-	{ "AIF2ADC Mux", "AIF2ADCDAT", "AIF2ADCR" },
-	{ "AIF2ADC Mux", "AIF3DACDAT", "AIF3ADCDAT" },
-
-	/* DAC1 inputs */
-	{ "DAC1L Mixer", "AIF2 Switch", "AIF2DACL" },
-	{ "DAC1L Mixer", "AIF1.2 Switch", "AIF1DAC2L" },
-	{ "DAC1L Mixer", "AIF1.1 Switch", "AIF1DAC1L" },
-	{ "DAC1L Mixer", "Left Sidetone Switch", "Left Sidetone" },
-	{ "DAC1L Mixer", "Right Sidetone Switch", "Right Sidetone" },
-
-	{ "DAC1R Mixer", "AIF2 Switch", "AIF2DACR" },
-	{ "DAC1R Mixer", "AIF1.2 Switch", "AIF1DAC2R" },
-	{ "DAC1R Mixer", "AIF1.1 Switch", "AIF1DAC1R" },
-	{ "DAC1R Mixer", "Left Sidetone Switch", "Left Sidetone" },
-	{ "DAC1R Mixer", "Right Sidetone Switch", "Right Sidetone" },
-
-	/* DAC2/AIF2 outputs  */
-	{ "AIF2ADCL", NULL, "AIF2DAC2L Mixer" },
-	{ "AIF2DAC2L Mixer", "AIF2 Switch", "AIF2DACL" },
-	{ "AIF2DAC2L Mixer", "AIF1.2 Switch", "AIF1DAC2L" },
-	{ "AIF2DAC2L Mixer", "AIF1.1 Switch", "AIF1DAC1L" },
-	{ "AIF2DAC2L Mixer", "Left Sidetone Switch", "Left Sidetone" },
-	{ "AIF2DAC2L Mixer", "Right Sidetone Switch", "Right Sidetone" },
-
-	{ "AIF2ADCR", NULL, "AIF2DAC2R Mixer" },
-	{ "AIF2DAC2R Mixer", "AIF2 Switch", "AIF2DACR" },
-	{ "AIF2DAC2R Mixer", "AIF1.2 Switch", "AIF1DAC2R" },
-	{ "AIF2DAC2R Mixer", "AIF1.1 Switch", "AIF1DAC1R" },
-	{ "AIF2DAC2R Mixer", "Left Sidetone Switch", "Left Sidetone" },
-	{ "AIF2DAC2R Mixer", "Right Sidetone Switch", "Right Sidetone" },
-
-	{ "AIF1ADCDAT", NULL, "AIF1ADC1L" },
-	{ "AIF1ADCDAT", NULL, "AIF1ADC1R" },
-	{ "AIF1ADCDAT", NULL, "AIF1ADC2L" },
-	{ "AIF1ADCDAT", NULL, "AIF1ADC2R" },
-
-	{ "AIF2ADCDAT", NULL, "AIF2ADC Mux" },
-
-	/* AIF3 output */
-	{ "AIF3ADCDAT", "AIF1ADCDAT", "AIF1ADC1L" },
-	{ "AIF3ADCDAT", "AIF1ADCDAT", "AIF1ADC1R" },
-	{ "AIF3ADCDAT", "AIF1ADCDAT", "AIF1ADC2L" },
-	{ "AIF3ADCDAT", "AIF1ADCDAT", "AIF1ADC2R" },
-	{ "AIF3ADCDAT", "AIF2ADCDAT", "AIF2ADCL" },
-	{ "AIF3ADCDAT", "AIF2ADCDAT", "AIF2ADCR" },
-	{ "AIF3ADCDAT", "AIF2DACDAT", "AIF2DACL" },
-	{ "AIF3ADCDAT", "AIF2DACDAT", "AIF2DACR" },
-
-	/* Sidetone */
-	{ "Left Sidetone", "ADC/DMIC1", "ADCL Mux" },
-	{ "Left Sidetone", "DMIC2", "DMIC2L" },
-	{ "Right Sidetone", "ADC/DMIC1", "ADCR Mux" },
-	{ "Right Sidetone", "DMIC2", "DMIC2R" },
-
-	/* Output stages */
-	{ "Left Output Mixer", "DAC Switch", "DAC1L" },
-	{ "Right Output Mixer", "DAC Switch", "DAC1R" },
-
-	{ "SPKL", "DAC1 Switch", "DAC1L" },
-	{ "SPKL", "DAC2 Switch", "DAC2L" },
-
-	{ "SPKR", "DAC1 Switch", "DAC1R" },
-	{ "SPKR", "DAC2 Switch", "DAC2R" },
-
-	{ "Left Headphone Mux", "DAC", "DAC1L" },
-	{ "Right Headphone Mux", "DAC", "DAC1R" },
-};
-
-static const struct snd_soc_dapm_route wm8994_lateclk_revd_intercon[] = {
-	{ "DAC1L", NULL, "Late DAC1L Enable PGA" },
-	{ "Late DAC1L Enable PGA", NULL, "DAC1L Mixer" },
-	{ "DAC1R", NULL, "Late DAC1R Enable PGA" },
-	{ "Late DAC1R Enable PGA", NULL, "DAC1R Mixer" },
-	{ "DAC2L", NULL, "Late DAC2L Enable PGA" },
-	{ "Late DAC2L Enable PGA", NULL, "AIF2DAC2L Mixer" },
-	{ "DAC2R", NULL, "Late DAC2R Enable PGA" },
-	{ "Late DAC2R Enable PGA", NULL, "AIF2DAC2R Mixer" }
-};
-
-static const struct snd_soc_dapm_route wm8994_lateclk_intercon[] = {
-	{ "DAC1L", NULL, "DAC1L Mixer" },
-	{ "DAC1R", NULL, "DAC1R Mixer" },
-	{ "DAC2L", NULL, "AIF2DAC2L Mixer" },
-	{ "DAC2R", NULL, "AIF2DAC2R Mixer" },
-};
-
-static const struct snd_soc_dapm_route wm8994_revd_intercon[] = {
-	{ "AIF1DACDAT", NULL, "AIF2DACDAT" },
-	{ "AIF2DACDAT", NULL, "AIF1DACDAT" },
-	{ "AIF1ADCDAT", NULL, "AIF2ADCDAT" },
-	{ "AIF2ADCDAT", NULL, "AIF1ADCDAT" },
-	{ "MICBIAS1", NULL, "CLK_SYS" },
-	{ "MICBIAS1", NULL, "MICBIAS Supply" },
-	{ "MICBIAS2", NULL, "CLK_SYS" },
-	{ "MICBIAS2", NULL, "MICBIAS Supply" },
-};
-
-static const struct snd_soc_dapm_route wm8994_intercon[] = {
-	{ "AIF2DACL", NULL, "AIF2DAC Mux" },
-	{ "AIF2DACR", NULL, "AIF2DAC Mux" },
-};
-
-static const struct snd_soc_dapm_route wm8958_intercon[] = {
-	{ "AIF2DACL", NULL, "AIF2DACL Mux" },
-	{ "AIF2DACR", NULL, "AIF2DACR Mux" },
-
-	{ "AIF2DACL Mux", "AIF2", "AIF2DAC Mux" },
-	{ "AIF2DACL Mux", "AIF3", "AIF3DACDAT" },
-	{ "AIF2DACR Mux", "AIF2", "AIF2DAC Mux" },
-	{ "AIF2DACR Mux", "AIF3", "AIF3DACDAT" },
-
-	{ "Mono PCM Out Mux", "AIF2ADCL", "AIF2ADCL" },
-	{ "Mono PCM Out Mux", "AIF2ADCR", "AIF2ADCR" },
-
-	{ "AIF3ADC Mux", "Mono PCM", "Mono PCM Out Mux" },
 };
 
-/* The size in bits of the FLL divide multiplied by 10
- * to allow rounding later */
-#define FIXED_FLL_SIZE ((1 << 16) * 10)
-
-struct fll_div {
-	u16 outdiv;
-	u16 n;
-	u16 k;
-	u16 clk_ref_div;
-	u16 fll_fratio;
+static const struct snd_soc_dapm_route audio_map[] = {
 };
 
-static int wm8994_get_fll_config(struct fll_div *fll,
-				 int freq_in, int freq_out)
+static int wm8994_add_widgets(struct snd_soc_codec *codec)
 {
-	u64 Kpart;
-	unsigned int K, Ndiv, Nmod;
-
-	pr_debug("FLL input=%dHz, output=%dHz\n", freq_in, freq_out);
-
-	/* Scale the input frequency down to <= 13.5MHz */
-	fll->clk_ref_div = 0;
-	while (freq_in > 13500000) {
-		fll->clk_ref_div++;
-		freq_in /= 2;
-
-		if (fll->clk_ref_div > 3)
-			return -EINVAL;
-	}
-	pr_debug("CLK_REF_DIV=%d, Fref=%dHz\n", fll->clk_ref_div, freq_in);
-
-	/* Scale the output to give 90MHz<=Fvco<=100MHz */
-	fll->outdiv = 3;
-	while (freq_out * (fll->outdiv + 1) < 90000000) {
-		fll->outdiv++;
-		if (fll->outdiv > 63)
-			return -EINVAL;
-	}
-	freq_out *= fll->outdiv + 1;
-	pr_debug("OUTDIV=%d, Fvco=%dHz\n", fll->outdiv, freq_out);
-
-	if (freq_in > 1000000) {
-		fll->fll_fratio = 0;
-	} else if (freq_in > 256000) {
-		fll->fll_fratio = 1;
-		freq_in *= 2;
-	} else if (freq_in > 128000) {
-		fll->fll_fratio = 2;
-		freq_in *= 4;
-	} else if (freq_in > 64000) {
-		fll->fll_fratio = 3;
-		freq_in *= 8;
-	} else {
-		fll->fll_fratio = 4;
-		freq_in *= 16;
-	}
-	pr_debug("FLL_FRATIO=%d, Fref=%dHz\n", fll->fll_fratio, freq_in);
-
-	/* Now, calculate N.K */
-	Ndiv = freq_out / freq_in;
-
-	fll->n = Ndiv;
-	Nmod = freq_out % freq_in;
-	pr_debug("Nmod=%d\n", Nmod);
-
-	/* Calculate fractional part - scale up so we can round. */
-	Kpart = FIXED_FLL_SIZE * (long long)Nmod;
-
-	do_div(Kpart, freq_in);
-
-	K = Kpart & 0xFFFFFFFF;
+	snd_soc_dapm_new_controls(&codec->dapm, wm8994_dapm_widgets,
+			ARRAY_SIZE(wm8994_dapm_widgets));
 
-	if ((K % 10) >= 5)
-		K += 5;
-
-	/* Move down to proper range now rounding is done */
-	fll->k = K / 10;
-
-	pr_debug("N=%x K=%x\n", fll->n, fll->k);
+	snd_soc_dapm_add_routes(&codec->dapm, audio_map, ARRAY_SIZE(audio_map));
 
+	snd_soc_dapm_new_widgets(&codec->dapm);
 	return 0;
 }
 
-static int _wm8994_set_fll(struct snd_soc_codec *codec, int id, int src,
-			  unsigned int freq_in, unsigned int freq_out)
+static int configure_clock(struct snd_soc_codec *codec)
 {
 	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	int reg_offset, ret;
-	struct fll_div fll;
-	u16 reg, aif1, aif2;
+	unsigned int reg;
 
-	aif1 = snd_soc_read(codec, WM8994_AIF1_CLOCKING_1)
-		& WM8994_AIF1CLK_ENA;
+	DEBUG_LOG("");
 
-	aif2 = snd_soc_read(codec, WM8994_AIF2_CLOCKING_1)
-		& WM8994_AIF2CLK_ENA;
-
-	switch (id) {
-	case WM8994_FLL1:
-		reg_offset = 0;
-		id = 0;
-		break;
-	case WM8994_FLL2:
-		reg_offset = 0x20;
-		id = 1;
-		break;
-	default:
-		return -EINVAL;
+	if (wm8994->codec_state != DEACTIVE) {
+		DEBUG_LOG("Codec is already actvied. Skip clock setting.");
+		return 0;
 	}
 
-	switch (src) {
-	case 0:
-		/* Allow no source specification when stopping */
-		if (freq_out)
-			return -EINVAL;
-		src = wm8994->fll[id].src;
-		break;
-	case WM8994_FLL_SRC_MCLK1:
-	case WM8994_FLL_SRC_MCLK2:
-	case WM8994_FLL_SRC_LRCLK:
-	case WM8994_FLL_SRC_BCLK:
-		break;
-	default:
-		return -EINVAL;
-	}
+	reg = wm8994_read(codec, WM8994_AIF1_CLOCKING_1);
+	reg &= ~WM8994_AIF1CLK_ENA;
+	reg &= ~WM8994_AIF1CLK_SRC_MASK;
+	wm8994_write(codec, WM8994_AIF1_CLOCKING_1, reg);
 
-	/* Are we changing anything? */
-	if (wm8994->fll[id].src == src &&
-	    wm8994->fll[id].in == freq_in && wm8994->fll[id].out == freq_out)
-		return 0;
+	switch (wm8994->sysclk_source) {
+	case WM8994_SYSCLK_MCLK:
+		dev_dbg(codec->dev, "Using %dHz MCLK\n", wm8994->mclk_rate);
 
-	/* If we're stopping the FLL redo the old config - no
-	 * registers will actually be written but we avoid GCC flow
-	 * analysis bugs spewing warnings.
-	 */
-	if (freq_out)
-		ret = wm8994_get_fll_config(&fll, freq_in, freq_out);
-	else
-		ret = wm8994_get_fll_config(&fll, wm8994->fll[id].in,
-					    wm8994->fll[id].out);
-	if (ret < 0)
-		return ret;
-
-	/* Gate the AIF clocks while we reclock */
-	snd_soc_update_bits(codec, WM8994_AIF1_CLOCKING_1,
-			    WM8994_AIF1CLK_ENA, 0);
-	snd_soc_update_bits(codec, WM8994_AIF2_CLOCKING_1,
-			    WM8994_AIF2CLK_ENA, 0);
-
-	/* We always need to disable the FLL while reconfiguring */
-	snd_soc_update_bits(codec, WM8994_FLL1_CONTROL_1 + reg_offset,
-			    WM8994_FLL1_ENA, 0);
-
-	reg = (fll.outdiv << WM8994_FLL1_OUTDIV_SHIFT) |
-		(fll.fll_fratio << WM8994_FLL1_FRATIO_SHIFT);
-	snd_soc_update_bits(codec, WM8994_FLL1_CONTROL_2 + reg_offset,
-			    WM8994_FLL1_OUTDIV_MASK |
-			    WM8994_FLL1_FRATIO_MASK, reg);
-
-	snd_soc_write(codec, WM8994_FLL1_CONTROL_3 + reg_offset, fll.k);
-
-	snd_soc_update_bits(codec, WM8994_FLL1_CONTROL_4 + reg_offset,
-			    WM8994_FLL1_N_MASK,
-				    fll.n << WM8994_FLL1_N_SHIFT);
-
-	snd_soc_update_bits(codec, WM8994_FLL1_CONTROL_5 + reg_offset,
-			    WM8994_FLL1_REFCLK_DIV_MASK |
-			    WM8994_FLL1_REFCLK_SRC_MASK,
-			    (fll.clk_ref_div << WM8994_FLL1_REFCLK_DIV_SHIFT) |
-			    (src - 1));
-
-	/* Enable (with fractional mode if required) */
-	if (freq_out) {
-		if (fll.k)
-			reg = WM8994_FLL1_ENA | WM8994_FLL1_FRAC;
-		else
-			reg = WM8994_FLL1_ENA;
-		snd_soc_update_bits(codec, WM8994_FLL1_CONTROL_1 + reg_offset,
-				    WM8994_FLL1_ENA | WM8994_FLL1_FRAC,
-				    reg);
-
-		msleep(5);
-	}
-
-	wm8994->fll[id].in = freq_in;
-	wm8994->fll[id].out = freq_out;
-	wm8994->fll[id].src = src;
+		reg = wm8994_read(codec, WM8994_AIF1_CLOCKING_1);
+		reg &= ~WM8994_AIF1CLK_ENA;
+		wm8994_write(codec, WM8994_AIF1_CLOCKING_1, reg);
 
-	/* Enable any gated AIF clocks */
-	snd_soc_update_bits(codec, WM8994_AIF1_CLOCKING_1,
-			    WM8994_AIF1CLK_ENA, aif1);
-	snd_soc_update_bits(codec, WM8994_AIF2_CLOCKING_1,
-			    WM8994_AIF2CLK_ENA, aif2);
+		reg = wm8994_read(codec, WM8994_AIF1_CLOCKING_1);
+		reg &= 0x07;
 
-	configure_clock(codec);
+		if (wm8994->mclk_rate > 13500000) {
+			reg |= WM8994_AIF1CLK_DIV;
+			wm8994->sysclk_rate = wm8994->mclk_rate / 2;
+		} else {
+			reg &= ~WM8994_AIF1CLK_DIV;
+			wm8994->sysclk_rate = wm8994->mclk_rate;
+		}
+		reg |= WM8994_AIF1CLK_ENA;
+		wm8994_write(codec, WM8994_AIF1_CLOCKING_1, reg);
+
+		/* Enable clocks to the Audio core and sysclk of wm8994 */
+		reg = wm8994_read(codec, WM8994_CLOCKING_1);
+		reg &= ~(WM8994_SYSCLK_SRC_MASK | WM8994_DSP_FSINTCLK_ENA_MASK
+				| WM8994_DSP_FS1CLK_ENA_MASK);
+		reg |= (WM8994_DSP_FS1CLK_ENA | WM8994_DSP_FSINTCLK_ENA);
+		wm8994_write(codec, WM8994_CLOCKING_1, reg);
+		break;
+
+	case WM8994_SYSCLK_FLL:
+		switch (wm8994->fs) {
+		case 8000:
+			wm8994_write(codec, WM8994_FLL1_CONTROL_2, 0x2F00);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_3, 0x3126);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_4, 0x0105);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_5, 0x0C88);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_1,
+				WM8994_FLL1_FRACN_ENA | WM8994_FLL1_ENA);
+			break;
 
-	return 0;
-}
+		case 11025:
+			wm8994_write(codec, WM8994_FLL1_CONTROL_2, 0x1F00);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_3, 0x86C2);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_5, 0x0C88);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_4, 0x00E5);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_1,
+				WM8994_FLL1_FRACN_ENA | WM8994_FLL1_ENA);
+			break;
 
+		case 12000:
+			wm8994_write(codec, WM8994_FLL1_CONTROL_2, 0x1F00);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_3, 0x3126);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_5, 0x0C88);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_4, 0x0105);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_1,
+				WM8994_FLL1_FRACN_ENA | WM8994_FLL1_ENA);
+			break;
 
-static int opclk_divs[] = { 10, 20, 30, 40, 55, 60, 80, 120, 160 };
+		case 16000:
+			wm8994_write(codec, WM8994_FLL1_CONTROL_2, 0x1900);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_3, 0xE23E);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_5, 0x0C88);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_4, 0x0105);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_1,
+				WM8994_FLL1_FRACN_ENA | WM8994_FLL1_ENA);
+			break;
 
-static int wm8994_set_fll(struct snd_soc_dai *dai, int id, int src,
-			  unsigned int freq_in, unsigned int freq_out)
-{
-	return _wm8994_set_fll(dai->codec, id, src, freq_in, freq_out);
-}
+		case 22050:
+			wm8994_write(codec, WM8994_FLL1_CONTROL_2, 0x0F00);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_3, 0x86C2);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_5, 0x0C88);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_4, 0x00E5);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_1,
+				WM8994_FLL1_FRACN_ENA | WM8994_FLL1_ENA);
+			break;
 
-static int wm8994_set_dai_sysclk(struct snd_soc_dai *dai,
-		int clk_id, unsigned int freq, int dir)
-{
-	struct snd_soc_codec *codec = dai->codec;
-	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	int i;
+		case 24000:
+			wm8994_write(codec, WM8994_FLL1_CONTROL_2, 0x0F00);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_3, 0x3126);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_5, 0x0C88);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_4, 0x0105);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_1,
+				WM8994_FLL1_FRACN_ENA | WM8994_FLL1_ENA);
+			break;
 
-	switch (dai->id) {
-	case 1:
-	case 2:
-		break;
+		case 32000:
+			wm8994_write(codec, WM8994_FLL1_CONTROL_2, 0x0C00);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_3, 0xE23E);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_5, 0x0C88);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_4, 0x0105);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_1,
+				WM8994_FLL1_FRACN_ENA | WM8994_FLL1_ENA);
+			break;
 
-	default:
-		/* AIF3 shares clocking with AIF1/2 */
-		return -EINVAL;
-	}
+		case 44100:
+			wm8994_write(codec, WM8994_FLL1_CONTROL_2, 0x0700);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_3, 0x86C2);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_5, 0x0C88);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_4, 0x00E5);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_1,
+				WM8994_FLL1_FRACN_ENA | WM8994_FLL1_ENA);
+			break;
 
-	switch (clk_id) {
-	case WM8994_SYSCLK_MCLK1:
-		wm8994->sysclk[dai->id - 1] = WM8994_SYSCLK_MCLK1;
-		wm8994->mclk[0] = freq;
-		dev_dbg(dai->dev, "AIF%d using MCLK1 at %uHz\n",
-			dai->id, freq);
-		break;
+		case 48000:
+			wm8994_write(codec, WM8994_FLL1_CONTROL_2, 0x0700);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_3, 0x3126);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_5, 0x0C88);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_4, 0x0105);
+			wm8994_write(codec, WM8994_FLL1_CONTROL_1,
+				WM8994_FLL1_FRACN_ENA | WM8994_FLL1_ENA);
+			break;
 
-	case WM8994_SYSCLK_MCLK2:
-		/* TODO: Set GPIO AF */
-		wm8994->sysclk[dai->id - 1] = WM8994_SYSCLK_MCLK2;
-		wm8994->mclk[1] = freq;
-		dev_dbg(dai->dev, "AIF%d using MCLK2 at %uHz\n",
-			dai->id, freq);
-		break;
+		default:
+			DEBUG_LOG_ERR("Unsupported Frequency\n");
+			break;
+		}
 
-	case WM8994_SYSCLK_FLL1:
-		wm8994->sysclk[dai->id - 1] = WM8994_SYSCLK_FLL1;
-		dev_dbg(dai->dev, "AIF%d using FLL1\n", dai->id);
-		break;
+		reg = wm8994_read(codec, WM8994_AIF1_CLOCKING_1);
+		reg |= WM8994_AIF1CLK_ENA;
+		reg |= WM8994_AIF1CLK_SRC_FLL1;
+		wm8994_write(codec, WM8994_AIF1_CLOCKING_1, reg);
 
-	case WM8994_SYSCLK_FLL2:
-		wm8994->sysclk[dai->id - 1] = WM8994_SYSCLK_FLL2;
-		dev_dbg(dai->dev, "AIF%d using FLL2\n", dai->id);
+		/* Enable clocks to the Audio core and sysclk of wm8994*/
+		reg = wm8994_read(codec, WM8994_CLOCKING_1);
+		reg &= ~(WM8994_SYSCLK_SRC_MASK | WM8994_DSP_FSINTCLK_ENA_MASK |
+				WM8994_DSP_FS1CLK_ENA_MASK);
+		reg |= (WM8994_DSP_FS1CLK_ENA | WM8994_DSP_FSINTCLK_ENA);
+		wm8994_write(codec, WM8994_CLOCKING_1, reg);
 		break;
 
-	case WM8994_SYSCLK_OPCLK:
-		/* Special case - a division (times 10) is given and
-		 * no effect on main clocking. 
-		 */
-		if (freq) {
-			for (i = 0; i < ARRAY_SIZE(opclk_divs); i++)
-				if (opclk_divs[i] == freq)
-					break;
-			if (i == ARRAY_SIZE(opclk_divs))
-				return -EINVAL;
-			snd_soc_update_bits(codec, WM8994_CLOCKING_2,
-					    WM8994_OPCLK_DIV_MASK, i);
-			snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_2,
-					    WM8994_OPCLK_ENA, WM8994_OPCLK_ENA);
-		} else {
-			snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_2,
-					    WM8994_OPCLK_ENA, 0);
-		}
-
 	default:
+		dev_err(codec->dev, "System clock not configured\n");
 		return -EINVAL;
 	}
 
-	configure_clock(codec);
+	dev_dbg(codec->dev, "CLK_SYS is %dHz\n", wm8994->sysclk_rate);
 
 	return 0;
 }
 
-static int wm8994_set_bias_level(struct snd_soc_codec *codec,
-				 enum snd_soc_bias_level level)
+static int wm8994_set_sysclk(struct snd_soc_dai *codec_dai,
+			     int clk_id, unsigned int freq, int dir)
 {
-	struct wm8994 *control = codec->control_data;
+	struct snd_soc_codec *codec = codec_dai->codec;
 	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
 
-	switch (level) {
-	case SND_SOC_BIAS_ON:
-		break;
+	DEBUG_LOG("clk_id =%d ", clk_id);
 
-	case SND_SOC_BIAS_PREPARE:
-		/* VMID=2x40k */
-		snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_1,
-				    WM8994_VMID_SEL_MASK, 0x2);
+	switch (clk_id) {
+	case WM8994_SYSCLK_MCLK:
+		wm8994->mclk_rate = freq;
+		wm8994->sysclk_source = clk_id;
 		break;
-
-	case SND_SOC_BIAS_STANDBY:
-		if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
-			pm_runtime_get_sync(codec->dev);
-
-			switch (control->type) {
-			case WM8994:
-				if (wm8994->revision < 4) {
-					/* Tweak DC servo and DSP
-					 * configuration for improved
-					 * performance. */
-					snd_soc_write(codec, 0x102, 0x3);
-					snd_soc_write(codec, 0x56, 0x3);
-					snd_soc_write(codec, 0x817, 0);
-					snd_soc_write(codec, 0x102, 0);
-				}
-				break;
-
-			case WM8958:
-				if (wm8994->revision == 0) {
-					/* Optimise performance for rev A */
-					snd_soc_write(codec, 0x102, 0x3);
-					snd_soc_write(codec, 0xcb, 0x81);
-					snd_soc_write(codec, 0x817, 0);
-					snd_soc_write(codec, 0x102, 0);
-
-					snd_soc_update_bits(codec,
-							    WM8958_CHARGE_PUMP_2,
-							    WM8958_CP_DISCH,
-							    WM8958_CP_DISCH);
-				}
-				break;
-			}
-
-			/* Discharge LINEOUT1 & 2 */
-			snd_soc_update_bits(codec, WM8994_ANTIPOP_1,
-					    WM8994_LINEOUT1_DISCH |
-					    WM8994_LINEOUT2_DISCH,
-					    WM8994_LINEOUT1_DISCH |
-					    WM8994_LINEOUT2_DISCH);
-
-			/* Startup bias, VMID ramp & buffer */
-			snd_soc_update_bits(codec, WM8994_ANTIPOP_2,
-					    WM8994_STARTUP_BIAS_ENA |
-					    WM8994_VMID_BUF_ENA |
-					    WM8994_VMID_RAMP_MASK,
-					    WM8994_STARTUP_BIAS_ENA |
-					    WM8994_VMID_BUF_ENA |
-					    (0x11 << WM8994_VMID_RAMP_SHIFT));
-
-			/* Main bias enable, VMID=2x40k */
-			snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_1,
-					    WM8994_BIAS_ENA |
-					    WM8994_VMID_SEL_MASK,
-					    WM8994_BIAS_ENA | 0x2);
-
-			msleep(20);
-		}
-
-		/* VMID=2x500k */
-		snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_1,
-				    WM8994_VMID_SEL_MASK, 0x4);
-
+	case WM8994_SYSCLK_FLL:
+		wm8994->sysclk_rate = freq;
+		wm8994->sysclk_source = clk_id;
 		break;
 
-	case SND_SOC_BIAS_OFF:
-		if (codec->dapm.bias_level == SND_SOC_BIAS_STANDBY) {
-			/* Switch over to startup biases */
-			snd_soc_update_bits(codec, WM8994_ANTIPOP_2,
-					    WM8994_BIAS_SRC |
-					    WM8994_STARTUP_BIAS_ENA |
-					    WM8994_VMID_BUF_ENA |
-					    WM8994_VMID_RAMP_MASK,
-					    WM8994_BIAS_SRC |
-					    WM8994_STARTUP_BIAS_ENA |
-					    WM8994_VMID_BUF_ENA |
-					    (1 << WM8994_VMID_RAMP_SHIFT));
-
-			/* Disable main biases */
-			snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_1,
-					    WM8994_BIAS_ENA |
-					    WM8994_VMID_SEL_MASK, 0);
-
-			/* Discharge line */
-			snd_soc_update_bits(codec, WM8994_ANTIPOP_1,
-					    WM8994_LINEOUT1_DISCH |
-					    WM8994_LINEOUT2_DISCH,
-					    WM8994_LINEOUT1_DISCH |
-					    WM8994_LINEOUT2_DISCH);
-
-			msleep(5);
-
-			/* Switch off startup biases */
-			snd_soc_update_bits(codec, WM8994_ANTIPOP_2,
-					    WM8994_BIAS_SRC |
-					    WM8994_STARTUP_BIAS_ENA |
-					    WM8994_VMID_BUF_ENA |
-					    WM8994_VMID_RAMP_MASK, 0);
-
-			wm8994->cur_fw = NULL;
-
-			pm_runtime_put(codec->dev);
-		}
-		break;
+	default:
+		return -EINVAL;
 	}
-	codec->dapm.bias_level = level;
+
 	return 0;
 }
 
 static int wm8994_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
 {
 	struct snd_soc_codec *codec = dai->codec;
-	struct wm8994 *control = codec->control_data;
-	int ms_reg;
-	int aif1_reg;
-	int ms = 0;
-	int aif1 = 0;
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
 
-	switch (dai->id) {
-	case 1:
-		ms_reg = WM8994_AIF1_MASTER_SLAVE;
-		aif1_reg = WM8994_AIF1_CONTROL_1;
-		break;
-	case 2:
-		ms_reg = WM8994_AIF2_MASTER_SLAVE;
-		aif1_reg = WM8994_AIF2_CONTROL_1;
-		break;
-	default:
-		return -EINVAL;
-	}
+	unsigned int aif1 = wm8994_read(codec, WM8994_AIF1_CONTROL_1);
+	unsigned int aif2 = wm8994_read(codec, WM8994_AIF1_MASTER_SLAVE);
+
+	DEBUG_LOG("");
+
+	aif1 &= ~(WM8994_AIF1_LRCLK_INV | WM8994_AIF1_BCLK_INV |
+			WM8994_AIF1_WL_MASK | WM8994_AIF1_FMT_MASK);
+
+	aif2 &= ~(WM8994_AIF1_LRCLK_FRC_MASK |
+			WM8994_AIF1_CLK_FRC | WM8994_AIF1_MSTR);
 
 	switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 	case SND_SOC_DAIFMT_CBS_CFS:
+		wm8994->master = 0;
+		break;
+	case SND_SOC_DAIFMT_CBS_CFM:
+		aif2 |= (WM8994_AIF1_MSTR | WM8994_AIF1_LRCLK_FRC);
+		wm8994->master = 1;
+		break;
+	case SND_SOC_DAIFMT_CBM_CFS:
+		aif2 |= (WM8994_AIF1_MSTR | WM8994_AIF1_CLK_FRC);
+		wm8994->master = 1;
 		break;
 	case SND_SOC_DAIFMT_CBM_CFM:
-		ms = WM8994_AIF1_MSTR;
+		aif2 |= (WM8994_AIF1_MSTR | WM8994_AIF1_CLK_FRC |
+				WM8994_AIF1_LRCLK_FRC);
+		wm8994->master = 1;
 		break;
 	default:
 		return -EINVAL;
@@ -1990,7 +1067,6 @@ static int wm8994_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
 	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 	case SND_SOC_DAIFMT_DSP_A:
 	case SND_SOC_DAIFMT_DSP_B:
-		/* frame inversion not valid for DSP modes */
 		switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 		case SND_SOC_DAIFMT_NB_NF:
 			break;
@@ -2025,254 +1101,156 @@ static int wm8994_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
 		return -EINVAL;
 	}
 
-	/* The AIF2 format configuration needs to be mirrored to AIF3
-	 * on WM8958 if it's in use so just do it all the time. */
-	if (control->type == WM8958 && dai->id == 2)
-		snd_soc_update_bits(codec, WM8958_AIF3_CONTROL_1,
-				    WM8994_AIF1_LRCLK_INV |
-				    WM8958_AIF3_FMT_MASK, aif1);
-
-	snd_soc_update_bits(codec, aif1_reg,
-			    WM8994_AIF1_BCLK_INV | WM8994_AIF1_LRCLK_INV |
-			    WM8994_AIF1_FMT_MASK,
-			    aif1);
-	snd_soc_update_bits(codec, ms_reg, WM8994_AIF1_MSTR,
-			    ms);
+	aif1 |= 0x4000;
+	wm8994_write(codec, WM8994_AIF1_CONTROL_1, aif1);
+	wm8994_write(codec, WM8994_AIF1_MASTER_SLAVE, aif2);
+	wm8994_write(codec, WM8994_AIF1_CONTROL_2, 0x4000);
 
 	return 0;
 }
 
-static struct {
-	int val, rate;
-} srs[] = {
-	{ 0,   8000 },
-	{ 1,  11025 },
-	{ 2,  12000 },
-	{ 3,  16000 },
-	{ 4,  22050 },
-	{ 5,  24000 },
-	{ 6,  32000 },
-	{ 7,  44100 },
-	{ 8,  48000 },
-	{ 9,  88200 },
-	{ 10, 96000 },
-};
-
-static int fs_ratios[] = {
-	64, 128, 192, 256, 348, 512, 768, 1024, 1408, 1536
-};
-
-static int bclk_divs[] = {
-	10, 15, 20, 30, 40, 50, 60, 80, 110, 120, 160, 220, 240, 320, 440, 480,
-	640, 880, 960, 1280, 1760, 1920
-};
-
 static int wm8994_hw_params(struct snd_pcm_substream *substream,
 			    struct snd_pcm_hw_params *params,
 			    struct snd_soc_dai *dai)
 {
 	struct snd_soc_codec *codec = dai->codec;
-	struct wm8994 *control = codec->control_data;
 	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	int aif1_reg;
-	int aif2_reg;
-	int bclk_reg;
-	int lrclk_reg;
-	int rate_reg;
-	int aif1 = 0;
-	int aif2 = 0;
-	int bclk = 0;
-	int lrclk = 0;
-	int rate_val = 0;
-	int id = dai->id - 1;
-
-	int i, cur_val, best_val, bclk_rate, best;
-
-	switch (dai->id) {
-	case 1:
-		aif1_reg = WM8994_AIF1_CONTROL_1;
-		aif2_reg = WM8994_AIF1_CONTROL_2;
-		bclk_reg = WM8994_AIF1_BCLK;
-		rate_reg = WM8994_AIF1_RATE;
-		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK ||
-		    wm8994->lrclk_shared[0]) {
-			lrclk_reg = WM8994_AIF1DAC_LRCLK;
-		} else {
-			lrclk_reg = WM8994_AIF1ADC_LRCLK;
-			dev_dbg(codec->dev, "AIF1 using split LRCLK\n");
-		}
-		break;
-	case 2:
-		aif1_reg = WM8994_AIF2_CONTROL_1;
-		aif2_reg = WM8994_AIF2_CONTROL_2;
-		bclk_reg = WM8994_AIF2_BCLK;
-		rate_reg = WM8994_AIF2_RATE;
-		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK ||
-		    wm8994->lrclk_shared[1]) {
-			lrclk_reg = WM8994_AIF2DAC_LRCLK;
-		} else {
-			lrclk_reg = WM8994_AIF2ADC_LRCLK;
-			dev_dbg(codec->dev, "AIF2 using split LRCLK\n");
-		}
-		break;
-	case 3:
-		switch (control->type) {
-		case WM8958:
-			aif1_reg = WM8958_AIF3_CONTROL_1;
-			break;
-		default:
-			return 0;
-		}
-	default:
-		return -EINVAL;
-	}
+	int ret, i, best, best_val, cur_val;
+	unsigned int clocking1, clocking3, aif1, aif4, aif5;
+
+	DEBUG_LOG("");
+
+	clocking1 = wm8994_read(codec, WM8994_AIF1_BCLK);
+	clocking1 &= ~WM8994_AIF1_BCLK_DIV_MASK;
+
+	clocking3 = wm8994_read(codec, WM8994_AIF1_RATE);
+	clocking3 &= ~(WM8994_AIF1_SR_MASK | WM8994_AIF1CLK_RATE_MASK);
+
+	aif1 = wm8994_read(codec, WM8994_AIF1_CONTROL_1);
+	aif1 &= ~WM8994_AIF1_WL_MASK;
+	aif4 = wm8994_read(codec, WM8994_AIF1ADC_LRCLK);
+	aif4 &= ~WM8994_AIF1ADC_LRCLK_DIR;
+	aif5 = wm8994_read(codec, WM8994_AIF1DAC_LRCLK);
+	aif5 &= ~WM8994_AIF1DAC_LRCLK_DIR_MASK;
+
+	wm8994->fs = params_rate(params);
+	wm8994->bclk = 2 * wm8994->fs;
 
-	bclk_rate = params_rate(params) * 4;
 	switch (params_format(params)) {
 	case SNDRV_PCM_FORMAT_S16_LE:
-		bclk_rate *= 16;
+		wm8994->bclk *= 16;
 		break;
+
 	case SNDRV_PCM_FORMAT_S20_3LE:
-		bclk_rate *= 20;
-		aif1 |= 0x20;
+		wm8994->bclk *= 20;
+		aif1 |= (0x01 << WM8994_AIF1_WL_SHIFT);
 		break;
+
 	case SNDRV_PCM_FORMAT_S24_LE:
-		bclk_rate *= 24;
-		aif1 |= 0x40;
+		wm8994->bclk *= 24;
+		aif1 |= (0x10 << WM8994_AIF1_WL_SHIFT);
 		break;
+
 	case SNDRV_PCM_FORMAT_S32_LE:
-		bclk_rate *= 32;
-		aif1 |= 0x60;
+		wm8994->bclk *= 32;
+		aif1 |= (0x11 << WM8994_AIF1_WL_SHIFT);
 		break;
+
 	default:
 		return -EINVAL;
 	}
 
-	/* Try to find an appropriate sample rate; look for an exact match. */
-	for (i = 0; i < ARRAY_SIZE(srs); i++)
-		if (srs[i].rate == params_rate(params))
-			break;
-	if (i == ARRAY_SIZE(srs))
-		return -EINVAL;
-	rate_val |= srs[i].val << WM8994_AIF1_SR_SHIFT;
+	ret = configure_clock(codec);
+	if (ret != 0)
+		return ret;
 
-	dev_dbg(dai->dev, "Sample rate is %dHz\n", srs[i].rate);
-	dev_dbg(dai->dev, "AIF%dCLK is %dHz, target BCLK %dHz\n",
-		dai->id, wm8994->aifclk[id], bclk_rate);
+	dev_dbg(codec->dev, "Target BCLK is %dHz\n", wm8994->bclk);
 
-	if (params_channels(params) == 1 &&
-	    (snd_soc_read(codec, aif1_reg) & 0x18) == 0x18)
-		aif2 |= WM8994_AIF1_MONO;
+	/* Select nearest CLK_SYS_RATE */
+	if (wm8994->fs == 8000)
+		best = 3;
+	else {
+		best = 0;
+		best_val = abs((wm8994->sysclk_rate / clk_sys_rates[0].ratio)
+				- wm8994->fs);
 
-	if (wm8994->aifclk[id] == 0) {
-		dev_err(dai->dev, "AIF%dCLK not configured\n", dai->id);
-		return -EINVAL;
+		for (i = 1; i < ARRAY_SIZE(clk_sys_rates); i++) {
+			cur_val = abs((wm8994->sysclk_rate /
+					clk_sys_rates[i].ratio)	- wm8994->fs);
+
+			if (cur_val < best_val) {
+				best = i;
+				best_val = cur_val;
+			}
+		}
+		dev_dbg(codec->dev, "Selected CLK_SYS_RATIO of %d\n",
+				clk_sys_rates[best].ratio);
 	}
 
-	/* AIFCLK/fs ratio; look for a close match in either direction */
+	clocking3 |= (clk_sys_rates[best].clk_sys_rate
+			<< WM8994_AIF1CLK_RATE_SHIFT);
+
+	/* Sampling rate */
 	best = 0;
-	best_val = abs((fs_ratios[0] * params_rate(params))
-		       - wm8994->aifclk[id]);
-	for (i = 1; i < ARRAY_SIZE(fs_ratios); i++) {
-		cur_val = abs((fs_ratios[i] * params_rate(params))
-			      - wm8994->aifclk[id]);
-		if (cur_val >= best_val)
-			continue;
-		best = i;
-		best_val = cur_val;
+	best_val = abs(wm8994->fs - sample_rates[0].rate);
+	for (i = 1; i < ARRAY_SIZE(sample_rates); i++) {
+		cur_val = abs(wm8994->fs - sample_rates[i].rate);
+		if (cur_val < best_val) {
+			best = i;
+			best_val = cur_val;
+		}
 	}
-	dev_dbg(dai->dev, "Selected AIF%dCLK/fs = %d\n",
-		dai->id, fs_ratios[best]);
-	rate_val |= best;
-
-	/* We may not get quite the right frequency if using
-	 * approximate clocks so look for the closest match that is
-	 * higher than the target (we need to ensure that there enough
-	 * BCLKs to clock out the samples).
-	 */
+	dev_dbg(codec->dev, "Selected SAMPLE_RATE of %dHz\n",
+			sample_rates[best].rate);
+
+	clocking3 |= (sample_rates[best].sample_rate << WM8994_AIF1_SR_SHIFT);
+
+	/* BCLK_DIV */
 	best = 0;
+	best_val = INT_MAX;
 	for (i = 0; i < ARRAY_SIZE(bclk_divs); i++) {
-		cur_val = (wm8994->aifclk[id] * 10 / bclk_divs[i]) - bclk_rate;
-		if (cur_val < 0) /* BCLK table is sorted */
-			break;
-		best = i;
-	}
-	bclk_rate = wm8994->aifclk[id] * 10 / bclk_divs[best];
-	dev_dbg(dai->dev, "Using BCLK_DIV %d for actual BCLK %dHz\n",
-		bclk_divs[best], bclk_rate);
-	bclk |= best << WM8994_AIF1_BCLK_DIV_SHIFT;
-
-	lrclk = bclk_rate / params_rate(params);
-	dev_dbg(dai->dev, "Using LRCLK rate %d for actual LRCLK %dHz\n",
-		lrclk, bclk_rate / lrclk);
-
-	snd_soc_update_bits(codec, aif1_reg, WM8994_AIF1_WL_MASK, aif1);
-	snd_soc_update_bits(codec, aif2_reg, WM8994_AIF1_MONO, aif2);
-	snd_soc_update_bits(codec, bclk_reg, WM8994_AIF1_BCLK_DIV_MASK, bclk);
-	snd_soc_update_bits(codec, lrclk_reg, WM8994_AIF1DAC_RATE_MASK,
-			    lrclk);
-	snd_soc_update_bits(codec, rate_reg, WM8994_AIF1_SR_MASK |
-			    WM8994_AIF1CLK_RATE_MASK, rate_val);
-
-	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-		switch (dai->id) {
-		case 1:
-			wm8994->dac_rates[0] = params_rate(params);
-			wm8994_set_retune_mobile(codec, 0);
-			wm8994_set_retune_mobile(codec, 1);
-			break;
-		case 2:
-			wm8994->dac_rates[1] = params_rate(params);
-			wm8994_set_retune_mobile(codec, 2);
+		cur_val = ((wm8994->sysclk_rate) / bclk_divs[i].div)
+				  - wm8994->bclk;
+		if (cur_val < 0)
 			break;
+		if (cur_val < best_val) {
+			best = i;
+			best_val = cur_val;
 		}
 	}
+	wm8994->bclk = (wm8994->sysclk_rate) / bclk_divs[best].div;
 
-	return 0;
-}
+	dev_dbg(codec->dev, "Selected BCLK_DIV of %d for %dHz BCLK\n",
+			bclk_divs[best].div, wm8994->bclk);
 
-static int wm8994_aif3_hw_params(struct snd_pcm_substream *substream,
-				 struct snd_pcm_hw_params *params,
-				 struct snd_soc_dai *dai)
-{
-	struct snd_soc_codec *codec = dai->codec;
-	struct wm8994 *control = codec->control_data;
-	int aif1_reg;
-	int aif1 = 0;
+	clocking1 |= bclk_divs[best].bclk_div << WM8994_AIF1_BCLK_DIV_SHIFT;
 
-	switch (dai->id) {
-	case 3:
-		switch (control->type) {
-		case WM8958:
-			aif1_reg = WM8958_AIF3_CONTROL_1;
-			break;
-		default:
-			return 0;
-		}
-	default:
-		return 0;
-	}
+	/* LRCLK is a simple fraction of BCLK */
+	dev_dbg(codec->dev, "LRCLK_RATE is %d\n", wm8994->bclk / wm8994->fs);
 
-	switch (params_format(params)) {
-	case SNDRV_PCM_FORMAT_S16_LE:
-		break;
-	case SNDRV_PCM_FORMAT_S20_3LE:
-		aif1 |= 0x20;
-		break;
-	case SNDRV_PCM_FORMAT_S24_LE:
-		aif1 |= 0x40;
-		break;
-	case SNDRV_PCM_FORMAT_S32_LE:
-		aif1 |= 0x60;
-		break;
-	default:
-		return -EINVAL;
-	}
+	aif4 |= wm8994->bclk / wm8994->fs;
+	aif5 |= wm8994->bclk / wm8994->fs;
+
+#ifdef HDMI_USE_AUDIO
+	/* set bclk to 32fs for 44.1kHz 16 bit playback.*/
+	if (wm8994->fs == 44100)
+		wm8994_write(codec, WM8994_AIF1_BCLK, 0x70);
+#endif
+
+//TODO...we need to set proper BCLK & LRCLK to support different frequency songs..In modifying
+//BCLK & LRCLK , its giving noisy and improper frequency sound..this has to be checked
+#ifndef CONFIG_SND_S5P_WM8994_MASTER
+	//wm8994_write(codec,WM8994_AIF1_BCLK, clocking1);
+	//wm8994_write(codec,WM8994_AIF1ADC_LRCLK, aif4);
+	//wm8994_write(codec,WM8994_AIF1DAC_LRCLK, aif5);
+#endif
+	wm8994_write(codec, WM8994_AIF1_RATE, clocking3);
+	wm8994_write(codec, WM8994_AIF1_CONTROL_1, aif1);
 
-	return snd_soc_update_bits(codec, aif1_reg, WM8994_AIF1_WL_MASK, aif1);
+	return 0;
 }
 
-static int wm8994_aif_mute(struct snd_soc_dai *codec_dai, int mute)
+static int wm8994_digital_mute(struct snd_soc_dai *codec_dai, int mute)
 {
 	struct snd_soc_codec *codec = codec_dai->codec;
 	int mute_reg;
@@ -2299,904 +1277,374 @@ static int wm8994_aif_mute(struct snd_soc_dai *codec_dai, int mute)
 	return 0;
 }
 
-static int wm8994_set_tristate(struct snd_soc_dai *codec_dai, int tristate)
+static int wm8994_startup(struct snd_pcm_substream *substream,
+			  struct snd_soc_dai *codec_dai)
 {
 	struct snd_soc_codec *codec = codec_dai->codec;
-	int reg, val, mask;
-
-	switch (codec_dai->id) {
-	case 1:
-		reg = WM8994_AIF1_MASTER_SLAVE;
-		mask = WM8994_AIF1_TRI;
-		break;
-	case 2:
-		reg = WM8994_AIF2_MASTER_SLAVE;
-		mask = WM8994_AIF2_TRI;
-		break;
-	case 3:
-		reg = WM8994_POWER_MANAGEMENT_6;
-		mask = WM8994_AIF3_TRI;
-		break;
-	default:
-		return -EINVAL;
-	}
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
 
-	if (tristate)
-		val = mask;
+	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+		wm8994->stream_state |=  PCM_STREAM_PLAYBACK;
 	else
-		val = 0;
+		wm8994->stream_state |= PCM_STREAM_CAPTURE;
+
+
+	if (wm8994->power_state == CODEC_OFF) {
+		if (!get_audio_power_status()) {
+			DEBUG_LOG("Power on codec");
+			audio_power(1);
+		}
+
+		wm8994->power_state = CODEC_ON;
+		DEBUG_LOG("Turn on codec!! Power state =[%d]",
+				wm8994->power_state);
 
-	return snd_soc_update_bits(codec, reg, mask, val);
+		/* For initialize codec */
+		wm8994_write(codec, WM8994_POWER_MANAGEMENT_1,
+				0x3 << WM8994_VMID_SEL_SHIFT | WM8994_BIAS_ENA);
+		msleep(50);
+		wm8994_write(codec, WM8994_POWER_MANAGEMENT_1,
+				WM8994_VMID_SEL_NORMAL | WM8994_BIAS_ENA);
+		wm8994_write(codec, WM8994_OVERSAMPLING, 0x0001);
+	} else
+		DEBUG_LOG("Already turned on codec!!");
+
+	return 0;
 }
 
-#define WM8994_RATES SNDRV_PCM_RATE_8000_96000
+static void wm8994_shutdown(struct snd_pcm_substream *substream,
+			    struct snd_soc_dai *codec_dai)
+{
+	wm8994_shutdown_codec(substream, codec_dai->codec);
+}
 
-#define WM8994_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
-			SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
+static void wm8994_shutdown_codec(struct snd_pcm_substream *substream,
+			    struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
 
-static struct snd_soc_dai_ops wm8994_aif1_dai_ops = {
-	.set_sysclk	= wm8994_set_dai_sysclk,
-	.set_fmt	= wm8994_set_dai_fmt,
-	.hw_params	= wm8994_hw_params,
-	.digital_mute	= wm8994_aif_mute,
-	.set_pll	= wm8994_set_fll,
-	.set_tristate	= wm8994_set_tristate,
-};
+	if (wm8994->testmode_config_flag == SEC_TEST_HWCODEC) {
+		DEBUG_LOG_ERR("SEC_TEST_HWCODEC is activated!! Don't shutdown(reset) sequence!!");
+		return;
+	}
 
-static struct snd_soc_dai_ops wm8994_aif2_dai_ops = {
-	.set_sysclk	= wm8994_set_dai_sysclk,
-	.set_fmt	= wm8994_set_dai_fmt,
-	.hw_params	= wm8994_hw_params,
-	.digital_mute   = wm8994_aif_mute,
-	.set_pll	= wm8994_set_fll,
-	.set_tristate	= wm8994_set_tristate,
-};
+	DEBUG_LOG("Stream_state = [0x%X],  Codec State = [0x%X]",
+			wm8994->stream_state, wm8994->codec_state);
+
+	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
+		wm8994->stream_state &=  ~(PCM_STREAM_CAPTURE);
+		wm8994->codec_state &= ~(CAPTURE_ACTIVE);
+	} else {
+		wm8994->codec_state &= ~(PLAYBACK_ACTIVE);
+		wm8994->stream_state &= ~(PCM_STREAM_PLAYBACK);
+	}
+
+	if ((wm8994->codec_state == DEACTIVE) &&
+			(wm8994->stream_state == PCM_STREAM_DEACTIVE)) {
+		DEBUG_LOG("Turn off Codec!!");
+		audio_ctrl_mic_bias_gpio(0);
+		wm8994->power_state = CODEC_OFF;
+		wm8994->cur_path = PLAYBACK_OFF;
+		wm8994->rec_path = MIC_OFF;
+		wm8994->fmradio_path = FMR_OFF;
+		wm8994->fmr_mix_path = FMR_MIX_OFF;
+		wm8994->ringtone_active = OFF;
+		wm8994->call_record_path = CALL_RECORDING_OFF;
+		wm8994->call_record_ch = CH_OFF;
+		wm8994_write(codec, WM8994_SOFTWARE_RESET, 0x0000);
+		return;
+	}
+
+	DEBUG_LOG("Preserve codec state = [0x%X], Stream State = [0x%X]",
+			wm8994->codec_state, wm8994->stream_state);
+
+	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
+		wm8994_disable_rec_path(codec);
+		wm8994->codec_state &= ~(CAPTURE_ACTIVE);
+	} else {
+		if (wm8994->codec_state & CALL_ACTIVE) {
+			int val;
+
+			val = wm8994_read(codec, WM8994_AIF1_DAC1_FILTERS_1);
+			val &= ~(WM8994_AIF1DAC1_MUTE_MASK);
+			val |= (WM8994_AIF1DAC1_MUTE);
+			wm8994_write(codec, WM8994_AIF1_DAC1_FILTERS_1, val);
+		} else if(wm8994->codec_state & CAPTURE_ACTIVE) {
+			wm8994_disable_playback_path(codec);
+		} else if(wm8994->codec_state & FMRADIO_ACTIVE) {
+			// FM radio deactive
+			int val;
+
+			val = wm8994_read(codec, WM8994_AIF1_DAC1_FILTERS_1);
+			val &= ~(WM8994_AIF1DAC1_MUTE_MASK);
+			val |= (WM8994_AIF1DAC1_MUTE);
+			wm8994_write(codec, WM8994_AIF1_DAC1_FILTERS_1, val);
+		} else {
+			// Playback deactive
+		}
+	}
+}
+
+//static struct snd_soc_device *wm8994_socdev;
+static struct snd_soc_codec *wm8994_codec;
 
-static struct snd_soc_dai_ops wm8994_aif3_dai_ops = {
-	.hw_params	= wm8994_aif3_hw_params,
-	.set_tristate	= wm8994_set_tristate,
+#define WM8994_RATES SNDRV_PCM_RATE_8000_96000
+#define WM8994_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
+			SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
+static struct snd_soc_dai_ops wm8994_ops = {
+	.startup = wm8994_startup,
+	.shutdown = wm8994_shutdown,
+	.set_sysclk = wm8994_set_sysclk,
+	.set_fmt = wm8994_set_dai_fmt,
+	.hw_params = wm8994_hw_params,
+	.digital_mute = wm8994_digital_mute,
 };
 
-static struct snd_soc_dai_driver wm8994_dai[] = {
+struct snd_soc_dai_driver wm8994_dai[] = {
 	{
-		.name = "wm8994-aif1",
-		.id = 1,
+		.name = "WM8994 PAIFRX",
 		.playback = {
-			.stream_name = "AIF1 Playback",
+			.stream_name = "Playback",
 			.channels_min = 1,
-			.channels_max = 2,
+			.channels_max = 6,
 			.rates = WM8994_RATES,
 			.formats = WM8994_FORMATS,
 		},
 		.capture = {
-			.stream_name = "AIF1 Capture",
-			.channels_min = 1,
-			.channels_max = 2,
-			.rates = WM8994_RATES,
-			.formats = WM8994_FORMATS,
-		 },
-		.ops = &wm8994_aif1_dai_ops,
-	},
-	{
-		.name = "wm8994-aif2",
-		.id = 2,
-		.playback = {
-			.stream_name = "AIF2 Playback",
+			.stream_name = "Capture",
 			.channels_min = 1,
 			.channels_max = 2,
 			.rates = WM8994_RATES,
 			.formats = WM8994_FORMATS,
 		},
-		.capture = {
-			.stream_name = "AIF2 Capture",
-			.channels_min = 1,
-			.channels_max = 2,
-			.rates = WM8994_RATES,
-			.formats = WM8994_FORMATS,
-		},
-		.ops = &wm8994_aif2_dai_ops,
+		.ops = &wm8994_ops,
 	},
-	{
-		.name = "wm8994-aif3",
-		.id = 3,
-		.playback = {
-			.stream_name = "AIF3 Playback",
-			.channels_min = 1,
-			.channels_max = 2,
-			.rates = WM8994_RATES,
-			.formats = WM8994_FORMATS,
-		},
-		.capture = {
-			.stream_name = "AIF3 Capture",
-			.channels_min = 1,
-			.channels_max = 2,
-			.rates = WM8994_RATES,
-			.formats = WM8994_FORMATS,
-		},
-		.ops = &wm8994_aif3_dai_ops,
-	}
 };
+//EXPORT_SYMBOL_GPL(wm8994_dai);
 
-#ifdef CONFIG_PM
-static int wm8994_suspend(struct snd_soc_codec *codec, pm_message_t state)
-{
-	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	struct wm8994 *control = codec->control_data;
-	int i, ret;
-
-	switch (control->type) {
-	case WM8994:
-		snd_soc_update_bits(codec, WM8994_MICBIAS, WM8994_MICD_ENA, 0);
-		break;
-	case WM8958:
-		snd_soc_update_bits(codec, WM8958_MIC_DETECT_1,
-				    WM8958_MICD_ENA, 0);
-		break;
-	}
-
-	for (i = 0; i < ARRAY_SIZE(wm8994->fll); i++) {
-		memcpy(&wm8994->fll_suspend[i], &wm8994->fll[i],
-		       sizeof(struct wm8994_fll_config));
-		ret = _wm8994_set_fll(codec, i + 1, 0, 0, 0);
-		if (ret < 0)
-			dev_warn(codec->dev, "Failed to stop FLL%d: %d\n",
-				 i + 1, ret);
-	}
-
-	wm8994_set_bias_level(codec, SND_SOC_BIAS_OFF);
-
-	return 0;
-}
-
-static int wm8994_resume(struct snd_soc_codec *codec)
+/*
+ * initialise the WM8994 driver
+ * register the mixer and dsp interfaces with the kernel
+ */
+static int wm8994_init(struct wm8994_priv *wm8994_private)
 {
-	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	struct wm8994 *control = codec->control_data;
-	int i, ret;
-	unsigned int val, mask;
-
-	if (wm8994->revision < 4) {
-		/* force a HW read */
-		val = wm8994_reg_read(codec->control_data,
-				      WM8994_POWER_MANAGEMENT_5);
-
-		/* modify the cache only */
-		codec->cache_only = 1;
-		mask =  WM8994_DAC1R_ENA | WM8994_DAC1L_ENA |
-			WM8994_DAC2R_ENA | WM8994_DAC2L_ENA;
-		val &= mask;
-		snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_5,
-				    mask, val);
-		codec->cache_only = 0;
-	}
-
-	/* Restore the registers */
-	ret = snd_soc_cache_sync(codec);
-	if (ret != 0)
-		dev_err(codec->dev, "Failed to sync cache: %d\n", ret);
-
-	wm8994_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
-
-	for (i = 0; i < ARRAY_SIZE(wm8994->fll); i++) {
-		if (!wm8994->fll_suspend[i].out)
-			continue;
+	struct snd_soc_codec *codec = wm8994_private->codec;
+	struct wm8994_priv *wm8994;
+	int ret = 0;
+	DEBUG_LOG("");
+	wm8994 = kzalloc(sizeof(struct wm8994_priv), GFP_KERNEL);
+	if (wm8994 == NULL)
+		return -ENOMEM;
 
-		ret = _wm8994_set_fll(codec, i + 1,
-				     wm8994->fll_suspend[i].src,
-				     wm8994->fll_suspend[i].in,
-				     wm8994->fll_suspend[i].out);
-		if (ret < 0)
-			dev_warn(codec->dev, "Failed to restore FLL%d: %d\n",
-				 i + 1, ret);
-	}
+	snd_soc_codec_set_drvdata(codec, wm8994);
 
-	switch (control->type) {
-	case WM8994:
-		if (wm8994->micdet[0].jack || wm8994->micdet[1].jack)
-			snd_soc_update_bits(codec, WM8994_MICBIAS,
-					    WM8994_MICD_ENA, WM8994_MICD_ENA);
-		break;
-	case WM8958:
-		if (wm8994->jack_cb)
-			snd_soc_update_bits(codec, WM8958_MIC_DETECT_1,
-					    WM8958_MICD_ENA, WM8958_MICD_ENA);
-		break;
+#if 0
+	mutex_init(&codec->mutex);
+	INIT_LIST_HEAD(&codec->dapm_widgets);
+	INIT_LIST_HEAD(&codec->dapm_paths);
+	codec->name = "WM8994";
+	codec->owner = THIS_MODULE;
+	codec->read = wm8994_read;
+	codec->write = wm8994_write;
+	//codec->set_bias_level = wm8994_set_bias_level;
+	codec->dai = &wm8994_dai;
+	codec->num_dai = 1;//ARRAY_SIZE(wm8994_dai);
+#endif
+	wm8994->universal_playback_path = universal_wm8994_playback_paths;
+	wm8994->universal_voicecall_path = universal_wm8994_voicecall_paths;
+	wm8994->universal_mic_path = universal_wm8994_mic_paths;
+	wm8994->stream_state = PCM_STREAM_DEACTIVE;
+	wm8994->codec_state = DEACTIVE;
+	wm8994->cur_path = PLAYBACK_OFF;
+	wm8994->rec_path = MIC_OFF;
+	wm8994->call_record_path = CALL_RECORDING_OFF;
+	wm8994->call_record_ch = CH_OFF;
+	wm8994->fmradio_path = FMR_OFF;
+	wm8994->fmr_mix_path = FMR_MIX_OFF;
+	wm8994->testmode_config_flag = SEC_NORMAL;
+	wm8994->power_state = CODEC_OFF;
+	wm8994->recognition_active = REC_OFF;
+	wm8994->ringtone_active = OFF;
+
+
+	wm8994_write(codec, WM8994_SOFTWARE_RESET, 0x0000);
+
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, 0x3 << WM8994_VMID_SEL_SHIFT | WM8994_BIAS_ENA);
+	msleep(50);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, WM8994_VMID_SEL_NORMAL | WM8994_BIAS_ENA);
+
+	wm8994->hw_version = wm8994_read(codec, 0x100);
+
+	//wm8994_socdev->card->codec = codec;
+	wm8994_codec = codec;
+
+#if 0
+	ret = snd_soc_new_pcms(wm8994_socdev, SNDRV_DEFAULT_IDX1,
+			       SNDRV_DEFAULT_STR1);
+	if (ret < 0) {
+		DEBUG_LOG_ERR("failed to create pcms\n");
+		goto pcm_err;
 	}
-
-	return 0;
-}
-#else
-#define wm8994_suspend NULL
-#define wm8994_resume NULL
 #endif
 
-static void wm8994_handle_retune_mobile_pdata(struct wm8994_priv *wm8994)
-{
-	struct snd_soc_codec *codec = wm8994->codec;
-	struct wm8994_pdata *pdata = wm8994->pdata;
-	struct snd_kcontrol_new controls[] = {
-		SOC_ENUM_EXT("AIF1.1 EQ Mode",
-			     wm8994->retune_mobile_enum,
-			     wm8994_get_retune_mobile_enum,
-			     wm8994_put_retune_mobile_enum),
-		SOC_ENUM_EXT("AIF1.2 EQ Mode",
-			     wm8994->retune_mobile_enum,
-			     wm8994_get_retune_mobile_enum,
-			     wm8994_put_retune_mobile_enum),
-		SOC_ENUM_EXT("AIF2 EQ Mode",
-			     wm8994->retune_mobile_enum,
-			     wm8994_get_retune_mobile_enum,
-			     wm8994_put_retune_mobile_enum),
-	};
-	int ret, i, j;
-	const char **t;
-
-	/* We need an array of texts for the enum API but the number
-	 * of texts is likely to be less than the number of
-	 * configurations due to the sample rate dependency of the
-	 * configurations. */
-	wm8994->num_retune_mobile_texts = 0;
-	wm8994->retune_mobile_texts = NULL;
-	for (i = 0; i < pdata->num_retune_mobile_cfgs; i++) {
-		for (j = 0; j < wm8994->num_retune_mobile_texts; j++) {
-			if (strcmp(pdata->retune_mobile_cfgs[i].name,
-				   wm8994->retune_mobile_texts[j]) == 0)
-				break;
-		}
-
-		if (j != wm8994->num_retune_mobile_texts)
-			continue;
+	wm8994_add_controls(codec);
+	wm8994_add_widgets(codec);
 
-		/* Expand the array... */
-		t = krealloc(wm8994->retune_mobile_texts,
-			     sizeof(char *) * 
-			     (wm8994->num_retune_mobile_texts + 1),
-			     GFP_KERNEL);
-		if (t == NULL)
-			continue;
-
-		/* ...store the new entry... */
-		t[wm8994->num_retune_mobile_texts] = 
-			pdata->retune_mobile_cfgs[i].name;
-
-		/* ...and remember the new version. */
-		wm8994->num_retune_mobile_texts++;
-		wm8994->retune_mobile_texts = t;
-	}
-
-	dev_dbg(codec->dev, "Allocated %d unique ReTune Mobile names\n",
-		wm8994->num_retune_mobile_texts);
+	return ret;
 
-	wm8994->retune_mobile_enum.max = wm8994->num_retune_mobile_texts;
-	wm8994->retune_mobile_enum.texts = wm8994->retune_mobile_texts;
+//card_err:
+	//snd_soc_free_pcms(wm8994_socdev);
+	//snd_soc_dapm_free(wm8994_socdev);
+//pcm_err:
 
-	ret = snd_soc_add_controls(wm8994->codec, controls,
-				   ARRAY_SIZE(controls));
-	if (ret != 0)
-		dev_err(wm8994->codec->dev,
-			"Failed to add ReTune Mobile controls: %d\n", ret);
+	return ret;
 }
 
-static void wm8994_handle_pdata(struct wm8994_priv *wm8994)
-{
-	struct snd_soc_codec *codec = wm8994->codec;
-	struct wm8994_pdata *pdata = wm8994->pdata;
-	int ret, i;
-
-	if (!pdata)
-		return;
+/* If the i2c layer weren't so broken, we could pass this kind of data
+   around */
 
-	wm_hubs_handle_analogue_pdata(codec, pdata->lineout1_diff,
-				      pdata->lineout2_diff,
-				      pdata->lineout1fb,
-				      pdata->lineout2fb,
-				      pdata->jd_scthr,
-				      pdata->jd_thr,
-				      pdata->micbias1_lvl,
-				      pdata->micbias2_lvl);
-
-	dev_dbg(codec->dev, "%d DRC configurations\n", pdata->num_drc_cfgs);
-
-	if (pdata->num_drc_cfgs) {
-		struct snd_kcontrol_new controls[] = {
-			SOC_ENUM_EXT("AIF1DRC1 Mode", wm8994->drc_enum,
-				     wm8994_get_drc_enum, wm8994_put_drc_enum),
-			SOC_ENUM_EXT("AIF1DRC2 Mode", wm8994->drc_enum,
-				     wm8994_get_drc_enum, wm8994_put_drc_enum),
-			SOC_ENUM_EXT("AIF2DRC Mode", wm8994->drc_enum,
-				     wm8994_get_drc_enum, wm8994_put_drc_enum),
-		};
-
-		/* We need an array of texts for the enum API */
-		wm8994->drc_texts = kmalloc(sizeof(char *)
-					    * pdata->num_drc_cfgs, GFP_KERNEL);
-		if (!wm8994->drc_texts) {
-			dev_err(wm8994->codec->dev,
-				"Failed to allocate %d DRC config texts\n",
-				pdata->num_drc_cfgs);
-			return;
-		}
-
-		for (i = 0; i < pdata->num_drc_cfgs; i++)
-			wm8994->drc_texts[i] = pdata->drc_cfgs[i].name;
+static int wm8994_codec_probe(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994_priv;
+	int ret = -ENODEV;
 
-		wm8994->drc_enum.max = pdata->num_drc_cfgs;
-		wm8994->drc_enum.texts = wm8994->drc_texts;
+	DEBUG_LOG("");
+	pr_info("WM8994 Audio Codec %s\n", WM8994_VERSION);
 
-		ret = snd_soc_add_controls(wm8994->codec, controls,
-					   ARRAY_SIZE(controls));
-		if (ret != 0)
-			dev_err(wm8994->codec->dev,
-				"Failed to add DRC mode controls: %d\n", ret);
+	wm8994_priv = kzalloc(sizeof(struct wm8994_priv), GFP_KERNEL);
+	if (wm8994_priv == NULL)
+		return -ENOMEM;
 
-		for (i = 0; i < WM8994_NUM_DRC; i++)
-			wm8994_set_drc(codec, i);
-	}
+	wm8994_priv->codec = codec;
+#ifdef PM_DEBUG
+	pm_codec = codec;
+#endif
 
-	dev_dbg(codec->dev, "%d ReTune Mobile configurations\n",
-		pdata->num_retune_mobile_cfgs);
+	codec->hw_write = (hw_write_t) i2c_master_send;
+	//i2c_set_clientdata(i2c, wm8994_priv);
+	//codec->control_data = i2c;
+	codec->control_data = to_i2c_client(codec->dev);
+	//codec->dev = &i2c->dev;
 
-	if (pdata->num_retune_mobile_cfgs)
-		wm8994_handle_retune_mobile_pdata(wm8994);
-	else
-		snd_soc_add_controls(wm8994->codec, wm8994_eq_controls,
-				     ARRAY_SIZE(wm8994_eq_controls));
+	ret = wm8994_init(wm8994_priv);
+#ifdef CONFIG_SND_WM8994_EXTENSIONS
+	wm8994_extensions_pcm_probe(codec);
+#endif
+	if (ret)
+		dev_err(codec->dev, "failed to initialize WM8994\n");
 
-	for (i = 0; i < ARRAY_SIZE(pdata->micbias); i++) {
-		if (pdata->micbias[i]) {
-			snd_soc_write(codec, WM8958_MICBIAS1 + i,
-				pdata->micbias[i] & 0xffff);
-		}
-	}
+	return ret;
 }
 
-/**
- * wm8994_mic_detect - Enable microphone detection via the WM8994 IRQ
- *
- * @codec:   WM8994 codec
- * @jack:    jack to report detection events on
- * @micbias: microphone bias to detect on
- * @det:     value to report for presence detection
- * @shrt:    value to report for short detection
- *
- * Enable microphone detection via IRQ on the WM8994.  If GPIOs are
- * being used to bring out signals to the processor then only platform
- * data configuration is needed for WM8994 and processor GPIOs should
- * be configured using snd_soc_jack_add_gpios() instead.
- *
- * Configuration of detection levels is available via the micbias1_lvl
- * and micbias2_lvl platform data members.
- */
-int wm8994_mic_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack,
-		      int micbias, int det, int shrt)
+static int  wm8994_codec_remove(struct snd_soc_codec *codec)
 {
-	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	struct wm8994_micdet *micdet;
-	struct wm8994 *control = codec->control_data;
-	int reg;
-
-	if (control->type != WM8994)
-		return -EINVAL;
-
-	switch (micbias) {
-	case 1:
-		micdet = &wm8994->micdet[0];
-		break;
-	case 2:
-		micdet = &wm8994->micdet[1];
-		break;
-	default:
-		return -EINVAL;
-	}	
-
-	dev_dbg(codec->dev, "Configuring microphone detection on %d: %x %x\n",
-		micbias, det, shrt);
-
-	/* Store the configuration */
-	micdet->jack = jack;
-	micdet->det = det;
-	micdet->shrt = shrt;
-
-	/* If either of the jacks is set up then enable detection */
-	if (wm8994->micdet[0].jack || wm8994->micdet[1].jack)
-		reg = WM8994_MICD_ENA;
-	else 
-		reg = 0;
-
-	snd_soc_update_bits(codec, WM8994_MICBIAS, WM8994_MICD_ENA, reg);
-
+	struct wm8994_priv *wm8994_priv = snd_soc_codec_get_drvdata(codec);
+	kfree(wm8994_priv);
 	return 0;
 }
-EXPORT_SYMBOL_GPL(wm8994_mic_detect);
 
-static irqreturn_t wm8994_mic_irq(int irq, void *data)
+#if 0
+/* power down chip */
+static int wm8994_remove(struct platform_device *pdev)
 {
-	struct wm8994_priv *priv = data;
-	struct snd_soc_codec *codec = priv->codec;
-	int reg;
-	int report;
+	//struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+	struct snd_soc_codec *codec = wm8994_codec;
+
+	//snd_soc_free_pcms(socdev);
+	//snd_soc_dapm_free(socdev);
 
-#ifndef CONFIG_SND_SOC_WM8994_MODULE
-	trace_snd_soc_jack_irq(dev_name(codec->dev));
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+	i2c_unregister_device(codec->control_data);
+	i2c_del_driver(&wm8994_i2c_driver);
 #endif
 
-	reg = snd_soc_read(codec, WM8994_INTERRUPT_RAW_STATUS_2);
-	if (reg < 0) {
-		dev_err(codec->dev, "Failed to read microphone status: %d\n",
-			reg);
-		return IRQ_HANDLED;
-	}
+	//kfree(codec->drvdata);
 
-	dev_dbg(codec->dev, "Microphone status: %x\n", reg);
-
-	report = 0;
-	if (reg & WM8994_MIC1_DET_STS)
-		report |= priv->micdet[0].det;
-	if (reg & WM8994_MIC1_SHRT_STS)
-		report |= priv->micdet[0].shrt;
-	snd_soc_jack_report(priv->micdet[0].jack, report,
-			    priv->micdet[0].det | priv->micdet[0].shrt);
-
-	report = 0;
-	if (reg & WM8994_MIC2_DET_STS)
-		report |= priv->micdet[1].det;
-	if (reg & WM8994_MIC2_SHRT_STS)
-		report |= priv->micdet[1].shrt;
-	snd_soc_jack_report(priv->micdet[1].jack, report,
-			    priv->micdet[1].det | priv->micdet[1].shrt);
-
-	return IRQ_HANDLED;
+	return 0;
 }
+#endif
 
-/* Default microphone detection handler for WM8958 - the user can
- * override this if they wish.
- */
-static void wm8958_default_micdet(u16 status, void *data)
+#ifdef CONFIG_PM
+static int wm8994_suspend(struct snd_soc_codec *codec, pm_message_t state)
 {
-	struct snd_soc_codec *codec = data;
 	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	int report = 0;
 
-	/* If nothing present then clear our statuses */
-	if (!(status & WM8958_MICD_STS))
-		goto done;
+	DEBUG_LOG("Codec State = [0x%X], Stream State = [0x%X]",
+			wm8994->codec_state, wm8994->stream_state);
 
-	report = SND_JACK_MICROPHONE;
+	if (wm8994->testmode_config_flag == SEC_TEST_HWCODEC) {
+		DEBUG_LOG_ERR("SEC_TEST_HWCODEC is activated!! Skip suspend sequence!!");
+		return 0;
+	}
 
-	/* Everything else is buttons; just assign slots */
-	if (status & 0x1c)
-		report |= SND_JACK_BTN_0;
+	if (wm8994->codec_state == DEACTIVE &&
+		wm8994->stream_state == PCM_STREAM_DEACTIVE) {
+		wm8994->power_state = CODEC_OFF;
+		wm8994_write(codec, WM8994_SOFTWARE_RESET, 0x0000);
+		audio_power(0);
+	}
 
-done:
-	snd_soc_jack_report(wm8994->micdet[0].jack, report,
-			    SND_JACK_BTN_0 | SND_JACK_MICROPHONE);
+	return 0;
 }
 
-/**
- * wm8958_mic_detect - Enable microphone detection via the WM8958 IRQ
- *
- * @codec:   WM8958 codec
- * @jack:    jack to report detection events on
- *
- * Enable microphone detection functionality for the WM8958.  By
- * default simple detection which supports the detection of up to 6
- * buttons plus video and microphone functionality is supported.
- *
- * The WM8958 has an advanced jack detection facility which is able to
- * support complex accessory detection, especially when used in
- * conjunction with external circuitry.  In order to provide maximum
- * flexiblity a callback is provided which allows a completely custom
- * detection algorithm.
- */
-int wm8958_mic_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack,
-		      wm8958_micdet_cb cb, void *cb_data)
+static int wm8994_resume(struct snd_soc_codec *codec)
 {
 	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	struct wm8994 *control = codec->control_data;
 
-	if (control->type != WM8958)
-		return -EINVAL;
-
-	if (jack) {
-		if (!cb) {
-			dev_dbg(codec->dev, "Using default micdet callback\n");
-			cb = wm8958_default_micdet;
-			cb_data = codec;
-		}
+	DEBUG_LOG("%s..", __func__);
+	DEBUG_LOG_ERR("------WM8994 Revision = [%d]-------",
+		      wm8994->hw_version);
 
-		wm8994->micdet[0].jack = jack;
-		wm8994->jack_cb = cb;
-		wm8994->jack_cb_data = cb_data;
-
-		snd_soc_update_bits(codec, WM8958_MIC_DETECT_1,
-				    WM8958_MICD_ENA, WM8958_MICD_ENA);
-	} else {
-		snd_soc_update_bits(codec, WM8958_MIC_DETECT_1,
-				    WM8958_MICD_ENA, 0);
+	if (wm8994->testmode_config_flag == SEC_TEST_HWCODEC) {
+		DEBUG_LOG_ERR("SEC_TEST_HWCODEC is activated!! Skip resume sequence!!");
+		return 0;
 	}
 
+	if (wm8994->power_state == CODEC_OFF) {
+		// Turn on sequence by recommend Wolfson.
+		audio_power(1);
+		wm8994->power_state = CODEC_ON;
+		wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, 0x3 << WM8994_VMID_SEL_SHIFT | WM8994_BIAS_ENA);
+		msleep(50);	// Wait to setup PLL.
+		wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, WM8994_VMID_SEL_NORMAL | WM8994_BIAS_ENA);
+		wm8994_write(codec,WM8994_OVERSAMPLING, 0x0000);
+	}
 	return 0;
 }
-EXPORT_SYMBOL_GPL(wm8958_mic_detect);
-
-static irqreturn_t wm8958_mic_irq(int irq, void *data)
-{
-	struct wm8994_priv *wm8994 = data;
-	struct snd_soc_codec *codec = wm8994->codec;
-	int reg;
-
-	reg = snd_soc_read(codec, WM8958_MIC_DETECT_3);
-	if (reg < 0) {
-		dev_err(codec->dev, "Failed to read mic detect status: %d\n",
-			reg);
-		return IRQ_NONE;
-	}
-
-	if (!(reg & WM8958_MICD_VALID)) {
-		dev_dbg(codec->dev, "Mic detect data not valid\n");
-		goto out;
-	}
-
-#ifndef CONFIG_SND_SOC_WM8994_MODULE
-	trace_snd_soc_jack_irq(dev_name(codec->dev));
 #endif
 
-	if (wm8994->jack_cb)
-		wm8994->jack_cb(reg, wm8994->jack_cb_data);
-	else
-		dev_warn(codec->dev, "Accessory detection with no callback\n");
-
-out:
-	return IRQ_HANDLED;
-}
+#if 0
+struct snd_soc_codec_device soc_codec_dev_wm8994 = {
+	.probe = wm8994_probe,
+	.remove = wm8994_remove,
+#ifdef CONFIG_PM
+	.suspend = wm8994_suspend,
+	.resume = wm8994_resume,
+#endif
+};
+#endif
 
-static int wm8994_codec_probe(struct snd_soc_codec *codec)
+#if 0
+static int __init wm8994_modinit(void)
 {
-	struct wm8994 *control;
-	struct wm8994_priv *wm8994;
-	struct snd_soc_dapm_context *dapm = &codec->dapm;
-	int ret, i;
-
-	codec->control_data = dev_get_drvdata(codec->dev->parent);
-	control = codec->control_data;
-
-	wm8994 = kzalloc(sizeof(struct wm8994_priv), GFP_KERNEL);
-	if (wm8994 == NULL)
-		return -ENOMEM;
-	snd_soc_codec_set_drvdata(codec, wm8994);
-
-	wm8994->pdata = dev_get_platdata(codec->dev->parent);
-	wm8994->codec = codec;
-
-	if (wm8994->pdata && wm8994->pdata->micdet_irq)
-		wm8994->micdet_irq = wm8994->pdata->micdet_irq;
-	else if (wm8994->pdata && wm8994->pdata->irq_base)
-		wm8994->micdet_irq = wm8994->pdata->irq_base +
-				     WM8994_IRQ_MIC1_DET;
-
-	pm_runtime_enable(codec->dev);
-	pm_runtime_resume(codec->dev);
-
-	/* Read our current status back from the chip - we don't want to
-	 * reset as this may interfere with the GPIO or LDO operation. */
-	for (i = 0; i < WM8994_CACHE_SIZE; i++) {
-		if (!wm8994_readable(codec, i) || wm8994_volatile(codec, i))
-			continue;
-
-		ret = wm8994_reg_read(codec->control_data, i);
-		if (ret <= 0)
-			continue;
-
-		ret = snd_soc_cache_write(codec, i, ret);
-		if (ret != 0) {
-			dev_err(codec->dev,
-				"Failed to initialise cache for 0x%x: %d\n",
-				i, ret);
-			goto err;
-		}
-	}
-
-	/* Set revision-specific configuration */
-	wm8994->revision = snd_soc_read(codec, WM8994_CHIP_REVISION);
-	switch (control->type) {
-	case WM8994:
-		switch (wm8994->revision) {
-		case 2:
-		case 3:
-			wm8994->hubs.dcs_codes = -5;
-			wm8994->hubs.hp_startup_mode = 1;
-			wm8994->hubs.dcs_readback_mode = 1;
-			break;
-		default:
-			wm8994->hubs.dcs_readback_mode = 1;
-			break;
-		}
-
-	case WM8958:
-		wm8994->hubs.dcs_readback_mode = 1;
-		break;
-
-	default:
-		break;
-	}
-
-	switch (control->type) {
-	case WM8994:
-		if (wm8994->micdet_irq) {
-			ret = request_threaded_irq(wm8994->micdet_irq, NULL,
-						   wm8994_mic_irq,
-						   IRQF_TRIGGER_RISING,
-						   "Mic1 detect",
-						   wm8994);
-			if (ret != 0)
-				dev_warn(codec->dev,
-					 "Failed to request Mic1 detect IRQ: %d\n",
-					 ret);
-		}
-
-		ret = wm8994_request_irq(codec->control_data,
-					 WM8994_IRQ_MIC1_SHRT,
-					 wm8994_mic_irq, "Mic 1 short",
-					 wm8994);
-		if (ret != 0)
-			dev_warn(codec->dev,
-				 "Failed to request Mic1 short IRQ: %d\n",
-				 ret);
-
-		ret = wm8994_request_irq(codec->control_data,
-					 WM8994_IRQ_MIC2_DET,
-					 wm8994_mic_irq, "Mic 2 detect",
-					 wm8994);
-		if (ret != 0)
-			dev_warn(codec->dev,
-				 "Failed to request Mic2 detect IRQ: %d\n",
-				 ret);
-
-		ret = wm8994_request_irq(codec->control_data,
-					 WM8994_IRQ_MIC2_SHRT,
-					 wm8994_mic_irq, "Mic 2 short",
-					 wm8994);
-		if (ret != 0)
-			dev_warn(codec->dev,
-				 "Failed to request Mic2 short IRQ: %d\n",
-				 ret);
-		break;
-
-	case WM8958:
-		if (wm8994->micdet_irq) {
-			ret = request_threaded_irq(wm8994->micdet_irq, NULL,
-						   wm8958_mic_irq,
-						   IRQF_TRIGGER_RISING,
-						   "Mic detect",
-						   wm8994);
-			if (ret != 0)
-				dev_warn(codec->dev,
-					 "Failed to request Mic detect IRQ: %d\n",
-					 ret);
-		}
-	}
-
-	/* Remember if AIFnLRCLK is configured as a GPIO.  This should be
-	 * configured on init - if a system wants to do this dynamically
-	 * at runtime we can deal with that then.
-	 */
-	ret = wm8994_reg_read(codec->control_data, WM8994_GPIO_1);
-	if (ret < 0) {
-		dev_err(codec->dev, "Failed to read GPIO1 state: %d\n", ret);
-		goto err_irq;
-	}
-	if ((ret & WM8994_GPN_FN_MASK) != WM8994_GP_FN_PIN_SPECIFIC) {
-		wm8994->lrclk_shared[0] = 1;
-		wm8994_dai[0].symmetric_rates = 1;
-	} else {
-		wm8994->lrclk_shared[0] = 0;
-	}
-
-	ret = wm8994_reg_read(codec->control_data, WM8994_GPIO_6);
-	if (ret < 0) {
-		dev_err(codec->dev, "Failed to read GPIO6 state: %d\n", ret);
-		goto err_irq;
-	}
-	if ((ret & WM8994_GPN_FN_MASK) != WM8994_GP_FN_PIN_SPECIFIC) {
-		wm8994->lrclk_shared[1] = 1;
-		wm8994_dai[1].symmetric_rates = 1;
-	} else {
-		wm8994->lrclk_shared[1] = 0;
-	}
-
-	wm8994_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
-
-	/* Latch volume updates (right only; we always do left then right). */
-	snd_soc_update_bits(codec, WM8994_AIF1_DAC1_LEFT_VOLUME,
-			    WM8994_AIF1DAC1_VU, WM8994_AIF1DAC1_VU);
-	snd_soc_update_bits(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME,
-			    WM8994_AIF1DAC1_VU, WM8994_AIF1DAC1_VU);
-	snd_soc_update_bits(codec, WM8994_AIF1_DAC2_LEFT_VOLUME,
-			    WM8994_AIF1DAC2_VU, WM8994_AIF1DAC2_VU);
-	snd_soc_update_bits(codec, WM8994_AIF1_DAC2_RIGHT_VOLUME,
-			    WM8994_AIF1DAC2_VU, WM8994_AIF1DAC2_VU);
-	snd_soc_update_bits(codec, WM8994_AIF2_DAC_LEFT_VOLUME,
-			    WM8994_AIF2DAC_VU, WM8994_AIF2DAC_VU);
-	snd_soc_update_bits(codec, WM8994_AIF2_DAC_RIGHT_VOLUME,
-			    WM8994_AIF2DAC_VU, WM8994_AIF2DAC_VU);
-	snd_soc_update_bits(codec, WM8994_AIF1_ADC1_LEFT_VOLUME,
-			    WM8994_AIF1ADC1_VU, WM8994_AIF1ADC1_VU);
-	snd_soc_update_bits(codec, WM8994_AIF1_ADC1_RIGHT_VOLUME,
-			    WM8994_AIF1ADC1_VU, WM8994_AIF1ADC1_VU);
-	snd_soc_update_bits(codec, WM8994_AIF1_ADC2_LEFT_VOLUME,
-			    WM8994_AIF1ADC2_VU, WM8994_AIF1ADC2_VU);
-	snd_soc_update_bits(codec, WM8994_AIF1_ADC2_RIGHT_VOLUME,
-			    WM8994_AIF1ADC2_VU, WM8994_AIF1ADC2_VU);
-	snd_soc_update_bits(codec, WM8994_AIF2_ADC_LEFT_VOLUME,
-			    WM8994_AIF2ADC_VU, WM8994_AIF1ADC2_VU);
-	snd_soc_update_bits(codec, WM8994_AIF2_ADC_RIGHT_VOLUME,
-			    WM8994_AIF2ADC_VU, WM8994_AIF1ADC2_VU);
-	snd_soc_update_bits(codec, WM8994_DAC1_LEFT_VOLUME,
-			    WM8994_DAC1_VU, WM8994_DAC1_VU);
-	snd_soc_update_bits(codec, WM8994_DAC1_RIGHT_VOLUME,
-			    WM8994_DAC1_VU, WM8994_DAC1_VU);
-	snd_soc_update_bits(codec, WM8994_DAC2_LEFT_VOLUME,
-			    WM8994_DAC2_VU, WM8994_DAC2_VU);
-	snd_soc_update_bits(codec, WM8994_DAC2_RIGHT_VOLUME,
-			    WM8994_DAC2_VU, WM8994_DAC2_VU);
-
-	/* Set the low bit of the 3D stereo depth so TLV matches */
-	snd_soc_update_bits(codec, WM8994_AIF1_DAC1_FILTERS_2,
-			    1 << WM8994_AIF1DAC1_3D_GAIN_SHIFT,
-			    1 << WM8994_AIF1DAC1_3D_GAIN_SHIFT);
-	snd_soc_update_bits(codec, WM8994_AIF1_DAC2_FILTERS_2,
-			    1 << WM8994_AIF1DAC2_3D_GAIN_SHIFT,
-			    1 << WM8994_AIF1DAC2_3D_GAIN_SHIFT);
-	snd_soc_update_bits(codec, WM8994_AIF2_DAC_FILTERS_2,
-			    1 << WM8994_AIF2DAC_3D_GAIN_SHIFT,
-			    1 << WM8994_AIF2DAC_3D_GAIN_SHIFT);
-
-	/* Unconditionally enable AIF1 ADC TDM mode; it only affects
-	 * behaviour on idle TDM clock cycles. */
-	snd_soc_update_bits(codec, WM8994_AIF1_CONTROL_1,
-			    WM8994_AIF1ADC_TDM, WM8994_AIF1ADC_TDM);
-
-	wm8994_update_class_w(codec);
-
-	wm8994_handle_pdata(wm8994);
-
-	wm_hubs_add_analogue_controls(codec);
-	snd_soc_add_controls(codec, wm8994_snd_controls,
-			     ARRAY_SIZE(wm8994_snd_controls));
-	snd_soc_dapm_new_controls(dapm, wm8994_dapm_widgets,
-				  ARRAY_SIZE(wm8994_dapm_widgets));
-
-	switch (control->type) {
-	case WM8994:
-		snd_soc_dapm_new_controls(dapm, wm8994_specific_dapm_widgets,
-					  ARRAY_SIZE(wm8994_specific_dapm_widgets));
-		if (wm8994->revision < 4) {
-			snd_soc_dapm_new_controls(dapm, wm8994_lateclk_revd_widgets,
-						  ARRAY_SIZE(wm8994_lateclk_revd_widgets));
-			snd_soc_dapm_new_controls(dapm, wm8994_adc_revd_widgets,
-						  ARRAY_SIZE(wm8994_adc_revd_widgets));
-			snd_soc_dapm_new_controls(dapm, wm8994_dac_revd_widgets,
-						  ARRAY_SIZE(wm8994_dac_revd_widgets));
-		} else {
-			snd_soc_dapm_new_controls(dapm, wm8994_lateclk_widgets,
-						  ARRAY_SIZE(wm8994_lateclk_widgets));
-			snd_soc_dapm_new_controls(dapm, wm8994_adc_widgets,
-						  ARRAY_SIZE(wm8994_adc_widgets));
-			snd_soc_dapm_new_controls(dapm, wm8994_dac_widgets,
-						  ARRAY_SIZE(wm8994_dac_widgets));
-		}
-		break;
-	case WM8958:
-		snd_soc_add_controls(codec, wm8958_snd_controls,
-				     ARRAY_SIZE(wm8958_snd_controls));
-		snd_soc_dapm_new_controls(dapm, wm8958_dapm_widgets,
-					  ARRAY_SIZE(wm8958_dapm_widgets));
-		if (wm8994->revision < 1) {
-			snd_soc_dapm_new_controls(dapm, wm8994_lateclk_revd_widgets,
-						  ARRAY_SIZE(wm8994_lateclk_revd_widgets));
-			snd_soc_dapm_new_controls(dapm, wm8994_adc_revd_widgets,
-						  ARRAY_SIZE(wm8994_adc_revd_widgets));
-			snd_soc_dapm_new_controls(dapm, wm8994_dac_revd_widgets,
-						  ARRAY_SIZE(wm8994_dac_revd_widgets));
-		} else {
-			snd_soc_dapm_new_controls(dapm, wm8994_lateclk_widgets,
-						  ARRAY_SIZE(wm8994_lateclk_widgets));
-			snd_soc_dapm_new_controls(dapm, wm8994_adc_widgets,
-						  ARRAY_SIZE(wm8994_adc_widgets));
-			snd_soc_dapm_new_controls(dapm, wm8994_dac_widgets,
-						  ARRAY_SIZE(wm8994_dac_widgets));
-		}
-		break;
-	}
-		
-
-	wm_hubs_add_analogue_routes(codec, 0, 0);
-	snd_soc_dapm_add_routes(dapm, intercon, ARRAY_SIZE(intercon));
-
-	switch (control->type) {
-	case WM8994:
-		snd_soc_dapm_add_routes(dapm, wm8994_intercon,
-					ARRAY_SIZE(wm8994_intercon));
-
-		if (wm8994->revision < 4) {
-			snd_soc_dapm_add_routes(dapm, wm8994_revd_intercon,
-						ARRAY_SIZE(wm8994_revd_intercon));
-			snd_soc_dapm_add_routes(dapm, wm8994_lateclk_revd_intercon,
-						ARRAY_SIZE(wm8994_lateclk_revd_intercon));
-		} else {
-			snd_soc_dapm_add_routes(dapm, wm8994_lateclk_intercon,
-						ARRAY_SIZE(wm8994_lateclk_intercon));
-		}
-		break;
-	case WM8958:
-		if (wm8994->revision < 1) {
-			snd_soc_dapm_add_routes(dapm, wm8994_revd_intercon,
-						ARRAY_SIZE(wm8994_revd_intercon));
-			snd_soc_dapm_add_routes(dapm, wm8994_lateclk_revd_intercon,
-						ARRAY_SIZE(wm8994_lateclk_revd_intercon));
-		} else {
-			snd_soc_dapm_add_routes(dapm, wm8994_lateclk_intercon,
-						ARRAY_SIZE(wm8994_lateclk_intercon));
-			snd_soc_dapm_add_routes(dapm, wm8958_intercon,
-						ARRAY_SIZE(wm8958_intercon));
-		}
-
-		wm8958_dsp2_init(codec);
-		break;
-	}
-
-	return 0;
+	int ret;
+	ret = snd_soc_register_dai(&wm8994_dai);
+	if (ret)
+		pr_err("..dai registration failed..\n");
 
-err_irq:
-	wm8994_free_irq(codec->control_data, WM8994_IRQ_MIC2_SHRT, wm8994);
-	wm8994_free_irq(codec->control_data, WM8994_IRQ_MIC2_DET, wm8994);
-	wm8994_free_irq(codec->control_data, WM8994_IRQ_MIC1_SHRT, wm8994);
-	if (wm8994->micdet_irq)
-		free_irq(wm8994->micdet_irq, wm8994);
-err:
-	kfree(wm8994);
 	return ret;
 }
 
-static int  wm8994_codec_remove(struct snd_soc_codec *codec)
-{
-	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
-	struct wm8994 *control = codec->control_data;
-
-	wm8994_set_bias_level(codec, SND_SOC_BIAS_OFF);
-
-	pm_runtime_disable(codec->dev);
-
-	switch (control->type) {
-	case WM8994:
-		if (wm8994->micdet_irq)
-			free_irq(wm8994->micdet_irq, wm8994);
-		wm8994_free_irq(codec->control_data, WM8994_IRQ_MIC2_DET,
-				wm8994);
-		wm8994_free_irq(codec->control_data, WM8994_IRQ_MIC1_SHRT,
-				wm8994);
-		wm8994_free_irq(codec->control_data, WM8994_IRQ_MIC1_DET,
-				wm8994);
-		break;
-
-	case WM8958:
-		if (wm8994->micdet_irq)
-			free_irq(wm8994->micdet_irq, wm8994);
-		break;
-	}
-	if (wm8994->mbc)
-		release_firmware(wm8994->mbc);
-	if (wm8994->mbc_vss)
-		release_firmware(wm8994->mbc_vss);
-	if (wm8994->enh_eq)
-		release_firmware(wm8994->enh_eq);
-	kfree(wm8994->retune_mobile_texts);
-	kfree(wm8994->drc_texts);
-	kfree(wm8994);
+module_init(wm8994_modinit);
 
-	return 0;
+static void __exit wm8994_exit(void)
+{
+	snd_soc_unregister_dai(&wm8994_dai);
 }
 
+module_exit(wm8994_exit);
+#endif
+
 static struct snd_soc_codec_driver soc_codec_dev_wm8994 = {
 	.probe =	wm8994_codec_probe,
 	.remove =	wm8994_codec_remove,
@@ -3204,51 +1652,65 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8994 = {
 	.resume =	wm8994_resume,
 	.read =		wm8994_read,
 	.write =	wm8994_write,
-	.readable_register = wm8994_readable,
-	.volatile_register = wm8994_volatile,
-	.set_bias_level = wm8994_set_bias_level,
+	//.readable_register = wm8994_readable,
+	//.volatile_register = wm8994_volatile,
+	//.set_bias_level = wm8994_set_bias_level,
 
-	.reg_cache_size = WM8994_CACHE_SIZE,
-	.reg_cache_default = wm8994_reg_defaults,
+	.reg_cache_size = WM8994_IRQ_POLARITY,
+	//.reg_cache_size = WM8994_CACHE_SIZE,
+	//.reg_cache_default = wm8994_reg_defaults,
 	.reg_word_size = 2,
 	.compress_type = SND_SOC_RBTREE_COMPRESSION,
 };
 
-static int __devinit wm8994_probe(struct platform_device *pdev)
+static int wm8994_i2c_probe(struct i2c_client *client,
+			    const struct i2c_device_id *id)
 {
-	return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_wm8994,
+	/* Board Specific Function */
+	audio_init();
+	audio_power(1);
+	msleep(10);
+
+	return snd_soc_register_codec(&client->dev, &soc_codec_dev_wm8994,
 			wm8994_dai, ARRAY_SIZE(wm8994_dai));
 }
 
-static int __devexit wm8994_remove(struct platform_device *pdev)
+static int wm8994_i2c_remove(struct i2c_client *client)
 {
-	snd_soc_unregister_codec(&pdev->dev);
+	snd_soc_unregister_codec(&client->dev);
 	return 0;
 }
 
-static struct platform_driver wm8994_codec_driver = {
+
+static const struct i2c_device_id wm8994_i2c_id[] = {
+	{"wm8994-samsung", 0},
+	{}
+};
+
+MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
+
+static struct i2c_driver wm8994_i2c_driver = {
 	.driver = {
-		   .name = "wm8994-codec",
+		   .name = "wm8994-samsung-codec",
 		   .owner = THIS_MODULE,
 		   },
-	.probe = wm8994_probe,
-	.remove = __devexit_p(wm8994_remove),
+	.probe = wm8994_i2c_probe,
+	.remove = wm8994_i2c_remove,
+	.id_table = wm8994_i2c_id,
 };
 
-static __init int wm8994_init(void)
+static __init int wm8994_driver_init(void)
 {
-	return platform_driver_register(&wm8994_codec_driver);
+	return i2c_add_driver(&wm8994_i2c_driver);
 }
-module_init(wm8994_init);
+module_init(wm8994_driver_init);
 
-static __exit void wm8994_exit(void)
+static __exit void wm8994_driver_exit(void)
 {
-	platform_driver_unregister(&wm8994_codec_driver);
+	i2c_del_driver(&wm8994_i2c_driver);
 }
-module_exit(wm8994_exit);
-
+module_exit(wm8994_driver_exit);
 
 MODULE_DESCRIPTION("ASoC WM8994 driver");
-MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_AUTHOR("Shaju Abraham shaju.abraham@samsung.com");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:wm8994-codec");
diff --git a/sound/soc/codecs/wm8994.h b/sound/soc/codecs/wm8994.h
index 13257dc..e97ad86 100644
--- a/sound/soc/codecs/wm8994.h
+++ b/sound/soc/codecs/wm8994.h
@@ -10,10 +10,7 @@
 #define _WM8994_H

 

 #include <sound/soc.h>

-

-extern struct snd_soc_codec_device soc_codec_dev_wm8994;

-// We don't use array	- DW Shim.

-//extern struct snd_soc_dai wm8994_dai[];

+
 

 /* Sources for AIF1/2 SYSCLK - use with set_dai_sysclk() */

 #define WM8994_SYSCLK_MCLK1 1

@@ -24,30 +21,56 @@ extern struct snd_soc_codec_device soc_codec_dev_wm8994;
 #define WM8994_FLL1 1

 #define WM8994_FLL2 2

 

-//-----------------------------------------------------------

-// Added belows codes by Samsung Electronics.

+/* Added belows codes by Samsung Electronics.*/
 

 #include "wm8994_def.h"

 

-extern struct snd_soc_dai wm8994_dai;

-

 #define WM8994_SYSCLK_MCLK     1

 #define WM8994_SYSCLK_FLL      2

 

 #define AUDIO_COMMON_DEBUG  0 

-//#define WM8994_REGISTER_DUMP

-#if defined CONFIG_SND_SOC_WM8994_PCM

-#define ATTACH_ADDITINAL_PCM_DRIVER	// for VT call.

-#endif

-//------------------------------------------------

-// Definitions of enum type

-//------------------------------------------------

-enum audio_path	{ OFF, RCV, SPK, HP, BT, SPK_HP};

-enum mic_path		{ MAIN, SUB, MIC_OFF};

-enum fmradio_audio_path { FMR_OFF, FMR_SPK, FMR_HP, FMR_SPK_MIX, FMR_HP_MIX, FMR_SPK_HP_MIX};

-enum call_state		{ DISCONNECT, CONNECT};

-enum power_state	{ CODEC_OFF, CODEC_ON };

-enum mic_state		{ MIC_NO_USE, MIC_USE};

+

+#define DEACTIVE            0x00

+#define PLAYBACK_ACTIVE     0x01

+#define CAPTURE_ACTIVE      0x02

+#define CALL_ACTIVE         0x04

+#define FMRADIO_ACTIVE      0x08

+

+#define PCM_STREAM_DEACTIVE 0x00

+#define PCM_STREAM_PLAYBACK 0x01

+#define PCM_STREAM_CAPTURE  0x02

+

+#define CMD_FMR_INPUT_DEACTIVE          0 // Codec Input PGA off for reducing white noise.

+#define CMD_FMR_INPUT_ACTIVE            1 // Codec Input PGA on

+#define CMD_FMR_FLAG_CLEAR              2 // Radio flag clear for shutdown - to reduce pop up noise.

+#define CMD_FMR_END                     3 // Codec off in FM radio mode - to reduce pop up noise.

+#define CMD_RECOGNITION_DEACTIVE        4 // Distingush recognition gain. To use default MIC gain.

+#define CMD_RECOGNITION_ACTIVE          5 // Distingush recognition gain. To use MIC gain for recognition.

+#define CMD_CALL_FLAG_CLEAR             6 // Call flag clear for shutdown - to reduce pop up noise.

+#define CMD_CALL_END                    7 // Codec off in call mode - to reduce pop up noise.

+

+#define HPAMP_OFF       0x00

+#define HPAMP_PLAYBACK  0x01

+#define HPAMP_CALL      0x02

+#define HPAMP_FMR       0x04

+#define HPAMP_CH_NORMAL 0x08

+

+#define CODEC_TURN_OFF	0x01
+
+/*
+ * Definitions of enum type
+ */

+enum playback_path            { PLAYBACK_OFF, RCV, SPK, HP, HP_NO_MIC, BT, SPK_HP,RING_SPK, RING_HP, RING_NO_MIC, RING_SPK_HP, EXTRA_DOCK_SPEAKER, TV_OUT, HDMI_TV_OUT, HDMI_SPK, HDMI_DUAL };

+enum mic_path		       { MAIN, SUB, BT_REC, MIC_OFF };

+enum fmradio_path          { FMR_OFF, FMR_SPK, FMR_HP, FMR_SPK_MIX, FMR_HP_MIX, FMR_DUAL_MIX };

+enum fmradio_mix_path	   { FMR_MIX_OFF, FMR_MIX_HP, FMR_MIX_SPK, FMR_MIX_DUAL };

+enum power_state	       { CODEC_OFF, CODEC_ON };

+enum recognition	       { REC_OFF, REC_ON };

+enum state                 { OFF, ON };

+enum voice_record_path     { CALL_RECORDING_OFF, CALL_RECORDING_MAIN, CALL_RECORDING_SUB};

+enum factory_test          { SEC_NORMAL, SEC_TEST_HWCODEC , SEC_TEST_15MODE, SEC_TEST_PBA_LOOPBACK, SEC_TEST_PBA_DUAL_SPK, SEC_TEST_HQRL_LOOPBACK};

+enum call_recording_channel {CH_OFF, CH_UPLINK, CH_DOWNLINK, CH_UDLINK};

+

 

 typedef void (*select_route)(struct snd_soc_codec *);

 typedef void (*select_mic_route)(struct snd_soc_codec *);

@@ -55,66 +78,90 @@ typedef void (*select_mic_route)(struct snd_soc_codec *);
 struct wm8994_setup_data {

 	int i2c_bus;

 	unsigned short i2c_address;

-};

-

+};
+
 struct wm8994_priv {

-	//u16 reg_cache[WM8994_REGISTER_COUNT];

-	struct snd_soc_codec codec;

+	struct snd_soc_codec *codec;
 	int master;

 	int sysclk_source;

 	unsigned int mclk_rate;

 	unsigned int sysclk_rate;

 	unsigned int fs;

-	unsigned int bclk;

-	unsigned int hw_version;		// For wolfson H/W version. 1 = Rev B, 3 = Rev D

-	enum audio_path cur_path;

+	unsigned int bclk;
+	unsigned int codec_state;

+	unsigned int  stream_state;

+	enum playback_path cur_path;

 	enum mic_path rec_path;

-	enum fmradio_audio_path fmradio_path;

-	enum call_state call_state;

+	enum fmradio_path fmradio_path;

+	enum fmradio_mix_path fmr_mix_path;

 	enum power_state power_state;

-	enum mic_state mic_state;

+	enum recognition recognition_active;		// for control gain to voice recognition.

+	enum state ringtone_active;

+	enum voice_record_path call_record_path;

+	enum call_recording_channel call_record_ch;

 	select_route *universal_playback_path;

 	select_route *universal_voicecall_path;

-	select_mic_route *universal_mic_path;

-	int testmode_config_flag;	// for testmode.

-};

+	select_mic_route *universal_mic_path;
+	int testmode_config_flag;	// for testmode.
+	unsigned int hw_version;

+};
 

 #if AUDIO_COMMON_DEBUG

-#define DEBUG_LOG(format,...)\

-	printk ("[ "SUBJECT " (%s,%d) ] " format "\n", __func__, __LINE__, ## __VA_ARGS__);

+#define DEBUG_LOG(format, ...)\
+	printk(KERN_INFO "[ "SUBJECT " (%s,%d) ] " format "\n", \
+			__func__, __LINE__, ## __VA_ARGS__);
 #else

-#define DEBUG_LOG(format,...)

+#define DEBUG_LOG(format, ...)
 #endif

 

-#define DEBUG_LOG_ERR(format,...)\

-	printk (KERN_ERR "[ "SUBJECT " (%s,%d) ] " format "\n", __func__, __LINE__, ## __VA_ARGS__);

+#define DEBUG_LOG_ERR(format, ...)\
+	printk(KERN_ERR "[ "SUBJECT " (%s,%d) ] " format "\n", \
+			__func__, __LINE__, ## __VA_ARGS__);
 

-// Definitions of function prototype.

-inline unsigned int wm8994_read(struct snd_soc_codec *codec,unsigned int reg);

+/* Definitions of function prototype. */
+unsigned int wm8994_read(struct snd_soc_codec *codec,unsigned int reg);
 int wm8994_write(struct snd_soc_codec *codec, unsigned int reg, unsigned int value);

 int audio_init(void);

-int audio_power(int en);

-void audio_ctrl_mic_bias_gpio(int enable);

+int audio_power(int en);
+

 void wm8994_set_off(struct snd_soc_codec *codec);

-void wm8994_disable_playback_path(struct snd_soc_codec *codec, enum audio_path path);

-void wm8994_disable_fmradio_path(struct snd_soc_codec *codec, enum fmradio_audio_path path);

-void wm8994_disable_rec_path(struct snd_soc_codec *codec,enum mic_path rec_path);

+void wm8994_disable_playback_path(struct snd_soc_codec *codec);

+void wm8994_disable_fmradio_path(struct snd_soc_codec *codec);

+void wm8994_disable_rec_path(struct snd_soc_codec *codec);

 void  wm8994_record_main_mic( struct snd_soc_codec *codec);

 void wm8994_record_headset_mic( struct snd_soc_codec *codec);

+void wm8994_record_bluetooth(struct snd_soc_codec *codec);

 void wm8994_set_playback_receiver(struct snd_soc_codec *codec);

 void wm8994_set_playback_headset(struct snd_soc_codec *codec);

-void wm8994_set_playback_speaker(struct snd_soc_codec *codec);

+void wm8994_set_playback_speaker(struct snd_soc_codec *codec);
 void wm8994_set_playback_speaker_headset(struct snd_soc_codec *codec);

-void wm8994_set_voicecall_receiver(struct snd_soc_codec *codec);

+void wm8994_set_playback_bluetooth(struct snd_soc_codec *codec);

+void wm8994_set_playback_extra_dock_speaker(struct snd_soc_codec *codec);

+void wm8994_set_playback_hdmi_tvout(struct snd_soc_codec *codec);

+void wm8994_set_playback_speaker_hdmitvout(struct snd_soc_codec *codec);

+void wm8994_set_playback_speakerheadset_hdmitvout(struct snd_soc_codec *codec);

+void wm8994_set_voicecall_common_setting(struct snd_soc_codec *codec);

+void wm8994_set_voicecall_receiver(struct snd_soc_codec *codec);
+void wm8994_set_voicecall_headphone(struct snd_soc_codec *codec);

 void wm8994_set_voicecall_headset(struct snd_soc_codec *codec);

 void wm8994_set_voicecall_speaker(struct snd_soc_codec *codec);

-void wm8994_set_voicecall_bluetooth(struct snd_soc_codec *codec);

+void wm8994_set_voicecall_bluetooth(struct snd_soc_codec *codec);
+void wm8994_set_voicecall_record(struct snd_soc_codec *codec, int path_num);

+void wm8994_call_recording_change_path(struct snd_soc_codec *codec);

+void wm8994_set_voicecall_record_off(struct snd_soc_codec *codec);

+void wm8994_set_fmradio_common(struct snd_soc_codec *codec, int onoff);

 void wm8994_set_fmradio_headset(struct snd_soc_codec *codec);

 void wm8994_set_fmradio_speaker(struct snd_soc_codec *codec);

 void wm8994_set_fmradio_headset_mix(struct snd_soc_codec *codec);

 void wm8994_set_fmradio_speaker_mix(struct snd_soc_codec *codec);

-void wm8994_set_fmradio_speaker_headset_mix(struct snd_soc_codec *codec);

+void wm8994_set_fmradio_speaker_headset_mix(struct snd_soc_codec *codec);
 #if defined WM8994_REGISTER_DUMP

 void wm8994_register_dump(struct snd_soc_codec *codec);

 #endif

 #endif

+

+void audio_ctrl_earmic_bias_gpio(int enable);

+void audio_ctrl_mic_bias_gpio(int enable);
+

+int get_audio_power_status(void);
+

diff --git a/sound/soc/codecs/wm8994_extensions.c b/sound/soc/codecs/wm8994_extensions.c
index e6df363..5736e37 100644
--- a/sound/soc/codecs/wm8994_extensions.c
+++ b/sound/soc/codecs/wm8994_extensions.c
@@ -53,7 +53,7 @@ unsigned short origin_recgain;
 unsigned short origin_recgain_mixer;
 #endif
 
-#ifdef NEXUS_S
+#if defined(NEXUS_S) || defined(GALAXY_TAB)
 bool speaker_tuning = false;
 #endif
 
@@ -519,7 +519,7 @@ bool is_path_media_or_fm_no_call_no_record()
 	return false;
 }
 
-#ifdef NEXUS_S
+#if defined(NEXUS_S) || defined(GALAXY_TAB)
 void update_speaker_tuning(bool with_mute)
 {
 	DECLARE_WM8994(codec);
@@ -598,8 +598,8 @@ unsigned short osr128_get_value(unsigned short val)
     if (debug_log(LOG_INFOS))
         printk("wm8994_extensions: %s %s %s %d\n",
                __func__,
-               dac_osr128 ? "dac_osr128" : "", 
-               adc_osr128 ? "adc_osr128" : "", 
+               dac_osr128 ? "dac_osr128" : "",
+               adc_osr128 ? "adc_osr128" : "",
                val);
 
 	return val;
@@ -1003,7 +1003,7 @@ static ssize_t name##_store(struct device *dev, struct device_attribute *attr, \
 	return size;							       \
 }
 
-#ifdef NEXUS_S
+#if defined(NEXUS_S) || defined(GALAXY_TAB)
 DECLARE_BOOL_SHOW(speaker_tuning);
 DECLARE_BOOL_STORE_UPDATE_WITH_MUTE(speaker_tuning,
 				    update_speaker_tuning,
@@ -1659,7 +1659,7 @@ static DEVICE_ATTR(headphone_amplifier_level, S_IRUGO | S_IWUGO,
 		   headphone_amplifier_level_store);
 #endif
 
-#ifdef NEXUS_S
+#if defined(NEXUS_S) || defined(GALAXY_TAB)
 static DEVICE_ATTR(speaker_tuning, S_IRUGO | S_IWUGO,
 		   speaker_tuning_show,
 		   speaker_tuning_store);
@@ -1804,7 +1804,7 @@ static struct attribute *wm8994_extensions_attributes[] = {
 #ifdef CONFIG_SND_WM8994_EXTENSIONS_HP_LEVEL_CONTROL
 	&dev_attr_headphone_amplifier_level.attr,
 #endif
-#ifdef NEXUS_S
+#if defined(NEXUS_S) || defined(GALAXY_TAB)
 	&dev_attr_speaker_tuning.attr,
 #endif
 #ifdef CONFIG_SND_WM8994_EXTENSIONS_FM
@@ -1944,7 +1944,7 @@ void wm8994_extensions_record_main_mic()
 }
 #endif
 
-#ifdef NEXUS_S
+#if defined(NEXUS_S) || defined(GALAXY_TAB)
 void wm8994_extensions_playback_speaker()
 {
 	// global kill switch
diff --git a/sound/soc/codecs/wm8994_extensions.h b/sound/soc/codecs/wm8994_extensions.h
index 1d79768..4f1e35c 100644
--- a/sound/soc/codecs/wm8994_extensions.h
+++ b/sound/soc/codecs/wm8994_extensions.h
@@ -17,7 +17,7 @@
 #define NEXUS_S
 #endif
 
-#if defined(CONFIG_FB_S3C_AMS701KA) || defined(CONFIG_KOR_MODEL_M180S)
+#if defined(CONFIG_FB_S3C_AMS701KA) || defined(CONFIG_KOR_MODEL_M180S) || defined (CONFIG_MACH_P1)
 #define GALAXY_TAB
 #endif
 
diff --git a/sound/soc/codecs/wm8994_p1.c b/sound/soc/codecs/wm8994_p1.c
new file mode 100644
index 0000000..d1d2fae
--- /dev/null
+++ b/sound/soc/codecs/wm8994_p1.c
@@ -0,0 +1,4732 @@
+/*
+ * wm8994_p1.c  --  WM8994 ALSA Soc Audio driver related Aries
+ *
+ *  Copyright (C) 2010 Samsung Electronics.
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <linux/delay.h>
+#include <asm/io.h>
+#include <asm/gpio.h>
+#include <plat/gpio-cfg.h>
+#include <plat/map-base.h>
+#include <mach/regs-clock.h>
+#include <mach/gpio-p1.h>
+#include "wm8994.h"
+#include "wm8994_def.h"
+
+#ifdef CONFIG_SND_WM8994_EXTENSIONS
+#include "wm8994_extensions.h"
+#endif
+
+/*
+ * Debug Feature
+ */
+#define SUBJECT "wm8994_p1.c"
+
+/*
+ * Definitions of tunning volumes for wm8994
+ */
+// DAC
+#define TUNING_DAC1L_VOL 0xC0 // 610h
+#define TUNING_DAC1R_VOL 0xC0 // 611h
+#define TUNING_DAC2L_VOL 0xC0 // 612h
+#define TUNING_DAC2R_VOL 0xC0 // 613h
+
+// Speaker
+#define TUNING_SPKL_VOL 0x3E // 26h
+#define TUNING_SPKR_VOL 0x3E // 27h
+#define TUNING_CLASSD_VOL 0x6 // 25h
+
+#define TUNING_SPKMIXL_ATTEN 0x0 // 22h
+#define TUNING_SPKMIXR_ATTEN 0x0 // 23h
+
+#define TUNING_MP3_SPKR_VOL 0x3E // 27h
+#define TUNING_MP3_SPKL_VOL 0x3E // 26h
+#define TUNING_MP3_CLASSD_VOL 0x5 // 25h
+
+#define TUNING_FMRADIO_SPKL_VOL 0x3E // 26h
+#define TUNING_FMRADIO_CLASSD_VOL 0x5 // 25h
+
+#define TUNING_CALL_CLASSD_VOL 0x24 // 25h
+#define TUNING_CALL_SPKL_VOL 0x3E // 26h
+#define TUNING_CALL_SPKR_VOL 0x3E // 27h
+
+// Headset
+#define TUNING_EAR_OUTMIX5_VOL 0x0 // 31h
+#define TUNING_EAR_OUTMIX6_VOL 0x0 // 32h
+
+#define TUNING_RING_OUTPUTL_VOL 0x36 // 1Ch
+#define TUNING_RING_OUTPUTR_VOL 0x36 // 1Dh
+#define TUNING_RING_OPGAL_VOL 0x39 // 20h
+#define TUNING_RING_OPGAR_VOL 0x39 // 21h
+
+#define TUNING_MP3_OUTPUTL_VOL 0x36 // 1Ch
+#define TUNING_MP3_OUTPUTR_VOL 0x36 // 1Dh
+#define TUNING_MP3_OPGAL_VOL 0x39 // 20h
+#define TUNING_MP3_OPGAR_VOL 0x39 // 21h
+
+// Dual
+#define TUNING_MP3_DUAL_OUTPUTL_VOL 0x1E // 1Ch
+#define TUNING_MP3_DUAL_OUTPUTR_VOL 0x1E // 1Dh
+
+// Extra_Dock_speaker
+#define TUNING_MP3_EXTRA_DOCK_SPK_OPGAL_VOL 0x3D // 20h
+#define TUNING_MP3_EXTRA_DOCK_SPK_OPGAR_VOL 0x3D // 21h
+
+#define TUNING_EXTRA_DOCK_SPK_OUTMIX5_VOL 0x2 // 31h
+#define TUNING_EXTRA_DOCK_SPK_OUTMIX6_VOL 0x2 // 32h
+#define TUNING_MP3_EXTRA_DOCK_SPK_VOL 0x0 //1Eh
+
+
+#define TUNING_CALL_OUTPUTL_VOL 0x39 // 1Ch
+#define TUNING_CALL_OUTPUTR_VOL 0x39 // 1Dh
+#define TUNING_CALL_OPGAL_VOL 0x39 // 20h
+#define TUNING_CALL_OPGAR_VOL 0x39 // 21h
+
+#define TUNING_FMRADIO_OUTPUTL_VOL 0x3D // 1Ch
+#define TUNING_FMRADIO_OUTPUTR_VOL 0x3D // 1Dh
+#define TUNING_FMRADIO_OPGAL_VOL 0x39 // 20h
+#define TUNING_FMRADIO_OPGAR_VOL 0x39 // 21h
+
+#define TUNING_HPOUTMIX_VOL 0x0
+
+// Dual
+#define TUNING_DUAL_OUTPUTL_VOL 0x20 // 1Ch
+#define TUNING_DUAL_OUTPUTR_VOL 0x20 // 1Dh
+
+//------------------------------------------------
+// Recording
+// Main MIC
+#if defined(CONFIG_PHONE_P1_GSM)
+#define TUNING_RECORD_MAIN_INPUTLINE_VOL 0x17 // 18h
+#define TUNING_RECORD_MAIN_AIF1ADCL_VOL 0xC0 // 400h
+#define TUNING_RECORD_MAIN_AIF1ADCR_VOL 0xC0 // 401h
+#elif defined(CONFIG_PHONE_P1_CDMA)
+#define TUNING_RECORD_MAIN_INPUTLINE_VOL 0x15 // 18h
+#define TUNING_RECORD_MAIN_AIF1ADCL_VOL 0xFF // 400h
+#define TUNING_RECORD_MAIN_AIF1ADCR_VOL 0xFF // 401h
+#endif
+
+#define TUNING_RECOGNITION_MAIN_INPUTLINE_VOL 0x0F // 18h
+#define TUNING_RECOGNITION_MAIN_AIF1ADCL_VOL 0xC0 // 400h
+#define TUNING_RECOGNITION_MAIN_AIF1ADCR_VOL 0xC0 // 401h
+
+// Ear MIC
+#define TUNING_RECORD_SUB_INPUTMIX_VOL 0x15 // 1Ah
+#define TUNING_RECORD_SUB_AIF1ADCL_VOL 0xC0 // 400h
+#define TUNING_RECORD_SUB_AIF1ADCR_VOL 0xC0 // 401h
+
+#if defined(CONFIG_PHONE_P1_GSM)
+#define TUNING_RECOGNITION_SUB_INPUTMIX_VOL 0x0A // 1Ah
+#elif defined(CONFIG_PHONE_P1_CDMA)
+#define TUNING_RECOGNITION_SUB_INPUTMIX_VOL 0x10 // 1Ah
+#endif
+#define TUNING_RECOGNITION_SUB_AIF1ADCL_VOL 0xC0 // 400h
+#define TUNING_RECOGNITION_SUB_AIF1ADCR_VOL 0xC0 // 401h
+
+//BT MIC
+#define TUNING_RECORD_BT_AIF2DACR_VOL 0xC0 //501h
+#define TUNING_RECORD_BT_AIF2DACL_VOL 0xC0 //502h
+
+#define TUNING_RECORD_BT_AIF1ADC1L_VOL 0xC0 //400h
+#define TUNING_RECORD_BT_AIF1ADC1R_VOL 0xC0 //401h
+
+#define TUNING_RECOGNITION_BT_AIF2DACL_VOL 0xC0 //501h
+#define TUNING_RECOGNITION_BT_AIF2DACR_VOL 0xC0 //502h
+#define TUNING_RECOGNITION_BT_AIF1ADC1L_VOL 0xB8 //400h
+#define TUNING_RECOGNITION_BT_AIF1ADC1R_VOL 0xB8 //401h
+
+// Call Main MIC
+#define TUNING_CALL_RCV_INPUTMIX_VOL 0x16 // 18h
+#define TUNING_CALL_RCV_MIXER_VOL WM8994_IN1L_MIXINL_VOL // 29h 30dB
+#define TUNING_CALL_SPK_INPUTMIX_VOL 0x17 // 18h
+
+#define TUNING_CALL_SPK_MIXER_VOL WM8994_IN1L_MIXINL_VOL // 29h 30dB
+
+
+// Call Ear MIC
+#define TUNING_CALL_EAR_INPUTMIX_VOL 0x1F // 1Ah
+
+// Receiver
+#define TUNING_RCV_OUTMIX5_VOL 0x0 // 31h
+#define TUNING_RCV_OUTMIX6_VOL 0x0 // 32h
+#define TUNING_RCV_OPGAL_VOL 0x3D // 20h
+#define TUNING_RCV_OPGAR_VOL 0x3D // 21h
+#define TUNING_HPOUT2_VOL 0x0 // 1Fh
+
+//Input
+#define TUNING_DAC1L_RADIO_VOL 0xA8 // 402h
+#define TUNING_DAC1R_RADIO_VOL	 0xA8 // 403h
+
+//Dual
+#define TUNING_DUAL_DAC1L_RADIO_VOL 0x70 // 402h
+#define TUNING_DUAL_DAC1R_RADIO_VOL 0x70 // 403h
+
+// FM Radio Input
+#define TUNING_FMRADIO_EAR_INPUTMIXL_VOL 0x0B // 19h
+#define TUNING_FMRADIO_EAR_INPUTMIXR_VOL 0x0B // 1Bh
+
+#define TUNING_FMRADIO_SPK_INPUTMIXL_VOL 0x0F // 19h
+#define TUNING_FMRADIO_SPK_INPUTMIXR_VOL 0x0F // 1Bh
+
+
+// ear loopback
+#define TUNING_LOOPBACK_EAR_INPUTMIX_VOL 0x1D // 1Ah
+
+#define TUNING_LOOPBACK_OUTPUTL_VOL 0x37 // 1Ch
+#define TUNING_LOOPBACK_OUTPUTR_VOL 0x37 // 1Dh
+#define TUNING_LOOPBACK_OPGAL_VOL 0x39 // 20h
+#define TUNING_LOOPBACK_OPGAR_VOL 0x39 // 21h
+
+
+int audio_init(void)
+{
+	//CODEC LDO SETTING
+	if (gpio_is_valid(GPIO_CODEC_LDO_EN))
+	{
+		if (gpio_request(GPIO_CODEC_LDO_EN, "CODEC_LDO_EN"))
+		{
+			DEBUG_LOG_ERR("Failed to request CODEC_LDO_EN!");
+		}
+
+		gpio_direction_output(GPIO_CODEC_LDO_EN, 0);
+	}
+
+	s3c_gpio_setpull(GPIO_CODEC_LDO_EN, S3C_GPIO_PULL_NONE);
+
+	s3c_gpio_slp_cfgpin(GPIO_CODEC_LDO_EN, S3C_GPIO_SLP_PREV);
+	s3c_gpio_slp_setpull_updown(GPIO_CODEC_LDO_EN, S3C_GPIO_PULL_NONE);
+
+
+	if (gpio_is_valid(GPIO_MICBIAS_EN))
+	{
+		if (gpio_request(GPIO_MICBIAS_EN, "GPJ4"))
+		{
+			DEBUG_LOG_ERR("Failed to request GPIO_MICBIAS_EN!");
+		}
+
+		gpio_direction_output(GPIO_MICBIAS_EN, 0);
+	}
+
+	s3c_gpio_setpull(GPIO_MICBIAS_EN, S3C_GPIO_PULL_NONE);
+
+	s3c_gpio_slp_cfgpin(GPIO_MICBIAS_EN, S3C_GPIO_SLP_PREV);
+	s3c_gpio_slp_setpull_updown(GPIO_MICBIAS_EN, S3C_GPIO_PULL_NONE);
+
+	DEBUG_LOG("MICBIAS Init");
+
+	return 0;
+}
+
+
+int codec_power_status = 0;
+
+int audio_power(int en)
+{
+	u32 val;
+
+
+	if(en)
+	{
+		// Forbid to turn off MCLK in sleep mode.
+		val = __raw_readl(S5P_SLEEP_CFG);
+		val |= (S5P_SLEEP_CFG_USBOSC_EN);
+		__raw_writel(val , S5P_SLEEP_CFG);
+
+		// Turn on LDO for codec.
+		gpio_set_value(GPIO_CODEC_LDO_EN, 1);
+
+		msleep(10);	// Wait for warming up.
+
+		// Turn on master clock.
+#if (defined CONFIG_SND_S5P_WM8994_MASTER)
+		__raw_writel(__raw_readl(S5P_OTHERS) | (3<<8) , S5P_OTHERS);
+		//__raw_writel(__raw_readl(S5P_CLK_OUT) | (0x1) , S5P_CLK_OUT);
+#endif
+	}
+	else
+	{
+		// Turn off LDO for codec.
+		gpio_set_value(GPIO_CODEC_LDO_EN, 0);
+
+		msleep(125);	// Wait to turn off codec entirely.
+
+		// Turn off master clock.
+#if (defined CONFIG_SND_S5P_WM8994_MASTER)
+		__raw_writel(__raw_readl(S5P_OTHERS) & (~(0x3<<8)) , S5P_OTHERS);
+		__raw_writel(__raw_readl(S5P_CLK_OUT) & (0xFFFFFFFE) , S5P_CLK_OUT);
+#endif
+
+		// Allow to turn off MCLK in sleep mode.
+		val = __raw_readl(S5P_SLEEP_CFG);
+		val &= ~(S5P_SLEEP_CFG_USBOSC_EN);
+		__raw_writel(val , S5P_SLEEP_CFG);
+	}
+
+	codec_power_status = en;
+	DEBUG_LOG("AUDIO POWER COMPLETED : %d", en);
+
+	return 0;
+}
+
+int get_audio_power_status(void)
+{
+	return codec_power_status;
+}
+
+
+void audio_ctrl_mic_bias_gpio(int enable)
+{
+	//DEBUG_LOG("audio_ctrl_mic_bias_gpio = [%d]", enable);
+
+	if(enable)
+	{
+		DEBUG_LOG("MICBIAS On");
+		gpio_set_value(GPIO_MICBIAS_EN, 1);
+	}
+	else
+	{
+		DEBUG_LOG("MICBIAS Off");
+		gpio_set_value(GPIO_MICBIAS_EN, 0);
+	}
+}
+
+void audio_ctrl_earmic_bias_gpio(int enable)
+{
+	if(enable)
+	{
+		DEBUG_LOG("EAR_MICBIAS On");
+		gpio_set_value(GPIO_EAR_MICBIAS0_EN, 1);
+		gpio_set_value(GPIO_EAR_MICBIAS_EN, 1);
+	}
+	else
+	{
+		DEBUG_LOG("EAR_MICBIAS Off");
+		gpio_set_value(GPIO_EAR_MICBIAS0_EN, 0);
+		gpio_set_value(GPIO_EAR_MICBIAS_EN, 0);
+	}
+}
+
+
+/*Audio Routing routines for the universal board..wm8994 codec*/
+void wm8994_disable_playback_path(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	u16 val;
+	enum playback_path path = wm8994->rec_path;
+
+	DEBUG_LOG("Path = [%d]", path);
+
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_1);
+
+	switch(path)
+	{
+		case RCV:
+			//Disable the HPOUT2
+			val &= ~(WM8994_HPOUT2_ENA_MASK);
+			wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+			// Disable left MIXOUT
+			val = wm8994_read(codec,WM8994_OUTPUT_MIXER_1);
+			val &= ~(WM8994_DAC1L_TO_MIXOUTL_MASK);
+			wm8994_write(codec,WM8994_OUTPUT_MIXER_1,val);
+
+			// Disable right MIXOUT
+			val = wm8994_read(codec,WM8994_OUTPUT_MIXER_2);
+			val &= ~(WM8994_DAC1R_TO_MIXOUTR_MASK);
+			wm8994_write(codec,WM8994_OUTPUT_MIXER_2,val);
+
+			// Disable HPOUT Mixer
+			val = wm8994_read(codec,WM8994_HPOUT2_MIXER);
+			val &= ~(WM8994_MIXOUTLVOL_TO_HPOUT2_MASK | WM8994_MIXOUTRVOL_TO_HPOUT2_MASK);
+			wm8994_write(codec,WM8994_HPOUT2_MIXER,val);
+
+			// Disable mixout volume control
+			val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_3);
+			val &= ~(WM8994_MIXOUTLVOL_ENA_MASK | WM8994_MIXOUTRVOL_ENA_MASK | WM8994_MIXOUTL_ENA_MASK | WM8994_MIXOUTR_ENA_MASK);
+			wm8994_write(codec,WM8994_POWER_MANAGEMENT_3,val);
+		break;
+
+		case SPK:
+			//Disable the SPKOUTL & SPKOUTR
+			val &= ~(WM8994_SPKOUTL_ENA_MASK|WM8994_SPKOUTR_ENA_MASK);
+			wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+			// Disable SPKLVOL
+			val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_3);
+			val &= ~(WM8994_SPKLVOL_ENA_MASK | WM8994_SPKRVOL_ENA_MASK);
+			wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, val);
+
+			// Disable SPKOUT mixer
+			val = wm8994_read(codec,WM8994_SPKOUT_MIXERS);
+			val &= ~(WM8994_SPKMIXL_TO_SPKOUTL_MASK | WM8994_SPKMIXR_TO_SPKOUTR_MASK);
+			wm8994_write(codec, WM8994_SPKOUT_MIXERS, val);
+
+			//Mute Speaker mixer
+			val = wm8994_read(codec,WM8994_SPEAKER_MIXER);
+			val &= ~(WM8994_DAC1L_TO_SPKMIXL_MASK | WM8994_DAC1R_TO_SPKMIXR_MASK);
+			wm8994_write(codec, WM8994_SPEAKER_MIXER ,val);
+		break;
+
+		case HP:
+		case HP_NO_MIC:
+			//Disable the HPOUT1L & HPOUT1R
+			val &= ~(WM8994_HPOUT1L_ENA_MASK |WM8994_HPOUT1R_ENA_MASK);
+			wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+			// Disable DAC1L to HPOUT1L path
+			val = wm8994_read(codec, WM8994_OUTPUT_MIXER_1);
+			val &= ~(WM8994_DAC1L_TO_HPOUT1L_MASK | WM8994_DAC1L_TO_MIXOUTL_MASK);
+			wm8994_write(codec,WM8994_OUTPUT_MIXER_1, val);
+
+			// Disable DAC1R to HPOUT1R path
+			val = wm8994_read(codec, WM8994_OUTPUT_MIXER_2);
+			val &= ~(WM8994_DAC1R_TO_HPOUT1R_MASK | WM8994_DAC1R_TO_MIXOUTR_MASK);
+			wm8994_write(codec, WM8994_OUTPUT_MIXER_2, val);
+
+			//Disable Charge Pump
+			val = wm8994_read(codec, WM8994_CHARGE_PUMP_1);
+			val &= ~WM8994_CP_ENA_MASK ;
+			val |=  WM8994_CP_ENA_DEFAULT ; // this is from wolfson
+			wm8994_write(codec, WM8994_CHARGE_PUMP_1, val);
+
+			// Intermediate HP settings
+			val = wm8994_read(codec, WM8994_ANALOGUE_HP_1);
+			val &= ~(WM8994_HPOUT1R_DLY_MASK |WM8994_HPOUT1R_OUTP_MASK |WM8994_HPOUT1R_RMV_SHORT_MASK |
+				WM8994_HPOUT1L_DLY_MASK |WM8994_HPOUT1L_OUTP_MASK | WM8994_HPOUT1L_RMV_SHORT_MASK);
+			wm8994_write(codec, WM8994_ANALOGUE_HP_1, val);
+		break;
+
+		case BT :
+			; //todo
+		break;
+
+		case SPK_HP :
+			//Disable the HPOUT1L & HPOUT1R & SPKOUTL & SPKOUTR
+			val &= ~(WM8994_HPOUT1L_ENA_MASK |WM8994_HPOUT1R_ENA_MASK |WM8994_SPKOUTL_ENA_MASK | WM8994_SPKOUTR_ENA_MASK);
+			wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+			// ------------------ Ear path setting ------------------
+			// Disable DAC1L to HPOUT1L path
+			val = wm8994_read(codec, WM8994_OUTPUT_MIXER_1);
+			val &= ~(WM8994_DAC1L_TO_HPOUT1L_MASK | WM8994_DAC1L_TO_MIXOUTL_MASK);
+			wm8994_write(codec,WM8994_OUTPUT_MIXER_1, val);
+
+			// Disable DAC1R to HPOUT1R path
+			val = wm8994_read(codec, WM8994_OUTPUT_MIXER_2);
+			val &= ~(WM8994_DAC1R_TO_HPOUT1R_MASK | WM8994_DAC1R_TO_MIXOUTR_MASK);
+			wm8994_write(codec, WM8994_OUTPUT_MIXER_2, val);
+
+			//Disable Charge Pump
+			val = wm8994_read(codec, WM8994_CHARGE_PUMP_1);
+			val &= ~WM8994_CP_ENA_MASK ;
+			val |=  WM8994_CP_ENA_DEFAULT ; // this is from wolfson
+			wm8994_write(codec, WM8994_CHARGE_PUMP_1, val);
+
+			// Intermediate HP settings
+			val = wm8994_read(codec, WM8994_ANALOGUE_HP_1);
+			val &= ~(WM8994_HPOUT1R_DLY_MASK |WM8994_HPOUT1R_OUTP_MASK |WM8994_HPOUT1R_RMV_SHORT_MASK |
+				WM8994_HPOUT1L_DLY_MASK |WM8994_HPOUT1L_OUTP_MASK | WM8994_HPOUT1L_RMV_SHORT_MASK);
+			wm8994_write(codec, WM8994_ANALOGUE_HP_1, val);
+
+			// ------------------ Spk path setting ------------------
+			// Disable SPKLVOL
+			val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_3);
+			val &= ~(WM8994_SPKLVOL_ENA_MASK | WM8994_SPKRVOL_ENA_MASK);
+			wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, val);
+
+			// Disable SPKOUT mixer
+			val = wm8994_read(codec,WM8994_SPKOUT_MIXERS);
+			val &= ~(WM8994_SPKMIXL_TO_SPKOUTL_MASK | WM8994_SPKMIXR_TO_SPKOUTR_MASK);
+			wm8994_write(codec, WM8994_SPKOUT_MIXERS, val);
+
+			//Mute Speaker mixer
+			val = wm8994_read(codec,WM8994_SPEAKER_MIXER);
+			val &= ~(WM8994_DAC1L_TO_SPKMIXL_MASK | WM8994_DAC1R_TO_SPKMIXR_MASK);
+			wm8994_write(codec, WM8994_SPEAKER_MIXER ,val);
+		break;
+
+		default:
+			DEBUG_LOG_ERR("Path[%d] is not invaild!", path);
+			return;
+		break;
+	}
+}
+
+void wm8994_disable_rec_path(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	u16 val;
+	enum mic_path mic = wm8994->rec_path;
+
+	wm8994->rec_path = MIC_OFF;
+
+	if (!(wm8994->codec_state & CALL_ACTIVE))
+		audio_ctrl_mic_bias_gpio(0);
+
+	switch (mic) {
+	case MAIN:
+		DEBUG_LOG("Disabling MAIN Mic Path..\n");
+
+		if(!(wm8994->codec_state & CALL_ACTIVE))	// Normal case
+		{
+			val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_2  );
+			val &= ~( WM8994_IN1L_ENA_MASK | WM8994_MIXINL_ENA_MASK);
+			wm8994_write(codec,WM8994_POWER_MANAGEMENT_2, val);
+
+			if(wm8994->testmode_config_flag == SEC_NORMAL)
+			{
+				/* Mute IN1L PGA, update volume */
+				val = wm8994_read(codec,
+						WM8994_LEFT_LINE_INPUT_1_2_VOLUME);
+				val &= ~(WM8994_IN1L_MUTE_MASK | WM8994_IN1L_VOL_MASK);
+				val |= (WM8994_IN1L_VU | WM8994_IN1L_MUTE);
+				wm8994_write(codec, WM8994_LEFT_LINE_INPUT_1_2_VOLUME,
+						val);
+
+				/*Mute the PGA */
+				val = wm8994_read(codec, WM8994_INPUT_MIXER_3);
+				val &= ~(WM8994_IN1L_TO_MIXINL_MASK |
+					WM8994_IN1L_MIXINL_VOL_MASK |
+					WM8994_MIXOUTL_MIXINL_VOL_MASK);
+				wm8994_write(codec, WM8994_INPUT_MIXER_3, val);
+			}
+
+			/* Disconnect IN1LN ans IN1LP to the inputs */
+			val = wm8994_read(codec, WM8994_INPUT_MIXER_2);
+			val &= (WM8994_IN1LN_TO_IN1L_MASK | WM8994_IN1LP_TO_IN1L_MASK);
+			wm8994_write(codec, WM8994_INPUT_MIXER_2, val);
+
+			//Digital Paths
+			val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_4);
+			val &= ~(WM8994_ADCL_ENA_MASK |WM8994_AIF1ADC1L_ENA_MASK);
+			wm8994_write(codec,WM8994_POWER_MANAGEMENT_4, val);
+		}
+		else
+		{
+			//Digital Paths
+			val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_4);
+			val &= ~(WM8994_AIF1ADC1L_ENA_MASK);
+			wm8994_write(codec,WM8994_POWER_MANAGEMENT_4, val);
+		}
+
+		/* Disable timeslots */
+		val = wm8994_read(codec, WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING);
+		val &= ~(WM8994_ADC1L_TO_AIF1ADC1L);
+		wm8994_write(codec, WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING, val);
+		break;
+
+	case SUB:
+		DEBUG_LOG("Disbaling SUB Mic path..");
+
+		if(!(wm8994->codec_state & CALL_ACTIVE))	// Normal case
+		{
+			val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_2);
+			val &= ~(WM8994_IN1R_ENA_MASK |WM8994_MIXINR_ENA_MASK);
+			wm8994_write(codec,WM8994_POWER_MANAGEMENT_2,val);
+
+			if(wm8994->testmode_config_flag == SEC_NORMAL)
+			{
+				// Disable volume,unmute Right Line
+				val = wm8994_read(codec,WM8994_RIGHT_LINE_INPUT_1_2_VOLUME);
+				val &= ~(WM8994_IN1R_MUTE_MASK | WM8994_IN1R_VOL_MASK);	// Unmute IN1R
+				val |= (WM8994_IN1R_VU | WM8994_IN1R_MUTE);
+				wm8994_write(codec,WM8994_RIGHT_LINE_INPUT_1_2_VOLUME, val);
+
+				// Mute right pga, set volume
+				val = wm8994_read(codec,WM8994_INPUT_MIXER_4);
+				val&= ~(WM8994_IN1R_TO_MIXINR_MASK | WM8994_IN1R_MIXINR_VOL_MASK | WM8994_MIXOUTR_MIXINR_VOL_MASK);
+				wm8994_write(codec,WM8994_INPUT_MIXER_4, val);
+			}
+
+			//Disconnect in1rn to inr1 and in1rp to inrp
+			val = wm8994_read(codec,WM8994_INPUT_MIXER_2);
+			val &= ~(WM8994_IN1RN_TO_IN1R_MASK | WM8994_IN1RP_TO_IN1R_MASK);
+			wm8994_write(codec,WM8994_INPUT_MIXER_2, val);
+
+			//Digital Paths
+			//Disable right ADC and time slot
+			val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_4);
+			val &= ~(WM8994_ADCR_ENA_MASK | WM8994_AIF1ADC1R_ENA_MASK);
+			wm8994_write(codec, WM8994_POWER_MANAGEMENT_4, val);
+		}
+		else
+		{
+			//Digital Paths
+			//Disable right ADC and time slot
+			val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_4);
+			val &= ~(WM8994_AIF1ADC1R_ENA_MASK);
+			wm8994_write(codec,WM8994_POWER_MANAGEMENT_4, val);
+
+			val = wm8994_read(codec, WM8994_AIF1_CONTROL_1);	//605H : 0x0010
+			val &= ~(WM8994_AIF1ADCL_SRC_MASK);
+			wm8994_write(codec, WM8994_AIF1_CONTROL_1, val);
+		}
+
+		/* ADC Right mixer routing */
+		val = wm8994_read(codec, WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING);
+		val &= ~(WM8994_ADC1R_TO_AIF1ADC1R_MASK);
+		wm8994_write(codec, WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING, val);
+		break;
+
+		case BT_REC:
+			if(!(wm8994->codec_state & CALL_ACTIVE))	// Normal case
+			{
+				//R1542(606h) - 0x0000
+				val = wm8994_read(codec, WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING);
+				val &= ~(WM8994_AIF2DACL_TO_AIF1ADC1L_MASK | WM8994_ADC1L_TO_AIF1ADC1L_MASK);
+				wm8994_write(codec, WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING, val);
+
+				//R1543(607h) - 0x0000
+				val = wm8994_read(codec, WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING);
+				val &= ~(WM8994_AIF2DACR_TO_AIF1ADC1R_MASK | WM8994_ADC1R_TO_AIF1ADC1R_MASK);
+				wm8994_write(codec, WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING, val);
+
+				//R1312(520h) - 0x0200
+				val = wm8994_read(codec, WM8994_AIF2_DAC_FILTERS_1);
+				val &= ~(WM8994_AIF2DAC_MUTE_MASK);
+				val |= (WM8994_AIF2DAC_MUTE);
+				wm8994_write(codec, WM8994_AIF2_DAC_FILTERS_1, val);
+			}
+		break;
+
+		default:
+                    if((wm8994->codec_state & CALL_ACTIVE) &&  (wm8994->call_record_ch == CH_OFF))
+                    {
+                            if(wm8994->call_record_path == CALL_RECORDING_MAIN)
+                            {
+                                    DEBUG_LOG("Disabling MAIN Mic Path in call");
+                                    //Digital Paths
+                                    val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_4);
+                                    val &= ~(WM8994_AIF1ADC1L_ENA_MASK);
+                                    wm8994_write(codec,WM8994_POWER_MANAGEMENT_4, val);
+
+                                    //Disable timeslots
+                                    val = wm8994_read(codec,WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING);
+                                    val &= ~(WM8994_ADC1L_TO_AIF1ADC1L);
+                                    wm8994_write(codec,WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING, val);
+                            }
+                            else if(wm8994->call_record_path == CALL_RECORDING_SUB)
+                            {
+                                    DEBUG_LOG("Disbaling SUB Mic path in call");
+                                    //Digital Paths
+                                    //Disable right ADC and time slot
+                                    val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_4);
+                                    val &= ~(WM8994_AIF1ADC1R_ENA_MASK);
+                                    wm8994_write(codec,WM8994_POWER_MANAGEMENT_4, val);
+
+                                    val = wm8994_read(codec, WM8994_AIF1_CONTROL_1);	//605H : 0x0010
+                                    val &= ~(WM8994_AIF1ADCL_SRC_MASK);
+                                    wm8994_write(codec, WM8994_AIF1_CONTROL_1, val);
+
+                                    //ADC Right mixer routing
+                                    val = wm8994_read(codec,WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING);
+                                    val &= ~(WM8994_ADC1R_TO_AIF1ADC1R_MASK);
+                                    wm8994_write(codec, WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING, val);
+                            }
+
+                            wm8994->call_record_path = CALL_RECORDING_OFF;
+                    }
+                    else
+                    {
+                            DEBUG_LOG_ERR("Path[%d] is not invaild!", mic);
+                    }
+		break;
+	}
+}
+
+void wm8994_disable_fmradio_path(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	u16 val;
+	enum fmradio_path path = wm8994->rec_path;
+
+	DEBUG_LOG("Turn off fmradio_path = [%d]", path);
+
+	switch(path)
+	{
+		case FMR_OFF :
+			wm8994->fmradio_path = FMR_OFF;
+
+			//---------------------------------------------------
+			// Disable speaker setting for FM radio
+			if(wm8994->codec_state & CALL_ACTIVE)
+			{
+
+			//disable the SPKOUTL
+			val =wm8994_read(codec,WM8994_POWER_MANAGEMENT_1);
+			val &= ~(WM8994_SPKOUTL_ENA_MASK);
+			wm8994_write(codec,WM8994_POWER_MANAGEMENT_1 ,val);
+
+			// Disable SPK Volume.
+			val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_3);
+			val &= ~(WM8994_SPKRVOL_ENA_MASK | WM8994_SPKLVOL_ENA_MASK);
+			wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, val);
+
+			if(wm8994->testmode_config_flag == SEC_NORMAL)
+			{
+				// Mute the SPKMIXVOLUME
+				val = wm8994_read(codec, WM8994_SPKMIXL_ATTENUATION);
+				val &= ~(WM8994_SPKMIXL_VOL_MASK);
+				wm8994_write(codec, WM8994_SPKMIXL_ATTENUATION, val);
+
+				val = wm8994_read(codec, WM8994_SPKMIXR_ATTENUATION);
+				val &= ~(WM8994_SPKMIXR_VOL_MASK);
+				wm8994_write(codec, WM8994_SPKMIXR_ATTENUATION, val);
+
+				val = wm8994_read(codec, WM8994_SPEAKER_VOLUME_LEFT);
+				val &= ~(WM8994_SPKOUTL_MUTE_N_MASK | WM8994_SPKOUTL_VOL_MASK);
+				wm8994_write(codec, WM8994_SPEAKER_VOLUME_LEFT, val);
+
+				val = wm8994_read(codec, WM8994_SPEAKER_VOLUME_RIGHT);
+				val &= ~(WM8994_SPKOUTR_MUTE_N_MASK | WM8994_SPKOUTR_VOL_MASK);
+				val |= (WM8994_SPKOUT_VU);
+				wm8994_write(codec, WM8994_SPEAKER_VOLUME_RIGHT, val);
+
+				val = wm8994_read(codec, WM8994_CLASSD);
+				val &= ~(WM8994_SPKOUTL_BOOST_MASK);
+				wm8994_write(codec, WM8994_CLASSD, val);
+			}
+
+			/*Output MIxer-Output PGA*/
+			val = wm8994_read(codec,WM8994_SPKOUT_MIXERS );
+			val &= ~(WM8994_SPKMIXL_TO_SPKOUTL_MASK |
+				WM8994_SPKMIXR_TO_SPKOUTL_MASK | WM8994_SPKMIXR_TO_SPKOUTR_MASK);
+			wm8994_write(codec, WM8994_SPKOUT_MIXERS, val);
+
+			// Output mixer setting
+			val = wm8994_read(codec, WM8994_SPEAKER_MIXER);
+			val &= ~(WM8994_MIXINL_TO_SPKMIXL_MASK | WM8994_MIXINR_TO_SPKMIXR_MASK);
+			wm8994_write(codec, WM8994_SPEAKER_MIXER, val);
+
+			//---------------------------------------------------
+			// Disable earpath setting for FM radio
+
+			//Disable end point for preventing pop up noise.
+			val =wm8994_read(codec,WM8994_POWER_MANAGEMENT_1);
+			val &= ~(WM8994_HPOUT1L_ENA_MASK |WM8994_HPOUT1R_ENA_MASK);
+			wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+			// Disable MIXOUT
+			val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_3);
+			val &= ~(WM8994_MIXOUTLVOL_ENA_MASK | WM8994_MIXOUTRVOL_ENA_MASK | WM8994_MIXOUTL_ENA_MASK | WM8994_MIXOUTR_ENA_MASK);
+			wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, val);
+
+			if(wm8994->testmode_config_flag == SEC_NORMAL)
+			{
+				// Output setting
+				val = wm8994_read(codec, WM8994_LEFT_OUTPUT_VOLUME);
+				val &= ~(WM8994_HPOUT1L_MUTE_N_MASK | WM8994_HPOUT1L_VOL_MASK);
+				wm8994_write(codec, WM8994_LEFT_OUTPUT_VOLUME, val);
+
+				val = wm8994_read(codec, WM8994_RIGHT_OUTPUT_VOLUME);
+				val &= ~(WM8994_HPOUT1R_MUTE_N_MASK | WM8994_HPOUT1R_VOL_MASK);
+				val |= (WM8994_HPOUT1_VU);
+				wm8994_write(codec, WM8994_RIGHT_OUTPUT_VOLUME, val);
+			}
+
+			//Disable Charge Pump
+			val = wm8994_read(codec, WM8994_CHARGE_PUMP_1);
+			val &= ~WM8994_CP_ENA_MASK ;
+			val |= WM8994_CP_ENA_DEFAULT ; // this is from wolfson
+			wm8994_write(codec, WM8994_CHARGE_PUMP_1, val);
+
+			// Intermediate HP settings
+			val = wm8994_read(codec, WM8994_ANALOGUE_HP_1);
+			val &= ~(WM8994_HPOUT1R_DLY_MASK |WM8994_HPOUT1R_OUTP_MASK |WM8994_HPOUT1R_RMV_SHORT_MASK |
+				WM8994_HPOUT1L_DLY_MASK |WM8994_HPOUT1L_OUTP_MASK | WM8994_HPOUT1L_RMV_SHORT_MASK);
+			wm8994_write(codec, WM8994_ANALOGUE_HP_1, val);
+
+			// Disable Output mixer setting
+			val = wm8994_read(codec, WM8994_OUTPUT_MIXER_1);
+			val &= ~(WM8994_DAC1L_TO_HPOUT1L_MASK | WM8994_MIXINL_TO_MIXOUTL_MASK);
+			wm8994_write(codec, WM8994_OUTPUT_MIXER_1, val);
+
+			val = wm8994_read(codec, WM8994_OUTPUT_MIXER_2);
+			val &= ~(WM8994_DAC1R_TO_HPOUT1R_MASK | WM8994_MIXINR_TO_MIXOUTR_MASK);
+			wm8994_write(codec, WM8994_OUTPUT_MIXER_2, val);
+
+			//---------------------------------------------------
+			// Disable common setting for FM radio
+
+			// Disable IN2 and MIXIN
+			val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_2);
+			val &= ~(WM8994_TSHUT_ENA_MASK | WM8994_TSHUT_OPDIS_MASK | WM8994_OPCLK_ENA_MASK |
+					WM8994_MIXINL_ENA_MASK | WM8994_MIXINR_ENA_MASK | WM8994_IN2L_ENA_MASK | WM8994_IN2R_ENA_MASK);
+			wm8994_write(codec, WM8994_POWER_MANAGEMENT_2, val);
+
+			// Disable Input mixer setting
+			val = wm8994_read(codec, WM8994_INPUT_MIXER_2);
+			val &= ~(WM8994_IN2LN_TO_IN2L_MASK | WM8994_IN2RN_TO_IN2R_MASK);
+			wm8994_write(codec, WM8994_INPUT_MIXER_2, val);
+
+			if(wm8994->testmode_config_flag == SEC_NORMAL)
+			{
+				// Disable IN2L to MIXINL
+				val = wm8994_read(codec, WM8994_INPUT_MIXER_3);
+				val &= ~(WM8994_IN2L_TO_MIXINL_MASK);
+				wm8994_write(codec, WM8994_INPUT_MIXER_3, val);
+
+				//Disable IN2R to MIXINR
+				val = wm8994_read(codec, WM8994_INPUT_MIXER_4);
+				val &= ~(WM8994_IN2R_TO_MIXINR_MASK);
+				wm8994_write(codec, WM8994_INPUT_MIXER_4, val);
+			}
+
+			// Mute IN2L PGA volume
+			val = wm8994_read(codec, WM8994_LEFT_LINE_INPUT_3_4_VOLUME);
+			val &= ~(WM8994_IN2L_VU_MASK | WM8994_IN2L_MUTE_MASK | WM8994_IN2L_VOL_MASK);
+			val |= (WM8994_IN2L_MUTE);
+			wm8994_write(codec, WM8994_LEFT_LINE_INPUT_3_4_VOLUME, val);
+
+			val = wm8994_read(codec, WM8994_RIGHT_LINE_INPUT_3_4_VOLUME);
+			val &= ~(WM8994_IN2R_VU_MASK | WM8994_IN2R_MUTE_MASK | WM8994_IN2R_VOL_MASK);
+			val |= (WM8994_IN2R_VU |WM8994_IN2R_MUTE);
+			wm8994_write(codec, WM8994_RIGHT_LINE_INPUT_3_4_VOLUME, val);
+
+			//---------------------------------------------------
+			// Disable path setting for mixing
+			val = wm8994_read(codec,WM8994_SPEAKER_MIXER);
+			val &= ~(WM8994_DAC1L_TO_SPKMIXL_MASK);
+			wm8994_write(codec, WM8994_SPEAKER_MIXER, val);
+
+			// Disable DAC1L to HPOUT1L path
+			val = wm8994_read(codec, WM8994_OUTPUT_MIXER_1);
+			val &= ~(WM8994_DAC1L_TO_HPOUT1L_MASK | WM8994_DAC1L_TO_MIXOUTL_MASK);
+			wm8994_write(codec,WM8994_OUTPUT_MIXER_1, val);
+
+			// Disable DAC1R to HPOUT1R path
+			val = wm8994_read(codec, WM8994_OUTPUT_MIXER_2);
+			val &= ~(WM8994_DAC1R_TO_HPOUT1R_MASK | WM8994_DAC1R_TO_MIXOUTR_MASK);
+			wm8994_write(codec, WM8994_OUTPUT_MIXER_2, val);
+			}
+			break;
+
+		case FMR_SPK :
+			//disable the SPKOUTL
+			val =wm8994_read(codec,WM8994_POWER_MANAGEMENT_1);
+			val &= ~(WM8994_SPKOUTL_ENA_MASK);
+//			wm8994_write(codec,WM8994_POWER_MANAGEMENT_1 ,val);
+
+			// Disable SPK Volume.
+			val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_3);
+			val &= ~(WM8994_SPKRVOL_ENA_MASK | WM8994_SPKLVOL_ENA_MASK);
+//			wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, val);
+
+			if(wm8994->testmode_config_flag == SEC_NORMAL)
+			{
+				// Mute the SPKMIXVOLUME
+				val = wm8994_read(codec, WM8994_SPKMIXL_ATTENUATION);
+				val &= ~(WM8994_SPKMIXL_VOL_MASK);
+				wm8994_write(codec, WM8994_SPKMIXL_ATTENUATION, val);
+
+				val = wm8994_read(codec, WM8994_SPKMIXR_ATTENUATION);
+				val &= ~(WM8994_SPKMIXR_VOL_MASK);
+				wm8994_write(codec, WM8994_SPKMIXR_ATTENUATION, val);
+
+				val = wm8994_read(codec, WM8994_SPEAKER_VOLUME_LEFT);
+				val &= ~(WM8994_SPKOUTL_MUTE_N_MASK | WM8994_SPKOUTL_VOL_MASK);
+				wm8994_write(codec, WM8994_SPEAKER_VOLUME_LEFT, val);
+
+				val = wm8994_read(codec, WM8994_SPEAKER_VOLUME_RIGHT);
+				val &= ~(WM8994_SPKOUTR_MUTE_N_MASK | WM8994_SPKOUTR_VOL_MASK);
+				val |= (WM8994_SPKOUT_VU);
+				wm8994_write(codec, WM8994_SPEAKER_VOLUME_RIGHT, val);
+
+				val = wm8994_read(codec, WM8994_CLASSD);
+				val &= ~(WM8994_SPKOUTL_BOOST_MASK);
+				wm8994_write(codec, WM8994_CLASSD, val);
+			}
+
+			/*Output MIxer-Output PGA*/
+			val = wm8994_read(codec,WM8994_SPKOUT_MIXERS );
+			val &= ~(WM8994_SPKMIXL_TO_SPKOUTL_MASK |
+				WM8994_SPKMIXR_TO_SPKOUTL_MASK | WM8994_SPKMIXR_TO_SPKOUTR_MASK);
+			wm8994_write(codec, WM8994_SPKOUT_MIXERS, val);
+
+			// Output mixer setting
+			val = wm8994_read(codec, WM8994_SPEAKER_MIXER);
+			val &= ~(WM8994_MIXINL_TO_SPKMIXL_MASK | WM8994_MIXINR_TO_SPKMIXR_MASK);
+			wm8994_write(codec, WM8994_SPEAKER_MIXER, val);
+			break;
+
+		case FMR_HP :
+			//Disable end point for preventing pop up noise.
+			val =wm8994_read(codec,WM8994_POWER_MANAGEMENT_1);
+			val &= ~(WM8994_HPOUT1L_ENA_MASK |WM8994_HPOUT1R_ENA_MASK);
+			wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+			// Disable MIXOUT
+			val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_3);
+			val &= ~(WM8994_MIXOUTLVOL_ENA_MASK | WM8994_MIXOUTRVOL_ENA_MASK | WM8994_MIXOUTL_ENA_MASK | WM8994_MIXOUTR_ENA_MASK);
+			wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, val);
+
+			if(wm8994->testmode_config_flag == SEC_NORMAL)
+			{
+				// Output setting
+				val = wm8994_read(codec, WM8994_LEFT_OUTPUT_VOLUME);
+				val &= ~(WM8994_HPOUT1L_MUTE_N_MASK | WM8994_HPOUT1L_VOL_MASK);
+				wm8994_write(codec, WM8994_LEFT_OUTPUT_VOLUME, val);
+
+				val = wm8994_read(codec, WM8994_RIGHT_OUTPUT_VOLUME);
+				val &= ~(WM8994_HPOUT1R_MUTE_N_MASK | WM8994_HPOUT1R_VOL_MASK);
+				val |= (WM8994_HPOUT1_VU);
+				wm8994_write(codec, WM8994_RIGHT_OUTPUT_VOLUME, val);
+			}
+
+			//Disable Charge Pump
+			val = wm8994_read(codec, WM8994_CHARGE_PUMP_1);
+			val &= ~WM8994_CP_ENA_MASK ;
+			val |= WM8994_CP_ENA_DEFAULT ; // this is from wolfson
+			wm8994_write(codec, WM8994_CHARGE_PUMP_1, val);
+
+			// Intermediate HP settings
+			val = wm8994_read(codec, WM8994_ANALOGUE_HP_1);
+			val &= ~(WM8994_HPOUT1R_DLY_MASK |WM8994_HPOUT1R_OUTP_MASK |WM8994_HPOUT1R_RMV_SHORT_MASK |
+				WM8994_HPOUT1L_DLY_MASK |WM8994_HPOUT1L_OUTP_MASK | WM8994_HPOUT1L_RMV_SHORT_MASK);
+			wm8994_write(codec, WM8994_ANALOGUE_HP_1, val);
+
+			// Disable Output mixer setting
+			val = wm8994_read(codec, WM8994_OUTPUT_MIXER_1);
+			val &= ~(WM8994_DAC1L_TO_HPOUT1L_MASK | WM8994_MIXINL_TO_MIXOUTL_MASK);
+			wm8994_write(codec, WM8994_OUTPUT_MIXER_1, val);
+
+			val = wm8994_read(codec, WM8994_OUTPUT_MIXER_2);
+			val &= ~(WM8994_DAC1R_TO_HPOUT1R_MASK | WM8994_MIXINR_TO_MIXOUTR_MASK);
+			wm8994_write(codec, WM8994_OUTPUT_MIXER_2, val);
+			break;
+
+		case FMR_SPK_MIX :
+			//Mute the DAC path
+			val = wm8994_read(codec,WM8994_SPEAKER_MIXER);
+			val &= ~(WM8994_DAC1L_TO_SPKMIXL_MASK);
+			wm8994_write(codec, WM8994_SPEAKER_MIXER, val);
+			break;
+
+		case FMR_HP_MIX :
+			// Disable DAC1L to HPOUT1L path
+			val = wm8994_read(codec, WM8994_OUTPUT_MIXER_1);
+			val &= ~(WM8994_DAC1L_TO_HPOUT1L_MASK | WM8994_DAC1L_TO_MIXOUTL_MASK);
+			wm8994_write(codec,WM8994_OUTPUT_MIXER_1, val);
+
+			// Disable DAC1R to HPOUT1R path
+			val = wm8994_read(codec, WM8994_OUTPUT_MIXER_2);
+			val &= ~(WM8994_DAC1R_TO_HPOUT1R_MASK | WM8994_DAC1R_TO_MIXOUTR_MASK);
+			wm8994_write(codec, WM8994_OUTPUT_MIXER_2, val);
+			break;
+
+		case FMR_DUAL_MIX :
+			//Mute the DAC path
+			val = wm8994_read(codec,WM8994_SPEAKER_MIXER);
+			val &= ~(WM8994_DAC1L_TO_SPKMIXL_MASK);
+			wm8994_write(codec, WM8994_SPEAKER_MIXER, val);
+
+			// Disable DAC1L to HPOUT1L path
+			val = wm8994_read(codec, WM8994_OUTPUT_MIXER_1);
+			val &= ~(WM8994_DAC1L_TO_HPOUT1L_MASK | WM8994_DAC1L_TO_MIXOUTL_MASK);
+			wm8994_write(codec,WM8994_OUTPUT_MIXER_1, val);
+
+			// Disable DAC1R to HPOUT1R path
+			val = wm8994_read(codec, WM8994_OUTPUT_MIXER_2);
+			val &= ~(WM8994_DAC1R_TO_HPOUT1R_MASK | WM8994_DAC1R_TO_MIXOUTR_MASK);
+			wm8994_write(codec, WM8994_OUTPUT_MIXER_2, val);
+			break;
+
+		default:
+			DEBUG_LOG_ERR("fmradio path[%d] is not invaild!", path);
+			return;
+			break;
+	}
+}
+
+void wm8994_record_headset_mic(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	u16 val;
+
+	DEBUG_LOG("Recording through Headset Mic\n");
+
+#if defined(CONFIG_PHONE_P1_GSM)
+	audio_ctrl_mic_bias_gpio(0);
+	audio_ctrl_earmic_bias_gpio(1);
+
+
+	if(!(wm8994->codec_state & CALL_ACTIVE))	// Normal case
+	{
+		// Disable FM radio path
+		val = wm8994_read(codec, WM8994_SPEAKER_MIXER);
+		val &= ~WM8994_MIXINL_TO_SPKMIXL_MASK;
+		wm8994_write(codec, WM8994_SPEAKER_MIXER, val);
+
+		val = wm8994_read(codec, WM8994_OUTPUT_MIXER_1);
+		val &= ~WM8994_MIXINL_TO_MIXOUTL_MASK;
+		wm8994_write(codec, WM8994_OUTPUT_MIXER_1, val);
+
+		val = wm8994_read(codec, WM8994_OUTPUT_MIXER_2);
+		val &= ~WM8994_MIXINR_TO_MIXOUTR_MASK;
+		wm8994_write(codec, WM8994_OUTPUT_MIXER_2, val);
+
+		val = wm8994_read(codec, WM8994_DAC2_LEFT_MIXER_ROUTING);	//604H : 0x0010
+		val &= ~(WM8994_ADC1_TO_DAC2L_MASK);
+		wm8994_write(codec, WM8994_DAC2_LEFT_MIXER_ROUTING, val);
+
+		val = wm8994_read(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING);	//605H : 0x0010
+		val &= ~(WM8994_ADC1_TO_DAC2R_MASK);
+		wm8994_write(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING, val);
+
+		// Mixing left channel output to right channel.
+		val = wm8994_read(codec, WM8994_AIF1_CONTROL_1);	//605H : 0x0010
+		val &= ~(WM8994_AIF1ADCL_SRC_MASK | WM8994_AIF1ADCR_SRC_MASK);
+		val |= (WM8994_AIF1ADCL_SRC | WM8994_AIF1ADCR_SRC);
+		wm8994_write(codec, WM8994_AIF1_CONTROL_1, val);
+
+		wm8994_write(codec,WM8994_ANTIPOP_2,0x68);	//Ear  mic volume issue fix
+
+		//Enable mic bias, vmid, bias generator
+		val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1 );
+		val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK);
+		val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL);
+		wm8994_write(codec,WM8994_POWER_MANAGEMENT_1,val);
+
+		//Enable Right Input Mixer,Enable IN1R PGA - Temporary inserted for blocking MIC and FM radio mixing - DW Shim 2010.03.04
+		//val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_2 );
+		//val &= ~(WM8994_IN1R_ENA_MASK |WM8994_MIXINR_ENA_MASK  );
+		//val |= (WM8994_MIXINR_ENA | WM8994_IN1R_ENA );
+		val = (WM8994_MIXINR_ENA | WM8994_IN1R_ENA );
+		wm8994_write(codec,WM8994_POWER_MANAGEMENT_2,val);
+
+		if(wm8994->testmode_config_flag == SEC_NORMAL)
+		{
+			// Enable volume,unmute Right Line
+			val = wm8994_read(codec,WM8994_RIGHT_LINE_INPUT_1_2_VOLUME);
+			val &= ~(WM8994_IN1R_MUTE_MASK | WM8994_IN1R_VOL_MASK);	// Unmute IN1R
+			if(wm8994->recognition_active == REC_ON)
+                                val |= (WM8994_IN1R_VU | TUNING_RECOGNITION_SUB_INPUTMIX_VOL);
+			else
+				val |= (WM8994_IN1R_VU | TUNING_RECORD_SUB_INPUTMIX_VOL);
+			wm8994_write(codec,WM8994_RIGHT_LINE_INPUT_1_2_VOLUME,val);
+
+			// unmute right pga, set volume
+			val = wm8994_read(codec,WM8994_INPUT_MIXER_4 );
+			val&= ~(WM8994_IN1R_TO_MIXINR_MASK | WM8994_IN1R_MIXINR_VOL_MASK | WM8994_MIXOUTR_MIXINR_VOL_MASK);
+			val |= (WM8994_IN1R_TO_MIXINR | WM8994_IN1R_MIXINR_VOL);//30db
+			wm8994_write(codec,WM8994_INPUT_MIXER_4 ,val);
+		}
+
+		val = wm8994_read(codec, WM8994_AIF1_ADC1_LEFT_VOLUME);
+		val &= ~(WM8994_AIF1ADC1L_VOL_MASK);
+		if(wm8994->recognition_active == REC_ON)
+			val |= (TUNING_RECOGNITION_SUB_AIF1ADCL_VOL);
+		else
+			val |= (TUNING_RECORD_SUB_AIF1ADCL_VOL); // 0db
+		wm8994_write(codec, WM8994_AIF1_ADC1_LEFT_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_AIF1_ADC1_RIGHT_VOLUME);
+		val &= ~(WM8994_AIF1ADC1R_VOL_MASK);
+		if(wm8994->recognition_active == REC_ON)
+			val |= (WM8994_AIF1ADC1_VU | TUNING_RECOGNITION_SUB_AIF1ADCR_VOL);
+		else
+			val |= (WM8994_AIF1ADC1_VU | TUNING_RECORD_SUB_AIF1ADCR_VOL); // 0db
+		wm8994_write(codec, WM8994_AIF1_ADC1_RIGHT_VOLUME, val);
+
+		//connect in1rn to inr1 and in1rp to inrp - Temporary inserted for blocking MIC and FM radio mixing - DW Shim 2010.03.04
+		//val = wm8994_read(codec,WM8994_INPUT_MIXER_2);
+		//val &= ~( WM8994_IN1RN_TO_IN1R_MASK | WM8994_IN1RP_TO_IN1R_MASK);
+		//val |= (WM8994_IN1RN_TO_IN1R | WM8994_IN1RP_TO_IN1R)  ;
+		val = (WM8994_IN1RN_TO_IN1R | WM8994_IN1RP_TO_IN1R)  ;
+		wm8994_write(codec,WM8994_INPUT_MIXER_2,val);
+	}
+	else
+	{
+		// Mixing left channel output to right channel.
+		val = wm8994_read(codec, WM8994_AIF1_CONTROL_1);	//605H : 0x0010
+		val &= ~(WM8994_AIF1ADCL_SRC_MASK | WM8994_AIF1ADCR_SRC_MASK);
+		val |= (WM8994_AIF1ADCL_SRC | WM8994_AIF1ADCR_SRC);
+		wm8994_write(codec, WM8994_AIF1_CONTROL_1, val);
+	}
+#elif defined(CONFIG_PHONE_P1_CDMA)
+	audio_ctrl_mic_bias_gpio(1);
+
+	//Enable mic bias, vmid, bias generator
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1 );
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK | WM8994_MICB1_ENA_MASK  );
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL |WM8994_MICB1_ENA  );
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_1,val);
+
+	//Enable Right Input Mixer,Enable IN1R PGA - Temporary inserted for blocking MIC and FM radio mixing - DW Shim 2010.03.04
+//	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_2 );
+//	val &= ~(WM8994_IN1R_ENA_MASK |WM8994_MIXINR_ENA_MASK  );
+//	val |= (WM8994_MIXINR_ENA | WM8994_IN1R_ENA );
+	val = (WM8994_MIXINR_ENA | WM8994_IN1R_ENA );
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_2,val);
+
+	// Mixing left channel output to right channel.
+	val = wm8994_read(codec, WM8994_AIF1_CONTROL_1);	//605H : 0x0010
+	val &= ~(WM8994_AIF1ADCL_SRC_MASK | WM8994_AIF1ADCR_SRC_MASK);
+	val |= (WM8994_AIF1ADCL_SRC | WM8994_AIF1ADCR_SRC);
+	wm8994_write(codec, WM8994_AIF1_CONTROL_1, val);
+
+	if(!wm8994->testmode_config_flag)
+	{
+		// Enable volume,unmute Right Line
+		val = wm8994_read(codec,WM8994_RIGHT_LINE_INPUT_1_2_VOLUME);
+		val &= ~WM8994_IN1R_MUTE_MASK;	// Unmute IN1R
+		val |= (WM8994_IN1R_VU | TUNING_RECORD_SUB_INPUTMIX_VOL);
+		wm8994_write(codec,WM8994_RIGHT_LINE_INPUT_1_2_VOLUME,val);
+
+		// unmute right pga, set volume
+		val = wm8994_read(codec,WM8994_INPUT_MIXER_4 );
+		val&= ~(WM8994_IN1R_TO_MIXINR_MASK | WM8994_IN1R_MIXINR_VOL_MASK | WM8994_MIXOUTR_MIXINR_VOL_MASK);
+		val |= (WM8994_IN1R_TO_MIXINR);//0db
+		wm8994_write(codec,WM8994_INPUT_MIXER_4 ,val);
+
+		wm8994_write(codec, WM8994_AIF1_ADC1_RIGHT_VOLUME, WM8994_AIF1ADC1_VU | TUNING_RECORD_SUB_AIF1ADCR_VOL);
+		wm8994_write(codec, WM8994_AIF1_ADC1_LEFT_VOLUME, TUNING_RECORD_SUB_AIF1ADCL_VOL);
+	}
+
+	//connect in1rn to inr1 and in1rp to inrp - Temporary inserted for blocking MIC and FM radio mixing - DW Shim 2010.03.04
+//	val = wm8994_read(codec,WM8994_INPUT_MIXER_2);
+//	val &= ~( WM8994_IN1RN_TO_IN1R_MASK | WM8994_IN1RP_TO_IN1R_MASK);
+//	val |= (WM8994_IN1RN_TO_IN1R | WM8994_IN1RP_TO_IN1R)  ;
+	val = (WM8994_IN1RN_TO_IN1R | WM8994_IN1RP_TO_IN1R)  ;
+	wm8994_write(codec,WM8994_INPUT_MIXER_2,val);
+#endif
+
+	//Digital Paths
+	//Enable right ADC and time slot
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_4);
+	val &= ~(WM8994_ADCR_ENA_MASK |WM8994_AIF1ADC1R_ENA_MASK );
+	val |= (WM8994_AIF1ADC1R_ENA | WM8994_ADCR_ENA  );
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_4 ,val);
+
+	//ADC Right mixer routing
+	val = wm8994_read(codec,WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING);
+	val &= ~( WM8994_ADC1R_TO_AIF1ADC1R_MASK);
+	val |= WM8994_ADC1R_TO_AIF1ADC1R;
+	wm8994_write(codec,WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING,val);
+
+	val = wm8994_read(codec, WM8994_AIF1_MASTER_SLAVE);
+	val |= (WM8994_AIF1_MSTR | WM8994_AIF1_CLK_FRC | WM8994_AIF1_LRCLK_FRC);	// Master mode
+	wm8994_write(codec, WM8994_AIF1_MASTER_SLAVE, val);
+
+	wm8994_write( codec, WM8994_GPIO_1, 0xA101 );   // GPIO1 is Input Enable
+}
+
+void wm8994_record_main_mic(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	u16 val;
+
+	DEBUG_LOG("Recording through Main Mic\n");
+	audio_ctrl_mic_bias_gpio(1);
+
+#if defined(CONFIG_PHONE_P1_GSM)
+	if(!(wm8994->codec_state & CALL_ACTIVE))	// Normal case
+	{
+		// Disable FM radio path
+		val = wm8994_read(codec, WM8994_SPEAKER_MIXER);
+		val &= ~WM8994_MIXINL_TO_SPKMIXL_MASK;
+		wm8994_write(codec, WM8994_SPEAKER_MIXER, val);
+
+		val = wm8994_read(codec, WM8994_OUTPUT_MIXER_1);
+		val &= ~WM8994_MIXINL_TO_MIXOUTL_MASK;
+		wm8994_write(codec, WM8994_OUTPUT_MIXER_1, val);
+
+		val = wm8994_read(codec, WM8994_OUTPUT_MIXER_2);
+		val &= ~WM8994_MIXINR_TO_MIXOUTR_MASK;
+		wm8994_write(codec, WM8994_OUTPUT_MIXER_2, val);
+
+		val = wm8994_read(codec, WM8994_DAC2_LEFT_MIXER_ROUTING);	//604H : 0x0010
+		val &= ~(WM8994_ADC1_TO_DAC2L_MASK);
+		wm8994_write(codec, WM8994_DAC2_LEFT_MIXER_ROUTING, val);
+
+		val = wm8994_read(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING);	//605H : 0x0010
+		val &= ~(WM8994_ADC1_TO_DAC2R_MASK);
+		wm8994_write(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING, val);
+
+		// Mixing left channel output to right channel.
+		val = wm8994_read(codec, WM8994_AIF1_CONTROL_1);	//605H : 0x0010
+		val &= ~(WM8994_AIF1ADCL_SRC_MASK | WM8994_AIF1ADCR_SRC_MASK);
+		wm8994_write(codec, WM8994_AIF1_CONTROL_1, val);
+
+		wm8994_write(codec, WM8994_ANTIPOP_2, 0x68); //Main mic volume issue fix: requested H/W
+
+		//Enable micbias,vmid,mic1
+		val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1);
+		val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK);
+		val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL);
+		wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+		//Enable left input mixer and IN1L PGA	- Temporary inserted for blocking MIC and FM radio mixing - DW Shim 2010.03.04
+		//val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_2  );
+		//val &= ~( WM8994_IN1L_ENA_MASK | WM8994_MIXINL_ENA_MASK );
+		//val |= (WM8994_MIXINL_ENA |WM8994_IN1L_ENA );
+		val = (WM8994_MIXINL_ENA |WM8994_IN1L_ENA);
+		wm8994_write(codec, WM8994_POWER_MANAGEMENT_2, val);
+
+		//Enable HPF Filter for google voice search
+		if(wm8994->recognition_active == REC_ON
+		){
+			val = wm8994_read(codec, WM8994_AIF1_ADC1_FILTERS);
+			val &= ~(WM8994_AIF1ADC1L_HPF_MASK | WM8994_AIF1ADC1R_HPF_MASK);
+			val |= (WM8994_AIF1ADC1L_HPF | WM8994_AIF1ADC1R_HPF);
+			wm8994_write(codec, WM8994_AIF1_ADC1_FILTERS ,val);
+		}
+
+		if(wm8994->testmode_config_flag == SEC_NORMAL)
+		{
+			// Unmute IN1L PGA, update volume
+			val = wm8994_read(codec, WM8994_LEFT_LINE_INPUT_1_2_VOLUME);
+			val &= ~(WM8994_IN1L_MUTE_MASK | WM8994_IN1L_VOL_MASK);
+
+			if(wm8994->recognition_active == REC_ON)
+				val |= (WM8994_IN1L_VU |TUNING_RECOGNITION_MAIN_INPUTLINE_VOL); //volume
+			else
+				val |= (WM8994_IN1L_VU |TUNING_RECORD_MAIN_INPUTLINE_VOL); //volume
+
+			wm8994_write(codec, WM8994_LEFT_LINE_INPUT_1_2_VOLUME, val);
+
+			//Unmute the PGA
+			val = wm8994_read(codec, WM8994_INPUT_MIXER_3);
+			val&= ~(WM8994_IN1L_TO_MIXINL_MASK | WM8994_IN1L_MIXINL_VOL_MASK | WM8994_MIXOUTL_MIXINL_VOL_MASK);
+			val |= (WM8994_IN1L_TO_MIXINL | WM8994_IN1L_MIXINL_VOL); //30db
+
+			wm8994_write(codec, WM8994_INPUT_MIXER_3, val);
+		}
+
+		//Connect IN1LN ans IN1LP to the inputs - Temporary inserted for blocking MIC and FM radio mixing - DW Shim 2010.03.04
+		//val = wm8994_read(codec,WM8994_INPUT_MIXER_2);
+		//val &= (WM8994_IN1LN_TO_IN1L_MASK | WM8994_IN1LP_TO_IN1L_MASK);
+		//val |= (WM8994_IN1LP_TO_IN1L | WM8994_IN1LN_TO_IN1L);
+		val = (WM8994_IN1LP_TO_IN1L | WM8994_IN1LN_TO_IN1L);
+		wm8994_write(codec, WM8994_INPUT_MIXER_2, val);
+
+		//Digital Paths
+		val = wm8994_read(codec, WM8994_AIF1_ADC1_LEFT_VOLUME);
+		val &= ~(WM8994_AIF1ADC1L_VOL_MASK);
+
+		if(wm8994->recognition_active == REC_ON)
+			val |= (TUNING_RECOGNITION_MAIN_AIF1ADCL_VOL);
+		else
+			val |= (TUNING_RECORD_MAIN_AIF1ADCL_VOL); // 0db
+
+		wm8994_write(codec, WM8994_AIF1_ADC1_LEFT_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_AIF1_ADC1_RIGHT_VOLUME);
+		val &= ~(WM8994_AIF1ADC1R_VOL_MASK);
+
+		if(wm8994->recognition_active == REC_ON)
+			val |= (WM8994_AIF1ADC1_VU | TUNING_RECOGNITION_MAIN_AIF1ADCR_VOL);
+		else
+			val |= (WM8994_AIF1ADC1_VU | TUNING_RECORD_MAIN_AIF1ADCR_VOL); // 0db
+
+		wm8994_write(codec, WM8994_AIF1_ADC1_RIGHT_VOLUME, val);
+	}
+#elif defined(CONFIG_PHONE_P1_CDMA)
+
+	//Enable micbias,vmid,mic1
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1 );
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK | WM8994_MICB1_ENA_MASK  );
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL |WM8994_MICB1_ENA	);
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_1,val);
+
+	//Enable left input mixer and IN1L PGA	- Temporary inserted for blocking MIC and FM radio mixing - DW Shim 2010.03.04
+//	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_2  );
+//	val &= ~( WM8994_IN1L_ENA_MASK | WM8994_MIXINL_ENA_MASK );
+//	val |= (WM8994_MIXINL_ENA |WM8994_IN1L_ENA );
+	val = (WM8994_MIXINL_ENA |WM8994_IN1L_ENA );
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_2,val);
+
+	if(!wm8994->testmode_config_flag)
+	{
+		// Unmute IN1L PGA, update volume
+		val = wm8994_read(codec, WM8994_LEFT_LINE_INPUT_1_2_VOLUME);
+		val &= ~(WM8994_IN1L_MUTE_MASK | WM8994_IN1L_VOL_MASK);
+		val |= (WM8994_IN1L_VU |TUNING_RECORD_MAIN_INPUTLINE_VOL); //volume
+		wm8994_write(codec, WM8994_LEFT_LINE_INPUT_1_2_VOLUME, val);
+
+		//Unmute the PGA
+		val = wm8994_read(codec, WM8994_INPUT_MIXER_3);
+		val&= ~(WM8994_IN1L_TO_MIXINL_MASK | WM8994_IN1L_MIXINL_VOL_MASK | WM8994_MIXOUTL_MIXINL_VOL_MASK);
+		val |= (WM8994_IN1L_MIXINL_VOL | WM8994_IN1L_TO_MIXINL);	//30db
+		wm8994_write(codec, WM8994_INPUT_MIXER_3, val);
+	}
+
+	//Connect IN1LN ans IN1LP to the inputs - Temporary inserted for blocking MIC and FM radio mixing - DW Shim 2010.03.04
+	val = wm8994_read(codec,WM8994_INPUT_MIXER_2 );
+	val &= (WM8994_IN1LN_TO_IN1L_MASK | WM8994_IN1LP_TO_IN1L_MASK );
+	val |= ( WM8994_IN1LP_TO_IN1L | WM8994_IN1LN_TO_IN1L );
+	wm8994_write(codec, WM8994_INPUT_MIXER_2, val);
+#endif
+
+	//Digital Paths
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_4);
+	val &= ~(WM8994_ADCL_ENA_MASK | WM8994_AIF1ADC1L_ENA_MASK);
+	val |= (WM8994_AIF1ADC1L_ENA | WM8994_ADCL_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_4, val);
+

+	//Enable timeslots
+	val = wm8994_read(codec, WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING);
+	val |=WM8994_ADC1L_TO_AIF1ADC1L;
+	wm8994_write(codec, WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING, val);
+
+	val = wm8994_read(codec, WM8994_AIF1_MASTER_SLAVE);
+	val |= (WM8994_AIF1_MSTR | WM8994_AIF1_CLK_FRC | WM8994_AIF1_LRCLK_FRC);	// Master mode
+	wm8994_write(codec, WM8994_AIF1_MASTER_SLAVE, val);
+
+	wm8994_write(codec, WM8994_GPIO_1, 0xA101); // GPIO1 is Input Enable
+
+	// for stable pcm input when start google voice recognition
+	if(wm8994->recognition_active == REC_ON)
+	{
+		msleep(300);
+	}
+#ifdef CONFIG_SND_WM8994_EXTENSIONS_RECORD_PRESETS
+	wm8994_extensions_record_main_mic();
+#endif
+}
+
+void wm8994_record_bluetooth(struct snd_soc_codec *codec)
+{
+	u16 val;
+
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	DEBUG_LOG("BT Record Path for Voice Command");
+
+	if(!(wm8994->codec_state & CALL_ACTIVE))	// Normal case
+	{
+		wm8994_set_voicecall_common_setting(codec);
+
+		val = wm8994_read(codec, WM8994_DAC2_LEFT_MIXER_ROUTING);	//604H : 0x0010
+		val &= ~(WM8994_ADC1_TO_DAC2L_MASK);
+		wm8994_write(codec, WM8994_DAC2_LEFT_MIXER_ROUTING, val);
+
+		val = wm8994_read(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING);	//605H : 0x0010
+		val &= ~(WM8994_ADC1_TO_DAC2R_MASK);
+		wm8994_write(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING, val);
+
+		//R1(1h) - 0x0003 -normal vmid
+		val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_1);
+		val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK);
+		val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL);
+		wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+		/*Digital Path Enables and Unmutes*/
+		//R2(2h) - 0x0000
+		wm8994_write(codec, WM8994_POWER_MANAGEMENT_2, 0x0000);
+
+		//R3(3h) - 0x0000
+		wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, 0x0000);
+
+		//R4(4h) - 0x0300
+		//AIF1ADC1(Left/Right) Output
+		val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_4);
+		val &= ~(WM8994_AIF1ADC1L_ENA_MASK |WM8994_AIF1ADC1R_ENA_MASK);
+		val |= ( WM8994_AIF1ADC1L_ENA | WM8994_AIF1ADC1R_ENA);
+		wm8994_write(codec, WM8994_POWER_MANAGEMENT_4 , val);
+
+		//R5(5h) - 0x3000
+		//AIF2DAC(Left/Right) Input
+		val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_5);
+		val &= ~(WM8994_AIF2DACL_ENA_MASK | WM8994_AIF2DACR_ENA_MASK);
+		val |= (WM8994_AIF2DACL_ENA | WM8994_AIF2DACR_ENA);
+		wm8994_write(codec, WM8994_POWER_MANAGEMENT_5, val);
+
+		//R6(6h) - 0x0002
+		//AIF2_DACDAT_SRC(GPIO8/DACDAT3)
+		val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_6);
+		val &= ~(WM8994_AIF3_ADCDAT_SRC_MASK |WM8994_AIF2_DACDAT_SRC_MASK);
+		val |= (0x1 << WM8994_AIF3_ADCDAT_SRC_SHIFT | WM8994_AIF2_DACDAT_SRC);
+		wm8994_write(codec, WM8994_POWER_MANAGEMENT_6, val);
+
+		/*Un-Mute*/
+		//R1312(520h) - 0x0000
+		//AIF2DAC_MUTE(Un-mute)
+		val = wm8994_read(codec, WM8994_AIF2_DAC_FILTERS_1);
+		val &= ~(WM8994_AIF2DAC_MUTE_MASK);
+		wm8994_write(codec, WM8994_AIF2_DAC_FILTERS_1, val);
+
+		/*Mixer Routing*/
+		//R1542(606h) - 0x0002
+		//AIF2DACL_TO_AIF1ADC1L
+		val = wm8994_read(codec, WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING);
+		val &= ~(WM8994_AIF2DACL_TO_AIF1ADC1L_MASK);
+		val |= (WM8994_AIF2DACL_TO_AIF1ADC1L);
+		wm8994_write(codec, WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING, val);
+
+		//R1543(607h) - 0x0002
+		//AIF2DACR_TO_AIF1ADC1R
+		val = wm8994_read(codec, WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING);
+		val &= ~(WM8994_AIF2DACR_TO_AIF1ADC1R_MASK);
+		val |= (WM8994_AIF2DACR_TO_AIF1ADC1R);
+		wm8994_write(codec, WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING, val);
+
+		wm8994_write(codec, WM8994_AIF2_CLOCKING_1, 0x0019);
+
+		wm8994_write(codec, WM8994_OVERSAMPLING, 0X0000);
+
+		if(wm8994->testmode_config_flag == SEC_NORMAL)
+		{
+			//Digital Paths
+			//Enable HPF Filter for google voice search
+			if(wm8994->recognition_active == REC_ON
+			){
+				val = wm8994_read(codec,WM8994_AIF1_ADC1_FILTERS );
+				val &= ~(WM8994_AIF1ADC1L_HPF_MASK | WM8994_AIF1ADC1R_HPF_MASK);
+				//val |= (WM8994_AIF1ADC1L_HPF | WM8994_AIF1ADC1R_HPF); //HPF off
+				wm8994_write(codec,WM8994_AIF1_ADC1_FILTERS ,val);
+			}
+
+			//AIF1_ADC1 volume
+			val = wm8994_read(codec, WM8994_AIF1_ADC1_LEFT_VOLUME);
+			val &= ~(WM8994_AIF1ADC1L_VOL_MASK);
+			if(wm8994->recognition_active == REC_ON)
+				val |= (TUNING_RECOGNITION_BT_AIF1ADC1L_VOL);
+			else
+				val |= (TUNING_RECORD_BT_AIF1ADC1L_VOL);
+			wm8994_write(codec, WM8994_AIF1_ADC1_LEFT_VOLUME, val);
+
+			val = wm8994_read(codec, WM8994_AIF1_ADC1_RIGHT_VOLUME);
+			val &= ~(WM8994_AIF1ADC1R_VOL_MASK);
+			if(wm8994->recognition_active == REC_ON)
+				val |= (WM8994_AIF1ADC1_VU | TUNING_RECOGNITION_BT_AIF1ADC1R_VOL);
+			else
+				val |= (WM8994_AIF1ADC1_VU | TUNING_RECORD_BT_AIF1ADC1R_VOL);
+			wm8994_write(codec, WM8994_AIF1_ADC1_RIGHT_VOLUME, val);
+
+			//AIF2DAC volume
+			val = wm8994_read(codec, WM8994_AIF2_DAC_LEFT_VOLUME);
+			val &= ~(WM8994_AIF2DACL_VOL_MASK);
+			if(wm8994->recognition_active == REC_ON)
+				val |= (TUNING_RECOGNITION_BT_AIF2DACL_VOL);
+			else
+				val |= (TUNING_RECORD_BT_AIF2DACL_VOL);
+			wm8994_write(codec, WM8994_AIF2_DAC_LEFT_VOLUME, val);
+
+			val = wm8994_read(codec, WM8994_AIF2_DAC_RIGHT_VOLUME);
+			val &= ~(WM8994_AIF2DACR_VOL_MASK);
+			if(wm8994->recognition_active == REC_ON)
+				val |= (WM8994_AIF2DAC_VU | TUNING_RECOGNITION_BT_AIF2DACR_VOL);
+			else
+				val |= (WM8994_AIF2DAC_VU | TUNING_RECORD_BT_AIF2DACR_VOL);
+			wm8994_write(codec, WM8994_AIF2_DAC_RIGHT_VOLUME, val);
+		}
+		else
+		{
+			//volume update (for HwCodec Tuning)
+			val = wm8994_read(codec, WM8994_AIF1_ADC1_RIGHT_VOLUME);
+			val |= WM8994_AIF1ADC1_VU;
+			wm8994_write(codec, WM8994_AIF1_ADC1_RIGHT_VOLUME, val);
+
+			val = wm8994_read(codec, WM8994_AIF2_DAC_RIGHT_VOLUME);
+			val |= WM8994_AIF2DAC_VU;
+			wm8994_write(codec, WM8994_AIF2_DAC_RIGHT_VOLUME, val);
+		}
+
+		/*GPIO Configuration*/
+		wm8994_write(codec, WM8994_GPIO_8, WM8994_GP8_DIR | WM8994_GP8_DB);
+		wm8994_write(codec, WM8994_GPIO_9, WM8994_GP9_DB);
+		wm8994_write(codec, WM8994_GPIO_10, WM8994_GP10_DB);
+		wm8994_write(codec, WM8994_GPIO_11, WM8994_GP11_DB);
+	}
+}
+
+void wm8994_set_playback_receiver(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	u16 val;
+
+	DEBUG_LOG("");
+
+	if(wm8994->testmode_config_flag == SEC_NORMAL)
+	{
+		val = wm8994_read(codec, WM8994_OUTPUT_MIXER_5);
+		val &= ~(WM8994_DACL_MIXOUTL_VOL_MASK);
+		val |= TUNING_RCV_OUTMIX5_VOL << WM8994_DACL_MIXOUTL_VOL_SHIFT;
+		wm8994_write(codec,WM8994_OUTPUT_MIXER_5, val );
+
+		val = wm8994_read(codec, WM8994_OUTPUT_MIXER_6);
+		val &= ~(WM8994_DACR_MIXOUTR_VOL_MASK);
+		val |= TUNING_RCV_OUTMIX6_VOL << WM8994_DACR_MIXOUTR_VOL_SHIFT;
+		wm8994_write(codec,WM8994_OUTPUT_MIXER_6, val );
+
+		val = wm8994_read(codec, WM8994_LEFT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTL_MUTE_N_MASK | WM8994_MIXOUTL_VOL_MASK);
+		val |= (WM8994_MIXOUTL_MUTE_N | TUNING_RCV_OPGAL_VOL);
+		wm8994_write(codec,WM8994_LEFT_OPGA_VOLUME, val );
+
+		val = wm8994_read(codec, WM8994_RIGHT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTR_MUTE_N_MASK | WM8994_MIXOUTR_VOL_MASK);
+		val |= (WM8994_MIXOUT_VU | WM8994_MIXOUTR_MUTE_N | TUNING_RCV_OPGAR_VOL);
+		wm8994_write(codec,WM8994_RIGHT_OPGA_VOLUME, val );
+
+		val = wm8994_read(codec, WM8994_HPOUT2_VOLUME);
+		val &= ~(WM8994_HPOUT2_MUTE_MASK | WM8994_HPOUT2_VOL_MASK);
+		val |= TUNING_HPOUT2_VOL << WM8994_HPOUT2_VOL_SHIFT;
+		wm8994_write(codec,WM8994_HPOUT2_VOLUME, val );
+
+		//Unmute DAC1 left
+		val = wm8994_read(codec,WM8994_DAC1_LEFT_VOLUME );
+		val &= ~(WM8994_DAC1L_MUTE_MASK | WM8994_DAC1L_VOL_MASK);
+		val |= (TUNING_DAC1L_VOL);
+		wm8994_write(codec,WM8994_DAC1_LEFT_VOLUME ,val);
+
+		//Unmute and volume ctrl RightDAC
+		val = wm8994_read(codec, WM8994_DAC1_RIGHT_VOLUME );
+		val &= ~(WM8994_DAC1R_MUTE_MASK | WM8994_DAC1R_VOL_MASK);
+		val |= (WM8994_DAC1_VU | TUNING_DAC1R_VOL);
+		wm8994_write(codec,WM8994_DAC1_RIGHT_VOLUME,val);
+
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_LEFT_VOLUME);
+		val &= ~(WM8994_AIF1DAC1L_VOL_MASK);
+		val |= (TUNING_DAC1L_VOL);
+		wm8994_write(codec, WM8994_AIF1_DAC1_LEFT_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME);
+		val &= ~(WM8994_AIF1DAC1R_VOL_MASK);
+		val |= (WM8994_AIF1DAC1_VU |TUNING_DAC1R_VOL);
+		wm8994_write(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME, val);
+	}
+
+	val = wm8994_read(codec,WM8994_OUTPUT_MIXER_1);
+	val &= ~(WM8994_DAC1L_TO_MIXOUTL_MASK);
+	val |= (WM8994_DAC1L_TO_MIXOUTL);
+	wm8994_write(codec,WM8994_OUTPUT_MIXER_1,val);
+
+	val = wm8994_read(codec,WM8994_OUTPUT_MIXER_2);
+	val &= ~(WM8994_DAC1R_TO_MIXOUTR_MASK);
+	val |= (WM8994_DAC1R_TO_MIXOUTR);
+	wm8994_write(codec,WM8994_OUTPUT_MIXER_2,val);
+
+	val = wm8994_read(codec,WM8994_HPOUT2_MIXER);
+	val &= ~(WM8994_MIXOUTLVOL_TO_HPOUT2_MASK | WM8994_MIXOUTRVOL_TO_HPOUT2_MASK);
+	val |= (WM8994_MIXOUTRVOL_TO_HPOUT2 | WM8994_MIXOUTLVOL_TO_HPOUT2);
+	wm8994_write(codec,WM8994_HPOUT2_MIXER,val);
+
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_5);
+	val &= ~(WM8994_DAC1R_ENA_MASK | WM8994_DAC1L_ENA_MASK | WM8994_AIF1DAC1R_ENA_MASK | WM8994_AIF1DAC1L_ENA_MASK);
+	val |= (WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA | WM8994_DAC1L_ENA | WM8994_DAC1R_ENA);
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_5,val);
+
+	val = wm8994_read(codec,WM8994_AIF1_DAC1_FILTERS_1);
+	val &= ~(WM8994_AIF1DAC1_MUTE_MASK |WM8994_AIF1DAC1_MONO_MASK);
+	val |= (WM8994_AIF1DAC1_UNMUTE | WM8994_AIF1DAC1_MONO);
+	wm8994_write(codec,WM8994_AIF1_DAC1_FILTERS_1,val);
+
+	val = wm8994_read(codec,WM8994_DAC1_LEFT_MIXER_ROUTING);
+	val &= ~(WM8994_AIF1DAC1L_TO_DAC1L_MASK);
+	val |= (WM8994_AIF1DAC1L_TO_DAC1L);
+	wm8994_write(codec,WM8994_DAC1_LEFT_MIXER_ROUTING,val);
+
+	val = wm8994_read(codec,WM8994_DAC1_RIGHT_MIXER_ROUTING);
+	val &= ~(WM8994_AIF1DAC1R_TO_DAC1R_MASK);
+	val |= (WM8994_AIF1DAC1R_TO_DAC1R);
+	wm8994_write(codec,WM8994_DAC1_RIGHT_MIXER_ROUTING,val);
+
+	val = wm8994_read(codec, WM8994_CLOCKING_1);
+	val &= ~(WM8994_DSP_FS1CLK_ENA_MASK | WM8994_DSP_FSINTCLK_ENA_MASK);
+	val |= (WM8994_DSP_FS1CLK_ENA | WM8994_DSP_FSINTCLK_ENA);
+	wm8994_write(codec, WM8994_CLOCKING_1, val);
+
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_3);
+	val &= ~(WM8994_MIXOUTLVOL_ENA_MASK | WM8994_MIXOUTRVOL_ENA_MASK | WM8994_MIXOUTL_ENA_MASK | WM8994_MIXOUTR_ENA_MASK);
+	val |= (WM8994_MIXOUTL_ENA | WM8994_MIXOUTR_ENA | WM8994_MIXOUTRVOL_ENA | WM8994_MIXOUTLVOL_ENA);
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_3,val);
+
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1 );
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK | WM8994_HPOUT2_ENA_MASK );
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL | WM8994_HPOUT2_ENA );
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_1,val);
+}
+
+void wm8994_set_playback_headset(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	u16 val;
+
+	u16 TestReturn1=0;
+	u16 TestReturn2=0;
+	u16 TestLow1=0;
+	u16 TestHigh1=0;
+	u8 TestLow=0;
+	u8 TestHigh=0;
+
+	DEBUG_LOG("");
+
+	//Configuring the Digital Paths
+
+	// Enable the Timeslot0 to DAC1L
+	val = wm8994_read(codec, WM8994_DAC1_LEFT_MIXER_ROUTING  );
+	val &= ~(WM8994_AIF1DAC1L_TO_DAC1L_MASK);
+	val |= WM8994_AIF1DAC1L_TO_DAC1L;
+	wm8994_write(codec,WM8994_DAC1_LEFT_MIXER_ROUTING ,val);
+
+	//Enable the Timeslot0 to DAC1R
+	val = wm8994_read(codec, WM8994_DAC1_RIGHT_MIXER_ROUTING  );
+	val &= ~(WM8994_AIF1DAC1R_TO_DAC1R_MASK);
+	val |= WM8994_AIF1DAC1R_TO_DAC1R;
+	wm8994_write(codec,WM8994_DAC1_RIGHT_MIXER_ROUTING ,val);
+
+	val = wm8994_read(codec, 0x102 );
+	val &= ~(0x0003);
+	val = 0x0003;
+	wm8994_write(codec,0x102,val);
+
+	val = wm8994_read(codec, 0x56 );
+	val &= ~(0x0003);
+	val = 0x0003;
+	wm8994_write(codec,0x56,val);
+
+	val = wm8994_read(codec, 0x102 );
+	val &= ~(0x0000);
+	val = 0x0000;
+	wm8994_write(codec,0x102,val);
+
+	val = wm8994_read(codec, WM8994_CLASS_W_1  );
+	val &= ~(0x0005);
+	val |= 0x0005;
+	wm8994_write(codec,WM8994_CLASS_W_1,val);
+
+	// Headset Control
+	if(wm8994->testmode_config_flag == SEC_NORMAL)
+	{
+		val = wm8994_read(codec,WM8994_LEFT_OUTPUT_VOLUME);
+		val &= ~(WM8994_HPOUT1L_MUTE_N_MASK | WM8994_HPOUT1L_VOL_MASK);
+		if(wm8994->ringtone_active)
+		val |= (WM8994_HPOUT1L_MUTE_N | TUNING_RING_OUTPUTL_VOL);
+		else
+		val |= (WM8994_HPOUT1L_MUTE_N | TUNING_MP3_OUTPUTL_VOL);
+		wm8994_write(codec, WM8994_LEFT_OUTPUT_VOLUME, val);
+
+
+		val = wm8994_read(codec,WM8994_RIGHT_OUTPUT_VOLUME);
+		val &= ~(WM8994_HPOUT1R_MUTE_N_MASK | WM8994_HPOUT1R_VOL_MASK);
+		if(wm8994->ringtone_active)
+		val |= (WM8994_HPOUT1_VU | WM8994_HPOUT1R_MUTE_N | TUNING_RING_OUTPUTR_VOL);
+		else
+		val |= (WM8994_HPOUT1_VU | WM8994_HPOUT1R_MUTE_N | TUNING_MP3_OUTPUTR_VOL);
+		wm8994_write(codec, WM8994_RIGHT_OUTPUT_VOLUME, val);
+
+
+		val = wm8994_read(codec, WM8994_LEFT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTL_MUTE_N_MASK | WM8994_MIXOUTL_VOL_MASK);
+		if(wm8994->ringtone_active)
+		val |= (WM8994_MIXOUTL_MUTE_N | TUNING_RING_OPGAL_VOL);
+		else
+		val |= (WM8994_MIXOUTL_MUTE_N | TUNING_MP3_OPGAL_VOL);
+		wm8994_write(codec,WM8994_LEFT_OPGA_VOLUME, val );
+
+		val = wm8994_read(codec, WM8994_RIGHT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTR_MUTE_N_MASK | WM8994_MIXOUTR_VOL_MASK);
+		if(wm8994->ringtone_active)
+		val |= (WM8994_MIXOUT_VU | WM8994_MIXOUTR_MUTE_N | TUNING_RING_OPGAR_VOL);
+		else
+		val |= (WM8994_MIXOUT_VU | WM8994_MIXOUTR_MUTE_N | TUNING_MP3_OPGAR_VOL);
+		wm8994_write(codec,WM8994_RIGHT_OPGA_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_LEFT_VOLUME);
+		val &= ~(WM8994_AIF1DAC1L_VOL_MASK);
+		val |= (TUNING_DAC1L_VOL);
+		wm8994_write(codec, WM8994_AIF1_DAC1_LEFT_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME);
+		val &= ~(WM8994_AIF1DAC1R_VOL_MASK);
+		val |= (WM8994_AIF1DAC1_VU |TUNING_DAC1R_VOL);
+		wm8994_write(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME, val);
+	}
+
+	val = wm8994_read(codec, WM8994_DC_SERVO_2	);
+	val &= ~(0x03E0);
+	val = 0x03E0;
+	wm8994_write(codec,WM8994_DC_SERVO_2,val);
+
+	//Enable vmid,bias, hp left and right
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1 );
+#if defined(CONFIG_PHONE_P1_GSM)
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK |WM8994_HPOUT1L_ENA_MASK |WM8994_HPOUT1R_ENA_MASK | WM8994_SPKOUTL_ENA_MASK | WM8994_SPKOUTR_ENA_MASK );
+#elif defined(CONFIG_PHONE_P1_CDMA)
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK |WM8994_HPOUT1L_ENA_MASK |WM8994_HPOUT1R_ENA_MASK);
+#endif
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL | WM8994_HPOUT1R_ENA |WM8994_HPOUT1L_ENA);
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_1,val);
+
+	val = wm8994_read(codec, WM8994_ANALOGUE_HP_1  );
+	val &= ~(0x0022);
+	val = 0x0022;
+	wm8994_write(codec,WM8994_ANALOGUE_HP_1,val);
+
+	//Enable Charge Pump
+	val = wm8994_read(codec, WM8994_CHARGE_PUMP_1);
+	val &= ~WM8994_CP_ENA_MASK ;
+	val |= WM8994_CP_ENA | WM8994_CP_ENA_DEFAULT ; // this is from wolfson
+	wm8994_write(codec, WM8994_CHARGE_PUMP_1, val);
+
+	msleep(5);
+
+	//Enable Dac1 and DAC2 and the Timeslot0 for AIF1
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_5 );
+	val &= ~(WM8994_DAC1R_ENA_MASK | WM8994_DAC1L_ENA_MASK|WM8994_AIF1DAC1R_ENA_MASK | WM8994_AIF1DAC1L_ENA_MASK );
+	val |= (WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA  | WM8994_DAC1L_ENA |WM8994_DAC1R_ENA );
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_5 ,val);
+
+	// Enable DAC1L to HPOUT1L path
+	val = wm8994_read(codec, WM8994_OUTPUT_MIXER_1);
+	val &= ~(WM8994_DAC1L_TO_HPOUT1L_MASK | WM8994_DAC1L_TO_MIXOUTL_MASK);
+	val |= WM8994_DAC1L_TO_MIXOUTL ;
+	wm8994_write(codec,WM8994_OUTPUT_MIXER_1, val); // Enable MIXOUT
+
+	// Enable DAC1R to HPOUT1R path
+	val = wm8994_read(codec, WM8994_OUTPUT_MIXER_2);
+	val &= ~(WM8994_DAC1R_TO_HPOUT1R_MASK | WM8994_DAC1R_TO_MIXOUTR_MASK);
+	val |= WM8994_DAC1R_TO_MIXOUTR;
+	wm8994_write(codec, WM8994_OUTPUT_MIXER_2, val);
+
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_3);
+	val &= ~(WM8994_MIXOUTLVOL_ENA_MASK | WM8994_MIXOUTRVOL_ENA_MASK | WM8994_MIXOUTL_ENA_MASK | WM8994_MIXOUTR_ENA_MASK);
+	val |= (WM8994_MIXOUTLVOL_ENA | WM8994_MIXOUTRVOL_ENA | WM8994_MIXOUTL_ENA | WM8994_MIXOUTR_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, 0x0030);
+
+	val = wm8994_read(codec, WM8994_DC_SERVO_1 );
+	val &= ~(0x0303);
+	val = 0x0303;
+	wm8994_write(codec,WM8994_DC_SERVO_1,val);
+
+	msleep(160);	// 160ms delay
+
+	TestReturn1=wm8994_read(codec,WM8994_DC_SERVO_4);
+
+	TestLow=(signed char)(TestReturn1 & 0xff);
+	TestHigh=(signed char)((TestReturn1>>8) & 0xff);
+
+	TestLow1=((signed short)(TestLow-5))&0x00ff;
+	TestHigh1=(((signed short)(TestHigh-5)<<8)&0xff00);
+	TestReturn2=TestLow1|TestHigh1;
+	wm8994_write(codec,WM8994_DC_SERVO_4, TestReturn2);
+
+	val = wm8994_read(codec, WM8994_DC_SERVO_1 );
+	val &= ~(0x000F);
+	val = 0x000F;
+	wm8994_write(codec,WM8994_DC_SERVO_1,val);
+
+	msleep(20);
+
+	// Intermediate HP settings
+	val = wm8994_read(codec, WM8994_ANALOGUE_HP_1);
+	val &= ~(WM8994_HPOUT1R_DLY_MASK |WM8994_HPOUT1R_OUTP_MASK |WM8994_HPOUT1R_RMV_SHORT_MASK |
+		WM8994_HPOUT1L_DLY_MASK |WM8994_HPOUT1L_OUTP_MASK | WM8994_HPOUT1L_RMV_SHORT_MASK);
+	val = (WM8994_HPOUT1L_RMV_SHORT | WM8994_HPOUT1L_OUTP|WM8994_HPOUT1L_DLY |WM8994_HPOUT1R_RMV_SHORT |
+		WM8994_HPOUT1R_OUTP | WM8994_HPOUT1R_DLY);
+	wm8994_write(codec, WM8994_ANALOGUE_HP_1, val);
+
+	//Unmute DAC1 left
+	val = wm8994_read(codec,WM8994_DAC1_LEFT_VOLUME );
+	val &= ~(WM8994_DAC1L_MUTE_MASK | WM8994_DAC1L_VOL_MASK);
+	val |= (TUNING_DAC1L_VOL);
+	wm8994_write(codec,WM8994_DAC1_LEFT_VOLUME ,val);
+
+	//Unmute and volume ctrl RightDAC
+	val = wm8994_read(codec, WM8994_DAC1_RIGHT_VOLUME );
+	val &= ~(WM8994_DAC1R_MUTE_MASK | WM8994_DAC1R_VOL_MASK);
+	val |= (WM8994_DAC1_VU | TUNING_DAC1R_VOL); //0 db volume
+	wm8994_write(codec,WM8994_DAC1_RIGHT_VOLUME,val);
+
+	// Unmute the AF1DAC1
+	val = wm8994_read(codec, WM8994_AIF1_DAC1_FILTERS_1 );
+	val &= ~(WM8994_AIF1DAC1_MUTE_MASK | WM8994_AIF1DAC1_MONO_MASK);
+	val |= WM8994_AIF1DAC1_UNMUTE;
+	wm8994_write(codec,WM8994_AIF1_DAC1_FILTERS_1 ,val);
+}
+
+void wm8994_set_playback_speaker(struct snd_soc_codec *codec)
+{
+	u16 val;
+
+	DEBUG_LOG("");
+
+	//Disable end point for preventing pop up noise.
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1);
+#if defined(CONFIG_PHONE_P1_GSM)
+	val &= ~(WM8994_SPKOUTL_ENA_MASK | WM8994_SPKOUTR_ENA_MASK | WM8994_HPOUT1L_ENA_MASK | WM8994_HPOUT1R_ENA_MASK);
+#elif defined(CONFIG_PHONE_P1_CDMA)
+	val &= ~(WM8994_SPKOUTL_ENA_MASK);
+#endif
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_3);
+	val &= ~( WM8994_SPKLVOL_ENA_MASK | WM8994_SPKRVOL_ENA_MASK  );
+	val |= ( WM8994_SPKLVOL_ENA | WM8994_SPKRVOL_ENA );
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, val);
+
+	// Speaker Volume Control
+	// Unmute the SPKMIXVOLUME
+	val = wm8994_read(codec, WM8994_SPKMIXL_ATTENUATION);
+	val &= ~(WM8994_SPKMIXL_VOL_MASK);
+	val |= TUNING_SPKMIXL_ATTEN;
+	wm8994_write(codec, WM8994_SPKMIXL_ATTENUATION, val);
+
+	val = wm8994_read(codec,WM8994_SPKMIXR_ATTENUATION);
+	val &= ~(WM8994_SPKMIXR_VOL_MASK);
+	val |= TUNING_SPKMIXR_ATTEN;
+	wm8994_write(codec, WM8994_SPKMIXR_ATTENUATION, val);
+
+	val = wm8994_read(codec,WM8994_SPEAKER_VOLUME_LEFT );
+	val &= ~(WM8994_SPKOUT_VU_MASK | WM8994_SPKOUTL_MUTE_N_MASK | WM8994_SPKOUTL_VOL_MASK);
+	val |=(WM8994_SPKOUT_VU  | WM8994_SPKOUTL_MUTE_N | TUNING_MP3_SPKL_VOL );
+	wm8994_write(codec,WM8994_SPEAKER_VOLUME_LEFT ,val);
+
+	val = wm8994_read(codec,WM8994_SPEAKER_VOLUME_RIGHT );
+	val &= ~(WM8994_SPKOUT_VU_MASK | WM8994_SPKOUTR_MUTE_N_MASK | WM8994_SPKOUTR_VOL_MASK);
+	val |=(WM8994_SPKOUT_VU  | WM8994_SPKOUTR_MUTE_N | TUNING_MP3_SPKR_VOL );
+	wm8994_write(codec, WM8994_SPEAKER_VOLUME_RIGHT ,val);
+
+	/* Tunning Mobile Parameteric Equalizer 2010.05.13 */
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_GAINS_1, 0x3319);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_GAINS_2, 0x6300);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_1_A, 0x0F71);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_1_B, 0x0403);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_1_PG, 0x023C);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_2_A, 0x1EB5);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_2_B, 0xF145);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_2_C, 0x0B75);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_2_PG, 0x01C5);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_3_A, 0x1C58);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_3_B, 0xF373);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_3_C, 0x0A54);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_3_PG, 0x0558);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_4_A, 0x168E);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_4_B, 0xF829);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_4_C, 0x07AD);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_4_PG, 0x1103);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_5_A, 0xFA14);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_5_B, 0x0400);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_5_PG, 0x2850);
+
+	val = wm8994_read(codec,WM8994_CLASSD );
+	val &= ~(0x3F);
+	val |= 0x24;
+	wm8994_write(codec,WM8994_CLASSD ,val);
+
+	//Unmute DAC1 left
+	val = wm8994_read(codec,WM8994_DAC1_LEFT_VOLUME );
+	val &= ~(WM8994_DAC1L_MUTE_MASK | WM8994_DAC1L_VOL_MASK);
+	val |= (WM8994_DAC1_VU | TUNING_DAC1L_VOL); //0 db volume
+	wm8994_write(codec,WM8994_DAC1_LEFT_VOLUME ,val);
+
+	//Unmute and volume ctrl RightDAC
+	val = wm8994_read(codec, WM8994_DAC1_RIGHT_VOLUME );
+	val &= ~(WM8994_DAC1R_MUTE_MASK | WM8994_DAC1R_VOL_MASK);
+	val |= (WM8994_DAC1_VU | TUNING_DAC1R_VOL); //0 db volume
+	wm8994_write(codec,WM8994_DAC1_RIGHT_VOLUME,val);
+
+	val = wm8994_read(codec, WM8994_AIF1_DAC1_LEFT_VOLUME);
+#if defined(CONFIG_PHONE_P1_GSM)
+	val &= ~(WM8994_AIF1DAC1L_VOL_MASK);
+#elif defined(CONFIG_PHONE_P1_CDMA)
+	val &= ~(WM8994_DAC1L_MUTE_MASK | WM8994_DAC1L_VOL_MASK);
+#endif
+	val |= (TUNING_DAC1L_VOL);
+	wm8994_write(codec, WM8994_AIF1_DAC1_LEFT_VOLUME, val);
+
+	val = wm8994_read(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME);
+	val &= ~(WM8994_AIF1DAC1R_VOL_MASK);
+	val |= (WM8994_AIF1DAC1_VU |TUNING_DAC1R_VOL);
+	wm8994_write(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME, val);
+
+	val = wm8994_read(codec,WM8994_SPKOUT_MIXERS);
+	val &= ~(WM8994_SPKMIXL_TO_SPKOUTL_MASK |
+	WM8994_SPKMIXR_TO_SPKOUTL_MASK | WM8994_SPKMIXR_TO_SPKOUTR_MASK);
+	val |= (WM8994_SPKMIXL_TO_SPKOUTL | WM8994_SPKMIXR_TO_SPKOUTR );
+	wm8994_write(codec, WM8994_SPKOUT_MIXERS, val);
+
+	//Unmute the DAC path
+	val = wm8994_read(codec,WM8994_SPEAKER_MIXER);
+	val &= ~(WM8994_DAC1L_TO_SPKMIXL_MASK | WM8994_DAC1R_TO_SPKMIXR_MASK);
+	val |= (WM8994_DAC1L_TO_SPKMIXL | WM8994_DAC1R_TO_SPKMIXR ) ;
+	wm8994_write(codec, WM8994_SPEAKER_MIXER, val);
+
+	// Eable DAC1 Left and timeslot left
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_5);
+	val &= ~( WM8994_DAC1L_ENA_MASK | WM8994_AIF1DAC1L_ENA_MASK | WM8994_DAC1R_ENA_MASK | WM8994_AIF1DAC1R_ENA_MASK  );
+	val |= (WM8994_AIF1DAC1L_ENA | WM8994_DAC1L_ENA | WM8994_AIF1DAC1R_ENA | WM8994_DAC1R_ENA );
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_5, val);
+
+	//Unmute
+	val = wm8994_read(codec, WM8994_AIF1_DAC1_FILTERS_1);
+	val &= ~(WM8994_AIF1DAC1_MUTE_MASK | WM8994_AIF1DAC1_MONO_MASK);
+	val |= WM8994_AIF1DAC1_UNMUTE;
+	wm8994_write(codec, WM8994_AIF1_DAC1_FILTERS_1, val);
+
+	//enable timeslot0 to left dac
+	val = wm8994_read(codec, WM8994_DAC1_LEFT_MIXER_ROUTING);
+	val &= ~(WM8994_AIF1DAC1L_TO_DAC1L_MASK);
+	val |= WM8994_AIF1DAC1L_TO_DAC1L;
+	wm8994_write(codec, WM8994_DAC1_LEFT_MIXER_ROUTING, val);
+
+	val = wm8994_read(codec,WM8994_DAC1_RIGHT_MIXER_ROUTING );
+	val &= ~(WM8994_AIF1DAC1R_TO_DAC1R_MASK );
+	val |= WM8994_AIF1DAC1R_TO_DAC1R;
+	wm8994_write(codec,WM8994_DAC1_RIGHT_MIXER_ROUTING ,val);
+
+#ifdef CONFIG_SND_WM8994_EXTENSIONS
+	wm8994_extensions_playback_speaker();
+#endif
+
+	//Enbale bias,vmid and Left speaker
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1);
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK |WM8994_SPKOUTL_ENA_MASK | WM8994_SPKOUTR_ENA_MASK );
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL |	WM8994_SPKOUTL_ENA | WM8994_SPKOUTR_ENA  );
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+}
+
+
+void wm8994_set_playback_speaker_headset(struct snd_soc_codec *codec)
+{
+
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	u16 val;
+
+	u16 nReadServo4Val = 0;
+	u16 ncompensationResult = 0;
+	u16 nCompensationResultLow=0;
+	u16 nCompensationResultHigh=0;
+	u8  nServo4Low = 0;
+	u8  nServo4High = 0;
+
+	//------------------  Common Settings ------------------
+	// Enable the Timeslot0 to DAC1L
+	val = wm8994_read(codec, WM8994_DAC1_LEFT_MIXER_ROUTING );
+	val &= ~(WM8994_AIF1DAC1L_TO_DAC1L_MASK);
+	val |= WM8994_AIF1DAC1L_TO_DAC1L;
+	wm8994_write(codec,WM8994_DAC1_LEFT_MIXER_ROUTING ,val);
+
+	//Enable the Timeslot0 to DAC1R
+	val = wm8994_read(codec, WM8994_DAC1_RIGHT_MIXER_ROUTING  );
+	val &= ~(WM8994_AIF1DAC1R_TO_DAC1R_MASK);
+	val |= WM8994_AIF1DAC1R_TO_DAC1R;
+	wm8994_write(codec,WM8994_DAC1_RIGHT_MIXER_ROUTING ,val);
+
+
+	/* Tunning Mobile Parameteric Equalizer 2010.05.13 */
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_GAINS_1, 0x3319);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_GAINS_2, 0x6300);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_1_A, 0x0F71);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_1_B, 0x0403);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_1_PG, 0x023C);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_2_A, 0x1EB5);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_2_B, 0xF145);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_2_C, 0x0B75);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_2_PG, 0x01C5);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_3_A, 0x1C58);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_3_B, 0xF373);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_3_C, 0x0A54);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_3_PG, 0x0558);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_4_A, 0x168E);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_4_B, 0xF829);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_4_C, 0x07AD);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_4_PG, 0x1103);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_5_A, 0xFA14);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_5_B, 0x0400);
+	wm8994_write( codec,WM8994_AIF1_DAC1_EQ_BAND_5_PG, 0x2850);
+
+
+	val = wm8994_read(codec, WM8994_AIF1_DAC1_LEFT_VOLUME);
+	val &= ~(WM8994_AIF1DAC1L_VOL_MASK);
+	val |= (TUNING_DAC1L_VOL);
+	wm8994_write(codec, WM8994_AIF1_DAC1_LEFT_VOLUME, val);
+
+	val = wm8994_read(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME);
+	val &= ~(WM8994_AIF1DAC1R_VOL_MASK);
+	val |= (WM8994_AIF1DAC1_VU | TUNING_DAC1R_VOL);
+	wm8994_write(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME, val);
+
+	//------------------  Speaker Path Settings ------------------
+
+	// Speaker Volume Control
+	if(wm8994->testmode_config_flag == SEC_NORMAL)
+	{
+		val = wm8994_read(codec,WM8994_SPEAKER_VOLUME_LEFT);
+		val &= ~(WM8994_SPKOUTL_MUTE_N_MASK | WM8994_SPKOUTL_VOL_MASK);
+		val |= (WM8994_SPKOUTL_MUTE_N | TUNING_MP3_SPKL_VOL);
+		wm8994_write(codec, WM8994_SPEAKER_VOLUME_LEFT, val);
+
+		val = wm8994_read(codec,WM8994_SPEAKER_VOLUME_RIGHT);
+		val &= ~(WM8994_SPKOUTR_MUTE_N_MASK | WM8994_SPKOUTR_VOL_MASK);
+		val |= (WM8994_SPKOUT_VU | WM8994_SPKOUTL_MUTE_N | TUNING_MP3_SPKL_VOL);
+		wm8994_write(codec, WM8994_SPEAKER_VOLUME_RIGHT, val);
+
+		val = wm8994_read(codec,WM8994_CLASSD );
+		val &= ~(0x3F);
+		val |= 0x24;
+		wm8994_write(codec,WM8994_CLASSD ,val);
+	}
+
+
+	val = wm8994_read(codec,WM8994_SPKOUT_MIXERS );
+	val &= ~(WM8994_SPKMIXL_TO_SPKOUTL_MASK |
+	WM8994_SPKMIXR_TO_SPKOUTL_MASK | WM8994_SPKMIXR_TO_SPKOUTR_MASK);
+	val |= WM8994_SPKMIXL_TO_SPKOUTL;
+	val |= WM8994_SPKMIXR_TO_SPKOUTR;
+	wm8994_write(codec,WM8994_SPKOUT_MIXERS,val );
+
+	//Unmute the DAC path
+	val = wm8994_read(codec,WM8994_SPEAKER_MIXER );
+	val &= ~(WM8994_DAC1L_TO_SPKMIXL_MASK | WM8994_DAC1R_TO_SPKMIXR_MASK);
+	val |= ( WM8994_DAC1L_TO_SPKMIXL | WM8994_DAC1R_TO_SPKMIXR );
+	wm8994_write(codec,WM8994_SPEAKER_MIXER ,val);
+
+	//------------------  Ear Path Settings ------------------
+	//Configuring the Digital Paths
+	val = wm8994_read(codec, 0x102);
+	val &= ~(0x0003);
+	val = 0x0003;
+	wm8994_write(codec,0x102,val);
+
+	val = wm8994_read(codec, 0x56  );
+	val &= ~(0x0003);
+	val = 0x0003;
+	wm8994_write(codec,0x56,val);
+
+	val = wm8994_read(codec, 0x102 );
+	val &= ~(0x0000);
+	val = 0x0000;
+	wm8994_write(codec,0x102,val);
+
+	val = wm8994_read(codec, WM8994_CLASS_W_1  );
+	val &= ~(0x0005);
+	val = 0x0005;
+	wm8994_write(codec,WM8994_CLASS_W_1,val);
+
+	if(wm8994->testmode_config_flag == SEC_NORMAL)
+	{
+		val = wm8994_read(codec,WM8994_LEFT_OUTPUT_VOLUME);
+		val &= ~(WM8994_HPOUT1L_MUTE_N_MASK | WM8994_HPOUT1L_VOL_MASK);
+		val |= (WM8994_HPOUT1L_MUTE_N | TUNING_MP3_DUAL_OUTPUTL_VOL);
+		wm8994_write(codec, WM8994_LEFT_OUTPUT_VOLUME, val);
+
+		val = wm8994_read(codec,WM8994_RIGHT_OUTPUT_VOLUME);
+		val &= ~(WM8994_HPOUT1R_MUTE_N_MASK | WM8994_HPOUT1R_VOL_MASK);
+		val |= (WM8994_HPOUT1_VU | WM8994_HPOUT1R_MUTE_N | TUNING_MP3_DUAL_OUTPUTR_VOL);
+		wm8994_write(codec, WM8994_RIGHT_OUTPUT_VOLUME, val);
+	}
+
+	//* DC Servo Series Count
+	val = 0x03E0;
+	wm8994_write(codec, WM8994_DC_SERVO_2, val);
+
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_1);
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK |
+#if defined(CONFIG_PHONE_P1_GSM)
+		WM8994_HPOUT1L_ENA_MASK | WM8994_HPOUT1R_ENA_MASK | WM8994_SPKOUTL_ENA_MASK | WM8994_SPKOUTR_ENA_MASK );
+#elif defined(CONFIG_PHONE_P1_CDMA)
+		WM8994_HPOUT1L_ENA_MASK | WM8994_HPOUT1R_ENA_MASK | WM8994_SPKOUTL_ENA_MASK);
+#endif
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL |
+	WM8994_HPOUT1R_ENA	| WM8994_HPOUT1L_ENA | WM8994_SPKOUTL_ENA | WM8994_SPKOUTR_ENA );
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_1,val);
+
+	val = (WM8994_HPOUT1L_DLY | WM8994_HPOUT1R_DLY);
+	wm8994_write(codec, WM8994_ANALOGUE_HP_1, val);
+
+	//Enable Charge Pump
+	val = wm8994_read(codec, WM8994_CHARGE_PUMP_1);
+	val &= ~WM8994_CP_ENA_MASK ;
+	val |= WM8994_CP_ENA | WM8994_CP_ENA_DEFAULT ; // this is from wolfson
+	wm8994_write(codec, WM8994_CHARGE_PUMP_1, val);
+
+	msleep(5);
+
+	//Enable DAC1 and DAC2 and the Timeslot0 for AIF1
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_5 );
+	val &= ~(WM8994_DAC1R_ENA_MASK | WM8994_DAC1L_ENA_MASK|WM8994_AIF1DAC1R_ENA_MASK | WM8994_AIF1DAC1L_ENA_MASK );
+	val |= (WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA | WM8994_DAC1L_ENA |WM8994_DAC1R_ENA );
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_5,val);
+
+	// Enbale DAC1L to HPOUT1L path
+	val = wm8994_read(codec, WM8994_OUTPUT_MIXER_1);
+	val &= ~(WM8994_DAC1L_TO_HPOUT1L_MASK | WM8994_DAC1L_TO_MIXOUTL_MASK);
+	val |= WM8994_DAC1L_TO_MIXOUTL;
+	wm8994_write(codec,WM8994_OUTPUT_MIXER_1, val);
+
+	// Enbale DAC1R to HPOUT1R path
+	val = wm8994_read(codec, WM8994_OUTPUT_MIXER_2);
+	val &= ~(WM8994_DAC1R_TO_HPOUT1R_MASK | WM8994_DAC1R_TO_MIXOUTR_MASK);
+	val |= WM8994_DAC1R_TO_MIXOUTR;
+	wm8994_write(codec, WM8994_OUTPUT_MIXER_2, val);
+
+	//Enbale bias,vmid, hp left and right and Left speaker
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_3);
+	val &= ~(WM8994_MIXOUTLVOL_ENA_MASK | WM8994_MIXOUTRVOL_ENA_MASK | WM8994_MIXOUTL_ENA_MASK | WM8994_MIXOUTR_ENA_MASK | WM8994_SPKLVOL_ENA_MASK);
+	val |= (WM8994_MIXOUTLVOL_ENA | WM8994_MIXOUTRVOL_ENA | WM8994_MIXOUTL_ENA | WM8994_MIXOUTR_ENA | WM8994_SPKLVOL_ENA | WM8994_SPKRVOL_ENA );
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_3 ,val);
+
+	//* DC Servo
+	val = (WM8994_DCS_TRIG_SERIES_1 | WM8994_DCS_TRIG_SERIES_0 | WM8994_DCS_ENA_CHAN_1 | WM8994_DCS_ENA_CHAN_0);
+	wm8994_write(codec,WM8994_DC_SERVO_1, 0x0303 );
+
+	msleep(160);
+
+	nReadServo4Val=wm8994_read(codec,WM8994_DC_SERVO_4);
+	nServo4Low=(signed char)(nReadServo4Val & 0xff);
+	nServo4High=(signed char)((nReadServo4Val>>8) & 0xff);
+
+	nCompensationResultLow=((signed short)nServo4Low -5)&0x00ff;
+	nCompensationResultHigh=((signed short)(nServo4High -5)<<8)&0xff00;
+	ncompensationResult=nCompensationResultLow|nCompensationResultHigh;
+	wm8994_write(codec,WM8994_DC_SERVO_4, ncompensationResult);
+
+	val = (WM8994_DCS_TRIG_DAC_WR_1 | WM8994_DCS_TRIG_DAC_WR_0 | WM8994_DCS_ENA_CHAN_1 | WM8994_DCS_ENA_CHAN_0);
+	wm8994_write(codec,WM8994_DC_SERVO_1, val );
+
+	msleep(15);
+
+	// Intermediate HP settings
+	val = wm8994_read(codec, WM8994_ANALOGUE_HP_1);
+	val &= ~(WM8994_HPOUT1R_DLY_MASK |WM8994_HPOUT1R_OUTP_MASK |WM8994_HPOUT1R_RMV_SHORT_MASK |
+	WM8994_HPOUT1L_DLY_MASK |WM8994_HPOUT1L_OUTP_MASK | WM8994_HPOUT1L_RMV_SHORT_MASK);
+	val |= (WM8994_HPOUT1L_RMV_SHORT | WM8994_HPOUT1L_OUTP|WM8994_HPOUT1L_DLY |WM8994_HPOUT1R_RMV_SHORT |
+	WM8994_HPOUT1R_OUTP | WM8994_HPOUT1R_DLY);
+	wm8994_write(codec, WM8994_ANALOGUE_HP_1, val);
+
+	if(wm8994->testmode_config_flag == SEC_NORMAL)
+	{
+		//Unmute DAC1 left
+		val = wm8994_read(codec,WM8994_DAC1_LEFT_VOLUME );
+		val &= ~(WM8994_DAC1L_MUTE_MASK | WM8994_DAC1L_VOL_MASK);
+		val |= (TUNING_DAC1L_VOL);
+		wm8994_write(codec,WM8994_DAC1_LEFT_VOLUME ,val);
+
+		//Unmute and volume ctrl RightDAC
+		val = wm8994_read(codec, WM8994_DAC1_RIGHT_VOLUME );
+		val &= ~(WM8994_DAC1R_MUTE_MASK | WM8994_DAC1R_VOL_MASK);
+		val |= (WM8994_DAC1_VU | TUNING_DAC1R_VOL); //0 db volume
+		wm8994_write(codec,WM8994_DAC1_RIGHT_VOLUME,val);
+	}
+
+	//------------------  Common Settings ------------------
+	// Unmute the AIF1DAC1
+	val = wm8994_read(codec, WM8994_AIF1_DAC1_FILTERS_1 );
+	val &= ~(WM8994_AIF1DAC1_MUTE_MASK | WM8994_AIF1DAC1_MONO_MASK);
+	val |= (WM8994_AIF1DAC1_UNMUTE | WM8994_AIF1DAC1_MONO);
+	wm8994_write(codec,WM8994_AIF1_DAC1_FILTERS_1 ,val);
+
+
+	if(wm8994->testmode_config_flag == SEC_NORMAL)
+	{
+		// Unmute the SPKMIXVOLUME
+		val = wm8994_read(codec, WM8994_SPKMIXL_ATTENUATION);
+		val &= ~(WM8994_SPKMIXL_VOL_MASK);
+		val |= TUNING_SPKMIXL_ATTEN;
+		wm8994_write(codec, WM8994_SPKMIXL_ATTENUATION, val);
+
+		val = wm8994_read(codec,WM8994_SPKMIXR_ATTENUATION);
+		val &= ~(WM8994_SPKMIXR_VOL_MASK);
+		val |= TUNING_SPKMIXR_ATTEN;
+		wm8994_write(codec, WM8994_SPKMIXR_ATTENUATION, val);
+	}
+}
+
+
+void wm8994_set_playback_bluetooth(struct snd_soc_codec *codec)
+{
+	u16 val;
+
+	DEBUG_LOG("BT Playback Path for Voice Command\n");
+
+
+	wm8994_set_voicecall_common_setting(codec);
+
+	//R1(1h) - 0x0003 -normal vmid
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_1);
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK);
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+	/*Digital Path Enables and Unmutes*/
+	//R2(2h) - 0x0000
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_2, 0x0000);
+
+	//R3(3h) - 0x0000
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, 0x0000);
+
+	//R4(4h) - 0x3000
+	//AIF2ADC(Left/Right) Output
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_4 );
+	val &= ~(WM8994_AIF2ADCL_ENA_MASK |WM8994_AIF2ADCR_ENA_MASK);
+	val |= ( WM8994_AIF2ADCL_ENA | WM8994_AIF2ADCR_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_4 , val);
+
+	//R5(5h) - 0x0300
+	//AIF1DAC1(Left/Right) Input
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_5);	//05 : 3303
+	val &= ~(WM8994_AIF2DACL_ENA_MASK | WM8994_AIF2DACR_ENA_MASK | WM8994_AIF1DAC1L_ENA_MASK | WM8994_AIF1DAC1R_ENA_MASK
+		 | WM8994_DAC1L_ENA_MASK | WM8994_DAC1R_ENA_MASK);
+	val |= (WM8994_AIF2DACL_ENA | WM8994_AIF2DACR_ENA | WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA
+		 | WM8994_DAC1L_ENA | WM8994_DAC1R_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_5, val);
+
+	//R6(6h) - 0x0008
+	//AIF3_ADCDAT_SRC(AIF2ADCDAT2)
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_6);
+	val &= ~(WM8994_AIF3_ADCDAT_SRC_MASK);
+	val |= (0x0001 << WM8994_AIF3_ADCDAT_SRC_SHIFT);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_6, val);
+
+	/*Un-Mute*/
+	//R1056(420h) - 0x0000
+	//AIF1DAC1_MUTE(Un-mute)
+	val = wm8994_read(codec, WM8994_AIF1_DAC1_FILTERS_1);
+	val &= ~(WM8994_AIF1DAC1_MUTE_MASK | WM8994_AIF1DAC1_MONO_MASK);
+	val |= (WM8994_AIF1DAC1_UNMUTE);
+	wm8994_write(codec, WM8994_AIF1_DAC1_FILTERS_1, val);
+
+	/*Mixer Routing*/
+	//R1540(604h) - 0x0004
+	//AIF2DACL_TO_DAC2L
+	val = wm8994_read(codec, WM8994_DAC2_LEFT_MIXER_ROUTING);
+	val &= ~(WM8994_AIF1DAC1L_TO_DAC2L_MASK);
+	val |= (WM8994_AIF1DAC1L_TO_DAC2L);
+	wm8994_write(codec, WM8994_DAC2_LEFT_MIXER_ROUTING, val);
+
+	//R1541(605h) - 0x0004
+	//AIF2DACR_TO_DAC2R
+	val = wm8994_read(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING);
+	val &= ~(WM8994_AIF1DAC1R_TO_DAC2R_MASK);
+	val |= (WM8994_AIF1DAC1R_TO_DAC2R);
+	wm8994_write(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING, val);
+
+	/*Volume*/
+	wm8994_write(codec, WM8994_DAC2_LEFT_VOLUME, 0x01C0);
+	wm8994_write(codec, WM8994_DAC2_RIGHT_VOLUME, 0x01C0);
+
+	wm8994_write(codec, WM8994_AIF2_CLOCKING_1, 0x0019);
+
+	wm8994_write(codec, WM8994_OVERSAMPLING, 0X0000);
+
+	/*GPIO Configuration*/
+	wm8994_write(codec, WM8994_GPIO_8, WM8994_GP8_DIR | WM8994_GP8_DB);
+	wm8994_write(codec, WM8994_GPIO_9, WM8994_GP9_DB);
+	wm8994_write(codec, WM8994_GPIO_10, WM8994_GP10_DB);
+	wm8994_write(codec, WM8994_GPIO_11, WM8994_GP11_DB);
+}
+
+void wm8994_set_playback_extra_dock_speaker(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	u16 val;
+
+	DEBUG_LOG("");
+
+	wm8994_write(codec, WM8994_ANTIPOP_2, 0x0048);
+
+	//OUTPUT mute
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_3);
+	val &= ~(WM8994_LINEOUT2N_ENA_MASK | WM8994_LINEOUT2P_ENA_MASK);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, val);
+
+
+	if(wm8994->testmode_config_flag == SEC_NORMAL)
+	{
+		val = wm8994_read(codec, WM8994_OUTPUT_MIXER_5);
+		val &= ~(WM8994_DACL_MIXOUTL_VOL_MASK);
+		val |= TUNING_EXTRA_DOCK_SPK_OUTMIX5_VOL << WM8994_DACL_MIXOUTL_VOL_SHIFT;
+		wm8994_write(codec,WM8994_OUTPUT_MIXER_5, val );
+
+		val = wm8994_read(codec, WM8994_OUTPUT_MIXER_6);
+		val &= ~(WM8994_DACR_MIXOUTR_VOL_MASK);
+		val |= TUNING_EXTRA_DOCK_SPK_OUTMIX6_VOL << WM8994_DACR_MIXOUTR_VOL_SHIFT;
+		wm8994_write(codec,WM8994_OUTPUT_MIXER_6, val );
+
+		val = wm8994_read(codec, WM8994_LEFT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTL_MUTE_N_MASK | WM8994_MIXOUTL_VOL_MASK);
+		val |= (WM8994_MIXOUTL_MUTE_N | TUNING_MP3_EXTRA_DOCK_SPK_OPGAL_VOL);
+		wm8994_write(codec,WM8994_LEFT_OPGA_VOLUME, val );
+
+		val = wm8994_read(codec, WM8994_RIGHT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTR_MUTE_N_MASK | WM8994_MIXOUTR_VOL_MASK);
+		val |= (WM8994_MIXOUT_VU | WM8994_MIXOUTR_MUTE_N | TUNING_MP3_EXTRA_DOCK_SPK_OPGAR_VOL);
+		wm8994_write(codec,WM8994_RIGHT_OPGA_VOLUME, val );
+
+		val = wm8994_read(codec,WM8994_LINE_OUTPUTS_VOLUME);
+		val &= ~(WM8994_LINEOUT2_VOL_MASK);
+		val |= (TUNING_MP3_EXTRA_DOCK_SPK_VOL << WM8994_LINEOUT2_VOL_SHIFT);
+		wm8994_write(codec,WM8994_LINE_OUTPUTS_VOLUME,val);
+
+		//Unmute DAC1 left
+		val = wm8994_read(codec,WM8994_DAC1_LEFT_VOLUME );
+		val &= ~(WM8994_DAC1L_MUTE_MASK | WM8994_DAC1L_VOL_MASK);
+		val |= (TUNING_DAC1L_VOL);
+		wm8994_write(codec,WM8994_DAC1_LEFT_VOLUME ,val);
+
+		//Unmute and volume ctrl RightDAC
+		val = wm8994_read(codec, WM8994_DAC1_RIGHT_VOLUME );
+		val &= ~(WM8994_DAC1R_MUTE_MASK | WM8994_DAC1R_VOL_MASK);
+		val |= (WM8994_DAC1_VU | TUNING_DAC1R_VOL);
+		wm8994_write(codec,WM8994_DAC1_RIGHT_VOLUME,val);
+
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_LEFT_VOLUME);
+		val &= ~(WM8994_AIF1DAC1L_VOL_MASK);
+		val |= (TUNING_DAC1L_VOL);
+		wm8994_write(codec, WM8994_AIF1_DAC1_LEFT_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME);
+		val &= ~(WM8994_AIF1DAC1R_VOL_MASK);
+		val |= (WM8994_AIF1DAC1_VU |TUNING_DAC1R_VOL);
+		wm8994_write(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME, val);
+	}
+
+	val = wm8994_read(codec,WM8994_OUTPUT_MIXER_1);
+	val &= ~(WM8994_DAC1L_TO_MIXOUTL_MASK);
+	val |= (WM8994_DAC1L_TO_MIXOUTL);
+	wm8994_write(codec,WM8994_OUTPUT_MIXER_1,val);
+
+	val = wm8994_read(codec,WM8994_OUTPUT_MIXER_2);
+	val &= ~(WM8994_DAC1R_TO_MIXOUTR_MASK);
+	val |= (WM8994_DAC1R_TO_MIXOUTR);
+	wm8994_write(codec,WM8994_OUTPUT_MIXER_2,val);
+
+
+	val = wm8994_read(codec,WM8994_LINE_MIXER_2);
+	val &= ~(WM8994_MIXOUTR_TO_LINEOUT2N_MASK | WM8994_MIXOUTL_TO_LINEOUT2N_MASK | WM8994_LINEOUT2_MODE_MASK | WM8994_MIXOUTR_TO_LINEOUT2P_MASK);
+	val |= (WM8994_MIXOUTL_TO_LINEOUT2N | WM8994_LINEOUT2_MODE | WM8994_MIXOUTR_TO_LINEOUT2P);
+	wm8994_write(codec,WM8994_LINE_MIXER_2,val);
+
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_5);
+	val &= ~(WM8994_DAC1R_ENA_MASK | WM8994_DAC1L_ENA_MASK | WM8994_AIF1DAC1R_ENA_MASK | WM8994_AIF1DAC1L_ENA_MASK);
+	val |= (WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA | WM8994_DAC1L_ENA | WM8994_DAC1R_ENA);
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_5,val);
+
+	val = wm8994_read(codec,WM8994_AIF1_DAC1_FILTERS_1);
+	val &= ~(WM8994_AIF1DAC1_MUTE_MASK |WM8994_AIF1DAC1_MONO_MASK);
+	val |= (WM8994_AIF1DAC1_UNMUTE);
+	wm8994_write(codec,WM8994_AIF1_DAC1_FILTERS_1,val);
+
+	val = wm8994_read(codec,WM8994_LINE_OUTPUTS_VOLUME);
+	val &= ~(WM8994_LINEOUT2N_MUTE_MASK | WM8994_LINEOUT2P_MUTE_MASK);
+	wm8994_write(codec,WM8994_LINE_OUTPUTS_VOLUME,val);
+
+	val = wm8994_read(codec,WM8994_DAC1_LEFT_MIXER_ROUTING);
+	val &= ~(WM8994_AIF1DAC1L_TO_DAC1L_MASK);
+	val |= (WM8994_AIF1DAC1L_TO_DAC1L);
+	wm8994_write(codec,WM8994_DAC1_LEFT_MIXER_ROUTING,val);
+
+	val = wm8994_read(codec,WM8994_DAC1_RIGHT_MIXER_ROUTING);
+	val &= ~(WM8994_AIF1DAC1R_TO_DAC1R_MASK);
+	val |= (WM8994_AIF1DAC1R_TO_DAC1R);
+	wm8994_write(codec,WM8994_DAC1_RIGHT_MIXER_ROUTING,val);
+
+	val = wm8994_read(codec, WM8994_CLOCKING_1);
+	val &= ~(WM8994_DSP_FS1CLK_ENA_MASK | WM8994_DSP_FSINTCLK_ENA_MASK);
+	val |= (WM8994_DSP_FS1CLK_ENA | WM8994_DSP_FSINTCLK_ENA);
+	wm8994_write(codec, WM8994_CLOCKING_1, val);
+
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_3);
+#if defined(CONFIG_PHONE_P1_GSM)
+	val &= ~(WM8994_MIXOUTLVOL_ENA_MASK | WM8994_MIXOUTRVOL_ENA_MASK | WM8994_MIXOUTL_ENA_MASK | WM8994_MIXOUTR_ENA_MASK);
+	val |= (WM8994_MIXOUTL_ENA | WM8994_MIXOUTR_ENA | WM8994_MIXOUTRVOL_ENA | WM8994_MIXOUTLVOL_ENA);
+#elif defined(CONFIG_PHONE_P1_CDMA)
+	val &= ~(WM8994_LINEOUT2N_ENA_MASK | WM8994_LINEOUT2P_ENA_MASK | WM8994_MIXOUTLVOL_ENA_MASK | WM8994_MIXOUTRVOL_ENA_MASK | WM8994_MIXOUTL_ENA_MASK | WM8994_MIXOUTR_ENA_MASK);
+	val |= (WM8994_LINEOUT2N_ENA | WM8994_LINEOUT2P_ENA | WM8994_MIXOUTL_ENA | WM8994_MIXOUTR_ENA | WM8994_MIXOUTRVOL_ENA | WM8994_MIXOUTLVOL_ENA);
+#endif
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_3,val);
+
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1 );
+#if defined(CONFIG_PHONE_P1_GSM)
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK | WM8994_HPOUT2_ENA_MASK  | WM8994_HPOUT1L_ENA_MASK | WM8994_HPOUT1R_ENA_MASK
+		| WM8994_SPKOUTL_ENA_MASK | WM8994_SPKOUTR_ENA_MASK);
+#elif defined(CONFIG_PHONE_P1_CDMA)
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK | WM8994_HPOUT2_ENA_MASK );
+#endif
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL );
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_1,val);
+
+	/* To enhance THD, Ch Seperation Characteristic (2010.08.19, KDS)*/
+	val = wm8994_read(codec,WM8994_ADDITIONAL_CONTROL );
+	val &= ~(WM8994_LINEOUT1_FB_MASK | WM8994_LINEOUT2_FB_MASK );
+	/* To tune THD, Power of each frequency (2010.09.15, KDS)*/
+	// val |= WM8994_LINEOUT2_FB ;
+	wm8994_write(codec,WM8994_ADDITIONAL_CONTROL,val);
+
+	/* To tune THD, Power of each frequency (2010.09.15, KDS)*/
+	val = wm8994_read(codec,WM8994_ANTIPOP_1);
+	val &= ~(WM8994_LINEOUT_VMID_BUF_ENA_MASK | WM8994_HPOUT2_IN_ENA_MASK | WM8994_LINEOUT1_DISCH_MASK | WM8994_LINEOUT2_DISCH_MASK);
+	val |= WM8994_LINEOUT_VMID_BUF_ENA ;
+	wm8994_write(codec,WM8994_ANTIPOP_1,val);
+
+#if defined(CONFIG_PHONE_P1_GSM)
+	msleep(230);
+
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_3);
+	val &= ~(WM8994_LINEOUT2N_ENA_MASK | WM8994_LINEOUT2P_ENA_MASK);
+	val |= (WM8994_LINEOUT2N_ENA | WM8994_LINEOUT2P_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, val);
+#endif
+}
+
+
+void wm8994_set_playback_hdmi_tvout(struct snd_soc_codec *codec)
+{
+	int val;
+
+	DEBUG_LOG("");
+
+	//Disable all output
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1);
+	val &= ~(WM8994_HPOUT2_ENA_MASK | WM8994_HPOUT1L_ENA_MASK | WM8994_HPOUT1R_ENA_MASK
+		| WM8994_SPKOUTL_ENA_MASK | WM8994_SPKOUTR_ENA_MASK);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_3);
+	val &= ~(WM8994_LINEOUT2N_ENA_MASK | WM8994_LINEOUT2P_ENA_MASK);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, val);
+
+	wm8994_write(codec, WM8994_AIF1_BCLK, 0x70);
+}
+
+
+void wm8994_set_playback_speaker_hdmitvout(struct snd_soc_codec *codec)
+{
+	DEBUG_LOG("");
+
+	wm8994_write(codec, WM8994_AIF1_BCLK, 0x70);
+
+	wm8994_set_playback_speaker(codec);
+}
+
+
+void wm8994_set_playback_speakerheadset_hdmitvout(struct snd_soc_codec *codec)
+{
+	DEBUG_LOG("");
+
+	wm8994_write(codec, WM8994_AIF1_BCLK, 0x70);
+
+	wm8994_set_playback_speaker_headset(codec);
+}
+
+
+void wm8994_set_voicecall_common_setting(struct snd_soc_codec *codec)
+{
+	int val;
+
+	/*GPIO Configuration*/
+	wm8994_write(codec, WM8994_GPIO_1, 0xA101);
+	wm8994_write(codec, WM8994_GPIO_2, 0x8100);
+#if defined(CONFIG_PHONE_P1_GSM)
+	wm8994_write(codec, WM8994_GPIO_3, 0x0100);
+	wm8994_write(codec, WM8994_GPIO_4, 0x0100);
+	wm8994_write(codec, WM8994_GPIO_5, 0x8100);
+#elif defined(CONFIG_PHONE_P1_CDMA)
+    wm8994_write(codec, WM8994_GPIO_3, 0x8100);    // GPIO 3. Speech PCM Clock
+    wm8994_write(codec, WM8994_GPIO_4, 0x8100);    // GPIO 4. Speech PCM Sync
+    wm8994_write(codec, WM8994_GPIO_5, 0x8100);    // GPIO 5. Speech PCM Data Out
+#endif
+	wm8994_write(codec, WM8994_GPIO_6, 0xA101);
+	wm8994_write(codec, WM8994_GPIO_7, 0x0100);    // GPIO 7. Speech PCM Data Input
+	wm8994_write(codec, WM8994_GPIO_8, 0xA101);
+	wm8994_write(codec, WM8994_GPIO_9, 0xA101);
+	wm8994_write(codec, WM8994_GPIO_10, 0xA101);
+	wm8994_write(codec, WM8994_GPIO_11, 0xA101);
+
+	/*FLL2 Setting*/
+	wm8994_write(codec, WM8994_FLL2_CONTROL_2, 0x2F00);
+	wm8994_write(codec, WM8994_FLL2_CONTROL_3, 0x3126);
+	wm8994_write(codec, WM8994_FLL2_CONTROL_4, 0x0100);
+	wm8994_write(codec, WM8994_FLL2_CONTROL_5, 0x0C88);
+//	wm8994_write(codec, WM8994_FLL2_CONTROL_5, 0x0C89);	// CP 24MHz
+	wm8994_write(codec, WM8994_FLL2_CONTROL_1, WM8994_FLL2_FRACN_ENA | WM8994_FLL2_ENA);
+#if defined(CONFIG_PHONE_P1_GSM)
+	val = wm8994_read(codec, WM8994_AIF2_CLOCKING_1);
+	if(!(val & WM8994_AIF2CLK_ENA))
+		wm8994_write(codec, WM8994_AIF2_CLOCKING_1, 0x0018);
+#elif defined(CONFIG_PHONE_P1_CDMA)
+	wm8994_write(codec, WM8994_AIF2_CLOCKING_1, 0x0019);
+#endif
+	wm8994_write(codec, WM8994_AIF2_RATE, 0x3 << WM8994_AIF2CLK_RATE_SHIFT);
+
+	// AIF2 Interface - PCM Stereo mode
+	wm8994_write(codec, WM8994_AIF2_CONTROL_1,	//Left Justified, BCLK invert, LRCLK Invert
+		WM8994_AIF2ADCR_SRC | WM8994_AIF2_BCLK_INV |0x18);
+
+	wm8994_write(codec, WM8994_AIF2_BCLK, 0x70);
+	wm8994_write(codec, WM8994_AIF2_CONTROL_2, 0x0000);
+#if defined(CONFIG_PHONE_P1_GSM)
+	wm8994_write(codec, WM8994_AIF2_MASTER_SLAVE, WM8994_AIF2_MSTR | WM8994_AIF2_CLK_FRC | WM8994_AIF2_LRCLK_FRC);	//Master
+#elif defined(CONFIG_PHONE_P1_CDMA)
+	wm8994_write(codec, WM8994_AIF2_MASTER_SLAVE, 0x0000);
+#endif
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_5);	//05 : 3303
+	val &= ~(WM8994_AIF2DACL_ENA_MASK | WM8994_AIF2DACR_ENA_MASK | WM8994_AIF1DAC1L_ENA_MASK | WM8994_AIF1DAC1R_ENA_MASK
+		 | WM8994_DAC1L_ENA_MASK | WM8994_DAC1R_ENA_MASK);
+	val |= (WM8994_AIF2DACL_ENA | WM8994_AIF2DACR_ENA | WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA
+		 | WM8994_DAC1L_ENA | WM8994_DAC1R_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_5, val);
+
+	/*Clocking*/
+	val = wm8994_read(codec, WM8994_CLOCKING_1);
+	val |= (WM8994_DSP_FS2CLK_ENA);
+	wm8994_write(codec, WM8994_CLOCKING_1, val);
+
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_6, 0x0);
+
+//	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, 0x0);
+
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_3 );
+	val &= ~( WM8994_SPKLVOL_ENA_MASK | WM8994_SPKRVOL_ENA_MASK  );
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_3 ,val);
+
+
+	val = wm8994_read(codec,WM8994_SPEAKER_MIXER );
+	val &= ~(WM8994_DAC1L_TO_SPKMIXL_MASK | WM8994_DAC1R_TO_SPKMIXR_MASK);
+	wm8994_write(codec,WM8994_SPEAKER_MIXER ,val);
+
+
+	// AIF1 & AIF2 Output is connected to DAC1
+	val = wm8994_read(codec,WM8994_DAC1_LEFT_MIXER_ROUTING);
+	val &= ~(WM8994_AIF1DAC1L_TO_DAC1L_MASK | WM8994_AIF2DACL_TO_DAC1L_MASK);
+	val |= (WM8994_AIF1DAC1L_TO_DAC1L | WM8994_AIF2DACL_TO_DAC1L);
+	wm8994_write(codec,WM8994_DAC1_LEFT_MIXER_ROUTING, val );
+
+	val = wm8994_read(codec,WM8994_DAC1_RIGHT_MIXER_ROUTING);
+	val &= ~(WM8994_AIF1DAC1R_TO_DAC1R_MASK | WM8994_AIF2DACR_TO_DAC1R_MASK);
+	val |= (WM8994_AIF1DAC1R_TO_DAC1R | WM8994_AIF2DACR_TO_DAC1R);
+	wm8994_write(codec,WM8994_DAC1_RIGHT_MIXER_ROUTING, val);
+
+	val = wm8994_read(codec, WM8994_AIF1_DAC1_LEFT_VOLUME);
+	val &= ~(WM8994_AIF1DAC1L_VOL_MASK);
+	val |= (TUNING_DAC1L_VOL);
+	wm8994_write(codec, WM8994_AIF1_DAC1_LEFT_VOLUME, val);
+
+	val = wm8994_read(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME);
+	val &= ~(WM8994_AIF1DAC1R_VOL_MASK);
+	val |= (WM8994_AIF1DAC1_VU |TUNING_DAC1R_VOL);
+	wm8994_write(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME, val);
+
+	wm8994_write(codec, 0x6, 0x0);
+}
+
+void wm8994_set_voicecall_receiver(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	int val;
+
+	DEBUG_LOG("set_voicecall_receiver");
+
+	audio_ctrl_mic_bias_gpio(1);
+
+	wm8994_set_voicecall_common_setting(codec);
+
+	wm8994_write(codec, WM8994_CHARGE_PUMP_1, WM8994_CP_ENA_DEFAULT);	// Turn off charge pump.
+
+	// Analogue Input Configuration -Main MIC
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_2,
+		WM8994_TSHUT_ENA | WM8994_TSHUT_OPDIS | WM8994_MIXINL_ENA | WM8994_IN1L_ENA);
+
+	wm8994_write(codec, WM8994_INPUT_MIXER_2, WM8994_IN1LP_TO_IN1L | WM8994_IN1LN_TO_IN1L); 	// differential(3) or single ended(1)
+
+	/* Digital Path Enables and Unmutes*/
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_4, WM8994_AIF2ADCL_ENA | WM8994_ADCL_ENA);
+#if defined(CONFIG_PHONE_P1_CDMA)
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_5 ,
+		WM8994_AIF2DACL_ENA | WM8994_AIF2DACR_ENA | WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA |
+		WM8994_DAC1L_ENA | WM8994_DAC1R_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_6, 0x0000);
+#endif
+
+	wm8994_write(codec,WM8994_AIF1_DAC1_FILTERS_1, 0x0000 );	//AIF1DAC1 Unmute, Mono Mix diable, Fast Ramp
+	wm8994_write(codec, WM8994_AIF2_DAC_FILTERS_1, 0x0000 );	//AIF2DAC Unmute, Mono Mix diable, Fast Ramp
+
+	wm8994_write(codec, WM8994_DAC2_MIXER_VOLUMES, 0x000C);
+	wm8994_write(codec, WM8994_DAC2_LEFT_VOLUME, 0x01C0 );
+	wm8994_write(codec, WM8994_DAC2_RIGHT_VOLUME, 0x01C0 );
+
+#if defined(CONFIG_PHONE_P1_CDMA)
+	// AIF1 & AIF2 Output is connected to DAC1
+	wm8994_write(codec, WM8994_DAC1_LEFT_MIXER_ROUTING, WM8994_AIF2DACL_TO_DAC1L | WM8994_AIF1DAC1L_TO_DAC1L);
+	wm8994_write(codec, WM8994_DAC1_RIGHT_MIXER_ROUTING, WM8994_AIF2DACR_TO_DAC1R | WM8994_AIF1DAC1R_TO_DAC1R);
+#endif
+	// Tx -> AIF2 Path
+	wm8994_write(codec, WM8994_DAC2_LEFT_MIXER_ROUTING, WM8994_ADC1_TO_DAC2L);
+	wm8994_write(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING, WM8994_ADC1_TO_DAC2R);
+
+#if defined(CONFIG_PHONE_P1_GSM)
+	wm8994_write(codec, WM8994_AIF2_CLOCKING_1, 0x0019);
+#endif
+
+	if((wm8994->testmode_config_flag == SEC_NORMAL)

+		|| (wm8994->testmode_config_flag == SEC_TEST_PBA_LOOPBACK)

+	)
+	{

+		// Unmute IN1L PGA, update volume
+		val = wm8994_read(codec, WM8994_LEFT_LINE_INPUT_1_2_VOLUME);
+		val &= ~(WM8994_IN1L_MUTE_MASK | WM8994_IN1L_VOL_MASK);
+		val |= (WM8994_IN1L_VU |TUNING_CALL_RCV_INPUTMIX_VOL); //volume
+		wm8994_write(codec, WM8994_LEFT_LINE_INPUT_1_2_VOLUME, val);
+
+		//Unmute the PGA
+		val = wm8994_read(codec, WM8994_INPUT_MIXER_3);
+		val&= ~(WM8994_IN1L_TO_MIXINL_MASK | WM8994_IN1L_MIXINL_VOL_MASK | WM8994_MIXOUTL_MIXINL_VOL_MASK);
+#if defined(CONFIG_PHONE_P1_GSM)
+		val |= (WM8994_IN1L_TO_MIXINL |TUNING_CALL_RCV_MIXER_VOL);//30db
+#elif defined(CONFIG_PHONE_P1_CDMA)
+		val |= (WM8994_IN1L_TO_MIXINL |WM8994_IN1L_MIXINL_VOL);//30db
+#endif
+		wm8994_write(codec, WM8994_INPUT_MIXER_3, val);
+
+		// Volume Control - Output
+		val = wm8994_read(codec, WM8994_OUTPUT_MIXER_5);
+		val &= ~(WM8994_DACL_MIXOUTL_VOL_MASK);
+		val |= TUNING_RCV_OUTMIX5_VOL << WM8994_DACL_MIXOUTL_VOL_SHIFT;
+		wm8994_write(codec,WM8994_OUTPUT_MIXER_5, val );
+
+		val = wm8994_read(codec, WM8994_OUTPUT_MIXER_6);
+		val &= ~(WM8994_DACR_MIXOUTR_VOL_MASK);
+		val |= TUNING_RCV_OUTMIX6_VOL << WM8994_DACR_MIXOUTR_VOL_SHIFT;
+		wm8994_write(codec,WM8994_OUTPUT_MIXER_6, val );
+
+		val = wm8994_read(codec, WM8994_LEFT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTL_MUTE_N_MASK | WM8994_MIXOUTL_VOL_MASK);
+#if defined(CONFIG_PHONE_P1_GSM)
+		val |= (WM8994_MIXOUTL_MUTE_N | TUNING_RCV_OPGAL_VOL);
+#elif defined(CONFIG_PHONE_P1_CDMA)
+		val |= (WM8994_MIXOUT_VU | WM8994_MIXOUTL_MUTE_N | TUNING_RCV_OPGAL_VOL);
+#endif
+		wm8994_write(codec,WM8994_LEFT_OPGA_VOLUME, val );
+
+		val = wm8994_read(codec, WM8994_RIGHT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTR_MUTE_N_MASK | WM8994_MIXOUTR_VOL_MASK);
+		val |= (WM8994_MIXOUT_VU | WM8994_MIXOUTR_MUTE_N | TUNING_RCV_OPGAR_VOL);
+		wm8994_write(codec,WM8994_RIGHT_OPGA_VOLUME, val );
+
+		val = wm8994_read(codec, WM8994_HPOUT2_VOLUME);
+		val &= ~(WM8994_HPOUT2_MUTE_MASK | WM8994_HPOUT2_VOL_MASK);
+		val |= TUNING_HPOUT2_VOL << WM8994_HPOUT2_VOL_SHIFT;
+		wm8994_write(codec,WM8994_HPOUT2_VOLUME, val );
+
+		//Unmute DAC1 left
+		val = wm8994_read(codec,WM8994_DAC1_LEFT_VOLUME );
+		val &= ~(WM8994_DAC1L_MUTE_MASK | WM8994_DAC1L_VOL_MASK);
+		val |= (TUNING_DAC1L_VOL);
+		wm8994_write(codec,WM8994_DAC1_LEFT_VOLUME ,val);
+
+		//Unmute and volume ctrl RightDAC
+		val = wm8994_read(codec, WM8994_DAC1_RIGHT_VOLUME );
+		val &= ~(WM8994_DAC1R_MUTE_MASK | WM8994_DAC1R_VOL_MASK);
+#if defined(CONFIG_PHONE_P1_GSM)
+		val |= (WM8994_DAC1_VU | TUNING_DAC1R_VOL); //0 db volume
+#elif defined(CONFIG_PHONE_P1_CDMA)
+		val |= TUNING_DAC1R_VOL; //0 db volume
+#endif
+		wm8994_write(codec,WM8994_DAC1_RIGHT_VOLUME,val);
+	}
+
+	// Output Mixing
+	wm8994_write(codec, WM8994_OUTPUT_MIXER_1, WM8994_DAC1L_TO_MIXOUTL);
+	wm8994_write(codec, WM8994_OUTPUT_MIXER_2, WM8994_DAC1R_TO_MIXOUTR );
+
+	// Analogue Output Configuration
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_3,
+		WM8994_MIXOUTLVOL_ENA | WM8994_MIXOUTRVOL_ENA |WM8994_MIXOUTL_ENA | WM8994_MIXOUTR_ENA);
+	wm8994_write(codec, WM8994_HPOUT2_MIXER, WM8994_MIXOUTLVOL_TO_HPOUT2 |WM8994_MIXOUTRVOL_TO_HPOUT2);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1,
+		WM8994_HPOUT2_ENA | WM8994_VMID_SEL_NORMAL | WM8994_BIAS_ENA);
+
+	//	wm8994_write(codec, WM8994_INPUT_MIXER_4, 0x0000 );
+}
+
+
+void wm8994_set_voicecall_headphone(struct snd_soc_codec *codec)
+{
+
+	int val;
+
+	u16 TestReturn1=0;
+	u16 TestReturn2=0;
+	u16 TestLow1=0;
+	u16 TestHigh1=0;
+	u8 TestLow=0;
+	u8 TestHigh=0;
+
+	DEBUG_LOG("");
+
+	audio_ctrl_mic_bias_gpio(1);
+
+	wm8994_set_voicecall_common_setting(codec);
+
+	/*Digital Path Enables and Unmutes*/
+	wm8994_write(codec, WM8994_DAC2_LEFT_MIXER_ROUTING, WM8994_ADC1_TO_DAC2L);
+	wm8994_write(codec,WM8994_DAC2_MIXER_VOLUMES, 0x000C );
+	wm8994_write(codec,WM8994_SIDETONE, 0x01C0);
+
+	/*Analogue Input Configuration*/
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_2, 0x6240 );
+
+	{
+		wm8994_write(codec,WM8994_LEFT_LINE_INPUT_1_2_VOLUME,0x0111);
+		wm8994_write(codec,WM8994_INPUT_MIXER_3 ,0x0030);
+	}
+
+	wm8994_write(codec,WM8994_INPUT_MIXER_2, 0x0030 );
+
+	/* Unmute*/
+	{
+		wm8994_write(codec,WM8994_LEFT_OPGA_VOLUME, 0x0071 );
+		wm8994_write(codec,WM8994_RIGHT_OPGA_VOLUME, 0x0171 );
+	}
+
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_4, 0x3003 );
+
+	val = wm8994_read(codec, 0x102 );
+	val &= ~(0x0003);
+	val = 0x0003;
+	wm8994_write(codec,0x102,val);
+
+	val = wm8994_read(codec, 0x56 );
+	val &= ~(0x0003);
+	val = 0x0003;
+	wm8994_write(codec,0x56,val);
+
+	val = wm8994_read(codec, 0x102 );
+	val &= ~(0x0000);
+	val = 0x0000;
+	wm8994_write(codec,0x102,val);
+
+	val = wm8994_read(codec, WM8994_CLASS_W_1 );
+	val &= ~(0x0005);
+	val |= 0x0005;
+	wm8994_write(codec,WM8994_CLASS_W_1,val);
+
+	{
+		val = wm8994_read(codec,WM8994_LEFT_OUTPUT_VOLUME);
+		val &= ~(WM8994_HPOUT1L_MUTE_N_MASK | WM8994_HPOUT1L_VOL_MASK);
+		val |= (WM8994_HPOUT1L_MUTE_N | TUNING_CALL_OUTPUTL_VOL);
+		wm8994_write(codec, WM8994_LEFT_OUTPUT_VOLUME, val);
+
+		val = wm8994_read(codec,WM8994_RIGHT_OUTPUT_VOLUME);
+		val &= ~(WM8994_HPOUT1R_MUTE_N_MASK | WM8994_HPOUT1R_VOL_MASK);
+		val |= (WM8994_HPOUT1_VU | WM8994_HPOUT1R_MUTE_N | TUNING_CALL_OUTPUTR_VOL);
+		wm8994_write(codec, WM8994_RIGHT_OUTPUT_VOLUME, val);
+	}
+
+	val = wm8994_read(codec, WM8994_DC_SERVO_2 );
+	val &= ~(0x03E0);
+	val = 0x03E0;
+	wm8994_write(codec,WM8994_DC_SERVO_2,val);
+
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_1, 0x0303 );
+
+	wm8994_write(codec,WM8994_ANALOGUE_HP_1, 0x0022 );
+	wm8994_write(codec,WM8994_CHARGE_PUMP_1, 0x9F25 );
+
+	msleep(5);
+
+	/*Analogue Output Configuration*/
+	wm8994_write(codec,WM8994_OUTPUT_MIXER_1, 0x0001 );
+	wm8994_write(codec,WM8994_OUTPUT_MIXER_2, 0x0001 );
+
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_3, 0x0030 );
+
+	wm8994_write(codec, WM8994_AIF2_CLOCKING_1, 0x0019);
+
+	wm8994_write(codec,WM8994_DC_SERVO_1, 0x303);
+
+	msleep(160);	// 160ms delay
+
+	TestReturn1=wm8994_read(codec,WM8994_DC_SERVO_4);
+
+	TestLow=(signed char)(TestReturn1 & 0xff);
+	TestHigh=(signed char)((TestReturn1>>8) & 0xff);
+
+	TestLow1=((signed short)TestLow-5)&0x00ff;
+	TestHigh1=(((signed short)(TestHigh-5)<<8)&0xff00);
+	TestReturn2=TestLow1|TestHigh1;
+	wm8994_write(codec,WM8994_DC_SERVO_4, TestReturn2);
+
+	val = wm8994_read(codec, WM8994_DC_SERVO_1 );
+	val &= ~(0x000F);
+	val = 0x000F;
+	wm8994_write(codec,WM8994_DC_SERVO_1,val);
+
+	msleep(15);
+
+	wm8994_write(codec,WM8994_ANALOGUE_HP_1, 0x00EE );
+
+	//Unmute DAC1 left
+	val = wm8994_read(codec,WM8994_DAC1_LEFT_VOLUME );
+	val &= ~(WM8994_DAC1L_MUTE_MASK | WM8994_DAC1L_VOL_MASK);
+	val |= (TUNING_DAC1L_VOL);
+	wm8994_write(codec,WM8994_DAC1_LEFT_VOLUME ,val);
+
+	//Unmute and volume ctrl RightDAC
+	val = wm8994_read(codec, WM8994_DAC1_RIGHT_VOLUME );
+	val &= ~(WM8994_DAC1R_MUTE_MASK | WM8994_DAC1R_VOL_MASK);
+	val |= (WM8994_DAC1_VU | TUNING_DAC1R_VOL); //0 db volume
+	wm8994_write(codec,WM8994_DAC1_RIGHT_VOLUME,val);
+
+	wm8994_write(codec,WM8994_DAC2_LEFT_VOLUME, 0x01C0 );
+
+	wm8994_write(codec,WM8994_AIF1_DAC1_FILTERS_1, 0x0000 );
+	wm8994_write(codec,WM8994_AIF2_DAC_FILTERS_1, 0x0000 );
+
+	wm8994_call_recording_change_path(codec);
+
+}
+
+void wm8994_set_voicecall_headset(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+	int val;
+	u16 TestReturn1=0;
+	u16 TestReturn2=0;
+	u16 TestLow1=0;
+	u16 TestHigh1=0;
+	u8 TestLow=0;
+	u8 TestHigh=0;
+
+	DEBUG_LOG("");
+
+	audio_ctrl_mic_bias_gpio(0);
+	audio_ctrl_earmic_bias_gpio(1);
+
+	wm8994_set_voicecall_common_setting(codec);
+
+	/*Digital Path Enables and Unmutes*/
+	wm8994_write(codec, WM8994_DAC2_LEFT_MIXER_ROUTING, WM8994_ADC2_TO_DAC2L);

+	wm8994_write(codec,WM8994_DAC2_MIXER_VOLUMES, 0x0180 );  

+	wm8994_write(codec,WM8994_SIDETONE, 0x01C0);

+

+	/*Analogue Input Configuration*/
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_2);
+	val &= ~(WM8994_TSHUT_ENA_MASK|WM8994_TSHUT_OPDIS_MASK|WM8994_MIXINR_ENA_MASK|WM8994_IN1R_ENA_MASK);
+	val |= (WM8994_TSHUT_ENA|WM8994_TSHUT_OPDIS|WM8994_MIXINR_ENA|WM8994_IN1R_ENA);
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_2, 0x6110 );
+
+	if(wm8994->testmode_config_flag == SEC_NORMAL)

+	{
+		val = wm8994_read(codec,WM8994_RIGHT_LINE_INPUT_1_2_VOLUME);
+		val &= ~(WM8994_IN1R_MUTE_MASK | WM8994_IN1R_VOL_MASK); // Unmute IN1R
+		val |= (WM8994_IN1R_VU | TUNING_CALL_EAR_INPUTMIX_VOL);
+		wm8994_write(codec,WM8994_RIGHT_LINE_INPUT_1_2_VOLUME,val);
+
+		// unmute right pga, set volume
+		val = wm8994_read(codec,WM8994_INPUT_MIXER_4 );
+		val&= ~(WM8994_IN1R_TO_MIXINR_MASK | WM8994_IN1R_MIXINR_VOL_MASK | WM8994_MIXOUTR_MIXINR_VOL_MASK);
+		val |= (WM8994_IN1R_TO_MIXINR);//0db
+		wm8994_write(codec,WM8994_INPUT_MIXER_4 ,val);
+	}
+
+	val = wm8994_read(codec,WM8994_INPUT_MIXER_2 );
+	val&= ~(WM8994_IN1RP_TO_IN1R_MASK |  WM8994_IN1RN_TO_IN1R_MASK);
+	val |= (WM8994_IN1RP_TO_IN1R|WM8994_IN1RN_TO_IN1R);//0db
+	wm8994_write(codec,WM8994_INPUT_MIXER_2, 0x0003 );
+
+	/* Unmute*/
+	if(wm8994->testmode_config_flag == SEC_NORMAL)

+	{
+		val = wm8994_read(codec, WM8994_LEFT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTL_MUTE_N_MASK | WM8994_MIXOUTL_VOL_MASK);
+		val |= (WM8994_MIXOUTL_MUTE_N | TUNING_CALL_OPGAL_VOL);
+		wm8994_write(codec,WM8994_LEFT_OPGA_VOLUME, val );
+
+		val = wm8994_read(codec, WM8994_RIGHT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTR_MUTE_N_MASK | WM8994_MIXOUTR_VOL_MASK);
+		val |= (WM8994_MIXOUT_VU | WM8994_MIXOUTR_MUTE_N | TUNING_CALL_OPGAR_VOL);
+		wm8994_write(codec,WM8994_RIGHT_OPGA_VOLUME, val );
+	}
+
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_4, 0x2001 );
+
+	val = wm8994_read(codec, 0x102 );
+	val &= ~(0x0003);
+	val = 0x0003;
+	wm8994_write(codec,0x102,val);
+
+	val = wm8994_read(codec, 0x56 );
+	val &= ~(0x0003);
+	val = 0x0003;
+	wm8994_write(codec,0x56,val);
+
+	val = wm8994_read(codec, 0x102 );
+	val &= ~(0x0000);
+	val = 0x0000;
+	wm8994_write(codec,0x102,val);
+
+	val = wm8994_read(codec, WM8994_CLASS_W_1 );
+	val &= ~(0x0005);
+	val |= 0x0005;
+	wm8994_write(codec,WM8994_CLASS_W_1,val);
+
+	if(wm8994->testmode_config_flag == SEC_NORMAL)

+	{
+		val = wm8994_read(codec,WM8994_LEFT_OUTPUT_VOLUME);
+		val &= ~(WM8994_HPOUT1L_MUTE_N_MASK | WM8994_HPOUT1L_VOL_MASK);
+		val |= (WM8994_HPOUT1L_MUTE_N | TUNING_CALL_OUTPUTL_VOL);
+		wm8994_write(codec, WM8994_LEFT_OUTPUT_VOLUME, val);
+
+		val = wm8994_read(codec,WM8994_RIGHT_OUTPUT_VOLUME);
+		val &= ~(WM8994_HPOUT1R_MUTE_N_MASK | WM8994_HPOUT1R_VOL_MASK);
+		val |= (WM8994_HPOUT1_VU | WM8994_HPOUT1R_MUTE_N | TUNING_CALL_OUTPUTR_VOL);
+		wm8994_write(codec, WM8994_RIGHT_OUTPUT_VOLUME, val);
+	}
+
+	val = wm8994_read(codec, WM8994_DC_SERVO_2 );
+	val &= ~(0x03E0);
+	val = 0x03E0;
+	wm8994_write(codec,WM8994_DC_SERVO_2,val);
+
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_1, 0x0303 );
+
+	wm8994_write(codec,WM8994_ANALOGUE_HP_1, 0x0022 );
+	wm8994_write(codec,WM8994_CHARGE_PUMP_1, 0x9F25 );
+
+	msleep(5);
+
+	/*Analogue Output Configuration*/
+	wm8994_write(codec,WM8994_OUTPUT_MIXER_1, 0x0001 );
+	wm8994_write(codec,WM8994_OUTPUT_MIXER_2, 0x0001 );
+
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_3, 0x0030 );
+
+	wm8994_write(codec, WM8994_AIF2_CLOCKING_1, 0x0019);
+
+	wm8994_write(codec,WM8994_DC_SERVO_1, 0x303);
+
+	msleep(160);	// 160ms delay
+
+	TestReturn1=wm8994_read(codec,WM8994_DC_SERVO_4);
+
+	TestLow=(signed char)(TestReturn1 & 0xff);
+	TestHigh=(signed char)((TestReturn1>>8) & 0xff);
+
+	TestLow1=((signed short)TestLow-5)&0x00ff;
+	TestHigh1=(((signed short)(TestHigh-5)<<8)&0xff00);
+	TestReturn2=TestLow1|TestHigh1;
+	wm8994_write(codec,WM8994_DC_SERVO_4, TestReturn2);
+
+	val = wm8994_read(codec, WM8994_DC_SERVO_1 );
+	val &= ~(0x000F);
+	val = 0x000F;
+	wm8994_write(codec,WM8994_DC_SERVO_1,val);
+
+	msleep(15);
+
+	wm8994_write(codec,WM8994_ANALOGUE_HP_1, 0x00EE );
+
+	//Unmute DAC1 left
+	val = wm8994_read(codec,WM8994_DAC1_LEFT_VOLUME );
+	val &= ~(WM8994_DAC1L_MUTE_MASK | WM8994_DAC1L_VOL_MASK);
+	val |= (TUNING_DAC1L_VOL);
+	wm8994_write(codec,WM8994_DAC1_LEFT_VOLUME ,val);
+
+	//Unmute and volume ctrl RightDAC
+	val = wm8994_read(codec, WM8994_DAC1_RIGHT_VOLUME );
+	val &= ~(WM8994_DAC1R_MUTE_MASK | WM8994_DAC1R_VOL_MASK);
+	val |= (WM8994_DAC1_VU | TUNING_DAC1R_VOL); //0 db volume
+	wm8994_write(codec,WM8994_DAC1_RIGHT_VOLUME,val);
+
+	wm8994_write(codec,WM8994_DAC2_LEFT_VOLUME, 0x01C0 );
+
+	wm8994_write(codec,WM8994_AIF1_DAC1_FILTERS_1, 0x0000 );
+	wm8994_write(codec,WM8994_AIF2_DAC_FILTERS_1, 0x0000 );
+
+	if(wm8994->testmode_config_flag == SEC_TEST_PBA_LOOPBACK)
+	{
+		DEBUG_LOG("SEC_TEST_PBA_LOOPBACK");
+
+		val = wm8994_read(codec,WM8994_RIGHT_LINE_INPUT_1_2_VOLUME);
+		val &= ~(WM8994_IN1R_MUTE_MASK | WM8994_IN1R_VOL_MASK); // Unmute IN1R
+		val |= (WM8994_IN1R_VU | TUNING_LOOPBACK_EAR_INPUTMIX_VOL);
+#if defined(CONFIG_PHONE_P1_GSM)
+		wm8994_write(codec,WM8994_RIGHT_LINE_INPUT_1_2_VOLUME,val);
+#elif defined(CONFIG_PHONE_P1_CDMA)
+		wm8994_write(codec,WM8994_RIGHT_LINE_INPUT_1_2_VOLUME,0x010B);
+#endif
+
+		// unmute right pga, set volume
+		val = wm8994_read(codec,WM8994_INPUT_MIXER_4 );
+		val&= ~(WM8994_IN1R_TO_MIXINR_MASK | WM8994_IN1R_MIXINR_VOL_MASK | WM8994_MIXOUTR_MIXINR_VOL_MASK);
+		val |= (WM8994_IN1R_TO_MIXINR);//0db
+		wm8994_write(codec,WM8994_INPUT_MIXER_4 ,val);
+
+		val = wm8994_read(codec, WM8994_LEFT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTL_MUTE_N_MASK | WM8994_MIXOUTL_VOL_MASK);
+		val |= (WM8994_MIXOUTL_MUTE_N | TUNING_LOOPBACK_OPGAL_VOL);
+		wm8994_write(codec,WM8994_LEFT_OPGA_VOLUME, val );
+
+		val = wm8994_read(codec, WM8994_RIGHT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTR_MUTE_N_MASK | WM8994_MIXOUTR_VOL_MASK);
+		val |= (WM8994_MIXOUT_VU | WM8994_MIXOUTR_MUTE_N | TUNING_LOOPBACK_OPGAR_VOL);
+		wm8994_write(codec,WM8994_RIGHT_OPGA_VOLUME, val );
+
+		val = wm8994_read(codec,WM8994_LEFT_OUTPUT_VOLUME);
+		val &= ~(WM8994_HPOUT1L_MUTE_N_MASK | WM8994_HPOUT1L_VOL_MASK);
+		val |= (WM8994_HPOUT1L_MUTE_N | TUNING_LOOPBACK_OUTPUTL_VOL);
+#if defined(CONFIG_PHONE_P1_GSM)
+		wm8994_write(codec, WM8994_LEFT_OUTPUT_VOLUME, val);
+#elif defined(CONFIG_PHONE_P1_CDMA)
+		wm8994_write(codec, WM8994_LEFT_OUTPUT_VOLUME, 0x007F);
+#endif
+
+		val = wm8994_read(codec,WM8994_RIGHT_OUTPUT_VOLUME);
+		val &= ~(WM8994_HPOUT1R_MUTE_N_MASK | WM8994_HPOUT1R_VOL_MASK);
+		val |= (WM8994_HPOUT1_VU | WM8994_HPOUT1R_MUTE_N | TUNING_LOOPBACK_OUTPUTR_VOL);
+#if defined(CONFIG_PHONE_P1_GSM)
+		wm8994_write(codec, WM8994_RIGHT_OUTPUT_VOLUME, val);
+#elif defined(CONFIG_PHONE_P1_CDMA)
+		wm8994_write(codec, WM8994_RIGHT_OUTPUT_VOLUME, 0x017F);
+#endif
+	}
+
+
+    wm8994_call_recording_change_path(codec);

+
+

+}
+
+void wm8994_set_voicecall_speaker(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	int val;
+
+	DEBUG_LOG("");
+
+	audio_ctrl_mic_bias_gpio(1);
+
+	wm8994_set_voicecall_common_setting(codec);
+
+	wm8994_write(codec,0x601, 0x0005 );
+	wm8994_write(codec,0x602, 0x0005 );
+	wm8994_write(codec,0x603, 0x000C );
+	// Tx -> AIF2 Path
+	wm8994_write(codec, WM8994_DAC2_LEFT_MIXER_ROUTING, WM8994_ADC1_TO_DAC2L);
+
+	/*Analogue Input Configuration*/
+	wm8994_write(codec,0x02, 0x6240 );/*wm8994_write(codec,WM8994_POWER_MANAGEMENT_2, WM8994_TSHUT_ENA|WM8994_TSHUT_OPDIS|WM8994_MIXINL_ENA|WM8994_IN1L_ENA );*/
+	wm8994_write(codec, WM8994_INPUT_MIXER_2, WM8994_IN1LP_TO_IN1L | WM8994_IN1LN_TO_IN1L); 	// differential(3) or single ended(1)
+
+	if((wm8994->testmode_config_flag == SEC_NORMAL)
+		|| (wm8994->testmode_config_flag == SEC_TEST_PBA_LOOPBACK))
+	{
+		// Volume Control - Input
+		val = wm8994_read(codec, WM8994_INPUT_MIXER_3);
+		val&= ~(WM8994_IN1L_TO_MIXINL_MASK | WM8994_IN1L_MIXINL_VOL_MASK | WM8994_MIXOUTL_MIXINL_VOL_MASK);
+		val |= (WM8994_IN1L_TO_MIXINL | TUNING_CALL_SPK_MIXER_VOL);//0db
+		wm8994_write(codec, WM8994_INPUT_MIXER_3, val);
+
+		val = wm8994_read(codec, WM8994_LEFT_LINE_INPUT_1_2_VOLUME );
+		val &= ~(WM8994_IN1L_MUTE_MASK | WM8994_IN1L_VOL_MASK); // Unmute IN1L
+		val |= (WM8994_IN1L_VU | TUNING_CALL_SPK_INPUTMIX_VOL);
+		wm8994_write(codec, WM8994_LEFT_LINE_INPUT_1_2_VOLUME , val);
+	}
+
+	/*Analogue Output Configuration*/
+	wm8994_write(codec,0x03, 0x0300 );
+
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_4, WM8994_AIF2ADCL_ENA | WM8994_ADCL_ENA);
+
+	wm8994_write(codec, WM8994_AIF2_CLOCKING_1, 0x0019);
+
+	if((wm8994->testmode_config_flag == SEC_NORMAL)

+		|| (wm8994->testmode_config_flag == SEC_TEST_PBA_LOOPBACK)

+	)

+	{
+		// Volume Control - Output
+		// Unmute the SPKMIXVOLUME
+		val = wm8994_read(codec, WM8994_SPKMIXL_ATTENUATION);
+		val &= ~(WM8994_SPKMIXL_VOL_MASK);
+		val |= TUNING_SPKMIXL_ATTEN;
+		wm8994_write(codec, WM8994_SPKMIXL_ATTENUATION, val);
+
+		val = wm8994_read(codec,WM8994_SPKMIXR_ATTENUATION);
+		val &= ~(WM8994_SPKMIXR_VOL_MASK);
+		val |= TUNING_SPKMIXR_ATTEN;
+		wm8994_write(codec, WM8994_SPKMIXR_ATTENUATION, val);
+
+
+		val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_3 );
+		val &= ~( WM8994_SPKLVOL_ENA_MASK | WM8994_SPKRVOL_ENA_MASK  );
+		val |= WM8994_SPKLVOL_ENA | WM8994_SPKRVOL_ENA;
+		wm8994_write(codec,WM8994_POWER_MANAGEMENT_3 ,val);
+
+		val = wm8994_read(codec,WM8994_SPEAKER_VOLUME_LEFT);
+		val &= ~(WM8994_SPKOUTL_MUTE_N_MASK | WM8994_SPKOUTL_VOL_MASK);
+		val |= (WM8994_SPKOUTL_MUTE_N | TUNING_CALL_SPKL_VOL);
+		wm8994_write(codec, WM8994_SPEAKER_VOLUME_LEFT, val);
+
+		val = wm8994_read(codec,WM8994_SPEAKER_VOLUME_RIGHT);
+		val &= ~(WM8994_SPKOUTR_MUTE_N_MASK | WM8994_SPKOUTR_VOL_MASK);
+		val |= (WM8994_SPKOUT_VU | WM8994_SPKOUTR_MUTE_N | TUNING_CALL_SPKR_VOL);
+		wm8994_write(codec, WM8994_SPEAKER_VOLUME_RIGHT, val);
+
+		wm8994_write(codec, WM8994_CLASSD, TUNING_CALL_CLASSD_VOL);
+	}
+
+	//Unmute the DAC path
+	val = wm8994_read(codec,WM8994_SPEAKER_MIXER );
+	val &= ~(WM8994_DAC1L_TO_SPKMIXL_MASK | WM8994_DAC1R_TO_SPKMIXR_MASK);
+	val |= ( WM8994_DAC1L_TO_SPKMIXL | WM8994_DAC1R_TO_SPKMIXR );
+	wm8994_write(codec,WM8994_SPEAKER_MIXER ,val);
+
+	val = wm8994_read(codec,WM8994_SPKOUT_MIXERS );
+	val &= ~(WM8994_SPKMIXL_TO_SPKOUTL_MASK |
+		WM8994_SPKMIXR_TO_SPKOUTL_MASK | WM8994_SPKMIXR_TO_SPKOUTR_MASK);
+	val |= WM8994_SPKMIXL_TO_SPKOUTL;
+	val |= WM8994_SPKMIXR_TO_SPKOUTR;
+	wm8994_write(codec,WM8994_SPKOUT_MIXERS,val );
+
+	wm8994_write(codec,0x36, 0x0003 );
+	/* Digital Path Enables and Unmutes*/
+
+	wm8994_write(codec,WM8994_SIDETONE, 0x01C0 );
+
+
+	wm8994_write(codec, WM8994_ANALOGUE_HP_1,0x0000);
+	wm8994_write(codec, WM8994_DC_SERVO_1,0x0000);
+
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1 );
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK |WM8994_SPKOUTL_ENA_MASK | WM8994_SPKOUTR_ENA_MASK);
+#if defined(CONFIG_PHONE_P1_GSM)
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL | WM8994_SPKOUTL_ENA | WM8994_SPKOUTR_ENA);
+#elif defined(CONFIG_PHONE_P1_CDMA)
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL | WM8994_SPKOUTL_ENA);
+#endif
+	wm8994_write(codec,WM8994_POWER_MANAGEMENT_1,val);
+
+	if((wm8994->testmode_config_flag == SEC_NORMAL)

+		|| (wm8994->testmode_config_flag == SEC_TEST_PBA_LOOPBACK)

+	)

+	{
+		//Unmute DAC1 left
+		val = wm8994_read(codec,WM8994_DAC1_LEFT_VOLUME );
+		val &= ~(WM8994_DAC1L_MUTE_MASK | WM8994_DAC1L_VOL_MASK);
+		val |= (TUNING_DAC1L_VOL);

+		wm8994_write(codec,WM8994_DAC1_LEFT_VOLUME ,val);
+
+		//Unmute and volume ctrl RightDAC
+		val = wm8994_read(codec, WM8994_DAC1_RIGHT_VOLUME );
+		val &= ~(WM8994_DAC1R_MUTE_MASK | WM8994_DAC1R_VOL_MASK);
+		val |= (WM8994_DAC1_VU | TUNING_DAC1R_VOL); //0 db volume	

+		wm8994_write(codec,WM8994_DAC1_RIGHT_VOLUME,val);
+	}
+
+	wm8994_write(codec,WM8994_DAC2_LEFT_VOLUME, 0x01C0 );
+	wm8994_write(codec,WM8994_AIF2_DAC_FILTERS_1, WM8994_AIF1DAC1_UNMUTE );
+	wm8994_write(codec,WM8994_AIF1_DAC1_FILTERS_1, WM8994_AIF1DAC2_UNMUTE );
+
+	wm8994_call_recording_change_path(codec);
+}
+
+void wm8994_set_voicecall_bluetooth(struct snd_soc_codec *codec)
+{
+#if defined(CONFIG_PHONE_P1_GSM)
+	int val;
+
+	wm8994_set_voicecall_common_setting(codec);
+
+	/*GPIO Configuration*/
+	wm8994_write(codec, WM8994_GPIO_8, WM8994_GP8_DIR | WM8994_GP8_DB);
+	wm8994_write(codec, WM8994_GPIO_9, WM8994_GP9_DB);
+	wm8994_write(codec, WM8994_GPIO_10, WM8994_GP10_DB);
+	wm8994_write(codec, WM8994_GPIO_11, WM8994_GP11_DB);
+
+	/*Digital Path Enables and Unmutes*/
+	val  = wm8994_read(codec, WM8994_POWER_MANAGEMENT_1);
+	val &= ~(WM8994_SPKOUTL_ENA_MASK | WM8994_SPKOUTR_ENA_MASK | WM8994_HPOUT2_ENA_MASK | WM8994_HPOUT1L_ENA_MASK | WM8994_HPOUT1R_ENA_MASK);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_4, WM8994_AIF2ADCL_ENA | WM8994_ADCL_ENA);
+
+	// If Input MIC is enabled, bluetooth Rx is muted.
+	wm8994_write(codec, WM8994_LEFT_LINE_INPUT_1_2_VOLUME, WM8994_IN1L_MUTE);
+	wm8994_write(codec, WM8994_RIGHT_LINE_INPUT_1_2_VOLUME, WM8994_IN1R_MUTE);
+	wm8994_write(codec, WM8994_INPUT_MIXER_2, 0x00);
+	wm8994_write(codec, WM8994_INPUT_MIXER_3, 0x00);
+	wm8994_write(codec, WM8994_INPUT_MIXER_4, 0x00);
+
+	//for BT DTMF Play
+	//Rx Path: AIF2ADCDAT2 select
+	//CP(CALL) Path:GPIO5/DACDAT2 select
+	//AP(DTMF) Path: DACDAT1 select
+	//Tx Path: GPIO8/DACDAT3 select
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_6, 0x000C);
+
+	// AIF1 & AIF2 Output is connected to DAC1
+	wm8994_write(codec, WM8994_DAC2_LEFT_MIXER_ROUTING, WM8994_AIF2DACL_TO_DAC2L | WM8994_AIF1DAC1L_TO_DAC2L);
+	wm8994_write(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING, WM8994_AIF2DACR_TO_DAC2R | WM8994_AIF1DAC1R_TO_DAC2R);
+
+	wm8994_write(codec, WM8994_AIF2_CLOCKING_1, 0x0019);
+
+	wm8994_write(codec, WM8994_DAC2_MIXER_VOLUMES, 0x000C);
+
+	wm8994_write(codec, WM8994_DAC2_LEFT_VOLUME, 0x01C0);
+	wm8994_write(codec, WM8994_DAC2_RIGHT_VOLUME, 0x01C0);
+
+	wm8994_write(codec, WM8994_OVERSAMPLING, 0X0000);
+
+	//Unmute DAC1 left
+	val = wm8994_read(codec,WM8994_DAC1_LEFT_VOLUME );
+	val &= ~(WM8994_DAC1L_MUTE_MASK | WM8994_DAC1L_VOL_MASK);
+	val |= (TUNING_DAC1L_VOL);
+	wm8994_write(codec,WM8994_DAC1_LEFT_VOLUME ,val);
+
+	//Unmute and volume ctrl RightDAC
+	val = wm8994_read(codec, WM8994_DAC1_RIGHT_VOLUME );
+	val &= ~(WM8994_DAC1R_MUTE_MASK | WM8994_DAC1R_VOL_MASK);
+	val |= (WM8994_DAC1_VU | TUNING_DAC1R_VOL); //0 db volume
+	wm8994_write(codec,WM8994_DAC1_RIGHT_VOLUME,val);
+
+	wm8994_write(codec, WM8994_AIF1_DAC1_FILTERS_1, 0x0000);
+	wm8994_write(codec, WM8994_AIF2_DAC_FILTERS_1, 0x0000);
+#elif defined(CONFIG_PHONE_P1_CDMA)
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, 0x0007); 	//fast vmid
+	msleep(50);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, 0x0003); 	//normal vmid
+
+	/*Digital Path Enables and Unmutes*/
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_2, 0x00);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, 0x00);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_4, 0x3000);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_5,
+		WM8994_AIF2DACL_ENA | WM8994_AIF2DACR_ENA | WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA| WM8994_DAC2L_ENA | WM8994_DAC2R_ENA);
+	//for BT DTMF Play
+	//Rx Path: AIF2ADCDAT2 select
+	//CP(CALL) Path:GPIO5/DACDAT2 select
+	//AP(DTMF) Path: DACDAT1 select
+	//Tx Path: GPIO8/DACDAT3 select
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_6, 0x0003<<WM8994_AIF2_ADCDAT_SRC_SHIFT);
+
+	wm8994_write(codec, WM8994_AIF2_DAC_FILTERS_1, 0x00 );
+
+	wm8994_write(codec, WM8994_DAC2_LEFT_MIXER_ROUTING, WM8994_AIF2DACL_TO_DAC2L | WM8994_AIF1DAC1L_TO_DAC2L);
+	wm8994_write(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING, WM8994_AIF2DACR_TO_DAC2R | WM8994_AIF1DAC1R_TO_DAC2R);
+
+	wm8994_write(codec, WM8994_DAC2_LEFT_VOLUME, 0x1C0 );
+	wm8994_write(codec, WM8994_DAC2_RIGHT_VOLUME, 0x1C0 );
+
+	/*Clocking*/
+	wm8994_write(codec, WM8994_CLOCKING_1, WM8994_DSP_FS1CLK_ENA | WM8994_DSP_FS2CLK_ENA | WM8994_DSP_FSINTCLK_ENA);
+	wm8994_write(codec, WM8994_AIF2_RATE, 0x0003<<WM8994_AIF2CLK_RATE_SHIFT);	//8kHz
+
+	/*AIF1Interface*/
+	wm8994_write(codec, WM8994_AIF1_CONTROL_2, 0x0000); //Left & Right DAC receives left interface data
+	wm8994_write(codec, WM8994_AIF1_MASTER_SLAVE, WM8994_AIF1_MSTR | WM8994_AIF1_CLK_FRC | WM8994_AIF1_LRCLK_FRC);	// Master mode
+
+	/*AIF2 Interface*/
+	wm8994_write(codec, WM8994_AIF2_CONTROL_2, 0x0000); //Left & Right DAC receives left interface data
+	wm8994_write(codec, WM8994_AIF2_MASTER_SLAVE, WM8994_AIF2_MSTR | WM8994_AIF2_CLK_FRC | WM8994_AIF2_LRCLK_FRC);	// Master mode
+	wm8994_write(codec, WM8994_AIF2_CONTROL_1,	//Left Justified, BCLK invert, LRCLK Invert
+		WM8994_AIF2ADCR_SRC | WM8994_AIF2_BCLK_INV |WM8994_AIF2_LRCLK_INV | 0x1 << WM8994_AIF2_FMT_SHIFT);
+
+	wm8994_write(codec, WM8994_OVERSAMPLING, 0X0000);
+
+	/*FLL2	Setting*/
+	wm8994_write(codec, WM8994_FLL2_CONTROL_2, 0x2F00); // REG 221 FLL1 Cntr2, FLL1 Setting
+	wm8994_write(codec, WM8994_FLL2_CONTROL_3, 0x3126); // REG 222 FLL1 Cntr3, K Value
+	wm8994_write(codec, WM8994_FLL2_CONTROL_4, 0x0100); // REG 223 FLL1 Cntr4, N Value
+	wm8994_write(codec, WM8994_FLL2_CONTROL_5, 0x0C88); // REG 224 FLL1 Cntr5
+	wm8994_write(codec, WM8994_AIF2_CLOCKING_1, 0x0019);	// REG 200 Enable AIF1 Clock, AIF1 Clock Source = FLL1
+	wm8994_write(codec, WM8994_FLL2_CONTROL_1, WM8994_FLL2_FRACN_ENA | WM8994_FLL2_ENA);
+
+	/*GPIO Configuration*/
+	wm8994_write(codec, WM8994_GPIO_1, 0xA101);
+	wm8994_write(codec, WM8994_GPIO_3, WM8994_GP3_DIR | WM8994_GP3_DB);
+	wm8994_write(codec, WM8994_GPIO_4, WM8994_GP4_DIR | WM8994_GP4_DB);
+	wm8994_write(codec, WM8994_GPIO_5, WM8994_GP5_DIR | WM8994_GP5_DB);
+	wm8994_write(codec, WM8994_GPIO_6, WM8994_GP6_DIR | WM8994_GP6_PD | WM8994_GP6_DB |0x1 << WM8994_GP6_FN_SHIFT);
+	wm8994_write(codec, WM8994_GPIO_7, WM8994_GP7_DB);
+	wm8994_write(codec, WM8994_GPIO_8, WM8994_GP8_DIR | WM8994_GP8_DB);
+	wm8994_write(codec, WM8994_GPIO_9, WM8994_GP9_DB);
+	wm8994_write(codec, WM8994_GPIO_10, WM8994_GP10_DB);
+	wm8994_write(codec, WM8994_GPIO_11, WM8994_GP11_DB);
+#endif
+}
+
+
+void wm8994_set_voicecall_record(struct snd_soc_codec *codec, int channel)
+{
+		struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+        u16 val;
+
+        DEBUG_LOG("channel = [%d]", channel);
+
+
+        if(wm8994 ->call_record_path == CALL_RECORDING_MAIN )
+        {
+                switch(channel)
+                {
+                        case CH_UDLINK:  //TxRx
+                                val = wm8994_read(codec,WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING );
+                                val &= ~( WM8994_ADC1L_TO_AIF1ADC1L_MASK | WM8994_AIF2DACL_TO_AIF1ADC1L_MASK);
+                                val |= (WM8994_ADC1L_TO_AIF1ADC1L | WM8994_AIF2DACL_TO_AIF1ADC1L );
+                                wm8994_write(codec,WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING ,val);
+
+                                val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_4);
+                                val &= ~( WM8994_AIF1ADC1L_ENA_MASK | WM8994_AIF1ADC1R_ENA_MASK);
+                                val |= ( WM8994_AIF1ADC1L_ENA|WM8994_AIF1ADC1R_ENA);
+                                wm8994_write(codec,WM8994_POWER_MANAGEMENT_4,val);
+
+                                wm8994_write(codec,0x300,0x4010);
+
+                                wm8994_write(codec,0x400,0x00C0);	// AIF1 INPUT VOLUME : 0x00C0:0db
+                        break;
+
+                        case CH_UPLINK:  //Tx only
+                                val = wm8994_read(codec,WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING );
+                                val &= ~( WM8994_ADC1L_TO_AIF1ADC1L_MASK | WM8994_AIF2DACL_TO_AIF1ADC1L_MASK);
+                                val |= (WM8994_ADC1L_TO_AIF1ADC1L);
+                                wm8994_write(codec,WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING ,val);
+
+                                val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_4);
+                                val &= ~( WM8994_AIF1ADC1L_ENA_MASK | WM8994_AIF1ADC1R_ENA_MASK);
+                                val |= ( WM8994_AIF1ADC1L_ENA|WM8994_AIF1ADC1R_ENA);
+                                wm8994_write(codec,WM8994_POWER_MANAGEMENT_4,val);
+
+                                wm8994_write(codec,0x300,0x4010);
+
+                                wm8994_write(codec,0x400,0x00C0);	// AIF1 INPUT VOLUME : 0x00C0:0db
+                        break;
+
+                        case CH_DOWNLINK:  //Rx only
+                                val = wm8994_read(codec,WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING );
+                                val &= ~( WM8994_ADC1L_TO_AIF1ADC1L_MASK | WM8994_AIF2DACL_TO_AIF1ADC1L_MASK);
+                                val |= (WM8994_AIF2DACL_TO_AIF1ADC1L );
+                                wm8994_write(codec,WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING ,val);
+
+                                val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_4);
+                                val &= ~( WM8994_AIF1ADC1L_ENA_MASK | WM8994_AIF1ADC1R_ENA_MASK);
+                                val |= ( WM8994_AIF1ADC1L_ENA|WM8994_AIF1ADC1R_ENA);
+                                wm8994_write(codec,WM8994_POWER_MANAGEMENT_4,val);
+
+                                wm8994_write(codec,0x300,0x4010);
+
+                                wm8994_write(codec,0x400,0x00C0);	// AIF1 INPUT VOLUME : 0x00C0:0db
+                        break;
+
+                        default:
+                                DEBUG_LOG("Recording through Main Mic in call");
+                                audio_ctrl_mic_bias_gpio(1);
+
+                                val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_4);
+                                val &= ~(WM8994_ADCL_ENA_MASK |WM8994_AIF1ADC1L_ENA_MASK);
+                                val |= (WM8994_AIF1ADC1L_ENA | WM8994_ADCL_ENA);
+                                wm8994_write(codec, WM8994_POWER_MANAGEMENT_4, val);
+
+                                //Enable timeslots
+                                val = wm8994_read(codec, WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING);
+                                val |=WM8994_ADC1L_TO_AIF1ADC1L;
+                                wm8994_write(codec, WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING, val);
+
+                                val = wm8994_read(codec, WM8994_AIF1_MASTER_SLAVE);
+                                val |= (WM8994_AIF1_MSTR | WM8994_AIF1_CLK_FRC | WM8994_AIF1_LRCLK_FRC);	// Master mode
+                                wm8994_write(codec, WM8994_AIF1_MASTER_SLAVE, val);
+
+                                wm8994_write(codec, WM8994_GPIO_1, 0xA101);   // GPIO1 is Input Enable
+
+                                // for stable pcm input when start google voice recognition
+                                if(wm8994->recognition_active == REC_ON)
+                                {
+                                        msleep(300);
+                                }
+                        break;
+                }
+        }
+        else if(wm8994 ->call_record_path == CALL_RECORDING_SUB)
+        {
+                switch(channel)
+                {
+                        case CH_UDLINK:  //TxRx
+                                val = wm8994_read(codec,WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING);
+                                val &= ~( WM8994_ADC1R_TO_AIF1ADC1R_MASK | WM8994_AIF2DACR_TO_AIF1ADC1R_MASK);
+                                val |= (WM8994_ADC1R_TO_AIF1ADC1R |WM8994_AIF2DACR_TO_AIF1ADC1R);
+                                wm8994_write(codec,WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING,val);
+
+                                val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_4);
+                                val &= ~( WM8994_AIF1ADC1L_ENA_MASK | WM8994_AIF1ADC1R_ENA_MASK);
+                                val |= ( WM8994_AIF1ADC1L_ENA|WM8994_AIF1ADC1R_ENA);
+                                wm8994_write(codec,WM8994_POWER_MANAGEMENT_4,val);
+
+                                wm8994_write(codec,0x300,0xC010);
+
+                                wm8994_write(codec,0x401,0x00C0);	// AIF1 INPUT VOLUME : 0x00C0:0db
+                        break;
+
+                        case CH_UPLINK:  //Tx only
+                                val = wm8994_read(codec,WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING);
+                                val &= ~( WM8994_ADC1R_TO_AIF1ADC1R_MASK | WM8994_AIF2DACR_TO_AIF1ADC1R_MASK);
+                                val |= (WM8994_ADC1R_TO_AIF1ADC1R );
+                                wm8994_write(codec,WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING,val);
+
+                                val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_4);
+                                val &= ~( WM8994_AIF1ADC1L_ENA_MASK | WM8994_AIF1ADC1R_ENA_MASK);
+                                val |= ( WM8994_AIF1ADC1L_ENA|WM8994_AIF1ADC1R_ENA);
+                                wm8994_write(codec,WM8994_POWER_MANAGEMENT_4,val);
+
+                                wm8994_write(codec,0x300,0xC010);
+
+                                wm8994_write(codec,0x401,0x00C0);	// AIF1 INPUT VOLUME : 0x00C0:0db
+                        break;
+
+                        case CH_DOWNLINK:  //Rx only
+                                val = wm8994_read(codec,WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING);
+                                val &= ~( WM8994_ADC1R_TO_AIF1ADC1R_MASK | WM8994_AIF2DACR_TO_AIF1ADC1R_MASK);
+                                val |= (WM8994_AIF2DACR_TO_AIF1ADC1R);
+                                wm8994_write(codec,WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING,val);
+
+                                val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_4);
+                                val &= ~( WM8994_AIF1ADC1L_ENA_MASK | WM8994_AIF1ADC1R_ENA_MASK);
+                                val |= ( WM8994_AIF1ADC1L_ENA|WM8994_AIF1ADC1R_ENA);
+                                wm8994_write(codec,WM8994_POWER_MANAGEMENT_4,val);
+
+                                wm8994_write(codec,0x300,0xC010);
+
+                                wm8994_write(codec,0x401,0x00C0);	// AIF1 INPUT VOLUME : 0x00C0:0db
+                        break;
+
+                        default:
+                                DEBUG_LOG("Recording through Headset Mic in call");
+
+                                audio_ctrl_mic_bias_gpio(0);
+                                audio_ctrl_earmic_bias_gpio(1);
+
+                                // Mixing left channel output to right channel.
+                                val = wm8994_read(codec, WM8994_AIF1_CONTROL_1);	//605H : 0x0010
+                                val &= ~(WM8994_AIF1ADCL_SRC_MASK | WM8994_AIF1ADCR_SRC_MASK);
+                                val |= (WM8994_AIF1ADCL_SRC | WM8994_AIF1ADCR_SRC);
+                                wm8994_write(codec, WM8994_AIF1_CONTROL_1, val);
+
+                                //Digital Paths
+                                //Enable right ADC and time slot
+                                val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_4);
+                                val &= ~(WM8994_ADCR_ENA_MASK |WM8994_AIF1ADC1R_ENA_MASK );
+                                val |= (WM8994_AIF1ADC1R_ENA | WM8994_ADCR_ENA  );
+                                wm8994_write(codec,WM8994_POWER_MANAGEMENT_4 ,val);
+
+                                //ADC Right mixer routing
+                                val = wm8994_read(codec,WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING);
+                                val &= ~( WM8994_ADC1R_TO_AIF1ADC1R_MASK);
+                                val |= WM8994_ADC1R_TO_AIF1ADC1R;
+                                wm8994_write(codec,WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING,val);
+
+                                val = wm8994_read(codec, WM8994_AIF1_MASTER_SLAVE);
+                                val |= (WM8994_AIF1_MSTR | WM8994_AIF1_CLK_FRC | WM8994_AIF1_LRCLK_FRC);	// Master mode
+                                wm8994_write(codec, WM8994_AIF1_MASTER_SLAVE, val);
+
+                                wm8994_write( codec, WM8994_GPIO_1, 0xA101 );   // GPIO1 is Input Enable
+                        break;
+                }
+        }
+}
+
+void wm8994_call_recording_change_path(struct snd_soc_codec *codec)
+{
+		struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+        if(wm8994->rec_path == MAIN)
+        {
+                wm8994->call_record_path = CALL_RECORDING_MAIN;
+                DEBUG_LOG("Changing rec_path[%d] -> call_record_path [%d]", wm8994 ->rec_path, wm8994 ->call_record_path);
+
+                wm8994->rec_path = MIC_OFF;
+        }
+        else if(wm8994->rec_path == SUB)
+        {
+                wm8994->call_record_path = CALL_RECORDING_SUB;
+                DEBUG_LOG("Changing rec_path[%d] -> call_record_path [%d]", wm8994 ->rec_path, wm8994 ->call_record_path);
+
+                wm8994->rec_path = MIC_OFF;
+        }
+
+
+        if(wm8994 ->call_record_path != CALL_RECORDING_OFF)
+        {
+                DEBUG_LOG("wm8994 ->call_record_path = [%d]", wm8994 ->call_record_path);
+                wm8994_set_voicecall_record(codec, (int)wm8994 ->call_record_ch);
+        }
+}
+
+void wm8994_set_voicecall_record_off(struct snd_soc_codec *codec)
+{
+	DEBUG_LOG("");
+
+	//codec off
+	wm8994_write(codec,WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING ,0x0000);
+	wm8994_write(codec,WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING,0x0000);
+}
+
+void wm8994_set_fmradio_common(struct snd_soc_codec *codec, int onoff)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	u16 val;
+
+	DEBUG_LOG("onoff = [%d]", onoff);
+
+	wm8994_write(codec, 0x39, 0x8);	//Cross Talk (H/W requested)
+
+	if(onoff)
+	{
+		val = wm8994_read(codec, WM8994_LEFT_LINE_INPUT_3_4_VOLUME);
+		val &= ~(WM8994_IN2L_VU_MASK | WM8994_IN2L_MUTE_MASK | WM8994_IN2L_VOL_MASK);
+		if(wm8994->fmradio_path == FMR_HP)
+			val |= (TUNING_FMRADIO_EAR_INPUTMIXL_VOL);
+		else
+			val |= (TUNING_FMRADIO_SPK_INPUTMIXL_VOL);
+		wm8994_write(codec, WM8994_LEFT_LINE_INPUT_3_4_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_RIGHT_LINE_INPUT_3_4_VOLUME);
+		val &= ~(WM8994_IN2R_VU_MASK | WM8994_IN2R_MUTE_MASK | WM8994_IN2R_VOL_MASK);
+		if(wm8994->fmradio_path == FMR_HP)
+			val |= (WM8994_IN2R_VU | TUNING_FMRADIO_EAR_INPUTMIXR_VOL);
+		else
+			val |= (WM8994_IN2R_VU | TUNING_FMRADIO_SPK_INPUTMIXR_VOL);
+		wm8994_write(codec, WM8994_RIGHT_LINE_INPUT_3_4_VOLUME, val);
+
+		// Input mixer setting - Temporary inserted for blocking MIC and FM radio mixing - DW Shim 2010.02.25
+	//	val = wm8994_read(codec, WM8994_INPUT_MIXER_2);
+	//	val &= ~(WM8994_IN2LN_TO_IN2L_MASK | WM8994_IN2RN_TO_IN2R_MASK);
+	//	val |= (WM8994_IN2LN_TO_IN2L | WM8994_IN2RN_TO_IN2R);
+		val = (WM8994_IN2LN_TO_IN2L | WM8994_IN2RN_TO_IN2R);
+		wm8994_write(codec, WM8994_INPUT_MIXER_2, val);
+
+		if(wm8994->testmode_config_flag == SEC_NORMAL)
+		{
+			// IN2L to MIXINL
+			val = wm8994_read(codec, WM8994_INPUT_MIXER_3);
+			val &= ~(WM8994_IN2L_TO_MIXINL_MASK);
+			val |= WM8994_IN2L_TO_MIXINL;
+			wm8994_write(codec, WM8994_INPUT_MIXER_3, val);
+
+			//IN2R to MIXINR
+			val = wm8994_read(codec, WM8994_INPUT_MIXER_4);
+			val &= ~(WM8994_IN2R_TO_MIXINR_MASK);
+			val |= WM8994_IN2R_TO_MIXINR;
+			wm8994_write(codec, WM8994_INPUT_MIXER_4, val);
+		}
+
+		//DRC for Noise-gate (AIF2)
+		wm8994_write(codec, WM8994_AIF2_ADC_FILTERS, 0xF800);
+		wm8994_write(codec, WM8994_AIF2_DAC_FILTERS_1, 0x0036);
+		wm8994_write(codec, WM8994_AIF2_DAC_FILTERS_2, 0x0010);
+		wm8994_write(codec, WM8994_AIF2_DRC_2, 0x0840);
+		wm8994_write(codec, WM8994_AIF2_DRC_3, 0x2400);
+		wm8994_write(codec, WM8994_AIF2_DRC_4, 0x0000);
+		wm8994_write(codec, WM8994_AIF2_DRC_5, 0x0000);
+		wm8994_write(codec, WM8994_AIF2_DRC_1, 0x019C);
+	}
+	else
+	{
+		val = wm8994_read(codec, WM8994_LEFT_LINE_INPUT_3_4_VOLUME);
+		val &= ~(WM8994_IN2L_VU_MASK | WM8994_IN2L_MUTE_MASK | WM8994_IN2L_VOL_MASK);
+		val |= (WM8994_IN2L_MUTE);
+		wm8994_write(codec, WM8994_LEFT_LINE_INPUT_3_4_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_RIGHT_LINE_INPUT_3_4_VOLUME);
+		val &= ~(WM8994_IN2R_VU_MASK | WM8994_IN2R_MUTE_MASK | WM8994_IN2R_VOL_MASK);
+		val |= (WM8994_IN2R_VU | WM8994_IN2R_MUTE);
+		wm8994_write(codec, WM8994_RIGHT_LINE_INPUT_3_4_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_INPUT_MIXER_2);
+		val &= ~(WM8994_IN2LN_TO_IN2L | WM8994_IN2RN_TO_IN2R);
+		wm8994_write(codec, WM8994_INPUT_MIXER_2, val);
+
+		if(wm8994->testmode_config_flag == SEC_NORMAL)
+		{
+			// IN2L to MIXINL
+			val = wm8994_read(codec, WM8994_INPUT_MIXER_3);
+			val &= ~(WM8994_IN2L_TO_MIXINL_MASK);
+			wm8994_write(codec, WM8994_INPUT_MIXER_3, val);
+
+			//IN2R to MIXINR
+			val = wm8994_read(codec, WM8994_INPUT_MIXER_4);
+			val &= ~(WM8994_IN2R_TO_MIXINR_MASK);
+			wm8994_write(codec, WM8994_INPUT_MIXER_4, val);
+		}
+	}
+}
+
+void wm8994_set_fmradio_headset(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	u16 val;
+
+#if defined(CONFIG_PHONE_P1_GSM)
+	u16 nReadServo4Val = 0;
+	u16 ncompensationResult = 0;
+	u16 nCompensationResultLow=0;
+	u16 nCompensationResultHigh=0;
+	u8  nServo4Low = 0;
+	u8  nServo4High = 0;
+
+	DEBUG_LOG("Routing ear path : FM Radio -> EAR Out");
+
+	wm8994->fmradio_path = FMR_HP;
+
+	wm8994_disable_fmradio_path(codec);
+
+	//DAC1 Setting
+	val = wm8994_read(codec, WM8994_DAC1_LEFT_MIXER_ROUTING);	//601H : 0x05
+	val &= ~(WM8994_AIF1DAC1L_TO_DAC1L_MASK | WM8994_AIF1DAC2L_TO_DAC1L_MASK | WM8994_AIF2DACL_TO_DAC1L_MASK);
+	val |= (WM8994_AIF2DACL_TO_DAC1L | WM8994_AIF1DAC1L_TO_DAC1L);
+	wm8994_write(codec, WM8994_DAC1_LEFT_MIXER_ROUTING, val);
+
+	val = wm8994_read(codec, WM8994_DAC1_RIGHT_MIXER_ROUTING);	//602H : 0x05
+	val &= ~(WM8994_AIF1DAC1R_TO_DAC1R_MASK | WM8994_AIF1DAC2R_TO_DAC1R_MASK | WM8994_AIF2DACR_TO_DAC1R_MASK);
+	val |= (WM8994_AIF1DAC1R_TO_DAC1R | WM8994_AIF2DACR_TO_DAC1R);
+	wm8994_write(codec, WM8994_DAC1_RIGHT_MIXER_ROUTING, val);
+
+	//* Headset
+	wm8994_write(codec, 0x102, 0x0003);
+	wm8994_write(codec, 0x56, 0x0003);
+	wm8994_write(codec, 0x102, 0x0000);
+
+	wm8994_write(codec, WM8994_GPIO_3, 0x0100);
+	wm8994_write(codec, WM8994_GPIO_4, 0x0100);
+	wm8994_write(codec, WM8994_GPIO_5, 0x8100);
+	wm8994_write(codec, WM8994_GPIO_6, 0xA101);
+	wm8994_write(codec, WM8994_GPIO_7, 0x0100);
+
+	val = wm8994_read(codec, WM8994_LEFT_OUTPUT_VOLUME);
+	val = 0x0000;
+	wm8994_write(codec, WM8994_LEFT_OUTPUT_VOLUME, val);
+
+	val = wm8994_read(codec, WM8994_RIGHT_OUTPUT_VOLUME);
+	val = 0x0100;
+	wm8994_write(codec, WM8994_RIGHT_OUTPUT_VOLUME, val);
+
+	// Disable reg sync to MCLK
+	val = wm8994_read(codec, WM8994_AIF1_CLOCKING_1 );
+	val &= ~(WM8994_AIF1CLK_ENA_MASK);
+	val |= WM8994_AIF1CLK_ENA;
+	wm8994_write(codec, WM8994_AIF1_CLOCKING_1, val );
+
+
+	// Analogue Path Config
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_2 );
+	val &= ~(WM8994_MIXINL_ENA_MASK | WM8994_MIXINR_ENA_MASK | WM8994_IN2L_ENA_MASK | WM8994_IN2R_ENA_MASK);
+	val |= (WM8994_MIXINL_ENA | WM8994_MIXINR_ENA| WM8994_IN2L_ENA| WM8994_IN2R_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_2 , val );
+
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_1);
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_NORMAL);
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1 , 0x0003);
+
+	//* Unmutes
+	// Output setting
+	if(wm8994->testmode_config_flag == SEC_NORMAL)
+	{
+		val = wm8994_read(codec, WM8994_LEFT_OUTPUT_VOLUME);
+		val &= ~(WM8994_HPOUT1L_MUTE_N_MASK | WM8994_HPOUT1L_VOL_MASK);
+		val |= (WM8994_HPOUT1L_MUTE_N | TUNING_FMRADIO_OUTPUTL_VOL);
+		wm8994_write(codec, WM8994_LEFT_OUTPUT_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_RIGHT_OUTPUT_VOLUME);
+		val &= ~(WM8994_HPOUT1R_MUTE_N_MASK | WM8994_HPOUT1R_VOL_MASK);
+		val |= (WM8994_HPOUT1_VU | WM8994_HPOUT1R_MUTE_N | TUNING_FMRADIO_OUTPUTR_VOL);
+		wm8994_write(codec, WM8994_RIGHT_OUTPUT_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_LEFT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTL_MUTE_N_MASK | WM8994_MIXOUTL_VOL_MASK);
+		val |= (WM8994_MIXOUTL_MUTE_N | TUNING_FMRADIO_OPGAL_VOL);
+		wm8994_write(codec,WM8994_LEFT_OPGA_VOLUME, val );
+
+		val = wm8994_read(codec, WM8994_RIGHT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTR_MUTE_N_MASK | WM8994_MIXOUTR_VOL_MASK);
+		val |= (WM8994_MIXOUT_VU | WM8994_MIXOUTR_MUTE_N | TUNING_FMRADIO_OPGAR_VOL);
+		wm8994_write(codec,WM8994_RIGHT_OPGA_VOLUME, val );
+
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_LEFT_VOLUME);
+		val &= ~(WM8994_AIF1DAC1L_VOL_MASK);
+		val |= (TUNING_DAC1L_RADIO_VOL);
+		wm8994_write(codec, WM8994_AIF1_DAC1_LEFT_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME);
+		val &= ~(WM8994_AIF1DAC1R_VOL_MASK);
+		val |= (WM8994_AIF1DAC1_VU |TUNING_DAC1R_RADIO_VOL);
+		wm8994_write(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME, val);
+	}
+
+	wm8994_set_fmradio_common(codec, 1);
+
+	//FLL2 Setting
+	val = wm8994_read(codec, WM8994_AIF2_CLOCKING_1);	//204H : 0x0011
+	val &= ~(WM8994_AIF2CLK_ENA_MASK | WM8994_AIF2CLK_SRC_MASK);
+	val |= (WM8994_AIF2CLK_ENA | 0x2 << WM8994_AIF2CLK_SRC_SHIFT);
+	wm8994_write(codec, WM8994_AIF2_CLOCKING_1, val);
+
+	val = wm8994_read(codec, WM8994_CLOCKING_1);	//208H : 0xF -> 0xE
+	val &= ~(WM8994_SYSCLK_SRC_MASK | WM8994_DSP_FSINTCLK_ENA_MASK | WM8994_DSP_FS2CLK_ENA_MASK | WM8994_DSP_FS1CLK_ENA_MASK);
+	val |= (WM8994_DSP_FS1CLK_ENA | WM8994_DSP_FS2CLK_ENA | WM8994_DSP_FSINTCLK_ENA);
+	wm8994_write(codec, WM8994_CLOCKING_1, val);
+
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_4);	//04H
+	val &= ~(WM8994_AIF2ADCL_ENA_MASK | WM8994_AIF2ADCR_ENA_MASK | WM8994_ADCL_ENA_MASK | WM8994_ADCR_ENA_MASK);
+	val |= (WM8994_AIF2ADCL_ENA | WM8994_AIF2ADCR_ENA | WM8994_ADCL_ENA | WM8994_ADCR_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_4, val);
+
+	//DAC2 Setting
+	wm8994_write(codec, WM8994_DAC2_MIXER_VOLUMES, 0x018C);	//603H : 0x018C
+
+	val = wm8994_read(codec, WM8994_DAC2_LEFT_MIXER_ROUTING);	//604H : 0x0010
+	val &= ~(WM8994_ADC1_TO_DAC2L_MASK);
+	val |= (WM8994_ADC1_TO_DAC2L);
+	wm8994_write(codec, WM8994_DAC2_LEFT_MIXER_ROUTING, val);
+
+	val = wm8994_read(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING);	//605H : 0x0010
+	val &= ~(WM8994_ADC2_TO_DAC2R_MASK);
+	val |= (WM8994_ADC2_TO_DAC2R);			// Changed value to support stereo
+	wm8994_write(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING, val);
+
+	val = wm8994_read(codec, WM8994_DAC2_LEFT_VOLUME);	//612 : 1C0
+	val &= ~(WM8994_DAC2L_MUTE_MASK | WM8994_DAC2L_VOL_MASK);
+	val |= (TUNING_DAC2L_VOL); //0 db volume
+	wm8994_write(codec,WM8994_DAC2_LEFT_VOLUME,val);
+
+	val = wm8994_read(codec, WM8994_DAC2_RIGHT_VOLUME);	//613 : 1C0
+	val &= ~(WM8994_DAC2R_MUTE_MASK | WM8994_DAC2R_VOL_MASK);
+	val |= (WM8994_DAC2_VU | TUNING_DAC2R_VOL); //0 db volume
+	wm8994_write(codec, WM8994_DAC2_RIGHT_VOLUME, val);
+
+	wm8994_write(codec, WM8994_AIF1_DAC1_EQ_GAINS_1, 0x0000);	//480 : 0
+
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_3);	//03 : F
+	val &= ~(WM8994_MIXOUTLVOL_ENA_MASK | WM8994_MIXOUTRVOL_ENA_MASK | WM8994_MIXOUTL_ENA_MASK | WM8994_MIXOUTR_ENA_MASK);
+	val |= (WM8994_MIXOUTLVOL_ENA | WM8994_MIXOUTRVOL_ENA | WM8994_MIXOUTL_ENA | WM8994_MIXOUTR_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, val);
+
+	wm8994_write(codec, WM8994_OVERSAMPLING, 0x0000);
+
+//AIF2 Master/Slave , LOOPBACK, AIF2DAC Unmute
+	val = wm8994_read(codec, WM8994_AIF2_MASTER_SLAVE);	//312 : 7000
+	val &= ~(WM8994_AIF2_LRCLK_FRC_MASK | WM8994_AIF2_CLK_FRC_MASK | WM8994_AIF2_MSTR_MASK);
+	val |= (WM8994_AIF2_LRCLK_FRC | WM8994_AIF2_CLK_FRC | WM8994_AIF2_MSTR);
+	wm8994_write(codec, WM8994_AIF2_MASTER_SLAVE, val);
+
+	val = wm8994_read(codec, WM8994_AIF2_CONTROL_2);	//311 : 4001
+	val &= ~(WM8994_AIF2_LOOPBACK_MASK);
+	val |= (WM8994_AIF2_LOOPBACK);
+	wm8994_write(codec, WM8994_AIF2_CONTROL_2, val);
+
+	wm8994_write(codec, WM8994_SIDETONE, 0x01c0);
+
+	//* DC Servo Series Count
+	val = 0x03E0;
+	wm8994_write(codec, WM8994_DC_SERVO_2, val);
+
+	//* HP first and second stage
+	//Enable vmid,bias, hp left and right
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1 );
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK | WM8994_HPOUT1L_ENA_MASK | WM8994_HPOUT1R_ENA_MASK);
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL | WM8994_HPOUT1R_ENA | WM8994_HPOUT1L_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+	val = (WM8994_HPOUT1L_DLY | WM8994_HPOUT1R_DLY);
+	wm8994_write(codec, WM8994_ANALOGUE_HP_1, val);
+
+	//Enable Charge Pump
+	val = wm8994_read(codec, WM8994_CHARGE_PUMP_1);
+	val &= ~WM8994_CP_ENA_MASK ;
+	val |= WM8994_CP_ENA | WM8994_CP_ENA_DEFAULT ; // this is from wolfson
+	wm8994_write(codec, WM8994_CHARGE_PUMP_1, 0x9F25);
+
+	msleep(5);
+
+	//Digital  Mixer setting
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_5);	//05 : 3303
+	val &= ~(WM8994_AIF2DACL_ENA_MASK | WM8994_AIF2DACR_ENA_MASK | WM8994_AIF1DAC1L_ENA_MASK | WM8994_AIF1DAC1R_ENA_MASK
+		 | WM8994_DAC1L_ENA_MASK | WM8994_DAC1R_ENA_MASK);
+	val |= (WM8994_AIF2DACL_ENA | WM8994_AIF2DACR_ENA | WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA
+		 | WM8994_DAC1L_ENA | WM8994_DAC1R_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_5, val);
+
+	val = wm8994_read(codec, WM8994_OUTPUT_MIXER_1);	//2D : 1
+	val &= ~(WM8994_DAC1L_TO_MIXOUTL_MASK);
+	val |= (WM8994_DAC1L_TO_MIXOUTL);
+	wm8994_write(codec, WM8994_OUTPUT_MIXER_1, val);
+
+	val = wm8994_read(codec, WM8994_OUTPUT_MIXER_2);	//2E : 1
+	val &= ~(WM8994_DAC1R_TO_MIXOUTR_MASK);
+	val |= (WM8994_DAC1R_TO_MIXOUTR);
+	wm8994_write(codec, WM8994_OUTPUT_MIXER_2, val);
+
+	//* DC Servo
+	val = (WM8994_DCS_TRIG_SERIES_1 | WM8994_DCS_TRIG_SERIES_0 | WM8994_DCS_ENA_CHAN_1 | WM8994_DCS_ENA_CHAN_0);
+	wm8994_write(codec,WM8994_DC_SERVO_1, 0x0303 );
+
+	msleep(160);
+
+	nReadServo4Val=wm8994_read(codec,WM8994_DC_SERVO_4);
+	nServo4Low=(signed char)(nReadServo4Val & 0xff);
+	nServo4High=(signed char)((nReadServo4Val>>8) & 0xff);
+
+	nCompensationResultLow=((signed short)nServo4Low -5)&0x00ff;
+	nCompensationResultHigh=((signed short)(nServo4High -5)<<8)&0xff00;
+	ncompensationResult=nCompensationResultLow|nCompensationResultHigh;
+	wm8994_write(codec,WM8994_DC_SERVO_4, ncompensationResult);
+
+	val = (WM8994_DCS_TRIG_DAC_WR_1 | WM8994_DCS_TRIG_DAC_WR_0 | WM8994_DCS_ENA_CHAN_1 | WM8994_DCS_ENA_CHAN_0);
+	wm8994_write(codec,WM8994_DC_SERVO_1, val );
+
+	msleep(20);
+
+	//* Headphone Output
+		// Intermediate HP settings
+	val = wm8994_read(codec, WM8994_ANALOGUE_HP_1);
+	val &= ~(WM8994_HPOUT1R_DLY_MASK |WM8994_HPOUT1R_OUTP_MASK |WM8994_HPOUT1R_RMV_SHORT_MASK |
+		WM8994_HPOUT1L_DLY_MASK |WM8994_HPOUT1L_OUTP_MASK | WM8994_HPOUT1L_RMV_SHORT_MASK);
+	val |= (WM8994_HPOUT1L_RMV_SHORT | WM8994_HPOUT1L_OUTP|WM8994_HPOUT1L_DLY |WM8994_HPOUT1R_RMV_SHORT |
+		WM8994_HPOUT1R_OUTP | WM8994_HPOUT1R_DLY);
+	wm8994_write(codec, WM8994_ANALOGUE_HP_1, val);
+
+	//DAC1, DAC2 Volume Setting
+	//Unmute DAC1 left
+	val = wm8994_read(codec,WM8994_DAC1_LEFT_VOLUME );	//610H : 1C0
+	val &= ~(WM8994_DAC1L_MUTE_MASK | WM8994_DAC1L_VOL_MASK);
+	val |= (TUNING_DAC1L_VOL);
+	wm8994_write(codec,WM8994_DAC1_LEFT_VOLUME ,val);
+
+	//Unmute and volume ctrl RightDAC
+	val = wm8994_read(codec, WM8994_DAC1_RIGHT_VOLUME);	//611 : 1C0
+	val &= ~(WM8994_DAC1R_MUTE_MASK | WM8994_DAC1R_VOL_MASK);
+	val |= (WM8994_DAC1_VU | TUNING_DAC1R_VOL); //0 db volume
+	wm8994_write(codec,WM8994_DAC1_RIGHT_VOLUME,val);
+
+	//DAC1 Unmute
+	wm8994_write(codec, WM8994_AIF1_DAC1_FILTERS_1, 0x0000);
+
+	val = wm8994_read(codec, WM8994_AIF2_DAC_FILTERS_1);	//520 : 0
+	val &= ~(WM8994_AIF2DAC_MUTE_MASK);
+	wm8994_write(codec, WM8994_AIF2_DAC_FILTERS_1, val);
+#elif defined(CONFIG_PHONE_P1_CDMA)
+	u16 nReadServo4Val = 0;
+	u16 ncompensationResult = 0;
+	u8 nCompensationResultLow=0;
+	u8 nCompensationResultHigh=0;
+	u16 nServo4Low = 0;
+	u16 nServo4High = 0;
+
+
+	DEBUG_LOG("Routing ear path : FM Radio -> EAR Out");
+
+	wm8994->fmradio_path = FMR_HP;
+
+	// Disable reg sync to MCLK
+	val = wm8994_read(codec, WM8994_AIF1_CLOCKING_1 );
+	val &= ~(WM8994_AIF1CLK_ENA_MASK);
+	val |= WM8994_AIF1CLK_ENA;
+	wm8994_write(codec, WM8994_AIF1_CLOCKING_1, val );
+
+	val = wm8994_read(codec, WM8994_CONTROL_INTERFACE  );
+	val &= ~(WM8994_AUTO_INC_MASK);
+	val |= WM8994_AUTO_INC;
+	wm8994_write(codec, WM8994_CONTROL_INTERFACE  , val );
+
+	// Analogue Path Config
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_2 );
+	val &= ~(WM8994_MIXINL_ENA_MASK | WM8994_MIXINR_ENA_MASK | WM8994_IN2L_ENA_MASK | WM8994_IN2R_ENA_MASK);
+	val |= (WM8994_MIXINL_ENA | WM8994_MIXINR_ENA| WM8994_IN2L_ENA| WM8994_IN2R_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_2 , val );
+
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_1);
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_NORMAL);
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1 , 0x0003);
+
+	val = wm8994_read(codec, WM8994_LEFT_OUTPUT_VOLUME);
+	val = 0x0000;
+	wm8994_write(codec, WM8994_LEFT_OUTPUT_VOLUME, val);
+
+	val = wm8994_read(codec, WM8994_RIGHT_OUTPUT_VOLUME);
+	val = 0x0000;
+	wm8994_write(codec, WM8994_RIGHT_OUTPUT_VOLUME, val);
+
+	wm8994_set_fmradio_common(codec, 1);
+
+	// Output mixer setting
+	val = wm8994_read(codec, WM8994_OUTPUT_MIXER_1);
+	val &= ~(WM8994_DAC1L_TO_HPOUT1L_MASK | WM8994_MIXINL_TO_MIXOUTL_MASK);
+	val |= (WM8994_MIXINL_TO_MIXOUTL);
+	wm8994_write(codec, WM8994_OUTPUT_MIXER_1, val);
+
+	val = wm8994_read(codec, WM8994_OUTPUT_MIXER_2);
+	val &= ~(WM8994_DAC1R_TO_HPOUT1R_MASK | WM8994_MIXINR_TO_MIXOUTR_MASK);
+	val |= (WM8994_MIXINR_TO_MIXOUTR);
+	wm8994_write(codec, WM8994_OUTPUT_MIXER_2, val);
+
+
+	//* Headset
+	wm8994_write(codec, 0x102, 0x0003);
+	wm8994_write(codec, 0x56, 0x0003);
+	wm8994_write(codec, 0x102, 0x0000);
+	wm8994_write(codec, 0x5D, 0x0002);
+
+
+	//* DC Servo Series Count
+	val = 0x03E0;
+	wm8994_write(codec, WM8994_DC_SERVO_2, val);
+
+	//* HP first and second stage
+	//Enable vmid,bias, hp left and right
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1 );
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK | WM8994_HPOUT1L_ENA_MASK | WM8994_HPOUT1R_ENA_MASK);
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL | WM8994_HPOUT1R_ENA | WM8994_HPOUT1L_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+	val = (WM8994_HPOUT1L_DLY | WM8994_HPOUT1R_DLY);
+	wm8994_write(codec, WM8994_ANALOGUE_HP_1, val);
+
+	//Enable Charge Pump
+	val = wm8994_read(codec, WM8994_CHARGE_PUMP_1);
+	val &= ~WM8994_CP_ENA_MASK ;
+	val |= WM8994_CP_ENA | WM8994_CP_ENA_DEFAULT ; // this is from wolfson
+	wm8994_write(codec, WM8994_CHARGE_PUMP_1, 0x9F25);
+
+	msleep(5);
+
+	//* DC Servo
+	val = (WM8994_DCS_TRIG_SERIES_1 | WM8994_DCS_TRIG_SERIES_0 | WM8994_DCS_ENA_CHAN_1 | WM8994_DCS_ENA_CHAN_0);
+	wm8994_write(codec,WM8994_DC_SERVO_1, 0x0303 );
+
+	msleep(160);
+
+	nReadServo4Val=wm8994_read(codec,WM8994_DC_SERVO_4);
+	nServo4Low=(u8)(nReadServo4Val & 0xff);
+	nServo4High=(u8)((nReadServo4Val>>8) & 0xff);
+
+	nCompensationResultLow=((u16)nServo4Low-4)&0x00ff;
+	nCompensationResultHigh=(((u16)nServo4High-4)<<8)&0xff00;
+	ncompensationResult=nCompensationResultLow|nCompensationResultHigh;
+	wm8994_write(codec,WM8994_DC_SERVO_4, ncompensationResult);
+
+	val = (WM8994_DCS_TRIG_DAC_WR_1 | WM8994_DCS_TRIG_DAC_WR_0 | WM8994_DCS_ENA_CHAN_1 | WM8994_DCS_ENA_CHAN_0);
+	wm8994_write(codec,WM8994_DC_SERVO_1, val );
+
+	msleep(20);
+
+	//* Headphone Output
+		// Intermediate HP settings
+	val = wm8994_read(codec, WM8994_ANALOGUE_HP_1);
+	val &= ~(WM8994_HPOUT1R_DLY_MASK |WM8994_HPOUT1R_OUTP_MASK |WM8994_HPOUT1R_RMV_SHORT_MASK |
+		WM8994_HPOUT1L_DLY_MASK |WM8994_HPOUT1L_OUTP_MASK | WM8994_HPOUT1L_RMV_SHORT_MASK);
+	val |= (WM8994_HPOUT1L_RMV_SHORT | WM8994_HPOUT1L_OUTP|WM8994_HPOUT1L_DLY |WM8994_HPOUT1R_RMV_SHORT |
+		WM8994_HPOUT1R_OUTP | WM8994_HPOUT1R_DLY);
+	wm8994_write(codec, WM8994_ANALOGUE_HP_1, val);
+
+	// Enable MIXOUT
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_3);
+	val &= ~(WM8994_MIXOUTLVOL_ENA_MASK | WM8994_MIXOUTRVOL_ENA_MASK | WM8994_MIXOUTL_ENA_MASK | WM8994_MIXOUTR_ENA_MASK);
+	val |= (WM8994_MIXOUTLVOL_ENA | WM8994_MIXOUTRVOL_ENA | WM8994_MIXOUTL_ENA | WM8994_MIXOUTR_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, val);
+
+
+	//* Unmutes
+	// Output setting
+	if(!wm8994->testmode_config_flag)
+	{
+		val = wm8994_read(codec, WM8994_LEFT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTL_MUTE_N_MASK | WM8994_MIXOUTL_VOL_MASK);
+		val |= (WM8994_MIXOUT_VU | WM8994_MIXOUTL_MUTE_N | TUNING_FMRADIO_OPGAL_VOL);
+		wm8994_write(codec,WM8994_LEFT_OPGA_VOLUME, val );
+
+		val = wm8994_read(codec, WM8994_RIGHT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTR_MUTE_N_MASK | WM8994_MIXOUTR_VOL_MASK);
+		val |= (WM8994_MIXOUT_VU | WM8994_MIXOUTR_MUTE_N | TUNING_FMRADIO_OPGAR_VOL);
+		wm8994_write(codec,WM8994_RIGHT_OPGA_VOLUME, val );
+
+		val = wm8994_read(codec, WM8994_LEFT_OUTPUT_VOLUME);
+		val &= ~(WM8994_HPOUT1L_MUTE_N_MASK | WM8994_HPOUT1L_VOL_MASK);
+		val |= (WM8994_HPOUT1_VU | WM8994_HPOUT1L_MUTE_N | TUNING_FMRADIO_OUTPUTL_VOL);
+		wm8994_write(codec, WM8994_LEFT_OUTPUT_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_RIGHT_OUTPUT_VOLUME);
+		val &= ~(WM8994_HPOUT1R_MUTE_N_MASK | WM8994_HPOUT1R_VOL_MASK);
+		val |= (WM8994_HPOUT1_VU | WM8994_HPOUT1R_MUTE_N | TUNING_FMRADIO_OUTPUTR_VOL);
+		wm8994_write(codec, WM8994_RIGHT_OUTPUT_VOLUME, val);
+	}
+#endif
+}
+
+void wm8994_set_fmradio_speaker(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	u16 val;
+
+	DEBUG_LOG("Routing spk path : FM Radio -> SPK Out");
+
+#if defined(CONFIG_PHONE_P1_GSM)
+	wm8994_disable_fmradio_path(codec);
+
+	wm8994->fmradio_path = FMR_SPK;
+
+	//Disable end point for preventing pop up noise.
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1);
+	val &= ~(WM8994_SPKOUTL_ENA_MASK);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_3);	//03 : 0100
+	val &= ~(WM8994_SPKRVOL_ENA_MASK | WM8994_SPKLVOL_ENA_MASK);
+	val |= (WM8994_SPKLVOL_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, val);
+
+	if(wm8994->testmode_config_flag == SEC_NORMAL)
+	{
+		// Unmute the SPKMIXVOLUME
+		val = wm8994_read(codec, WM8994_SPKMIXL_ATTENUATION);
+		val &= ~(WM8994_SPKMIXL_VOL_MASK);
+		val |= TUNING_SPKMIXL_ATTEN;
+		wm8994_write(codec, WM8994_SPKMIXL_ATTENUATION, val);
+
+		val = wm8994_read(codec, WM8994_SPKMIXR_ATTENUATION);
+		val &= ~(WM8994_SPKMIXR_VOL_MASK);
+		wm8994_write(codec, WM8994_SPKMIXR_ATTENUATION, val);
+
+		val = wm8994_read(codec, WM8994_SPEAKER_VOLUME_LEFT);
+		val &= ~(WM8994_SPKOUTL_MUTE_N_MASK | WM8994_SPKOUTL_VOL_MASK);
+		val |= (WM8994_SPKOUTL_MUTE_N | TUNING_FMRADIO_SPKL_VOL);
+		wm8994_write(codec, WM8994_SPEAKER_VOLUME_LEFT, val);
+
+		val = wm8994_read(codec, WM8994_SPEAKER_VOLUME_RIGHT);
+		val &= ~(WM8994_SPKOUTR_MUTE_N_MASK | WM8994_SPKOUTR_VOL_MASK);
+		val |= (WM8994_SPKOUT_VU);
+		wm8994_write(codec, WM8994_SPEAKER_VOLUME_RIGHT, val);
+
+		val = wm8994_read(codec, WM8994_CLASSD);
+		val &= ~(WM8994_SPKOUTL_BOOST_MASK);
+		val |= TUNING_FMRADIO_CLASSD_VOL << WM8994_SPKOUTL_BOOST_SHIFT;
+		wm8994_write(codec, WM8994_CLASSD, val);
+
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_LEFT_VOLUME);
+		val &= ~(WM8994_AIF1DAC1L_VOL_MASK);
+		val |= (TUNING_DAC1L_VOL);
+		wm8994_write(codec, WM8994_AIF1_DAC1_LEFT_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME);
+		val &= ~(WM8994_AIF1DAC1R_VOL_MASK);
+		val |= (WM8994_AIF1DAC1_VU |TUNING_DAC1R_VOL);
+		wm8994_write(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME, val);
+	}
+
+	wm8994_set_fmradio_common(codec, 1);
+
+	wm8994_write(codec, WM8994_GPIO_3, 0x0100);	//702
+	wm8994_write(codec, WM8994_GPIO_4, 0x0100);	//703
+	wm8994_write(codec, WM8994_GPIO_5, 0x8100);	//704
+	wm8994_write(codec, WM8994_GPIO_6, 0xA101);	//705
+	wm8994_write(codec, WM8994_GPIO_7, 0x0100);	//706
+
+	/*Output MIxer-Output PGA*/
+	val = wm8994_read(codec,WM8994_SPKOUT_MIXERS );
+	val &= ~(WM8994_SPKMIXL_TO_SPKOUTL_MASK |
+		WM8994_SPKMIXR_TO_SPKOUTL_MASK | WM8994_SPKMIXR_TO_SPKOUTR_MASK);
+	val |= (WM8994_SPKMIXL_TO_SPKOUTL);
+	wm8994_write(codec, WM8994_SPKOUT_MIXERS, val);
+
+	// Output mixer setting
+	val = wm8994_read(codec, WM8994_SPEAKER_MIXER);
+	val &= ~(WM8994_MIXINL_TO_SPKMIXL_MASK | WM8994_MIXINR_TO_SPKMIXR_MASK | WM8994_DAC1L_TO_SPKMIXL_MASK | WM8994_DAC1R_TO_SPKMIXR_MASK);
+	val |= (WM8994_DAC1L_TO_SPKMIXL);
+	wm8994_write(codec, WM8994_SPEAKER_MIXER, val);
+
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_5);	//05 : 3303
+	val &= ~(WM8994_AIF2DACL_ENA_MASK | WM8994_AIF2DACR_ENA_MASK | WM8994_AIF1DAC1L_ENA_MASK | WM8994_AIF1DAC1R_ENA_MASK
+		 | WM8994_DAC1L_ENA_MASK | WM8994_DAC1R_ENA_MASK);
+	val |= (WM8994_AIF2DACL_ENA | WM8994_AIF2DACR_ENA | WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA
+		 | WM8994_DAC1L_ENA | WM8994_DAC1R_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_5, val);
+
+	// Enable IN2 and MIXIN - Temporary inserted for blocking MIC and FM radio mixing - DW Shim 2010.03.04
+//	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_2);
+//	val &= ~(WM8994_TSHUT_ENA_MASK | WM8994_TSHUT_OPDIS_MASK | WM8994_OPCLK_ENA_MASK |
+//			WM8994_MIXINL_ENA_MASK | WM8994_MIXINR_ENA_MASK | WM8994_IN2L_ENA_MASK | WM8994_IN2R_ENA_MASK);
+//	val |= (WM8994_TSHUT_ENA | WM8994_TSHUT_OPDIS | WM8994_OPCLK_ENA | WM8994_MIXINL_ENA |
+//			WM8994_MIXINR_ENA | WM8994_IN2L_ENA | WM8994_IN2R_ENA);
+	val = (WM8994_TSHUT_ENA | WM8994_TSHUT_OPDIS | WM8994_OPCLK_ENA | WM8994_MIXINL_ENA |
+			WM8994_MIXINR_ENA | WM8994_IN2L_ENA | WM8994_IN2R_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_2, val);
+
+	//AIF2 clock source <- FLL1
+	val = wm8994_read(codec, WM8994_AIF2_CLOCKING_1);	//204H : 0x0011
+	val &= ~(WM8994_AIF2CLK_ENA_MASK | WM8994_AIF2CLK_SRC_MASK);
+	val |= (WM8994_AIF2CLK_ENA | 0x2 << WM8994_AIF2CLK_SRC_SHIFT);
+	wm8994_write(codec, WM8994_AIF2_CLOCKING_1, val);
+
+	val = wm8994_read(codec, WM8994_CLOCKING_1);	//208H : 0xF -> 0xE
+	val &= ~(WM8994_SYSCLK_SRC_MASK | WM8994_DSP_FSINTCLK_ENA_MASK | WM8994_DSP_FS2CLK_ENA_MASK | WM8994_DSP_FS1CLK_ENA_MASK);
+	val |= (WM8994_DSP_FS1CLK_ENA | WM8994_DSP_FS2CLK_ENA | WM8994_DSP_FSINTCLK_ENA);
+	wm8994_write(codec, WM8994_CLOCKING_1, val);
+
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_4);	//04H
+	val &= ~(WM8994_AIF2ADCL_ENA_MASK | WM8994_AIF2ADCR_ENA_MASK | WM8994_ADCL_ENA_MASK | WM8994_ADCR_ENA_MASK);
+	val |= (WM8994_AIF2ADCL_ENA | WM8994_AIF2ADCR_ENA | WM8994_ADCL_ENA | WM8994_ADCR_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_4, val);
+
+	//DAC2 Setting
+	//ADCR_TO_DAC2 vol, ADCL_TO_DAC2 vol
+	wm8994_write(codec, WM8994_DAC2_MIXER_VOLUMES, 0x018C); //603H : 0x018C
+
+	//ADCL_TO_DAC2L
+	val = wm8994_read(codec, WM8994_DAC2_LEFT_MIXER_ROUTING);	//604H : 0x0010
+	val &= ~(WM8994_ADC1_TO_DAC2L_MASK);
+	val |= (WM8994_ADC1_TO_DAC2L);
+	wm8994_write(codec, WM8994_DAC2_LEFT_MIXER_ROUTING, val);
+
+	//ADCR_TO_DAC2R
+	val = wm8994_read(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING);	//605H : 0x0010
+	val &= ~(WM8994_ADC2_TO_DAC2R_MASK);
+	val |= (WM8994_ADC2_TO_DAC2R);					// Changed value to support stereo
+	wm8994_write(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING, val);
+
+	//DAC block volume
+	//DAC1, DAC2 Volume Setting
+	//Unmute DAC1 left
+	val = wm8994_read(codec,WM8994_DAC1_LEFT_VOLUME );	//610H : 1C0
+	val &= ~(WM8994_DAC1L_MUTE_MASK | WM8994_DAC1L_VOL_MASK);
+	val |= (TUNING_DAC1L_VOL);
+	wm8994_write(codec,WM8994_DAC1_LEFT_VOLUME ,val);
+
+	//Unmute and volume ctrl RightDAC
+	val = wm8994_read(codec, WM8994_DAC1_RIGHT_VOLUME);	//611 : 1C0
+	val &= ~(WM8994_DAC1R_MUTE_MASK | WM8994_DAC1R_VOL_MASK);
+	val |= (WM8994_DAC1_VU | TUNING_DAC1R_VOL); //0 db volume
+	wm8994_write(codec,WM8994_DAC1_RIGHT_VOLUME,val);
+
+	val = wm8994_read(codec, WM8994_DAC2_LEFT_VOLUME);	//612 : 1C0
+	val &= ~(WM8994_DAC2L_MUTE_MASK | WM8994_DAC2L_VOL_MASK);
+	val |= (TUNING_DAC2L_VOL); //0 db volume
+	wm8994_write(codec,WM8994_DAC2_LEFT_VOLUME,val);
+
+	val = wm8994_read(codec, WM8994_DAC2_RIGHT_VOLUME);	//613 : 1C0
+	val &= ~(WM8994_DAC2R_MUTE_MASK | WM8994_DAC2R_VOL_MASK);
+	val |= (WM8994_DAC2_VU | TUNING_DAC2R_VOL); //0 db volume
+	wm8994_write(codec, WM8994_DAC2_RIGHT_VOLUME, val);
+
+	wm8994_write(codec, WM8994_AIF1_DAC1_EQ_GAINS_1, 0x0000);	//480 : 0
+
+//	wm8994_write(codec, 0x01, 0x1003);
+
+	wm8994_write(codec, WM8994_OVERSAMPLING, 0x0000);
+
+	//AIF2 Master/Slave , LOOPBACK, AIF2DAC Unmute
+	val = wm8994_read(codec, WM8994_AIF2_MASTER_SLAVE); //312 : 7000
+	val &= ~(WM8994_AIF2_LRCLK_FRC_MASK | WM8994_AIF2_CLK_FRC_MASK | WM8994_AIF2_MSTR_MASK);
+	val |= (WM8994_AIF2_LRCLK_FRC | WM8994_AIF2_CLK_FRC | WM8994_AIF2_MSTR);
+	wm8994_write(codec, WM8994_AIF2_MASTER_SLAVE, val);
+
+	val = wm8994_read(codec, WM8994_AIF2_CONTROL_2);	//311 : 4001
+	val &= ~(WM8994_AIF2_LOOPBACK_MASK);
+	val |= (WM8994_AIF2_LOOPBACK);
+	wm8994_write(codec, WM8994_AIF2_CONTROL_2, val);
+
+	val = wm8994_read(codec, WM8994_AIF2_DAC_FILTERS_1);	//520 : 0
+	val &= ~(WM8994_AIF2DAC_MUTE_MASK);
+	wm8994_write(codec, WM8994_AIF2_DAC_FILTERS_1, val);
+
+	//Enbale bias,vmid and Left speaker
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1);
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK |WM8994_SPKOUTL_ENA_MASK);
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL | WM8994_SPKOUTL_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+	//DAC Routing
+	val = wm8994_read(codec, WM8994_DAC1_LEFT_MIXER_ROUTING);	//601H : 0x05
+	val &= ~(WM8994_AIF1DAC1L_TO_DAC1L_MASK | WM8994_AIF1DAC2L_TO_DAC1L_MASK | WM8994_AIF2DACL_TO_DAC1L_MASK);
+	val |= (WM8994_AIF2DACL_TO_DAC1L | WM8994_AIF1DAC1L_TO_DAC1L);
+	wm8994_write(codec, WM8994_DAC1_LEFT_MIXER_ROUTING, val);
+
+	val = wm8994_read(codec, WM8994_DAC1_RIGHT_MIXER_ROUTING);	//602H : 0x05
+	val &= ~(WM8994_AIF1DAC1R_TO_DAC1R_MASK | WM8994_AIF1DAC2R_TO_DAC1R_MASK | WM8994_AIF2DACR_TO_DAC1R_MASK);
+	val |= (WM8994_AIF1DAC1R_TO_DAC1R | WM8994_AIF2DACR_TO_DAC1R);
+	wm8994_write(codec, WM8994_DAC1_RIGHT_MIXER_ROUTING, val);
+
+	wm8994_write(codec, WM8994_AIF1_DAC1_FILTERS_1, 0x0000);
+#elif defined(CONFIG_PHONE_P1_CDMA)
+	wm8994->fmradio_path = FMR_SPK;
+
+	//Disable end point for preventing pop up noise.
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1);
+	val &= ~(WM8994_SPKOUTL_ENA_MASK);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+	// Enable IN2 and MIXIN - Temporary inserted for blocking MIC and FM radio mixing - DW Shim 2010.03.04
+//	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_2);
+//	val &= ~(WM8994_TSHUT_ENA_MASK | WM8994_TSHUT_OPDIS_MASK | WM8994_OPCLK_ENA_MASK |
+//			WM8994_MIXINL_ENA_MASK | WM8994_MIXINR_ENA_MASK | WM8994_IN2L_ENA_MASK | WM8994_IN2R_ENA_MASK);
+//	val |= (WM8994_TSHUT_ENA | WM8994_TSHUT_OPDIS | WM8994_OPCLK_ENA | WM8994_MIXINL_ENA |
+//			WM8994_MIXINR_ENA | WM8994_IN2L_ENA | WM8994_IN2R_ENA);
+	val = (WM8994_TSHUT_ENA | WM8994_TSHUT_OPDIS | WM8994_OPCLK_ENA | WM8994_MIXINL_ENA |
+			WM8994_MIXINR_ENA | WM8994_IN2L_ENA | WM8994_IN2R_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_2, val);
+
+	wm8994_set_fmradio_common(codec, 1);
+
+	if(!wm8994->testmode_config_flag)
+	{
+		// Unmute the SPKMIXVOLUME
+		val = wm8994_read(codec, WM8994_SPKMIXL_ATTENUATION);
+		val &= ~(WM8994_SPKMIXL_VOL_MASK);
+		val |= TUNING_SPKMIXL_ATTEN;
+		wm8994_write(codec, WM8994_SPKMIXL_ATTENUATION, val);
+
+		val = wm8994_read(codec, WM8994_SPKMIXR_ATTENUATION);
+		val &= ~(WM8994_SPKMIXR_VOL_MASK);
+		wm8994_write(codec, WM8994_SPKMIXR_ATTENUATION, val);
+
+		val = wm8994_read(codec, WM8994_SPEAKER_VOLUME_LEFT);
+		val &= ~(WM8994_SPKOUTL_MUTE_N_MASK | WM8994_SPKOUTL_VOL_MASK);
+		val |= (WM8994_SPKOUT_VU | WM8994_SPKOUTL_MUTE_N | TUNING_FMRADIO_SPKL_VOL);
+		wm8994_write(codec, WM8994_SPEAKER_VOLUME_LEFT, val);
+
+		val = wm8994_read(codec, WM8994_SPEAKER_VOLUME_RIGHT);
+		val &= ~(WM8994_SPKOUTR_MUTE_N_MASK | WM8994_SPKOUTR_VOL_MASK);
+		wm8994_write(codec, WM8994_SPEAKER_VOLUME_RIGHT, val);
+
+		val = wm8994_read(codec, WM8994_CLASSD);
+		val &= ~(WM8994_SPKOUTL_BOOST_MASK);
+		val |= TUNING_FMRADIO_CLASSD_VOL << WM8994_SPKOUTL_BOOST_SHIFT;
+		wm8994_write(codec, WM8994_CLASSD, val);
+
+	}
+
+	/*Output MIxer-Output PGA*/
+	val = wm8994_read(codec,WM8994_SPKOUT_MIXERS );
+	val &= ~(WM8994_SPKMIXL_TO_SPKOUTL_MASK |
+		WM8994_SPKMIXR_TO_SPKOUTL_MASK | WM8994_SPKMIXR_TO_SPKOUTR_MASK);
+	val |= (WM8994_SPKMIXL_TO_SPKOUTL);
+	wm8994_write(codec, WM8994_SPKOUT_MIXERS, val);
+
+	// Output mixer setting
+	val = wm8994_read(codec, WM8994_SPEAKER_MIXER);
+	val &= ~(WM8994_MIXINL_TO_SPKMIXL_MASK | WM8994_MIXINR_TO_SPKMIXR_MASK);
+	val |= (WM8994_MIXINL_TO_SPKMIXL);
+	wm8994_write(codec, WM8994_SPEAKER_MIXER, val);
+
+	// Enable SPK Volume.
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_3);
+	val &= ~(WM8994_SPKRVOL_ENA_MASK | WM8994_SPKLVOL_ENA_MASK);
+	val |= (WM8994_SPKLVOL_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, val);
+
+	//Enbale bias,vmid and Left speaker
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1);
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK |WM8994_SPKOUTL_ENA_MASK);
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL | WM8994_SPKOUTL_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+#endif
+}
+
+void wm8994_set_fmradio_headset_mix(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	int val;
+
+	DEBUG_LOG("");
+
+	if(wm8994->fmradio_path == FMR_SPK)
+		wm8994_set_playback_headset(codec);
+	else
+	{
+		// Unmute the AF1DAC1
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_FILTERS_1 );
+		val &= ~(WM8994_AIF1DAC1_MUTE_MASK | WM8994_AIF1DAC1_MONO_MASK);
+		val |= WM8994_AIF1DAC1_UNMUTE;
+		wm8994_write(codec,WM8994_AIF1_DAC1_FILTERS_1 ,val);
+
+		// Enable the Timeslot0 to DAC1L
+		val = wm8994_read(codec, WM8994_DAC1_LEFT_MIXER_ROUTING  );
+		val &= ~(WM8994_AIF1DAC1L_TO_DAC1L_MASK);
+		val |= WM8994_AIF1DAC1L_TO_DAC1L;
+		wm8994_write(codec,WM8994_DAC1_LEFT_MIXER_ROUTING ,val);
+
+		//Enable the Timeslot0 to DAC1R
+		val = wm8994_read(codec, WM8994_DAC1_RIGHT_MIXER_ROUTING  );
+		val &= ~(WM8994_AIF1DAC1R_TO_DAC1R_MASK);
+		val |= WM8994_AIF1DAC1R_TO_DAC1R;
+		wm8994_write(codec,WM8994_DAC1_RIGHT_MIXER_ROUTING ,val);
+
+		// Enable DAC1L to HPOUT1L path
+		val = wm8994_read(codec, WM8994_OUTPUT_MIXER_1);
+		val &=	~(WM8994_DAC1L_TO_HPOUT1L_MASK | WM8994_DAC1L_TO_MIXOUTL_MASK);
+		val |= WM8994_DAC1L_TO_MIXOUTL ;
+		wm8994_write(codec,WM8994_OUTPUT_MIXER_1, val);
+
+		// Enable DAC1R to HPOUT1R path
+		val = wm8994_read(codec, WM8994_OUTPUT_MIXER_2);
+		val &= ~(WM8994_DAC1R_TO_HPOUT1R_MASK | WM8994_DAC1R_TO_MIXOUTR_MASK);
+		val |= WM8994_DAC1R_TO_MIXOUTR;
+		wm8994_write(codec, WM8994_OUTPUT_MIXER_2, val);
+
+		//Enable Dac1 and DAC2 and the Timeslot0 for AIF1
+		val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_5 );
+		val &= ~(WM8994_DAC1R_ENA_MASK | WM8994_DAC1L_ENA_MASK|WM8994_AIF1DAC1R_ENA_MASK |	WM8994_AIF1DAC1L_ENA_MASK );
+		val |= (WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA  | WM8994_DAC1L_ENA |WM8994_DAC1R_ENA );
+		wm8994_write(codec, WM8994_POWER_MANAGEMENT_5 ,val);
+
+		//Unmute DAC1 left
+		val = wm8994_read(codec,WM8994_DAC1_LEFT_VOLUME );
+		val &= ~(WM8994_DAC1L_MUTE_MASK | WM8994_DAC1L_VOL_MASK);
+		val |= (TUNING_DAC1L_VOL);
+		wm8994_write(codec,WM8994_DAC1_LEFT_VOLUME ,val);
+
+		//Unmute and volume ctrl RightDAC
+		val = wm8994_read(codec, WM8994_DAC1_RIGHT_VOLUME );
+		val &= ~(WM8994_DAC1R_MUTE_MASK | WM8994_DAC1R_VOL_MASK);
+		val |= (WM8994_DAC1_VU | TUNING_DAC1R_VOL); //0 db volume
+		wm8994_write(codec,WM8994_DAC1_RIGHT_VOLUME,val);
+
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_LEFT_VOLUME);
+		val &= ~(WM8994_AIF1DAC1L_VOL_MASK);
+		val |= (TUNING_DAC1L_RADIO_VOL);
+		wm8994_write(codec, WM8994_AIF1_DAC1_LEFT_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME);
+		val &= ~(WM8994_AIF1DAC1R_VOL_MASK);
+		val |= (WM8994_AIF1DAC1_VU |TUNING_DAC1R_RADIO_VOL);
+		wm8994_write(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME, val);
+	}
+}
+
+void wm8994_set_fmradio_speaker_mix(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	int val;
+
+	DEBUG_LOG("");
+
+	if(wm8994->fmradio_path == FMR_HP)
+		wm8994_set_playback_speaker(codec);
+	else
+	{
+		//Unmute DAC1 left
+		val = wm8994_read(codec,WM8994_DAC1_LEFT_VOLUME );
+		val &= ~(WM8994_DAC1L_MUTE_MASK | WM8994_DAC1L_VOL_MASK);
+		val |= (TUNING_DAC1L_VOL);
+		wm8994_write(codec,WM8994_DAC1_LEFT_VOLUME ,val);
+
+		//Unmute and volume ctrl RightDAC
+		val = wm8994_read(codec, WM8994_DAC1_RIGHT_VOLUME );
+		val &= ~(WM8994_DAC1R_MUTE_MASK | WM8994_DAC1R_VOL_MASK);
+		val |= (WM8994_DAC1_VU | TUNING_DAC1R_VOL); //0 db volume
+		wm8994_write(codec,WM8994_DAC1_RIGHT_VOLUME,val);
+
+		//Unmute the DAC path
+		val = wm8994_read(codec,WM8994_SPEAKER_MIXER);
+		val &= ~(WM8994_DAC1L_TO_SPKMIXL_MASK);
+		val |= WM8994_DAC1L_TO_SPKMIXL;
+		wm8994_write(codec, WM8994_SPEAKER_MIXER, val);
+
+		// Eable DAC1 Left and timeslot left
+		val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_5);
+		val &= ~( WM8994_DAC1L_ENA_MASK | WM8994_AIF1DAC1R_ENA_MASK | WM8994_AIF1DAC1L_ENA_MASK);
+		val |= (WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA | WM8994_DAC1L_ENA);
+		wm8994_write(codec, WM8994_POWER_MANAGEMENT_5, val);
+
+		//Unmute
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_FILTERS_1);
+		val &= ~(WM8994_AIF1DAC1_MUTE_MASK | WM8994_AIF1DAC1_MONO_MASK);
+		val |= (WM8994_AIF1DAC1_UNMUTE | WM8994_AIF1DAC1_MONO);
+		wm8994_write(codec, WM8994_AIF1_DAC1_FILTERS_1, val);
+
+		//enable timeslot0 to left dac
+		val = wm8994_read(codec, WM8994_DAC1_LEFT_MIXER_ROUTING);
+		val &= ~(WM8994_AIF1DAC1L_TO_DAC1L_MASK);
+		val |= WM8994_AIF1DAC1L_TO_DAC1L;
+		wm8994_write(codec, WM8994_DAC1_LEFT_MIXER_ROUTING, val);
+	}
+	wm8994->fmradio_path = FMR_SPK_MIX;
+}
+
+void wm8994_set_fmradio_speaker_headset_mix(struct snd_soc_codec *codec)
+{
+	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
+	u16 val;
+
+	u16 nReadServo4Val = 0;
+	u16 ncompensationResult = 0;
+	u16 nServo4Low = 0;
+	u16 nServo4High = 0;
+	u8  nCompensationResultLow=0;
+	u8 nCompensationResultHigh=0;
+
+	DEBUG_LOG("");
+
+	if(wm8994->fmradio_path == FMR_HP)
+		wm8994_disable_fmradio_path(codec);
+	else
+		wm8994_disable_fmradio_path(codec);
+
+	wm8994->fmradio_path = FMR_DUAL_MIX;
+
+	wm8994_write(codec, WM8994_GPIO_3, 0x0100);
+	wm8994_write(codec, WM8994_GPIO_4, 0x0100);
+	wm8994_write(codec, WM8994_GPIO_5, 0x8100);
+	wm8994_write(codec, WM8994_GPIO_6, 0xA101);
+	wm8994_write(codec, WM8994_GPIO_7, 0x0100);
+
+	// Disable reg sync to MCLK
+	val = wm8994_read(codec, WM8994_AIF1_CLOCKING_1);
+	val &= ~(WM8994_AIF1CLK_ENA_MASK);
+	val |= WM8994_AIF1CLK_ENA;
+	wm8994_write(codec, WM8994_AIF1_CLOCKING_1, val);
+
+
+	// Analogue Path Config
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_2  );
+	val &= ~(WM8994_MIXINL_ENA_MASK | WM8994_MIXINR_ENA_MASK | WM8994_IN2L_ENA_MASK | WM8994_IN2R_ENA_MASK);
+	val |= (WM8994_MIXINL_ENA | WM8994_MIXINR_ENA| WM8994_IN2L_ENA| WM8994_IN2R_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_2 , val );
+
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_1);
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_NORMAL);
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1 , 0x0003);
+
+	val = wm8994_read(codec, WM8994_LEFT_OUTPUT_VOLUME);
+	val = 0x0000;
+	wm8994_write(codec, WM8994_LEFT_OUTPUT_VOLUME, val);
+
+	val = wm8994_read(codec, WM8994_RIGHT_OUTPUT_VOLUME);
+	val = 0x0100;
+	wm8994_write(codec, WM8994_RIGHT_OUTPUT_VOLUME, val);
+
+//	wm8994_set_fmradio_common(codec, 1);
+
+	//FLL2 Setting
+	val = wm8994_read(codec, WM8994_AIF2_CLOCKING_1);	//204H : 0x0011
+	val &= ~(WM8994_AIF2CLK_ENA_MASK | WM8994_AIF2CLK_SRC_MASK);
+	val |= (WM8994_AIF2CLK_ENA | 0x2 << WM8994_AIF2CLK_SRC_SHIFT);
+	wm8994_write(codec, WM8994_AIF2_CLOCKING_1, val);
+
+	val = wm8994_read(codec, WM8994_CLOCKING_1);	//208H : 0xF -> 0xE
+	val &= ~(WM8994_SYSCLK_SRC_MASK | WM8994_DSP_FSINTCLK_ENA_MASK | WM8994_DSP_FS2CLK_ENA_MASK | WM8994_DSP_FS1CLK_ENA_MASK);
+	val |= (WM8994_DSP_FS1CLK_ENA | WM8994_DSP_FS2CLK_ENA | WM8994_DSP_FSINTCLK_ENA);
+	wm8994_write(codec, WM8994_CLOCKING_1, val);
+
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_4);	//04H
+	val &= ~(WM8994_AIF2ADCL_ENA_MASK | WM8994_AIF2ADCR_ENA_MASK | WM8994_ADCL_ENA_MASK | WM8994_ADCR_ENA_MASK);
+	val |= (WM8994_AIF2ADCL_ENA | WM8994_AIF2ADCR_ENA | WM8994_ADCL_ENA | WM8994_ADCR_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_4, val);
+
+	//DAC2 Setting
+	wm8994_write(codec, WM8994_DAC2_MIXER_VOLUMES, 0x018C);	//603H : 0x018C
+
+	val = wm8994_read(codec, WM8994_DAC2_LEFT_MIXER_ROUTING);	//604H : 0x0010
+	val &= ~(WM8994_ADC1_TO_DAC2L_MASK);
+	val |= (WM8994_ADC1_TO_DAC2L);
+	wm8994_write(codec, WM8994_DAC2_LEFT_MIXER_ROUTING, val);
+
+	val = wm8994_read(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING);	//605H : 0x0010
+	val &= ~(WM8994_ADC2_TO_DAC2R_MASK);
+	val |= (WM8994_ADC2_TO_DAC2R);					// Changed value to support stereo
+	wm8994_write(codec, WM8994_DAC2_RIGHT_MIXER_ROUTING, val);
+
+	//DRC for Noise-gate (AIF2)
+	wm8994_write(codec, 0x541, 0x0850);
+	wm8994_write(codec, 0x542, 0x0800);
+	wm8994_write(codec, 0x543, 0x0001);
+	wm8994_write(codec, 0x544, 0x0008);
+	wm8994_write(codec, 0x540, 0x01BC);
+
+	//DAC1 Setting
+	val = wm8994_read(codec, WM8994_DAC1_LEFT_MIXER_ROUTING);	//601H : 0x05
+	val &= ~(WM8994_AIF1DAC1L_TO_DAC1L_MASK | WM8994_AIF1DAC2L_TO_DAC1L_MASK | WM8994_AIF2DACL_TO_DAC1L_MASK);
+	val |= (WM8994_AIF2DACL_TO_DAC1L | WM8994_AIF1DAC1L_TO_DAC1L);
+	wm8994_write(codec, WM8994_DAC1_LEFT_MIXER_ROUTING, val);
+
+
+	val = wm8994_read(codec, WM8994_DAC1_RIGHT_MIXER_ROUTING);	//602H : 0x05
+	val &= ~(WM8994_AIF1DAC1R_TO_DAC1R_MASK | WM8994_AIF1DAC2R_TO_DAC1R_MASK | WM8994_AIF2DACR_TO_DAC1R_MASK);
+	val |= (WM8994_AIF1DAC1R_TO_DAC1R | WM8994_AIF2DACR_TO_DAC1R);
+	wm8994_write(codec, WM8994_DAC1_RIGHT_MIXER_ROUTING, val);
+
+	//DAC1, DAC2 Volume Setting
+	//Unmute DAC1 left
+	val = wm8994_read(codec,WM8994_DAC1_LEFT_VOLUME );	//610H : 1C0
+	val &= ~(WM8994_DAC1L_MUTE_MASK | WM8994_DAC1L_VOL_MASK);
+	val |= (TUNING_DAC1L_VOL);
+	wm8994_write(codec,WM8994_DAC1_LEFT_VOLUME ,val);
+
+	//Unmute and volume ctrl RightDAC
+	val = wm8994_read(codec, WM8994_DAC1_RIGHT_VOLUME);	//611 : 1C0
+	val &= ~(WM8994_DAC1R_MUTE_MASK | WM8994_DAC1R_VOL_MASK);
+	val |= (WM8994_DAC1_VU | TUNING_DAC1R_VOL); //0 db volume
+	wm8994_write(codec,WM8994_DAC1_RIGHT_VOLUME,val);
+
+
+	val = wm8994_read(codec, WM8994_DAC2_LEFT_VOLUME);	//612 : 1C0
+	val &= ~(WM8994_DAC2L_MUTE_MASK | WM8994_DAC2L_VOL_MASK);
+	val |= (TUNING_DAC2L_VOL); //0 db volume
+	wm8994_write(codec,WM8994_DAC2_LEFT_VOLUME,val);
+
+	val = wm8994_read(codec, WM8994_DAC2_RIGHT_VOLUME);	//613 : 1C0
+	val &= ~(WM8994_DAC2R_MUTE_MASK | WM8994_DAC2R_VOL_MASK);
+	val |= (WM8994_DAC2_VU | TUNING_DAC2R_VOL); //0 db volume
+	wm8994_write(codec, WM8994_DAC2_RIGHT_VOLUME, val);
+
+	wm8994_write(codec, WM8994_AIF1_DAC1_EQ_GAINS_1, 0x0000);	//480 : 0
+
+	//Digital  Mixer setting
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_5);	//05 : 3303
+	val &= ~(WM8994_AIF2DACL_ENA_MASK | WM8994_AIF2DACR_ENA_MASK | WM8994_AIF1DAC1L_ENA_MASK | WM8994_AIF1DAC1R_ENA_MASK
+		 | WM8994_DAC1L_ENA_MASK | WM8994_DAC1R_ENA_MASK);
+	val |= (WM8994_AIF2DACL_ENA | WM8994_AIF2DACR_ENA | WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA
+		 | WM8994_DAC1L_ENA | WM8994_DAC1R_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_5, val);
+
+	val = wm8994_read(codec, WM8994_POWER_MANAGEMENT_3);	//03 : F
+	val &= ~(WM8994_MIXOUTLVOL_ENA_MASK | WM8994_MIXOUTRVOL_ENA_MASK | WM8994_MIXOUTL_ENA_MASK | WM8994_MIXOUTR_ENA_MASK
+		|WM8994_SPKLVOL_ENA_MASK | WM8994_SPKRVOL_ENA_MASK);
+	val |= (WM8994_MIXOUTLVOL_ENA | WM8994_MIXOUTRVOL_ENA | WM8994_MIXOUTL_ENA | WM8994_MIXOUTR_ENA | WM8994_SPKLVOL_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_3, val);
+
+	val = wm8994_read(codec, WM8994_OUTPUT_MIXER_1);	//2D : 1
+	val &= ~(WM8994_DAC1L_TO_MIXOUTL_MASK);
+	val |= (WM8994_DAC1L_TO_MIXOUTL);
+	wm8994_write(codec, WM8994_OUTPUT_MIXER_1, val);
+
+	val = wm8994_read(codec, WM8994_OUTPUT_MIXER_2);	//2E : 1
+	val &= ~(WM8994_DAC1R_TO_MIXOUTR_MASK);
+	val |= (WM8994_DAC1R_TO_MIXOUTR);
+	wm8994_write(codec, WM8994_OUTPUT_MIXER_2, val);
+
+	val = wm8994_read(codec, WM8994_SPKOUT_MIXERS );
+	val &= ~(WM8994_SPKMIXL_TO_SPKOUTL_MASK |
+		WM8994_SPKMIXR_TO_SPKOUTL_MASK | WM8994_SPKMIXR_TO_SPKOUTR_MASK);
+	val |= (WM8994_SPKMIXL_TO_SPKOUTL);
+	wm8994_write(codec, WM8994_SPKOUT_MIXERS, val);
+
+	//Unmute the DAC path
+	val = wm8994_read(codec,WM8994_SPEAKER_MIXER);
+	val &= ~(WM8994_DAC1L_TO_SPKMIXL_MASK);
+	val |= WM8994_DAC1L_TO_SPKMIXL;
+	wm8994_write(codec, WM8994_SPEAKER_MIXER, val);
+
+	//AIF1 FLL Setting
+	wm8994_write(codec, WM8994_OVERSAMPLING, 0x0000);
+
+	//AIF2 Master/Slave , LOOPBACK, AIF2DAC Unmute
+	val = wm8994_read(codec, WM8994_AIF2_MASTER_SLAVE);	//312 : 7000
+	val &= ~(WM8994_AIF2_LRCLK_FRC_MASK | WM8994_AIF2_CLK_FRC_MASK | WM8994_AIF2_MSTR_MASK);
+	val |= (WM8994_AIF2_LRCLK_FRC | WM8994_AIF2_CLK_FRC | WM8994_AIF2_MSTR);
+	wm8994_write(codec, WM8994_AIF2_MASTER_SLAVE, val);
+
+	val = wm8994_read(codec, WM8994_AIF2_CONTROL_2);	//311 : 4001
+	val &= ~(WM8994_AIF2_LOOPBACK_MASK);
+	val |= (WM8994_AIF2_LOOPBACK);
+	wm8994_write(codec, WM8994_AIF2_CONTROL_2, val);
+
+	//* Unmutes
+	// Output setting
+	if(wm8994->testmode_config_flag == SEC_NORMAL)
+	{
+		val = wm8994_read(codec, WM8994_LEFT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTL_MUTE_N_MASK | WM8994_MIXOUTL_VOL_MASK);
+		val |= (WM8994_MIXOUTL_MUTE_N | TUNING_FMRADIO_OPGAL_VOL);
+		wm8994_write(codec,WM8994_LEFT_OPGA_VOLUME, val );
+
+		val = wm8994_read(codec, WM8994_RIGHT_OPGA_VOLUME);
+		val &= ~(WM8994_MIXOUTR_MUTE_N_MASK | WM8994_MIXOUTR_VOL_MASK);
+		val |= (WM8994_MIXOUT_VU | WM8994_MIXOUTR_MUTE_N | TUNING_FMRADIO_OPGAR_VOL);
+		wm8994_write(codec,WM8994_RIGHT_OPGA_VOLUME, val );
+
+		val = wm8994_read(codec, WM8994_LEFT_OUTPUT_VOLUME);
+		val &= ~(WM8994_HPOUT1L_MUTE_N_MASK | WM8994_HPOUT1L_VOL_MASK);
+		val |= (WM8994_HPOUT1L_MUTE_N | TUNING_FMRADIO_OUTPUTL_VOL);
+		wm8994_write(codec, WM8994_LEFT_OUTPUT_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_RIGHT_OUTPUT_VOLUME);
+		val &= ~(WM8994_HPOUT1R_MUTE_N_MASK | WM8994_HPOUT1R_VOL_MASK);
+		val |= (WM8994_HPOUT1_VU | WM8994_HPOUT1R_MUTE_N | TUNING_FMRADIO_OUTPUTR_VOL);
+		wm8994_write(codec, WM8994_RIGHT_OUTPUT_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_LEFT_VOLUME);
+		val &= ~(WM8994_AIF1DAC1L_VOL_MASK);
+		val |= (TUNING_DUAL_DAC1L_RADIO_VOL);
+		wm8994_write(codec, WM8994_AIF1_DAC1_LEFT_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME);
+		val &= ~(WM8994_AIF1DAC1R_VOL_MASK);
+		val |= (WM8994_AIF1DAC1_VU |TUNING_DUAL_DAC1R_RADIO_VOL);
+		wm8994_write(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME, val);
+
+		val = wm8994_read(codec, WM8994_CLASSD);
+		val &= ~(WM8994_SPKOUTL_BOOST_MASK);
+		val |= TUNING_FMRADIO_CLASSD_VOL << WM8994_SPKOUTL_BOOST_SHIFT;
+		wm8994_write(codec, WM8994_CLASSD, val);
+
+		val = wm8994_read(codec, WM8994_SPEAKER_VOLUME_LEFT);
+		val &= ~(WM8994_SPKOUTL_MUTE_N_MASK | WM8994_SPKOUTL_VOL_MASK);
+		val |= (WM8994_SPKOUT_VU | WM8994_SPKOUTL_MUTE_N | TUNING_FMRADIO_SPKL_VOL);
+		wm8994_write(codec, WM8994_SPEAKER_VOLUME_LEFT, val);
+	}
+	//* Headset
+	wm8994_write(codec, 0x102, 0x0003);
+	wm8994_write(codec, 0x56, 0x0003);
+	wm8994_write(codec, 0x102, 0x0000);
+	wm8994_write(codec, 0x5D, 0x0002);
+
+
+	//* DC Servo Series Count
+	val = 0x03E0;
+	wm8994_write(codec, WM8994_DC_SERVO_2, val);
+
+	//* HP first and second stage
+	//Enable vmid,bias, hp left and right
+	val = wm8994_read(codec,WM8994_POWER_MANAGEMENT_1 );
+	val &= ~(WM8994_BIAS_ENA_MASK | WM8994_VMID_SEL_MASK |WM8994_HPOUT1L_ENA_MASK | WM8994_HPOUT1R_ENA_MASK | WM8994_SPKOUTR_ENA_MASK | WM8994_SPKOUTL_ENA_MASK);
+	val |= (WM8994_BIAS_ENA | WM8994_VMID_SEL_NORMAL | WM8994_HPOUT1R_ENA | WM8994_HPOUT1L_ENA | WM8994_SPKOUTL_ENA);
+	wm8994_write(codec, WM8994_POWER_MANAGEMENT_1, val);
+
+	val = (WM8994_HPOUT1L_DLY | WM8994_HPOUT1R_DLY);
+	wm8994_write(codec, WM8994_ANALOGUE_HP_1, val);
+
+
+	//Enable Charge Pump
+	val = wm8994_read(codec, WM8994_CHARGE_PUMP_1);
+	val &= ~WM8994_CP_ENA_MASK ;
+	val |= WM8994_CP_ENA | WM8994_CP_ENA_DEFAULT ; // this is from wolfson
+	wm8994_write(codec, WM8994_CHARGE_PUMP_1, 0x9F25);
+
+	msleep(5);
+
+	//* DC Servo
+	val = (WM8994_DCS_TRIG_SERIES_1 | WM8994_DCS_TRIG_SERIES_0 | WM8994_DCS_ENA_CHAN_1 | WM8994_DCS_ENA_CHAN_0);
+	wm8994_write(codec,WM8994_DC_SERVO_1, 0x0303 );
+
+	msleep(160);
+
+	nReadServo4Val=wm8994_read(codec,WM8994_DC_SERVO_4);
+	nServo4Low=(u8)(nReadServo4Val & 0xff);
+	nServo4High=(u8)((nReadServo4Val>>8) & 0xff);
+
+	nCompensationResultLow=((u16)nServo4Low-5)&0x00ff;
+	nCompensationResultHigh=(((u16)nServo4High-5)<<8)&0xff00;
+	ncompensationResult=nCompensationResultLow|nCompensationResultHigh;
+	wm8994_write(codec,WM8994_DC_SERVO_4, ncompensationResult);
+
+	val = (WM8994_DCS_TRIG_DAC_WR_1 | WM8994_DCS_TRIG_DAC_WR_0 | WM8994_DCS_ENA_CHAN_1 | WM8994_DCS_ENA_CHAN_0);
+	wm8994_write(codec,WM8994_DC_SERVO_1, val );
+
+	msleep(20);
+
+	//* Headphone Output
+		// Intermediate HP settings
+	val = wm8994_read(codec, WM8994_ANALOGUE_HP_1);
+	val &= ~(WM8994_HPOUT1R_DLY_MASK |WM8994_HPOUT1R_OUTP_MASK |WM8994_HPOUT1R_RMV_SHORT_MASK |
+		WM8994_HPOUT1L_DLY_MASK |WM8994_HPOUT1L_OUTP_MASK | WM8994_HPOUT1L_RMV_SHORT_MASK);
+	val |= (WM8994_HPOUT1L_RMV_SHORT | WM8994_HPOUT1L_OUTP|WM8994_HPOUT1L_DLY |WM8994_HPOUT1R_RMV_SHORT |
+		WM8994_HPOUT1R_OUTP | WM8994_HPOUT1R_DLY);
+	wm8994_write(codec, WM8994_ANALOGUE_HP_1, val);
+
+	//DAC1 Unmute
+	val = wm8994_read(codec, WM8994_AIF1_DAC1_FILTERS_1);
+	val &= ~(WM8994_AIF1DAC1_MUTE_MASK | WM8994_AIF1DAC1_MONO_MASK);
+	val |= (WM8994_AIF1DAC1_UNMUTE | WM8994_AIF1DAC1_MONO);
+	wm8994_write(codec, WM8994_AIF1_DAC1_FILTERS_1, val);
+
+	val = wm8994_read(codec, WM8994_AIF2_DAC_FILTERS_1);	//520 : 0
+	val &= ~(WM8994_AIF2DAC_MUTE_MASK);
+	wm8994_write(codec, WM8994_AIF2_DAC_FILTERS_1, val);
+
+}
+
+
+#if defined WM8994_REGISTER_DUMP
+void wm8994_register_dump(struct snd_soc_codec *codec)
+{
+	int wm8994_register;
+
+	for(wm8994_register = 0; wm8994_register <= 0x6; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	DEBUG_LOG_ERR("Register= [%X], Value = [%X]", 0x15, wm8994_read(codec, 0x15));
+
+	for(wm8994_register = 0x18; wm8994_register <= 0x3C; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	DEBUG_LOG_ERR("Register= [%X], Value = [%X]", 0x4C, wm8994_read(codec, 0x4C));
+
+	for(wm8994_register = 0x51; wm8994_register <= 0x5C; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	DEBUG_LOG_ERR("Register= [%X], Value = [%X]", 0x60, wm8994_read(codec, 0x60));
+	DEBUG_LOG_ERR("Register= [%X], Value = [%X]", 0x101, wm8994_read(codec, 0x101));
+	DEBUG_LOG_ERR("Register= [%X], Value = [%X]", 0x110, wm8994_read(codec, 0x110));
+	DEBUG_LOG_ERR("Register= [%X], Value = [%X]", 0x111, wm8994_read(codec, 0x111));
+
+	for(wm8994_register = 0x200; wm8994_register <= 0x212; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	for(wm8994_register = 0x220; wm8994_register <= 0x224; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	for(wm8994_register = 0x240; wm8994_register <= 0x244; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	for(wm8994_register = 0x300; wm8994_register <= 0x317; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	for(wm8994_register = 0x400; wm8994_register <= 0x411; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	for(wm8994_register = 0x420; wm8994_register <= 0x423; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	for(wm8994_register = 0x440; wm8994_register <= 0x444; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	for(wm8994_register = 0x450; wm8994_register <= 0x454; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	for(wm8994_register = 0x480; wm8994_register <= 0x493; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	for(wm8994_register = 0x4A0; wm8994_register <= 0x4B3; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	for(wm8994_register = 0x500; wm8994_register <= 0x503; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	DEBUG_LOG_ERR("Register= [%X], Value = [%X]", 0x510, wm8994_read(codec, 0x510));
+	DEBUG_LOG_ERR("Register= [%X], Value = [%X]", 0x520, wm8994_read(codec, 0x520));
+	DEBUG_LOG_ERR("Register= [%X], Value = [%X]", 0x521, wm8994_read(codec, 0x521));
+
+	for(wm8994_register = 0x540; wm8994_register <= 0x544; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	for(wm8994_register = 0x580; wm8994_register <= 0x593; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	for(wm8994_register = 0x600; wm8994_register <= 0x614; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+	DEBUG_LOG_ERR("Register= [%X], Value = [%X]", 0x620, wm8994_read(codec, 0x620));
+	DEBUG_LOG_ERR("Register= [%X], Value = [%X]", 0x621, wm8994_read(codec, 0x621));
+
+	for(wm8994_register = 0x700; wm8994_register <= 0x70A; wm8994_register++)
+		DEBUG_LOG_ERR("Register= [%X], Value = [%X]", wm8994_register, wm8994_read(codec, wm8994_register));
+
+}
+#endif
diff --git a/sound/soc/samsung/Kconfig b/sound/soc/samsung/Kconfig
index 2600074..9364395 100644
--- a/sound/soc/samsung/Kconfig
+++ b/sound/soc/samsung/Kconfig
@@ -145,6 +145,17 @@ config SND_SOC_SAMSUNG_HERRING_WM8994
 	  Say Y if you want to add support for SoC audio on herring
 	  with the WM8994.
 
+config SND_SOC_SAMSUNG_P1_WM8994
+	tristate "SoC I2S Audio support for P1 - WM8994"
+	depends on SND_SOC_SAMSUNG && MACH_P1
+	select SND_S5PC1XX_I2S
+	select SND_SOC_WM8994
+	select S5P_INTERNAL_DMA
+	select SND_S5P_WM8994_MASTER
+	help
+	  Say Y if you want to add support for SoC audio on P1
+	  with the WM8994.
+
 config SND_SOC_SAMSUNG_RX1950_UDA1380
 	tristate "Audio support for the HP iPAQ RX1950"
 	depends on SND_SOC_SAMSUNG && MACH_RX1950
diff --git a/sound/soc/samsung/Makefile b/sound/soc/samsung/Makefile
index 98a007e..e10c2a7 100644
--- a/sound/soc/samsung/Makefile
+++ b/sound/soc/samsung/Makefile
@@ -1,5 +1,5 @@
 # S3c24XX Platform Support
-snd-soc-s3c24xx-objs := dma.o s3c-dma-wrapper.o 
+snd-soc-s3c24xx-objs := dma.o s3c-dma-wrapper.o
 snd-soc-s3c24xx-i2s-objs := s3c24xx-i2s.o
 snd-soc-s3c2412-i2s-objs := s3c2412-i2s.o
 snd-soc-s5pc1xx-i2s-objs := s5pc1xx-i2s.o
@@ -40,6 +40,7 @@ snd-soc-herring-wm8994-objs := herring-wm8994.o
 snd-soc-smdk-spdif-objs := smdk_spdif.o
 snd-soc-smdk-wm8580pcm-objs := smdk_wm8580pcm.o
 snd-soc-speyside-objs := speyside.o
+snd-soc-p1-wm8994-objs := p1-wm8994.o
 
 obj-$(CONFIG_SND_SOC_SAMSUNG_JIVE_WM8750) += snd-soc-jive-wm8750.o
 obj-$(CONFIG_SND_SOC_SAMSUNG_NEO1973_WM8753) += snd-soc-neo1973-wm8753.o
@@ -51,6 +52,7 @@ obj-$(CONFIG_SND_SOC_SAMSUNG_SIMTEC_HERMES) += snd-soc-s3c24xx-simtec-hermes.o
 obj-$(CONFIG_SND_SOC_SAMSUNG_SIMTEC_TLV320AIC23) += snd-soc-s3c24xx-simtec-tlv320aic23.o
 obj-$(CONFIG_SND_SOC_SAMSUNG_H1940_UDA1380) += snd-soc-h1940-uda1380.o
 obj-$(CONFIG_SND_SOC_SAMSUNG_HERRING_WM8994)  += snd-soc-herring-wm8994.o
+obj-$(CONFIG_SND_SOC_SAMSUNG_P1_WM8994)  += snd-soc-p1-wm8994.o
 obj-$(CONFIG_SND_SOC_SAMSUNG_RX1950_UDA1380) += snd-soc-rx1950-uda1380.o
 obj-$(CONFIG_SND_SOC_SAMSUNG_SMDK_WM8580) += snd-soc-smdk-wm8580.o
 obj-$(CONFIG_SND_SOC_SAMSUNG_SMDK_WM8994) += snd-soc-smdk-wm8994.o
diff --git a/sound/soc/samsung/p1-wm8994.c b/sound/soc/samsung/p1-wm8994.c
new file mode 100644
index 0000000..0ff6f68
--- /dev/null
+++ b/sound/soc/samsung/p1-wm8994.c
@@ -0,0 +1,357 @@
+/*
+ * p1_wm8994.c
+ *
+ * Copyright (C) 2010, Samsung Elect. Ltd. -
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <mach/regs-clock.h>
+#include <plat/regs-iis.h>
+#include "../codecs/wm8994.h"
+#include "s3c-dma.h"
+#include "s5pc1xx-i2s.h"
+
+#include <linux/io.h>
+
+#define I2S_NUM 0
+#define SRC_CLK 66738000
+
+/* #define CONFIG_SND_DEBUG */
+#ifdef CONFIG_SND_DEBUG
+#define debug_msg(x...) printk(x)
+#else
+#define debug_msg(x...)
+#endif
+
+/*  BLC(bits-per-channel) --> BFS(bit clock shud be >= FS*(Bit-per-channel)*2)*/
+/*  BFS --> RFS(must be a multiple of BFS)                                  */
+/*  RFS & SRC_CLK --> Prescalar Value(SRC_CLK / RFS_VAL / fs - 1)           */
+int smdkc110_hw_params(struct snd_pcm_substream *substream,
+	struct snd_pcm_hw_params *params)
+{
+	struct snd_soc_pcm_runtime *rtd = substream->private_data;
+	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
+	struct snd_soc_dai *codec_dai = rtd->codec_dai;
+	int bfs, rfs, ret;
+	u32 ap_codec_clk;
+#ifndef CONFIG_SND_S5P_WM8994_MASTER
+	struct clk    *clk_out, *clk_epll;
+	int psr;
+#endif
+	debug_msg("%s\n", __func__);
+
+	/* Choose BFS and RFS values combination that is supported by
+	 * both the WM8994 codec as well as the S5P AP
+	 *
+	 */
+	switch (params_format(params)) {
+	case SNDRV_PCM_FORMAT_S8:
+	/* Can take any RFS value for AP */
+			bfs = 16;
+			rfs = 256;
+			break;
+	case SNDRV_PCM_FORMAT_S16_LE:
+	/* Can take any RFS value for AP */
+			bfs = 32;
+			rfs = 256;
+			break;
+	case SNDRV_PCM_FORMAT_S20_3LE:
+	case SNDRV_PCM_FORMAT_S24_LE:
+			bfs = 48;
+			rfs = 512;
+			break;
+	/* Impossible, as the AP doesn't support 64fs or more BFS */
+	case SNDRV_PCM_FORMAT_S32_LE:
+	default:
+			return -EINVAL;
+	}
+
+#ifdef CONFIG_SND_S5P_WM8994_MASTER
+	/* Set the Codec DAI configuration */
+	ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
+				SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBM_CFM);
+
+	if (ret < 0) {
+		printk(KERN_ERR "smdkc110_wm8994_hw_params :\
+				 Codec DAI configuration error!\n");
+		return ret;
+	}
+
+	/* Set the AP DAI configuration */
+	ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
+				SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBM_CFM);
+
+	if (ret < 0) {
+		printk(KERN_ERR
+			"smdkc110_wm8994_hw_params :\
+				AP DAI configuration error!\n");
+		return ret;
+	}
+
+	/* Select the AP Sysclk */
+	ret = snd_soc_dai_set_sysclk(cpu_dai, S3C64XX_CDCLKSRC_EXT,
+					params_rate(params), SND_SOC_CLOCK_IN);
+
+	if (ret < 0) {
+		printk(KERN_ERR
+			"smdkc110_wm8994_hw_params :\
+			AP sys clock INT setting error!\n");
+		return ret;
+	}
+
+	ret = snd_soc_dai_set_sysclk(cpu_dai, S3C64XX_CLKSRC_I2SEXT,
+					params_rate(params), SND_SOC_CLOCK_IN);
+	if (ret < 0) {
+		printk(KERN_ERR
+			"smdkc110_wm8994_hw_params :\
+			AP sys clock I2SEXT setting error!\n");
+		return ret;
+	}
+
+	switch (params_rate(params)) {
+
+	case 8000:
+		ap_codec_clk = 4096000;
+		break;
+	case 11025:
+		ap_codec_clk = 2822400;
+		break;
+	case 12000:
+		ap_codec_clk = 6144000;
+		break;
+	case 16000:
+		ap_codec_clk = 4096000;
+		break;
+	case 22050:
+		ap_codec_clk = 6144000;
+		break;
+	case 24000:
+		ap_codec_clk = 6144000;
+		break;
+	case 32000:
+		ap_codec_clk = 8192000;
+		break;
+	case 44100:
+		ap_codec_clk = 11289600;
+		break;
+	case 48000:
+		ap_codec_clk = 12288000;
+		break;
+	default:
+		ap_codec_clk = 11289600;
+		break;
+	}
+
+	ret = snd_soc_dai_set_sysclk(codec_dai, WM8994_SYSCLK_FLL,
+					ap_codec_clk, 0);
+	if (ret < 0)
+		return ret;
+#else
+	ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
+				SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
+
+	if (ret < 0)
+		return ret;
+	ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
+				SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
+
+	if (ret < 0)
+
+		return ret;
+	ret = snd_soc_dai_set_sysclk(cpu_dai, S3C64XX_CLKSRC_CDCLK,
+					params_rate(params), SND_SOC_CLOCK_OUT);
+	if (ret < 0)
+		return ret;
+#ifdef USE_CLKAUDIO
+	ret = snd_soc_dai_set_sysclk(cpu_dai, S3C_CLKSRC_CLKAUDIO,
+					params_rate(params), SND_SOC_CLOCK_OUT);
+
+	if (ret < 0) {
+		printk(KERN_ERR
+			"smdkc110_wm8994_hw_params : \
+			AP sys clock setting error!\n");
+		return ret;
+	}
+#endif
+	clk_out = clk_get(NULL, "clk_out");
+	if (IS_ERR(clk_out)) {
+			printk(KERN_ERR
+				"failed to get CLK_OUT\n");
+			return -EBUSY;
+	}
+
+	clk_epll = clk_get(NULL, "fout_epll");
+	if (IS_ERR(clk_epll)) {
+		printk(KERN_ERR
+			"failed to get fout_epll\n");
+		clk_put(clk_out);
+		return -EBUSY;
+	}
+
+	if (clk_set_parent(clk_out, clk_epll)) {
+		printk(KERN_ERR
+			"failed to set CLK_EPLL as parent of CLK_OUT\n");
+		clk_put(clk_out);
+		clk_put(clk_epll);
+		return -EBUSY;
+	}
+
+
+	switch (params_rate(params)) {
+	case 8000:
+	case 16000:
+	case 32000:
+	case 48000:
+	case 64000:
+	case 96000:
+		clk_set_rate(clk_out, 12288000);
+		ap_codec_clk = SRC_CLK/4;
+		break;
+	case 11025:
+	case 22050:
+	case 44100:
+	case 88200:
+	default:
+		clk_set_rate(clk_out, 11289600);
+		ap_codec_clk = SRC_CLK/6;
+		break;
+	}
+
+	ret = snd_soc_dai_set_sysclk(codec_dai, WM8994_SYSCLK_MCLK,
+							ap_codec_clk, 0);
+	if (ret < 0) {
+		printk(KERN_ERR
+			"smdkc110_wm8994_hw_params : \
+				Codec sys clock setting error!\n");
+		return ret;
+	}
+
+	/* Calculate Prescalare/PLL values for supported Rates */
+	psr = SRC_CLK / rfs / params_rate(params);
+	ret = SRC_CLK / rfs - psr * params_rate(params);
+	/* round off */
+	if (ret >= params_rate(params)/2)
+		psr += 1;
+
+	psr -= 1;
+	printk(KERN_INFO
+		"SRC_CLK=%d PSR=%d RFS=%d BFS=%d\n", SRC_CLK, psr, rfs, bfs);
+
+	/* Set the AP Prescalar/Pll */
+	ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C_I2SV2_DIV_PRESCALER, psr);
+
+	if (ret < 0) {
+		printk(KERN_ERR
+			"smdkc110_wm8994_hw_params :\
+				AP prescalar setting error!\n");
+		return ret;
+	}
+
+	/* Set the AP RFS */
+	ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C_I2SV2_DIV_RCLK, rfs);
+	if (ret < 0) {
+		printk(KERN_ERR
+			"smdkc110_wm8994_hw_params : AP RFS setting error!\n");
+		return ret;
+	}
+
+	/* Set the AP BFS */
+	ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C_I2SV2_DIV_BCLK, bfs);
+
+	if (ret < 0) {
+		printk(KERN_ERR
+			"smdkc110_wm8994_hw_params : AP BCLK setting error!\n");
+		return ret;
+	}
+
+	clk_put(clk_epll);
+	clk_put(clk_out);
+#endif
+	return 0;
+
+}
+
+/* machine stream operations */
+static struct snd_soc_ops smdkc110_ops = {
+	.hw_params = smdkc110_hw_params,
+};
+
+/* digital audio interface glue - connects codec <--> CPU */
+static struct snd_soc_dai_link smdkc1xx_dai = {
+	.name = "WM8994",
+	.stream_name = "WM8994 HiFi Playback",
+	.cpu_dai_name = "samsung-i2s.0",
+	.codec_dai_name = "WM8994 PAIFRX",
+	.platform_name = "samsung-audio",
+	.codec_name = "wm8994-samsung-codec.4-001a",
+	.ops = &smdkc110_ops,
+};
+
+static struct snd_soc_card smdkc100 = {
+	.name = "smdkc110",
+	.dai_link = &smdkc1xx_dai,
+	.num_links = 1,
+};
+
+#if 0
+static struct wm8994_setup_data smdkc110_wm8994_setup = {
+	/*
+		The I2C address of the WM89940 is 0x34. To the I2C driver
+		the address is a 7-bit number hence the right shift .
+	*/
+	.i2c_address = 0x34,
+	.i2c_bus = 4,
+};
+
+/* audio subsystem */
+static struct snd_soc_device smdkc1xx_snd_devdata = {
+	.card = &smdkc100,
+	.codec_dev = &soc_codec_dev_wm8994,
+	.codec_data = &smdkc110_wm8994_setup,
+};
+#endif
+
+static struct platform_device *smdkc1xx_snd_device;
+static int __init smdkc110_audio_init(void)
+{
+	int ret;
+
+	debug_msg("%s\n", __func__);
+
+	smdkc1xx_snd_device = platform_device_alloc("soc-audio", 0);
+	if (!smdkc1xx_snd_device)
+		return -ENOMEM;
+
+	platform_set_drvdata(smdkc1xx_snd_device, &smdkc100);
+	ret = platform_device_add(smdkc1xx_snd_device);
+
+	if (ret)
+		platform_device_put(smdkc1xx_snd_device);
+
+	return ret;
+}
+
+static void __exit smdkc110_audio_exit(void)
+{
+	debug_msg("%s\n", __func__);
+
+	platform_device_unregister(smdkc1xx_snd_device);
+}
+
+module_init(smdkc110_audio_init);
+module_exit(smdkc110_audio_exit);
+
+/* Module information */
+MODULE_DESCRIPTION("ALSA SoC SMDKC110 WM8994");
+MODULE_LICENSE("GPL");