diff --git a/hal/audio_extn/hfp.c b/hal/audio_extn/hfp.c
index 9306894..2ff7e54 100644
--- a/hal/audio_extn/hfp.c
+++ b/hal/audio_extn/hfp.c
@@ -259,6 +259,8 @@
 
     list_add_tail(&adev->usecase_list, &uc_info->list);
 
+    audio_extn_tfa_98xx_set_mode_bt();
+
     select_devices(adev, hfpmod.ucid);
 
     pcm_dev_rx_id = platform_get_pcm_device_id(uc_info->id, PCM_PLAYBACK);
diff --git a/hal/audio_extn/tfa_98xx.c b/hal/audio_extn/tfa_98xx.c
index a4ff134..7667410 100644
--- a/hal/audio_extn/tfa_98xx.c
+++ b/hal/audio_extn/tfa_98xx.c
@@ -404,8 +404,7 @@
             return;
 
         ret = tfa_98xx_set_func_mode(I2S_CLOCK_ENABLE, data->adev, new_func_mode);
-        if (ret)
-        {
+        if (ret) {
             ALOGE("%s: tfa_98xx_set_func_mode enable return %d\n", __func__, ret);
         }
         data->update_ref_cnt = true;
@@ -414,6 +413,19 @@
     ALOGV("%s: exit\n", __func__);
 }
 
+void audio_extn_tfa_98xx_set_mode_bt(void)
+{
+    struct speaker_data *data = tfa98xx_speaker_data;
+    int ret = 0;
+
+    if (data) {
+        ret = tfa_98xx_set_func_mode(I2S_CLOCK_ENABLE, data->adev, Func_Mode_BT);
+        if (ret) {
+            ALOGE("%s: tfa_98xx_set_func_mode enable return %d\n", __func__, ret);
+        }
+    }
+}
+
 void audio_extn_tfa_98xx_update(void)
 {
     struct speaker_data *data = tfa98xx_speaker_data;
diff --git a/hal/audio_extn/tfa_98xx.h b/hal/audio_extn/tfa_98xx.h
index 302c3b5..3dab88f 100644
--- a/hal/audio_extn/tfa_98xx.h
+++ b/hal/audio_extn/tfa_98xx.h
@@ -21,6 +21,7 @@
 int audio_extn_tfa_98xx_enable_speaker(void);
 void audio_extn_tfa_98xx_disable_speaker(snd_device_t snd_device);
 void audio_extn_tfa_98xx_set_mode();
+void audio_extn_tfa_98xx_set_mode_bt(void);
 void audio_extn_tfa_98xx_update(void);
 void audio_extn_tfa_98xx_set_voice_vol(int vol);
 int audio_extn_tfa_98xx_init(struct audio_device *adev);
@@ -30,6 +31,7 @@
 #define audio_extn_tfa_98xx_enable_speaker(void)                (0)
 #define audio_extn_tfa_98xx_disable_speaker(snd_device)         (0)
 #define audio_extn_tfa_98xx_set_mode()                          (0)
+#define audio_extn_tfa_98xx_set_mode_bt()                       (0)
 #define audio_extn_tfa_98xx_update(void)                        (0)
 #define audio_extn_tfa_98xx_set_voice_vol(vol)                  (0)
 #define audio_extn_tfa_98xx_init(adev)                          (0)
