diff --git a/hal/Android.mk b/hal/Android.mk
index 02c4832..3dd408a 100644
--- a/hal/Android.mk
+++ b/hal/Android.mk
@@ -162,6 +162,11 @@
     LOCAL_SRC_FILES += audio_extn/dsm_feedback.c
 endif
 
+ifeq ($(strip $(AUDIO_FEATURE_ENABLED_A2DP_OFFLOAD)),true)
+    LOCAL_CFLAGS += -DA2DP_OFFLOAD_ENABLED
+    LOCAL_SRC_FILES += audio_extn/a2dp.c
+endif
+
 ifneq ($(filter msm8992 msm8994 msm8996 msm8998 sdm845,$(TARGET_BOARD_PLATFORM)),)
   # push codec/mad calibration to HW dep node
   # applicable to msm8992/8994 or newer platforms
diff --git a/hal/audio_extn/a2dp.c b/hal/audio_extn/a2dp.c
new file mode 100644
index 0000000..1a9421b
--- /dev/null
+++ b/hal/audio_extn/a2dp.c
@@ -0,0 +1,1338 @@
+/*
+ * Copyright (C) 2013-2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "a2dp_offload"
+/*#define LOG_NDEBUG 0*/
+#define LOG_NDDEBUG 0
+
+#include <dlfcn.h>
+#include <errno.h>
+#include <pthread.h>
+#include <stdlib.h>
+
+#include <cutils/log.h>
+#include <cutils/str_parms.h>
+#include <cutils/properties.h>
+#include <hardware/audio.h>
+
+#include "audio_hw.h"
+#include "audio_extn.h"
+#include "platform_api.h"
+
+#ifdef A2DP_OFFLOAD_ENABLED
+#define AUDIO_PARAMETER_A2DP_STARTED "A2dpStarted"
+#define BT_IPC_LIB_NAME  "libbthost_if.so"
+
+// Media format definitions
+#define ENC_MEDIA_FMT_AAC                                  0x00010DA6
+#define ENC_MEDIA_FMT_APTX                                 0x000131ff
+#define ENC_MEDIA_FMT_APTX_HD                              0x00013200
+#define ENC_MEDIA_FMT_LDAC                                 0x00013224
+#define ENC_MEDIA_FMT_SBC                                  0x00010BF2
+#define ENC_MEDIA_FMT_NONE                                 0
+#define MEDIA_FMT_SBC_ALLOCATION_METHOD_LOUDNESS           0
+#define MEDIA_FMT_SBC_ALLOCATION_METHOD_SNR                1
+#define MEDIA_FMT_AAC_AOT_LC                               2
+#define MEDIA_FMT_AAC_AOT_SBR                              5
+#define MEDIA_FMT_AAC_AOT_PS                               29
+#define MEDIA_FMT_SBC_CHANNEL_MODE_MONO                    1
+#define MEDIA_FMT_SBC_CHANNEL_MODE_STEREO                  2
+#define MEDIA_FMT_SBC_CHANNEL_MODE_DUAL_MONO               8
+#define MEDIA_FMT_SBC_CHANNEL_MODE_JOINT_STEREO            9
+
+// PCM channels
+#define PCM_CHANNEL_L                                      1
+#define PCM_CHANNEL_R                                      2
+#define PCM_CHANNEL_C                                      3
+
+// Mixer controls sent to ALSA
+#define MIXER_ENC_CONFIG_BLOCK     "SLIM_7_RX Encoder Config"
+#define MIXER_ENC_BIT_FORMAT       "AFE Input Bit Format"
+#define MIXER_SCRAMBLER_MODE       "AFE Scrambler Mode"
+#define MIXER_SAMPLE_RATE          "BT SampleRate"
+#define MIXER_AFE_IN_CHANNELS      "AFE Input Channels"
+
+// Encoder format strings
+#define ENC_FMT_AAC                "aac"
+#define ENC_FMT_APTX               "aptx"
+#define ENC_FMT_APTXHD             "aptxhd"
+#define ENC_FMT_LDAC               "ldac"
+#define ENC_FMT_SBC                "sbc"
+
+// System properties used for A2DP Offload
+#define SYSPROP_A2DP_OFFLOAD_ENABLED   "persist.vendor.bluetooth.a2dp_offload.enable"
+#define SYSPROP_A2DP_CODEC_LATENCIES   "vendor.audio.a2dp.codec.latency"
+
+// Default encoder bit width
+#define DEFAULT_ENCODER_BIT_FORMAT 16
+
+// Default encoder latency
+#define DEFAULT_ENCODER_LATENCY    200
+
+// Encoder latency offset for codecs supported
+#define ENCODER_LATENCY_AAC        70
+#define ENCODER_LATENCY_APTX       40
+#define ENCODER_LATENCY_APTX_HD    20
+#define ENCODER_LATENCY_LDAC       40
+#define ENCODER_LATENCY_SBC        10
+
+// Default A2DP sink latency offset
+#define DEFAULT_SINK_LATENCY_AAC       180
+#define DEFAULT_SINK_LATENCY_APTX      160
+#define DEFAULT_SINK_LATENCY_APTX_HD   180
+#define DEFAULT_SINK_LATENCY_LDAC      180
+#define DEFAULT_SINK_LATENCY_SBC       140
+
+/*
+ * Below enum values are extended from audio-base.h to
+ * keep encoder codec type local to bthost_ipc
+ * and audio_hal as these are intended only for handshake
+ * between IPC lib and Audio HAL.
+ */
+typedef enum {
+    ENC_CODEC_TYPE_INVALID = AUDIO_FORMAT_INVALID, // 0xFFFFFFFFUL
+    ENC_CODEC_TYPE_AAC = AUDIO_FORMAT_AAC, // 0x04000000UL
+    ENC_CODEC_TYPE_SBC = AUDIO_FORMAT_SBC, // 0x1F000000UL
+    ENC_CODEC_TYPE_APTX = AUDIO_FORMAT_APTX, // 0x20000000UL
+    ENC_CODEC_TYPE_APTX_HD = AUDIO_FORMAT_APTX_HD, // 0x21000000UL
+    ENC_CODEC_TYPE_LDAC = AUDIO_FORMAT_LDAC, // 0x23000000UL
+} enc_codec_t;
+
+typedef int (*audio_stream_open_t)(void);
+typedef int (*audio_stream_close_t)(void);
+typedef int (*audio_stream_start_t)(void);
+typedef int (*audio_stream_stop_t)(void);
+typedef int (*audio_stream_suspend_t)(void);
+typedef void (*audio_handoff_triggered_t)(void);
+typedef void (*clear_a2dp_suspend_flag_t)(void);
+typedef void * (*audio_get_codec_config_t)(uint8_t *multicast_status, uint8_t *num_dev,
+                               enc_codec_t *codec_type);
+typedef int (*audio_check_a2dp_ready_t)(void);
+typedef int (*audio_is_scrambling_enabled_t)(void);
+
+enum A2DP_STATE {
+    A2DP_STATE_CONNECTED,
+    A2DP_STATE_STARTED,
+    A2DP_STATE_STOPPED,
+    A2DP_STATE_DISCONNECTED,
+};
+
+/* Data structure used to:
+ * - Update the A2DP state machine
+ * - Communicate with the libbthost_if.so IPC library
+ * - Store DSP encoder configuration information
+ */
+struct a2dp_data {
+    /* Audio device handle */
+    struct audio_device *adev;
+    /* Bluetooth IPC library handle */
+    void *bt_lib_handle;
+    /* Open A2DP audio stream. Initialize audio datapath */
+    audio_stream_open_t audio_stream_open;
+    /* Close A2DP audio stream */
+    audio_stream_close_t audio_stream_close;
+    /* Start A2DP audio stream. Start audio datapath */
+    audio_stream_start_t audio_stream_start;
+    /* Stop A2DP audio stream */
+    audio_stream_stop_t audio_stream_stop;
+    /* Suspend A2DP audio stream */
+    audio_stream_suspend_t audio_stream_suspend;
+    /* Notify Bluetooth IPC library of handoff being triggered */
+    audio_handoff_triggered_t audio_handoff_triggered;
+    /* Clear A2DP suspend flag in Bluetooth IPC library */
+    clear_a2dp_suspend_flag_t clear_a2dp_suspend_flag;
+    /* Get codec configuration from Bluetooth stack via
+     * Bluetooth IPC library */
+    audio_get_codec_config_t audio_get_codec_config;
+    /* Check if A2DP is ready */
+    audio_check_a2dp_ready_t audio_check_a2dp_ready;
+    /* Check if scrambling is enabled on BTSoC */
+    audio_is_scrambling_enabled_t audio_is_scrambling_enabled;
+    /* Internal A2DP state identifier */
+    enum A2DP_STATE bt_state;
+    /* A2DP codec type configured */
+    enc_codec_t bt_encoder_format;
+    /* Sampling rate configured with A2DP encoder on DSP */
+    uint32_t enc_sampling_rate;
+    /* Channel configuration of A2DP on DSP */
+    uint32_t enc_channels;
+    /* Flag to denote whether A2DP audio datapath has started */
+    bool a2dp_started;
+    /* Flag to denote whether A2DP audio datapath is suspended */
+    bool a2dp_suspended;
+    /* Number of active sessions on A2DP output */
+    int  a2dp_total_active_session_request;
+    /* Flag to denote whether A2DP offload is supported */
+    bool is_a2dp_offload_supported;
+    /* Flag to denote whether codec reconfiguration/soft handoff is in progress */
+    bool is_handoff_in_progress;
+    /* Flag to denote whether APTX Dual Mono encoder is supported */
+    bool is_aptx_dual_mono_supported;
+};
+
+struct a2dp_data a2dp;
+
+/* START of DSP configurable structures
+ * These values should match with DSP interface defintion
+ */
+
+/* AAC encoder configuration structure. */
+typedef struct aac_enc_cfg_t aac_enc_cfg_t;
+
+struct aac_enc_cfg_t {
+    /* Encoder media format for AAC */
+    uint32_t      enc_format;
+
+    /* Encoding rate in bits per second */
+    uint32_t      bit_rate;
+
+   /* supported enc_mode are AAC_LC, AAC_SBR, AAC_PS */
+    uint32_t      enc_mode;
+
+    /* supported aac_fmt_flag are ADTS/RAW */
+    uint16_t      aac_fmt_flag;
+
+    /* supported channel_cfg are Native mode, Mono , Stereo */
+    uint16_t      channel_cfg;
+
+    /* Number of samples per second */
+    uint32_t      sample_rate;
+} __attribute__ ((packed));
+
+/* SBC encoder configuration structure. */
+typedef struct sbc_enc_cfg_t sbc_enc_cfg_t;
+
+struct sbc_enc_cfg_t {
+    /* Encoder media format for SBC */
+    uint32_t      enc_format;
+
+    /* supported num_subbands are 4/8 */
+    uint32_t      num_subbands;
+
+    /* supported blk_len are 4, 8, 12, 16 */
+    uint32_t      blk_len;
+
+    /* supported channel_mode are MONO, STEREO, DUAL_MONO, JOINT_STEREO */
+    uint32_t      channel_mode;
+
+    /* supported alloc_method are LOUNDNESS/SNR */
+    uint32_t      alloc_method;
+
+    /* supported bit_rate for mono channel is max 320kbps
+     * supported bit rate for stereo channel is max 512 kbps */
+    uint32_t      bit_rate;
+
+    /* Number of samples per second */
+    uint32_t      sample_rate;
+} __attribute__ ((packed));
+
+struct custom_enc_cfg_t {
+    /* Custom encoder media format */
+    uint32_t      enc_format;
+
+    /* Number of samples per second */
+    uint32_t      sample_rate;
+
+    /* supported num_channels are Mono/Stereo */
+    uint16_t      num_channels;
+
+    /* Reserved for future enhancement */
+    uint16_t      reserved;
+
+    /* supported channel_mapping for mono is CHANNEL_C
+     * supported channel mapping for stereo is CHANNEL_L and CHANNEL_R */
+    uint8_t       channel_mapping[8];
+
+    /* Reserved for future enhancement */
+    uint32_t      custom_size;
+} __attribute__ ((packed));
+
+struct aptx_v2_enc_cfg_ext_t {
+/* sync_mode introduced with APTX V2 libraries
+ * sync mode: 0x0 = stereo sync mode
+ *            0x01 = dual mono sync mode
+ *            0x02 = dual mono with no sync on either L or R codewords
+ */
+    uint32_t       sync_mode;
+} __attribute__ ((packed));
+
+/* APTX struct for combining custom enc and V2 members */
+struct aptx_enc_cfg_t {
+    struct custom_enc_cfg_t  custom_cfg;
+    struct aptx_v2_enc_cfg_ext_t aptx_v2_cfg;
+} __attribute__ ((packed));
+
+struct ldac_specific_enc_cfg_t {
+   /*
+    * This is used to calculate the encoder output
+    * bytes per frame (i.e. bytes per packet).
+    * Bit rate also configures the EQMID.
+    * The min bit rate 303000 bps is calculated for
+    * 44.1 kHz and 88.2 KHz sampling frequencies with
+    * Mobile use Quality.
+    * The max bit rate of 990000 bps is calculated for
+    * 96kHz and 48 KHz with High Quality
+    * @Range(in bits per second)
+    * 303000 for Mobile use Quality
+    * 606000 for standard Quality
+    * 909000 for High Quality
+    */
+    uint32_t      bit_rate;
+
+   /*
+    * The channel setting information for LDAC specification
+    * of Bluetooth A2DP which is determined by SRC and SNK
+    * devices in Bluetooth transmission.
+    * @Range:
+    * 0 for native mode
+    * 4 for mono
+    * 2 for dual channel
+    * 1 for stereo
+    */
+    uint16_t      channel_mode;
+
+   /*
+    * Maximum Transmission Unit (MTU).
+    * The minimum MTU that a L2CAP implementation for LDAC shall
+    * support is 679 bytes, because LDAC is optimized with 2-DH5
+    * packet as its target.
+    * @Range : 679
+    * @Default: 679 for LDACBT_MTU_2DH5
+    */
+    uint16_t      mtu;
+} __attribute__ ((packed));
+
+/* LDAC struct for combining custom enc and standard members */
+struct ldac_enc_cfg_t {
+    struct custom_enc_cfg_t  custom_cfg;
+    struct ldac_specific_enc_cfg_t ldac_cfg;
+} __attribute__ ((packed));
+
+/* Information about Bluetooth SBC encoder configuration
+ * This data is used between audio HAL module and
+ * Bluetooth IPC library to configure DSP encoder
+ */
+typedef struct {
+    uint32_t subband;          /* 4, 8 */
+    uint32_t blk_len;          /* 4, 8, 12, 16 */
+    uint16_t sampling_rate;    /* 44.1khz, 48khz */
+    uint8_t  channels;         /* 0(Mono), 1(Dual_mono), 2(Stereo), 3(JS) */
+    uint8_t  alloc;            /* 0(Loudness), 1(SNR) */
+    uint8_t  min_bitpool;      /* 2 */
+    uint8_t  max_bitpool;      /* 53(44.1khz), 51 (48khz) */
+    uint32_t bitrate;          /* 320kbps to 512kbps */
+    uint32_t bits_per_sample;  /* 16 bit */
+} audio_sbc_encoder_config;
+
+/* Information about Bluetooth APTX encoder configuration
+ * This data is used between audio HAL module and
+ * Bluetooth IPC library to configure DSP encoder
+ */
+typedef struct {
+    uint16_t sampling_rate;
+    uint8_t  channels;
+    uint32_t bitrate;
+    uint32_t bits_per_sample;
+} audio_aptx_default_config;
+
+typedef struct {
+    uint16_t sampling_rate;
+    uint8_t  channels;
+    uint32_t bitrate;
+    uint32_t sync_mode;
+} audio_aptx_dual_mono_config;
+
+typedef union {
+    audio_aptx_default_config *default_cfg;
+    audio_aptx_dual_mono_config *dual_mono_cfg;
+} audio_aptx_encoder_config;
+
+/* Information about Bluetooth AAC encoder configuration
+ * This data is used between audio HAL module and
+ * Bluetooth IPC library to configure DSP encoder
+ */
+typedef struct {
+    uint32_t enc_mode; /* LC, SBR, PS */
+    uint16_t format_flag; /* RAW, ADTS */
+    uint16_t channels; /* 1-Mono, 2-Stereo */
+    uint32_t sampling_rate;
+    uint32_t bitrate;
+    uint32_t bits_per_sample;
+} audio_aac_encoder_config;
+
+/* Information about Bluetooth LDAC encoder configuration
+ * This data is used between audio HAL module and
+ * Bluetooth IPC library to configure DSP encoder
+ */
+typedef struct {
+    uint32_t sampling_rate; /* 44100, 48000, 88200, 96000 */
+    uint32_t bit_rate; /* 303000, 606000, 909000 (in bits per second) */
+    uint16_t channel_mode; /* 0, 4, 2, 1 */
+    uint16_t mtu;
+    uint32_t bits_per_sample; /* 16, 24, 32 (bits) */
+} audio_ldac_encoder_config;
+
+/*********** END of DSP configurable structures ********************/
+
+static void a2dp_common_init()
+{
+    a2dp.a2dp_started = false;
+    a2dp.a2dp_total_active_session_request = 0;
+    a2dp.a2dp_suspended = false;
+    a2dp.bt_encoder_format = ENC_CODEC_TYPE_INVALID;
+    a2dp.bt_state = A2DP_STATE_DISCONNECTED;
+}
+
+static void update_offload_codec_support()
+{
+    char value[PROPERTY_VALUE_MAX] = {'\0'};
+
+    a2dp.is_a2dp_offload_supported =
+            property_get_bool(SYSPROP_A2DP_OFFLOAD_ENABLED, false);
+    ALOGD("%s: A2DP offload supported = %s", __func__, value);
+}
+
+/* API to open Bluetooth IPC library to start IPC communication */
+static int open_a2dp_output()
+{
+    int ret = 0;
+
+    ALOGD("%s: Open A2DP output start", __func__);
+
+    if (a2dp.bt_state != A2DP_STATE_DISCONNECTED) {
+        ALOGD("%s: Called A2DP open with improper state, Ignoring request state %d",
+                   __func__, a2dp.bt_state);
+        return -ENOSYS;
+    }
+
+    if (a2dp.bt_lib_handle == NULL) {
+        ALOGD("%s: Requesting for Bluetooth IPC lib handle", __func__);
+        a2dp.bt_lib_handle = dlopen(BT_IPC_LIB_NAME, RTLD_NOW);
+
+        if (a2dp.bt_lib_handle == NULL) {
+            ret = -errno;
+            ALOGE("%s: DLOPEN failed for %s errno %d strerror %s", __func__,
+                      BT_IPC_LIB_NAME, errno, strerror(errno));
+            a2dp.bt_state = A2DP_STATE_DISCONNECTED;
+            return ret;
+        } else {
+            a2dp.audio_stream_open = (audio_stream_open_t)
+                          dlsym(a2dp.bt_lib_handle, "audio_stream_open");
+            a2dp.audio_stream_start = (audio_stream_start_t)
+                          dlsym(a2dp.bt_lib_handle, "audio_stream_start");
+            a2dp.audio_get_codec_config = (audio_get_codec_config_t)
+                          dlsym(a2dp.bt_lib_handle, "audio_get_codec_config");
+            a2dp.audio_stream_suspend = (audio_stream_suspend_t)
+                          dlsym(a2dp.bt_lib_handle, "audio_stream_suspend");
+            a2dp.audio_handoff_triggered = (audio_handoff_triggered_t)
+                          dlsym(a2dp.bt_lib_handle, "audio_handoff_triggered");
+            a2dp.clear_a2dp_suspend_flag = (clear_a2dp_suspend_flag_t)
+                          dlsym(a2dp.bt_lib_handle, "clear_a2dp_suspend_flag");
+            a2dp.audio_stream_stop = (audio_stream_stop_t)
+                          dlsym(a2dp.bt_lib_handle, "audio_stream_stop");
+            a2dp.audio_stream_close = (audio_stream_close_t)
+                          dlsym(a2dp.bt_lib_handle, "audio_stream_close");
+            a2dp.audio_check_a2dp_ready = (audio_check_a2dp_ready_t)
+                        dlsym(a2dp.bt_lib_handle,"audio_check_a2dp_ready");
+            a2dp.audio_is_scrambling_enabled = (audio_is_scrambling_enabled_t)
+                        dlsym(a2dp.bt_lib_handle,"audio_is_scrambling_enabled");
+        }
+    }
+
+    if (a2dp.bt_lib_handle && a2dp.audio_stream_open) {
+        ALOGD("%s: calling Bluetooth stream open", __func__);
+        ret = a2dp.audio_stream_open();
+        if (ret != 0) {
+            ALOGE("%s: Failed to open output stream for A2DP: status %d", __func__, ret);
+            dlclose(a2dp.bt_lib_handle);
+            a2dp.bt_lib_handle = NULL;
+            a2dp.bt_state = A2DP_STATE_DISCONNECTED;
+            return ret;
+        }
+        a2dp.bt_state = A2DP_STATE_CONNECTED;
+    } else {
+        ALOGE("%s: A2DP handle is not identified, Ignoring open request", __func__);
+        a2dp.bt_state = A2DP_STATE_DISCONNECTED;
+        return -ENOSYS;
+    }
+
+    return ret;
+}
+
+static int close_a2dp_output()
+{
+    ALOGV("%s\n",__func__);
+    if (!(a2dp.bt_lib_handle && a2dp.audio_stream_close)) {
+        ALOGE("%s: A2DP handle is not identified, Ignoring close request", __func__);
+        return -ENOSYS;
+    }
+    if (a2dp.bt_state != A2DP_STATE_DISCONNECTED) {
+        ALOGD("%s: calling Bluetooth stream close", __func__);
+        if (a2dp.audio_stream_close() == false)
+            ALOGE("%s: failed close A2DP control path from Bluetooth IPC library", __func__);
+    }
+    a2dp_common_init();
+    a2dp.enc_sampling_rate = 0;
+    a2dp.enc_channels = 0;
+
+    return 0;
+}
+
+static int a2dp_check_and_set_scrambler()
+{
+    bool scrambler_mode = false;
+    struct mixer_ctl *ctrl_scrambler_mode = NULL;
+    int ret = 0;
+    if (a2dp.audio_is_scrambling_enabled && (a2dp.bt_state != A2DP_STATE_DISCONNECTED))
+        scrambler_mode = a2dp.audio_is_scrambling_enabled();
+
+    // Scrambling needs to be enabled in DSP if scrambler mode is set
+    // disable scrambling not required
+    if (scrambler_mode) {
+        // enable scrambler in dsp
+        ctrl_scrambler_mode = mixer_get_ctl_by_name(a2dp.adev->mixer,
+                                            MIXER_SCRAMBLER_MODE);
+        if (!ctrl_scrambler_mode) {
+            ALOGE("%s: ERROR scrambler mode mixer control not identifed", __func__);
+            return -ENOSYS;
+        } else {
+            ret = mixer_ctl_set_value(ctrl_scrambler_mode, 0, true);
+            if (ret != 0) {
+                ALOGE("%s: Could not set scrambler mode", __func__);
+                return ret;
+            }
+        }
+    }
+    return 0;
+}
+
+static void a2dp_set_backend_cfg()
+{
+    const char *rate_str = NULL, *in_channels = NULL;
+    uint32_t sampling_rate = a2dp.enc_sampling_rate;
+    struct mixer_ctl *ctl_sample_rate = NULL, *ctrl_in_channels = NULL;
+
+    // For LDAC encoder open slimbus port at 96Khz for 48Khz input
+    // and 88.2Khz for 44.1Khz input.
+    if ((a2dp.bt_encoder_format == ENC_CODEC_TYPE_LDAC) &&
+        (sampling_rate == 48000 || sampling_rate == 44100 )) {
+        sampling_rate = sampling_rate * 2;
+    }
+    // Configure backend sampling rate
+    switch (sampling_rate) {
+    case 44100:
+        rate_str = "KHZ_44P1";
+        break;
+    case 48000:
+        rate_str = "KHZ_48";
+        break;
+    case 88200:
+        rate_str = "KHZ_88P2";
+        break;
+    case 96000:
+        rate_str = "KHZ_96";
+        break;
+    default:
+        rate_str = "KHZ_48";
+        break;
+    }
+
+    ALOGD("%s: set backend sample rate =%s", __func__, rate_str);
+    ctl_sample_rate = mixer_get_ctl_by_name(a2dp.adev->mixer,
+                                        MIXER_SAMPLE_RATE);
+    if (!ctl_sample_rate) {
+        ALOGE("%s: ERROR backend sample rate mixer control not identifed", __func__);
+        return;
+    } else {
+        if (mixer_ctl_set_enum_by_string(ctl_sample_rate, rate_str) != 0) {
+            ALOGE("%s: Failed to set backend sample rate =%s", __func__, rate_str);
+            return;
+        }
+    }
+
+    // Configure AFE input channels
+    switch (a2dp.enc_channels) {
+    case 1:
+        in_channels = "One";
+        break;
+    case 2:
+    default:
+        in_channels = "Two";
+        break;
+    }
+
+    ALOGD("%s: set AFE input channels =%d", __func__, a2dp.enc_channels);
+    ctrl_in_channels = mixer_get_ctl_by_name(a2dp.adev->mixer,
+                                        MIXER_AFE_IN_CHANNELS);
+    if (!ctrl_in_channels) {
+        ALOGE("%s: ERROR AFE input channels mixer control not identifed", __func__);
+        return;
+    } else {
+        if (mixer_ctl_set_enum_by_string(ctrl_in_channels, in_channels) != 0) {
+            ALOGE("%s: Failed to set AFE in channels =%d", __func__, a2dp.enc_channels);
+            return;
+        }
+    }
+}
+
+static int a2dp_set_bit_format(uint32_t enc_bit_format)
+{
+    const char *bit_format = NULL;
+    struct mixer_ctl *ctrl_bit_format = NULL;
+
+    // Configure AFE Input Bit Format
+    switch (enc_bit_format) {
+    case 32:
+        bit_format = "S32_LE";
+        break;
+    case 24:
+        bit_format = "S24_LE";
+        break;
+    case 16:
+    default:
+        bit_format = "S16_LE";
+        break;
+    }
+
+    ALOGD("%s: set AFE input bit format = %d", __func__, enc_bit_format);
+    ctrl_bit_format = mixer_get_ctl_by_name(a2dp.adev->mixer,
+                                        MIXER_ENC_BIT_FORMAT);
+    if (!ctrl_bit_format) {
+        ALOGE("%s: ERROR AFE input bit format mixer control not identifed", __func__);
+        return -ENOSYS;
+    }
+    if (mixer_ctl_set_enum_by_string(ctrl_bit_format, bit_format) != 0) {
+        ALOGE("%s: Failed to set AFE input bit format = %d", __func__, enc_bit_format);
+        return -ENOSYS;
+    }
+    return 0;
+}
+
+static void a2dp_reset_backend_cfg()
+{
+    const char *rate_str = "KHZ_8", *in_channels = "Zero";
+    struct mixer_ctl *ctl_sample_rate = NULL, *ctrl_in_channels = NULL;
+
+    // Reset backend sampling rate
+    ALOGD("%s: reset backend sample rate = %s", __func__, rate_str);
+    ctl_sample_rate = mixer_get_ctl_by_name(a2dp.adev->mixer,
+                                        MIXER_SAMPLE_RATE);
+    if (!ctl_sample_rate) {
+        ALOGE("%s: ERROR backend sample rate mixer control not identifed", __func__);
+        return;
+    } else {
+        if (mixer_ctl_set_enum_by_string(ctl_sample_rate, rate_str) != 0) {
+            ALOGE("%s: Failed to reset backend sample rate = %s", __func__, rate_str);
+            return;
+        }
+    }
+
+    // Reset AFE input channels
+    ALOGD("%s: reset AFE input channels = %s", __func__, in_channels);
+    ctrl_in_channels = mixer_get_ctl_by_name(a2dp.adev->mixer,
+                                        MIXER_AFE_IN_CHANNELS);
+    if (!ctrl_in_channels) {
+        ALOGE("%s: ERROR AFE input channels mixer control not identifed", __func__);
+        return;
+    } else {
+        if (mixer_ctl_set_enum_by_string(ctrl_in_channels, in_channels) != 0) {
+            ALOGE("%s: Failed to reset AFE in channels =%d", __func__, a2dp.enc_channels);
+            return;
+        }
+    }
+}
+
+/* API to configure SBC DSP encoder */
+static bool configure_sbc_enc_format(audio_sbc_encoder_config *sbc_bt_cfg)
+{
+    struct mixer_ctl *ctl_enc_data = NULL, *ctrl_bit_format = NULL;
+    struct sbc_enc_cfg_t sbc_dsp_cfg;
+    bool is_configured = false;
+    int ret = 0;
+
+    if (sbc_bt_cfg == NULL) {
+        ALOGE("%s: Failed to get SBC encoder config from BT", __func__);
+        return false;
+    }
+
+    ctl_enc_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_ENC_CONFIG_BLOCK);
+    if (!ctl_enc_data) {
+        ALOGE("%s: ERROR A2DP encoder config data mixer control not identifed", __func__);
+        is_configured = false;
+        goto exit;
+    }
+    memset(&sbc_dsp_cfg, 0x0, sizeof(sbc_dsp_cfg));
+    sbc_dsp_cfg.enc_format = ENC_MEDIA_FMT_SBC;
+    sbc_dsp_cfg.num_subbands = sbc_bt_cfg->subband;
+    sbc_dsp_cfg.blk_len = sbc_bt_cfg->blk_len;
+    switch (sbc_bt_cfg->channels) {
+        case 0:
+            sbc_dsp_cfg.channel_mode = MEDIA_FMT_SBC_CHANNEL_MODE_MONO;
+            break;
+        case 1:
+            sbc_dsp_cfg.channel_mode = MEDIA_FMT_SBC_CHANNEL_MODE_DUAL_MONO;
+            break;
+        case 3:
+            sbc_dsp_cfg.channel_mode = MEDIA_FMT_SBC_CHANNEL_MODE_JOINT_STEREO;
+            break;
+        case 2:
+        default:
+            sbc_dsp_cfg.channel_mode = MEDIA_FMT_SBC_CHANNEL_MODE_STEREO;
+            break;
+    }
+    if (sbc_bt_cfg->alloc)
+        sbc_dsp_cfg.alloc_method = MEDIA_FMT_SBC_ALLOCATION_METHOD_LOUDNESS;
+    else
+        sbc_dsp_cfg.alloc_method = MEDIA_FMT_SBC_ALLOCATION_METHOD_SNR;
+    sbc_dsp_cfg.bit_rate = sbc_bt_cfg->bitrate;
+    sbc_dsp_cfg.sample_rate = sbc_bt_cfg->sampling_rate;
+    ret = mixer_ctl_set_array(ctl_enc_data, (void *)&sbc_dsp_cfg,
+                                    sizeof(sbc_dsp_cfg));
+    if (ret != 0) {
+        ALOGE("%s: failed to set SBC encoder config", __func__);
+        is_configured = false;
+        goto exit;
+    }
+    ret = a2dp_set_bit_format(sbc_bt_cfg->bits_per_sample);
+    if (ret != 0) {
+        is_configured = false;
+        goto exit;
+    }
+    is_configured = true;
+    a2dp.bt_encoder_format = ENC_CODEC_TYPE_SBC;
+    a2dp.enc_sampling_rate = sbc_bt_cfg->sampling_rate;
+
+    if (sbc_dsp_cfg.channel_mode == MEDIA_FMT_SBC_CHANNEL_MODE_MONO)
+        a2dp.enc_channels = 1;
+    else
+        a2dp.enc_channels = 2;
+
+    ALOGV("%s: Successfully updated SBC enc format with sampling rate: %d channel mode:%d",
+           __func__, sbc_dsp_cfg.sample_rate, sbc_dsp_cfg.channel_mode);
+exit:
+    return is_configured;
+}
+
+/* API to configure APTX DSP encoder */
+static bool configure_aptx_enc_format(audio_aptx_encoder_config *aptx_bt_cfg)
+{
+    struct mixer_ctl *ctl_enc_data = NULL, *ctrl_bit_format = NULL;
+    int mixer_size;
+    bool is_configured = false;
+    int ret = 0;
+    struct aptx_enc_cfg_t aptx_dsp_cfg;
+    mixer_size = sizeof(aptx_dsp_cfg);
+
+    if (aptx_bt_cfg == NULL) {
+        ALOGE("%s: Failed to get APTX encoder config from BT", __func__);
+        return false;
+    }
+
+    ctl_enc_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_ENC_CONFIG_BLOCK);
+    if (!ctl_enc_data) {
+        ALOGE("%s: ERROR A2DP encoder config data mixer control not identifed", __func__);
+        is_configured = false;
+        goto exit;
+    }
+
+    memset(&aptx_dsp_cfg, 0x0, sizeof(aptx_dsp_cfg));
+    aptx_dsp_cfg.custom_cfg.enc_format = ENC_MEDIA_FMT_APTX;
+
+    if (!a2dp.is_aptx_dual_mono_supported) {
+        aptx_dsp_cfg.custom_cfg.sample_rate = aptx_bt_cfg->default_cfg->sampling_rate;
+        aptx_dsp_cfg.custom_cfg.num_channels = aptx_bt_cfg->default_cfg->channels;
+    } else {
+        aptx_dsp_cfg.custom_cfg.sample_rate = aptx_bt_cfg->dual_mono_cfg->sampling_rate;
+        aptx_dsp_cfg.custom_cfg.num_channels = aptx_bt_cfg->dual_mono_cfg->channels;
+        aptx_dsp_cfg.aptx_v2_cfg.sync_mode = aptx_bt_cfg->dual_mono_cfg->sync_mode;
+    }
+
+    switch (aptx_dsp_cfg.custom_cfg.num_channels) {
+        case 1:
+            aptx_dsp_cfg.custom_cfg.channel_mapping[0] = PCM_CHANNEL_C;
+            break;
+        case 2:
+        default:
+            aptx_dsp_cfg.custom_cfg.channel_mapping[0] = PCM_CHANNEL_L;
+            aptx_dsp_cfg.custom_cfg.channel_mapping[1] = PCM_CHANNEL_R;
+            break;
+    }
+    ret = mixer_ctl_set_array(ctl_enc_data, (void *)&aptx_dsp_cfg,
+                              mixer_size);
+    if (ret != 0) {
+        ALOGE("%s: Failed to set APTX encoder config", __func__);
+        is_configured = false;
+        goto exit;
+    }
+    ret = a2dp_set_bit_format(aptx_bt_cfg->default_cfg->bits_per_sample);
+    if (ret != 0) {
+        is_configured = false;
+        goto exit;
+    }
+    is_configured = true;
+    a2dp.bt_encoder_format = ENC_CODEC_TYPE_APTX;
+    a2dp.enc_channels = aptx_dsp_cfg.custom_cfg.num_channels;
+    if (!a2dp.is_aptx_dual_mono_supported) {
+        a2dp.enc_sampling_rate = aptx_bt_cfg->default_cfg->sampling_rate;
+        ALOGV("%s: Successfully updated APTX enc format with sampling rate: %d \
+               channels:%d", __func__, aptx_dsp_cfg.custom_cfg.sample_rate,
+               aptx_dsp_cfg.custom_cfg.num_channels);
+    } else {
+        a2dp.enc_sampling_rate = aptx_bt_cfg->dual_mono_cfg->sampling_rate;
+        ALOGV("%s: Successfully updated APTX dual mono enc format with \
+               sampling rate: %d channels:%d sync mode %d", __func__,
+               aptx_dsp_cfg.custom_cfg.sample_rate,
+               aptx_dsp_cfg.custom_cfg.num_channels,
+               aptx_dsp_cfg.aptx_v2_cfg.sync_mode);
+    }
+
+exit:
+    return is_configured;
+}
+
+/* API to configure APTX HD DSP encoder
+ */
+static bool configure_aptx_hd_enc_format(audio_aptx_default_config *aptx_bt_cfg)
+{
+    struct mixer_ctl *ctl_enc_data = NULL, *ctrl_bit_format = NULL;
+    struct custom_enc_cfg_t aptx_dsp_cfg;
+    bool is_configured = false;
+    int ret = 0;
+
+    if (aptx_bt_cfg == NULL) {
+        ALOGE("%s: Failed to get APTX HD encoder config from BT", __func__);
+        return false;
+    }
+
+    ctl_enc_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_ENC_CONFIG_BLOCK);
+    if (!ctl_enc_data) {
+        ALOGE("%s: ERROR A2DP encoder config data mixer control not identifed", __func__);
+        is_configured = false;
+        goto exit;
+    }
+
+    memset(&aptx_dsp_cfg, 0x0, sizeof(aptx_dsp_cfg));
+    aptx_dsp_cfg.enc_format = ENC_MEDIA_FMT_APTX_HD;
+    aptx_dsp_cfg.sample_rate = aptx_bt_cfg->sampling_rate;
+    aptx_dsp_cfg.num_channels = aptx_bt_cfg->channels;
+    switch (aptx_dsp_cfg.num_channels) {
+        case 1:
+            aptx_dsp_cfg.channel_mapping[0] = PCM_CHANNEL_C;
+            break;
+        case 2:
+        default:
+            aptx_dsp_cfg.channel_mapping[0] = PCM_CHANNEL_L;
+            aptx_dsp_cfg.channel_mapping[1] = PCM_CHANNEL_R;
+            break;
+    }
+    ret = mixer_ctl_set_array(ctl_enc_data, (void *)&aptx_dsp_cfg,
+                              sizeof(aptx_dsp_cfg));
+    if (ret != 0) {
+        ALOGE("%s: Failed to set APTX HD encoder config", __func__);
+        is_configured = false;
+        goto exit;
+    }
+    ret = a2dp_set_bit_format(aptx_bt_cfg->bits_per_sample);
+    if (ret != 0) {
+        is_configured = false;
+        goto exit;
+    }
+    is_configured = true;
+    a2dp.bt_encoder_format = ENC_CODEC_TYPE_APTX_HD;
+    a2dp.enc_sampling_rate = aptx_bt_cfg->sampling_rate;
+    a2dp.enc_channels = aptx_bt_cfg->channels;
+    ALOGV("%s: Successfully updated APTX HD encformat with sampling rate: %d channels:%d",
+           __func__, aptx_dsp_cfg.sample_rate, aptx_dsp_cfg.num_channels);
+exit:
+    return is_configured;
+}
+
+/* API to configure AAC DSP encoder */
+static bool configure_aac_enc_format(audio_aac_encoder_config *aac_bt_cfg)
+{
+    struct mixer_ctl *ctl_enc_data = NULL, *ctrl_bit_format = NULL;
+    struct aac_enc_cfg_t aac_dsp_cfg;
+    bool is_configured = false;
+    int ret = 0;
+
+    if (aac_bt_cfg == NULL) {
+        ALOGE("%s: Failed to get AAC encoder config from BT", __func__);
+        return false;
+    }
+
+    ctl_enc_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_ENC_CONFIG_BLOCK);
+    if (!ctl_enc_data) {
+        ALOGE("%s: ERROR A2DP encoder config data mixer control not identifed", __func__);
+        is_configured = false;
+        goto exit;
+    }
+    memset(&aac_dsp_cfg, 0x0, sizeof(aac_dsp_cfg));
+    aac_dsp_cfg.enc_format = ENC_MEDIA_FMT_AAC;
+    aac_dsp_cfg.bit_rate = aac_bt_cfg->bitrate;
+    aac_dsp_cfg.sample_rate = aac_bt_cfg->sampling_rate;
+    switch (aac_bt_cfg->enc_mode) {
+        case 0:
+            aac_dsp_cfg.enc_mode = MEDIA_FMT_AAC_AOT_LC;
+            break;
+        case 2:
+            aac_dsp_cfg.enc_mode = MEDIA_FMT_AAC_AOT_PS;
+            break;
+        case 1:
+        default:
+            aac_dsp_cfg.enc_mode = MEDIA_FMT_AAC_AOT_SBR;
+            break;
+    }
+    aac_dsp_cfg.aac_fmt_flag = aac_bt_cfg->format_flag;
+    aac_dsp_cfg.channel_cfg = aac_bt_cfg->channels;
+    ret = mixer_ctl_set_array(ctl_enc_data, (void *)&aac_dsp_cfg,
+                              sizeof(aac_dsp_cfg));
+    if (ret != 0) {
+        ALOGE("%s: failed to set AAC encoder config", __func__);
+        is_configured = false;
+        goto exit;
+    }
+    ret = a2dp_set_bit_format(aac_bt_cfg->bits_per_sample);
+    if (ret != 0) {
+        is_configured = false;
+        goto exit;
+    }
+    is_configured = true;
+    a2dp.bt_encoder_format = ENC_CODEC_TYPE_AAC;
+    a2dp.enc_sampling_rate = aac_bt_cfg->sampling_rate;
+    a2dp.enc_channels = aac_bt_cfg->channels;;
+    ALOGV("%s: Successfully updated AAC enc format with sampling rate: %d channels:%d",
+           __func__, aac_dsp_cfg.sample_rate, aac_dsp_cfg.channel_cfg);
+exit:
+    return is_configured;
+}
+
+static bool configure_ldac_enc_format(audio_ldac_encoder_config *ldac_bt_cfg)
+{
+    struct mixer_ctl *ldac_enc_data = NULL, *ctrl_bit_format = NULL;
+    struct ldac_enc_cfg_t ldac_dsp_cfg;
+    bool is_configured = false;
+    int ret = 0;
+
+    if (ldac_bt_cfg == NULL) {
+        ALOGE("%s: Failed to get LDAC encoder config from BT", __func__);
+        return false;
+    }
+
+    ldac_enc_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_ENC_CONFIG_BLOCK);
+    if (!ldac_enc_data) {
+        ALOGE("%s: ERROR A2DP encoder config data mixer control not identifed", __func__);
+        is_configured = false;
+        goto exit;
+    }
+    memset(&ldac_dsp_cfg, 0x0, sizeof(ldac_dsp_cfg));
+
+    ldac_dsp_cfg.custom_cfg.enc_format = ENC_MEDIA_FMT_LDAC;
+    ldac_dsp_cfg.custom_cfg.sample_rate = ldac_bt_cfg->sampling_rate;
+    ldac_dsp_cfg.ldac_cfg.channel_mode = ldac_bt_cfg->channel_mode;
+    switch (ldac_dsp_cfg.ldac_cfg.channel_mode) {
+        case 4:
+            ldac_dsp_cfg.custom_cfg.channel_mapping[0] = PCM_CHANNEL_C;
+            ldac_dsp_cfg.custom_cfg.num_channels = 1;
+            break;
+        case 2:
+        case 1:
+        default:
+            ldac_dsp_cfg.custom_cfg.channel_mapping[0] = PCM_CHANNEL_L;
+            ldac_dsp_cfg.custom_cfg.channel_mapping[1] = PCM_CHANNEL_R;
+            ldac_dsp_cfg.custom_cfg.num_channels = 2;
+            break;
+    }
+
+    ldac_dsp_cfg.custom_cfg.custom_size = sizeof(ldac_dsp_cfg);
+    ldac_dsp_cfg.ldac_cfg.mtu = ldac_bt_cfg->mtu;
+    ldac_dsp_cfg.ldac_cfg.bit_rate = ldac_bt_cfg->bit_rate;
+    ret = mixer_ctl_set_array(ldac_enc_data, (void *)&ldac_dsp_cfg,
+                              sizeof(ldac_dsp_cfg));
+    if (ret != 0) {
+        ALOGE("%s: Failed to set LDAC encoder config", __func__);
+        is_configured = false;
+        goto exit;
+    }
+    ret = a2dp_set_bit_format(ldac_bt_cfg->bits_per_sample);
+    if (ret != 0) {
+        is_configured = false;
+        goto exit;
+    }
+    is_configured = true;
+    a2dp.bt_encoder_format = ENC_CODEC_TYPE_LDAC;
+    a2dp.enc_sampling_rate = ldac_bt_cfg->sampling_rate;
+    a2dp.enc_channels = ldac_dsp_cfg.custom_cfg.num_channels;
+    ALOGV("%s: Successfully updated LDAC encformat with sampling rate: %d channels:%d",
+           __func__, ldac_dsp_cfg.custom_cfg.sample_rate,
+           ldac_dsp_cfg.custom_cfg.num_channels);
+exit:
+    return is_configured;
+}
+
+bool configure_a2dp_encoder_format()
+{
+    void *codec_info = NULL;
+    uint8_t multi_cast = 0, num_dev = 1;
+    enc_codec_t codec_type = ENC_CODEC_TYPE_INVALID;
+    bool is_configured = false;
+    audio_aptx_encoder_config aptx_encoder_cfg;
+
+    if (!a2dp.audio_get_codec_config) {
+        ALOGE("%s: A2DP handle is not identified, ignoring A2DP encoder config", __func__);
+        return false;
+    }
+    ALOGD("%s: start", __func__);
+    codec_info = a2dp.audio_get_codec_config(&multi_cast, &num_dev,
+                               &codec_type);
+
+    switch (codec_type) {
+        case ENC_CODEC_TYPE_SBC:
+            ALOGD("%s: Received SBC encoder supported Bluetooth device", __func__);
+            is_configured =
+              configure_sbc_enc_format((audio_sbc_encoder_config *)codec_info);
+            break;
+        case ENC_CODEC_TYPE_APTX:
+            ALOGD("%s: Received APTX encoder supported Bluetooth device", __func__);
+            a2dp.is_aptx_dual_mono_supported = false;
+            aptx_encoder_cfg.default_cfg = (audio_aptx_default_config *)codec_info;
+            is_configured =
+              configure_aptx_enc_format(&aptx_encoder_cfg);
+            break;
+        case ENC_CODEC_TYPE_APTX_HD:
+            ALOGD("%s: Received APTX HD encoder supported Bluetooth device", __func__);
+            is_configured =
+              configure_aptx_hd_enc_format((audio_aptx_default_config *)codec_info);
+            break;
+        case ENC_CODEC_TYPE_AAC:
+            ALOGD("%s: Received AAC encoder supported Bluetooth device", __func__);
+            is_configured =
+              configure_aac_enc_format((audio_aac_encoder_config *)codec_info);
+            break;
+        case ENC_CODEC_TYPE_LDAC:
+            ALOGD("%s: Received LDAC encoder supported Bluetooth device", __func__);
+            is_configured =
+              configure_ldac_enc_format((audio_ldac_encoder_config *)codec_info);
+            break;
+        default:
+            ALOGD("%s: Received unsupported encoder format", __func__);
+            is_configured = false;
+            break;
+    }
+    return is_configured;
+}
+
+int audio_extn_a2dp_start_playback()
+{
+    int ret = 0;
+
+    ALOGD("%s: start", __func__);
+
+    if (!(a2dp.bt_lib_handle && a2dp.audio_stream_start
+       && a2dp.audio_get_codec_config)) {
+        ALOGE("%s: A2DP handle is not identified, Ignoring start request", __func__);
+        return -ENOSYS;
+    }
+
+    if (a2dp.a2dp_suspended) {
+        // session will be restarted after suspend completion
+        ALOGD("%s: A2DP start requested during suspend state", __func__);
+        return -ENOSYS;
+    }
+
+    if (!a2dp.a2dp_started && !a2dp.a2dp_total_active_session_request) {
+        ALOGD("%s: calling Bluetooth module stream start", __func__);
+        /* This call indicates Bluetooth IPC lib to start playback */
+        ret =  a2dp.audio_stream_start();
+        ALOGE("%s: Bluetooth controller start return = %d", __func__, ret);
+        if (ret != 0 ) {
+           ALOGE("%s: Bluetooth controller start failed", __func__);
+           a2dp.a2dp_started = false;
+        } else {
+           if (configure_a2dp_encoder_format() == true) {
+                a2dp.a2dp_started = true;
+                ret = 0;
+                ALOGD("%s: Start playback successful to Bluetooth IPC library", __func__);
+           } else {
+                ALOGD("%s: unable to configure DSP encoder", __func__);
+                a2dp.a2dp_started = false;
+                ret = -ETIMEDOUT;
+           }
+        }
+    }
+
+    if (a2dp.a2dp_started) {
+        a2dp.a2dp_total_active_session_request++;
+        a2dp_check_and_set_scrambler();
+        a2dp_set_backend_cfg();
+    }
+
+    ALOGD("%s: start A2DP playback total active sessions :%d", __func__,
+          a2dp.a2dp_total_active_session_request);
+    return ret;
+}
+
+static int reset_a2dp_enc_config_params()
+{
+    int ret = 0;
+
+    struct mixer_ctl *ctl_enc_config, *ctrl_bit_format;
+    struct sbc_enc_cfg_t dummy_reset_config;
+
+    memset(&dummy_reset_config, 0x0, sizeof(dummy_reset_config));
+    ctl_enc_config = mixer_get_ctl_by_name(a2dp.adev->mixer,
+                                           MIXER_ENC_CONFIG_BLOCK);
+    if (!ctl_enc_config) {
+        ALOGE("%s: ERROR A2DP encoder format mixer control not identifed", __func__);
+    } else {
+        ret = mixer_ctl_set_array(ctl_enc_config, (void *)&dummy_reset_config,
+                                        sizeof(dummy_reset_config));
+         a2dp.bt_encoder_format = ENC_MEDIA_FMT_NONE;
+    }
+
+    ret = a2dp_set_bit_format(DEFAULT_ENCODER_BIT_FORMAT);
+
+    return ret;
+}
+
+int audio_extn_a2dp_stop_playback()
+{
+    int ret = 0;
+
+    ALOGV("%s: stop", __func__);
+    if (!(a2dp.bt_lib_handle && a2dp.audio_stream_stop)) {
+        ALOGE("%s: A2DP handle is not identified, Ignoring start request", __func__);
+        return -ENOSYS;
+    }
+
+    if (a2dp.a2dp_total_active_session_request > 0)
+        a2dp.a2dp_total_active_session_request--;
+    else
+        ALOGE("%s: No active playback session requests on A2DP", __func__);
+
+    if (a2dp.a2dp_started && !a2dp.a2dp_total_active_session_request) {
+        ALOGV("%s: calling Bluetooth module stream stop", __func__);
+        ret = a2dp.audio_stream_stop();
+        if (ret < 0)
+            ALOGE("%s: stop stream to Bluetooth IPC lib failed", __func__);
+        else
+            ALOGV("%s: stop steam to Bluetooth IPC lib successful", __func__);
+        reset_a2dp_enc_config_params();
+        a2dp_reset_backend_cfg();
+        a2dp.a2dp_started = false;
+    }
+    ALOGD("%s: Stop A2DP playback total active sessions :%d", __func__,
+          a2dp.a2dp_total_active_session_request);
+    return 0;
+}
+
+void audio_extn_a2dp_set_parameters(struct str_parms *parms)
+{
+     int ret, val;
+     char value[32] = {0};
+     struct audio_usecase *uc_info;
+     struct listnode *node;
+
+     if (a2dp.is_a2dp_offload_supported == false) {
+        ALOGV("%s: No supported encoders identified,ignoring A2DP setparam", __func__);
+        return;
+     }
+
+     ret = str_parms_get_str(parms, AUDIO_PARAMETER_DEVICE_CONNECT, value,
+                            sizeof(value));
+     if (ret >= 0) {
+         val = atoi(value);
+         if (audio_is_a2dp_out_device(val)) {
+             ALOGV("%s: Received device connect request for A2DP", __func__);
+             open_a2dp_output();
+         }
+         goto param_handled;
+     }
+
+     ret = str_parms_get_str(parms, AUDIO_PARAMETER_DEVICE_DISCONNECT, value,
+                         sizeof(value));
+
+     if (ret >= 0) {
+         val = atoi(value);
+         if (audio_is_a2dp_out_device(val)) {
+             ALOGV("%s: Received device disconnect request", __func__);
+             reset_a2dp_enc_config_params();
+             close_a2dp_output();
+         }
+         goto param_handled;
+     }
+
+     ret = str_parms_get_str(parms, "A2dpSuspended", value, sizeof(value));
+     if (ret >= 0) {
+         if (a2dp.bt_lib_handle && (a2dp.bt_state != A2DP_STATE_DISCONNECTED)) {
+             if ((!strncmp(value, "true", sizeof(value))) && !a2dp.a2dp_suspended) {
+                ALOGD("%s: Setting A2DP to suspend state", __func__);
+                a2dp.a2dp_suspended = true;
+                list_for_each(node, &a2dp.adev->usecase_list) {
+                    uc_info = node_to_item(node, struct audio_usecase, list);
+                    if (uc_info->type == PCM_PLAYBACK &&
+                         (uc_info->stream.out->devices & AUDIO_DEVICE_OUT_ALL_A2DP)) {
+                        pthread_mutex_unlock(&a2dp.adev->lock);
+                        check_a2dp_restore(a2dp.adev, uc_info->stream.out, false);
+                        pthread_mutex_lock(&a2dp.adev->lock);
+                    }
+                }
+                reset_a2dp_enc_config_params();
+                if (a2dp.audio_stream_suspend)
+                   a2dp.audio_stream_suspend();
+            } else if (a2dp.a2dp_suspended) {
+                ALOGD("%s: Resetting A2DP suspend state", __func__);
+                struct audio_usecase *uc_info;
+                struct listnode *node;
+                if (a2dp.clear_a2dp_suspend_flag)
+                    a2dp.clear_a2dp_suspend_flag();
+                a2dp.a2dp_suspended = false;
+                /*
+                 * It is possible that before suspend, A2DP sessions can be active.
+                 * For example, during music + voice activation concurrency,
+                 * A2DP suspend will be called & Bluetooth will change to SCO mode.
+                 * Though music is paused as a part of voice activation,
+                 * compress session close happens only after pause timeout(10 secs).
+                 * So, if resume request comes before pause timeout, as A2DP session
+                 * is already active, IPC start will not be called from APM/audio_hw.
+                 * Fix this by calling A2DP start for IPC library post suspend
+                 * based on number of active session count.
+                 */
+                if (a2dp.a2dp_total_active_session_request > 0) {
+                    ALOGD("%s: Calling Bluetooth IPC lib start post suspend state", __func__);
+                    if (a2dp.audio_stream_start) {
+                        ret =  a2dp.audio_stream_start();
+                        if (ret != 0) {
+                            ALOGE("%s: Bluetooth controller start failed", __func__);
+                            a2dp.a2dp_started = false;
+                        }
+                    }
+                }
+                list_for_each(node, &a2dp.adev->usecase_list) {
+                    uc_info = node_to_item(node, struct audio_usecase, list);
+                    if (uc_info->type == PCM_PLAYBACK &&
+                         (uc_info->stream.out->devices & AUDIO_DEVICE_OUT_ALL_A2DP)) {
+                        pthread_mutex_unlock(&a2dp.adev->lock);
+                        check_a2dp_restore(a2dp.adev, uc_info->stream.out, true);
+                        pthread_mutex_lock(&a2dp.adev->lock);
+                    }
+                }
+            }
+        }
+        goto param_handled;
+     }
+param_handled:
+     ALOGV("%s: end of A2DP setparam", __func__);
+}
+
+void audio_extn_a2dp_set_handoff_mode(bool is_on)
+{
+    a2dp.is_handoff_in_progress = is_on;
+}
+
+bool audio_extn_a2dp_is_force_device_switch()
+{
+    // During encoder reconfiguration mode, force A2DP device switch
+    // Or if A2DP device is selected but earlier start failed as A2DP
+    // was suspended, force retry.
+    return a2dp.is_handoff_in_progress || !a2dp.a2dp_started;
+}
+
+void audio_extn_a2dp_get_sample_rate(int *sample_rate)
+{
+    *sample_rate = a2dp.enc_sampling_rate;
+}
+
+bool audio_extn_a2dp_is_ready()
+{
+    bool ret = false;
+
+    if (a2dp.a2dp_suspended)
+        goto exit;
+
+    if ((a2dp.bt_state != A2DP_STATE_DISCONNECTED) &&
+        (a2dp.is_a2dp_offload_supported) &&
+        (a2dp.audio_check_a2dp_ready))
+           ret = a2dp.audio_check_a2dp_ready();
+
+exit:
+    return ret;
+}
+
+bool audio_extn_a2dp_is_suspended()
+{
+    return a2dp.a2dp_suspended;
+}
+
+void audio_extn_a2dp_init(void *adev)
+{
+  a2dp.adev = (struct audio_device*)adev;
+  a2dp.bt_lib_handle = NULL;
+  a2dp_common_init();
+  a2dp.enc_sampling_rate = 48000;
+  a2dp.is_a2dp_offload_supported = false;
+  a2dp.is_handoff_in_progress = false;
+  a2dp.is_aptx_dual_mono_supported = false;
+  reset_a2dp_enc_config_params();
+  update_offload_codec_support();
+}
+
+uint32_t audio_extn_a2dp_get_encoder_latency()
+{
+    uint32_t latency = 0;
+    int avsync_runtime_prop = 0;
+    int sbc_offset = 0, aptx_offset = 0, aptxhd_offset = 0,
+        aac_offset = 0, ldac_offset = 0;
+    char value[PROPERTY_VALUE_MAX];
+
+    memset(value, '\0', sizeof(char) * PROPERTY_VALUE_MAX);
+    avsync_runtime_prop = property_get(SYSPROP_A2DP_CODEC_LATENCIES, value, NULL);
+    if (avsync_runtime_prop > 0) {
+        if (sscanf(value, "%d/%d/%d/%d/%d",
+            &sbc_offset, &aptx_offset, &aptxhd_offset, &aac_offset,
+            &ldac_offset) != 5) {
+            ALOGI("%s: Failed to parse avsync offset params from '%s'.", __func__, value);
+            avsync_runtime_prop = 0;
+        }
+    }
+
+    switch (a2dp.bt_encoder_format) {
+        case ENC_CODEC_TYPE_SBC:
+            latency = (avsync_runtime_prop > 0) ? sbc_offset : ENCODER_LATENCY_SBC;
+            latency += DEFAULT_SINK_LATENCY_SBC;
+            break;
+        case ENC_CODEC_TYPE_APTX:
+            latency = (avsync_runtime_prop > 0) ? aptx_offset : ENCODER_LATENCY_APTX;
+            latency += DEFAULT_SINK_LATENCY_APTX;
+            break;
+        case ENC_CODEC_TYPE_APTX_HD:
+            latency = (avsync_runtime_prop > 0) ? aptxhd_offset : ENCODER_LATENCY_APTX_HD;
+            latency += DEFAULT_SINK_LATENCY_APTX_HD;
+            break;
+        case ENC_CODEC_TYPE_AAC:
+            latency = (avsync_runtime_prop > 0) ? aac_offset : ENCODER_LATENCY_AAC;
+            latency += DEFAULT_SINK_LATENCY_AAC;
+            break;
+        case ENC_CODEC_TYPE_LDAC:
+            latency = (avsync_runtime_prop > 0) ? ldac_offset : ENCODER_LATENCY_LDAC;
+            latency += DEFAULT_SINK_LATENCY_LDAC;
+            break;
+        default:
+            latency = DEFAULT_ENCODER_LATENCY;
+            break;
+    }
+    return latency;
+}
+#endif // A2DP_OFFLOAD_ENABLED
diff --git a/hal/audio_extn/audio_extn.h b/hal/audio_extn/audio_extn.h
index 12fe04d..f2189a9 100644
--- a/hal/audio_extn/audio_extn.h
+++ b/hal/audio_extn/audio_extn.h
@@ -137,6 +137,30 @@
                                   size_t bytes);
 #endif
 
+#ifndef A2DP_OFFLOAD_ENABLED
+#define audio_extn_a2dp_init(adev)                       (0)
+#define audio_extn_a2dp_start_playback()                 (0)
+#define audio_extn_a2dp_stop_playback()                  (0)
+#define audio_extn_a2dp_set_parameters(parms)            (0)
+#define audio_extn_a2dp_is_force_device_switch()         (0)
+#define audio_extn_a2dp_set_handoff_mode(is_on)          (0)
+#define audio_extn_a2dp_get_sample_rate(sample_rate)     (0)
+#define audio_extn_a2dp_get_encoder_latency()            (0)
+#define audio_extn_a2dp_is_ready()                       (0)
+#define audio_extn_a2dp_is_suspended()                   (0)
+#else
+void audio_extn_a2dp_init(void *adev);
+int audio_extn_a2dp_start_playback();
+int audio_extn_a2dp_stop_playback();
+void audio_extn_a2dp_set_parameters(struct str_parms *parms);
+bool audio_extn_a2dp_is_force_device_switch();
+void audio_extn_a2dp_set_handoff_mode(bool is_on);
+void audio_extn_a2dp_get_sample_rate(int *sample_rate);
+uint32_t audio_extn_a2dp_get_encoder_latency();
+bool audio_extn_a2dp_is_ready();
+bool audio_extn_a2dp_is_suspended();
+#endif
+
 #ifndef DSM_FEEDBACK_ENABLED
 #define audio_extn_dsm_feedback_enable(adev, snd_device, benable)                (0)
 #else
diff --git a/hal/audio_extn/cirrus_playback.c b/hal/audio_extn/cirrus_playback.c
index 18513af..595ac85 100644
--- a/hal/audio_extn/cirrus_playback.c
+++ b/hal/audio_extn/cirrus_playback.c
@@ -31,6 +31,7 @@
 #include <stdio.h>
 #include <dlfcn.h>
 #include <math.h>
+#include <pthread.h>
 #include <time.h>
 #include <unistd.h>
 #include <cutils/properties.h>
diff --git a/hal/audio_extn/utils.c b/hal/audio_extn/utils.c
index 6139add..7bf274e 100644
--- a/hal/audio_extn/utils.c
+++ b/hal/audio_extn/utils.c
@@ -333,7 +333,8 @@
     struct stream_in *in;
 
     if (usecase->type == PCM_PLAYBACK) {
-        return platform_get_snd_device_acdb_id(usecase->out_snd_device);
+        return platform_get_snd_device_acdb_id(
+                audio_extn_get_spkr_prot_snd_device(usecase->out_snd_device));
     } else if(usecase->type == PCM_CAPTURE) {
         return platform_get_snd_device_acdb_id(usecase->in_snd_device);
     }
diff --git a/hal/audio_hw.c b/hal/audio_hw.c
index 115181a..f3e8f82 100644
--- a/hal/audio_hw.c
+++ b/hal/audio_hw.c
@@ -321,6 +321,9 @@
 //cache last MBDRC cal step level
 static int last_known_cal_step = -1 ;
 
+static int check_a2dp_restore_l(struct audio_device *adev, struct stream_out *out, bool restore);
+static int set_compr_volume(struct audio_stream_out *stream, float left, float right);
+
 static bool may_use_noirq_mode(struct audio_device *adev, audio_usecase_t uc_id,
                                int flags __unused)
 {
@@ -548,6 +551,22 @@
     cfg->gain[0] = cfg->gain[1] = APP_TYPE_GAIN_DEFAULT;
 }
 
+static bool is_btsco_device(snd_device_t out_snd_device, snd_device_t in_snd_device)
+{
+   return out_snd_device == SND_DEVICE_OUT_BT_SCO ||
+          out_snd_device == SND_DEVICE_OUT_BT_SCO_WB ||
+          in_snd_device == SND_DEVICE_IN_BT_SCO_MIC_WB_NREC ||
+          in_snd_device == SND_DEVICE_IN_BT_SCO_MIC_WB ||
+          in_snd_device == SND_DEVICE_IN_BT_SCO_MIC_NREC ||
+          in_snd_device == SND_DEVICE_IN_BT_SCO_MIC;
+
+}
+
+static bool is_a2dp_device(snd_device_t out_snd_device)
+{
+   return out_snd_device == SND_DEVICE_OUT_BT_A2DP;
+}
+
 int enable_audio_route(struct audio_device *adev,
                        struct audio_usecase *usecase)
 {
@@ -629,6 +648,12 @@
 
     audio_extn_dsm_feedback_enable(adev, snd_device, true);
 
+    if (is_a2dp_device(snd_device) &&
+        (audio_extn_a2dp_start_playback() < 0)) {
+           ALOGE("%s: failed to configure A2DP control path", __func__);
+           goto on_error;
+    }
+
     if ((snd_device == SND_DEVICE_OUT_SPEAKER ||
         snd_device == SND_DEVICE_OUT_SPEAKER_SAFE ||
         snd_device == SND_DEVICE_OUT_VOICE_SPEAKER) &&
@@ -684,6 +709,10 @@
     adev->snd_dev_ref_cnt[snd_device]--;
     if (adev->snd_dev_ref_cnt[snd_device] == 0) {
         audio_extn_dsm_feedback_enable(adev, snd_device, false);
+
+        if (is_a2dp_device(snd_device))
+            audio_extn_a2dp_stop_playback();
+
         if ((snd_device == SND_DEVICE_OUT_SPEAKER ||
             snd_device == SND_DEVICE_OUT_SPEAKER_SAFE ||
             snd_device == SND_DEVICE_OUT_SPEAKER_REVERSE ||
@@ -843,6 +872,15 @@
                                                                       uc_info,
                                                                       snd_device);
 
+    /* For a2dp device reconfigure all active sessions
+     * with new AFE encoder format based on a2dp state
+     */
+    if ((SND_DEVICE_OUT_BT_A2DP == snd_device ||
+         SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP == snd_device) &&
+         audio_extn_a2dp_is_force_device_switch()) {
+         force_routing = true;
+    }
+
     /*
      * This function is to make sure that all the usecases that are active on
      * the hardware codec backend are always routed to any one device that is
@@ -1166,6 +1204,25 @@
     return NULL;
 }
 
+static bool force_device_switch(struct audio_usecase *usecase)
+{
+    if (usecase->stream.out == NULL) {
+        ALOGE("%s: stream.out is NULL", __func__);
+        return false;
+    }
+
+    // Force all A2DP output devices to reconfigure for proper AFE encode format
+    // Also handle a case where in earlier A2DP start failed as A2DP stream was
+    // in suspended state, hence try to trigger a retry when we again get a routing request.
+    if ((usecase->stream.out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
+        audio_extn_a2dp_is_force_device_switch()) {
+         ALOGD("%s: Force A2DP device switch to update new encoder config", __func__);
+         return true;
+    }
+
+    return false;
+}
+
 int select_devices(struct audio_device *adev,
                    audio_usecase_t uc_id)
 {
@@ -1264,7 +1321,19 @@
 
     if (out_snd_device == usecase->out_snd_device &&
         in_snd_device == usecase->in_snd_device) {
-        return 0;
+        if (!force_device_switch(usecase))
+            return 0;
+    }
+
+    if (is_a2dp_device(out_snd_device) && !audio_extn_a2dp_is_ready()) {
+          ALOGD("SCO/A2DP is selected but they are not connected/ready hence dont route");
+          return 0;
+    }
+
+    if ((out_snd_device == SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP) &&
+        (!audio_extn_a2dp_is_ready())) {
+        ALOGW("%s: A2DP profile is not ready, routing to speaker only", __func__);
+        out_snd_device = SND_DEVICE_OUT_SPEAKER;
     }
 
     if (out_snd_device != SND_DEVICE_NONE &&
@@ -1338,7 +1407,8 @@
     /* Enable new sound devices */
     if (out_snd_device != SND_DEVICE_NONE) {
         if ((usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) ||
-            (usecase->devices & (AUDIO_DEVICE_OUT_USB_DEVICE|AUDIO_DEVICE_OUT_USB_HEADSET)))
+            (usecase->devices & (AUDIO_DEVICE_OUT_USB_DEVICE|AUDIO_DEVICE_OUT_USB_HEADSET)) ||
+            (usecase->devices & AUDIO_DEVICE_OUT_ALL_A2DP))
             check_and_route_playback_usecases(adev, usecase, out_snd_device);
         enable_snd_device(adev, out_snd_device);
     }
@@ -1645,7 +1715,7 @@
         out->offload_thread_blocked = true;
         pthread_mutex_unlock(&out->lock);
         send_callback = false;
-        switch(cmd->cmd) {
+        switch (cmd->cmd) {
         case OFFLOAD_CMD_WAIT_FOR_BUFFER:
             compress_wait(out->compr, -1);
             send_callback = true;
@@ -1850,6 +1920,7 @@
     int ret = 0;
     struct audio_usecase *uc_info;
     struct audio_device *adev = out->dev;
+    bool a2dp_combo = false;
 
     ALOGV("%s: enter: usecase(%d: %s) devices(%#x)",
           __func__, out->usecase, use_case_table[out->usecase], out->devices);
@@ -1861,6 +1932,19 @@
         goto error_config;
     }
 
+    if (out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) {
+        if (!audio_extn_a2dp_is_ready()) {
+            if (out->devices & AUDIO_DEVICE_OUT_SPEAKER) {
+                a2dp_combo = true;
+            } else {
+                if (!(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
+                    ALOGE("%s: A2DP profile is not ready, return error", __func__);
+                    ret = -EAGAIN;
+                    goto error_config;
+                }
+            }
+        }
+    }
     out->pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
     if (out->pcm_device_id < 0) {
         ALOGE("%s: Invalid PCM device id(%d) for the usecase(%d)",
@@ -1886,7 +1970,19 @@
     audio_streaming_hint_start();
     audio_extn_perf_lock_acquire();
 
-    select_devices(adev, out->usecase);
+    if ((out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
+        (!audio_extn_a2dp_is_ready())) {
+        if (!a2dp_combo) {
+            check_a2dp_restore_l(adev, out, false);
+        } else {
+            audio_devices_t dev = out->devices;
+            out->devices = AUDIO_DEVICE_OUT_SPEAKER;
+            select_devices(adev, out->usecase);
+            out->devices = dev;
+        }
+    } else {
+         select_devices(adev, out->usecase);
+    }
 
     audio_extn_extspk_update(adev->extspk);
 
@@ -2255,6 +2351,7 @@
     int ret, val = 0;
     bool select_new_device = false;
     int status = 0;
+    bool bypass_a2dp = false;
 
     ALOGD("%s: enter: usecase(%d: %s) kvpairs: %s",
           __func__, out->usecase, use_case_table[out->usecase], kvpairs);
@@ -2289,6 +2386,43 @@
             val = AUDIO_DEVICE_OUT_SPEAKER;
         }
 
+        /*
+         * When A2DP is disconnected the
+         * music playback is paused and the policy manager sends routing=0
+         * But the audioflingercontinues to write data until standby time
+         * (3sec). As BT is turned off, the write gets blocked.
+         * Avoid this by routing audio to speaker until standby.
+         */
+        if ((out->devices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP) &&
+                (val == AUDIO_DEVICE_NONE) &&
+                !audio_extn_a2dp_is_ready()) {
+                val = AUDIO_DEVICE_OUT_SPEAKER;
+        }
+
+        /* To avoid a2dp to sco overlapping / BT device improper state
+         * check with BT lib about a2dp streaming support before routing
+         */
+        if (val & AUDIO_DEVICE_OUT_ALL_A2DP) {
+            if (!audio_extn_a2dp_is_ready()) {
+                if (val & AUDIO_DEVICE_OUT_SPEAKER) {
+                    //combo usecase just by pass a2dp
+                    ALOGW("%s: A2DP profile is not ready,routing to speaker only", __func__);
+                    bypass_a2dp = true;
+                } else {
+                    ALOGE("%s: A2DP profile is not ready,ignoring routing request", __func__);
+                    /* update device to a2dp and don't route as BT returned error
+                     * However it is still possible a2dp routing called because
+                     * of current active device disconnection (like wired headset)
+                     */
+                    out->devices = val;
+                    pthread_mutex_unlock(&out->lock);
+                    pthread_mutex_unlock(&adev->lock);
+                    status = -ENOSYS;
+                    goto routing_fail;
+                }
+            }
+        }
+
         audio_devices_t new_dev = val;
 
         // Workaround: If routing to an non existing usb device, fail gracefully
@@ -2347,7 +2481,13 @@
                                                     out->handle);
                     }
                 }
-                select_devices(adev, out->usecase);
+                if (!bypass_a2dp) {
+                    select_devices(adev, out->usecase);
+                } else {
+                    out->devices = AUDIO_DEVICE_OUT_SPEAKER;
+                    select_devices(adev, out->usecase);
+                    out->devices = new_dev;
+                }
                 audio_extn_tfa_98xx_update();
 
                 // on device switch force swap, lower functions will make sure
@@ -2355,6 +2495,15 @@
 
                 if (!same_dev)
                     platform_set_swap_channels(adev, true);
+
+                if ((out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
+                    out->a2dp_compress_mute &&
+                    (!(out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) || audio_extn_a2dp_is_ready())) {
+                    pthread_mutex_lock(&out->compr_mute_lock);
+                    out->a2dp_compress_mute = false;
+                    set_compr_volume(&out->stream, out->volume_l, out->volume_r);
+                    pthread_mutex_unlock(&out->compr_mute_lock);
+                }
             }
 
         }
@@ -2503,6 +2652,7 @@
 {
     uint32_t hw_delay, period_ms;
     struct stream_out *out = (struct stream_out *)stream;
+    uint32_t latency;
 
     if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD)
         return COMPRESS_OFFLOAD_PLAYBACK_LATENCY;
@@ -2516,42 +2666,62 @@
         return period_ms + hw_delay;
     }
 
-    return (out->config.period_count * out->config.period_size * 1000) /
-           (out->config.rate);
+    latency = (out->config.period_count * out->config.period_size * 1000) /
+              (out->config.rate);
+
+    if (AUDIO_DEVICE_OUT_ALL_A2DP & out->devices)
+        latency += audio_extn_a2dp_get_encoder_latency();
+
+    return latency;
+}
+
+static int set_compr_volume(struct audio_stream_out *stream, float left,
+                          float right)
+{
+    struct stream_out *out = (struct stream_out *)stream;
+    int volume[2];
+    char mixer_ctl_name[128];
+    struct audio_device *adev = out->dev;
+    struct mixer_ctl *ctl;
+    int pcm_device_id = platform_get_pcm_device_id(out->usecase,
+                                               PCM_PLAYBACK);
+
+    snprintf(mixer_ctl_name, sizeof(mixer_ctl_name),
+             "Compress Playback %d Volume", pcm_device_id);
+    ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
+    if (!ctl) {
+        ALOGE("%s: Could not get ctl for mixer cmd - %s",
+              __func__, mixer_ctl_name);
+        return -EINVAL;
+    }
+    ALOGV("%s: ctl for mixer cmd - %s, left %f, right %f",
+           __func__, mixer_ctl_name, left, right);
+    volume[0] = (int)(left * COMPRESS_PLAYBACK_VOLUME_MAX);
+    volume[1] = (int)(right * COMPRESS_PLAYBACK_VOLUME_MAX);
+    mixer_ctl_set_array(ctl, volume, sizeof(volume) / sizeof(volume[0]));
+
+    return 0;
 }
 
 static int out_set_volume(struct audio_stream_out *stream, float left,
                           float right)
 {
     struct stream_out *out = (struct stream_out *)stream;
-    int volume[2];
+    int ret = 0;
 
     if (out->usecase == USECASE_AUDIO_PLAYBACK_HIFI) {
         /* only take left channel into account: the API is for stereo anyway */
         out->muted = (left == 0.0f);
         return 0;
     } else if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
-        const char *mixer_ctl_name = "Compress Playback Volume";
-        struct audio_device *adev = out->dev;
-        struct mixer_ctl *ctl;
-        ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
-        if (!ctl) {
-            /* try with the control based on device id */
-            int pcm_device_id = platform_get_pcm_device_id(out->usecase,
-                                                       PCM_PLAYBACK);
-            char ctl_name[128] = {0};
-            snprintf(ctl_name, sizeof(ctl_name),
-                     "Compress Playback %d Volume", pcm_device_id);
-            ctl = mixer_get_ctl_by_name(adev->mixer, ctl_name);
-            if (!ctl) {
-                ALOGE("%s: Could not get volume ctl mixer cmd", __func__);
-                return -EINVAL;
-            }
-        }
-        volume[0] = (int)(left * COMPRESS_PLAYBACK_VOLUME_MAX);
-        volume[1] = (int)(right * COMPRESS_PLAYBACK_VOLUME_MAX);
-        mixer_ctl_set_array(ctl, volume, sizeof(volume)/sizeof(volume[0]));
-        return 0;
+        pthread_mutex_lock(&out->compr_mute_lock);
+        ALOGV("%s: compress mute %d", __func__, out->a2dp_compress_mute);
+        if (!out->a2dp_compress_mute)
+            ret = set_compr_volume(stream, left, right);
+        out->volume_l = left;
+        out->volume_r = right;
+        pthread_mutex_unlock(&out->compr_mute_lock);
+        return ret;
     } else if (out->usecase == USECASE_AUDIO_PLAYBACK_VOIP) {
         out->app_type_cfg.gain[0] = (int)(left * VOIP_PLAYBACK_VOLUME_MAX);
         out->app_type_cfg.gain[1] = (int)(right * VOIP_PLAYBACK_VOLUME_MAX);
@@ -2639,6 +2809,17 @@
         error_code = ERROR_CODE_WRITE;
         goto exit;
     }
+
+    if ((out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
+        (audio_extn_a2dp_is_suspended())) {
+        if (!(out->devices & AUDIO_DEVICE_OUT_SPEAKER)) {
+            if (!(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
+                ret = -EIO;
+                goto exit;
+            }
+        }
+    }
+
     if (out->standby) {
         out->standby = false;
         pthread_mutex_lock(&adev->lock);
@@ -2818,6 +2999,13 @@
             // TODO: check return value
             compress_get_tstamp(out->compr, &dsp_frames,
                     &out->sample_rate);
+            // Adjustment accounts for A2DP encoder latency with offload usecases
+            // Note: Encoder latency is returned in ms.
+            if (AUDIO_DEVICE_OUT_ALL_A2DP & out->devices) {
+                unsigned long offset =
+                            (audio_extn_a2dp_get_encoder_latency() * out->sample_rate / 1000);
+                dsp_frames = (dsp_frames > offset) ? (dsp_frames - offset) : 0;
+            }
             ALOGVV("%s rendered frames %ld sample_rate %d",
                    __func__, dsp_frames, out->sample_rate);
             *frames = dsp_frames;
@@ -2836,6 +3024,13 @@
                 signed_frames -=
                     (platform_render_latency(out->usecase) * out->sample_rate / 1000000LL);
 
+                // Adjustment accounts for A2DP encoder latency with non-offload usecases
+                // Note: Encoder latency is returned in ms, while platform_render_latency in us.
+                if (AUDIO_DEVICE_OUT_ALL_A2DP & out->devices) {
+                    signed_frames -=
+                            (audio_extn_a2dp_get_encoder_latency() * out->sample_rate / 1000);
+                }
+
                 // It would be unusual for this value to be negative, but check just in case ...
                 if (signed_frames >= 0) {
                     *frames = signed_frames;
@@ -3769,6 +3964,8 @@
     *stream_out = NULL;
     out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
 
+    pthread_mutex_init(&out->compr_mute_lock, (const pthread_mutexattr_t *) NULL);
+
     if (devices == AUDIO_DEVICE_NONE)
         devices = AUDIO_DEVICE_OUT_SPEAKER;
 
@@ -3777,6 +3974,7 @@
     out->dev = adev;
     out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO;
     out->handle = handle;
+    out->a2dp_compress_mute = false;
 
     /* Init use case and pcm_config */
     if ((is_hdmi || is_usb_dev) &&
@@ -4237,6 +4435,8 @@
             free(out->compr_config.codec);
     }
 
+    out->a2dp_compress_mute = false;
+
     if (adev->voice_tx_output == out)
         adev->voice_tx_output = NULL;
 
@@ -4290,7 +4490,7 @@
     ret = str_parms_get_int(parms, "rotation", &val);
     if (ret >= 0) {
         bool reverse_speakers = false;
-        switch(val) {
+        switch (val) {
         // FIXME: note that the code below assumes that the speakers are in the correct placement
         //   relative to the user when the device is rotated 90deg from its default rotation. This
         //   assumption is device-specific, not platform-specific like this code.
@@ -4356,6 +4556,31 @@
     }
 
     audio_extn_hfp_set_parameters(adev, parms);
+    audio_extn_a2dp_set_parameters(parms);
+    // reconfigure should be done only after updating A2DP state in audio extension
+    ret = str_parms_get_str(parms,"reconfigA2dp", value, sizeof(value));
+    if (ret >= 0) {
+        struct audio_usecase *usecase;
+        struct listnode *node;
+        list_for_each(node, &adev->usecase_list) {
+            usecase = node_to_item(node, struct audio_usecase, list);
+            if ((usecase->type == PCM_PLAYBACK) &&
+                (usecase->devices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP)) {
+                ALOGD("%s: reconfigure A2DP... forcing device switch", __func__);
+
+                pthread_mutex_unlock(&adev->lock);
+                lock_output_stream(usecase->stream.out);
+                pthread_mutex_lock(&adev->lock);
+                audio_extn_a2dp_set_handoff_mode(true);
+                // force device switch to reconfigure encoder
+                select_devices(adev, usecase->id);
+                audio_extn_a2dp_set_handoff_mode(false);
+                pthread_mutex_unlock(&usecase->stream.out->lock);
+                break;
+            }
+        }
+    }
+
 done:
     str_parms_destroy(parms);
     pthread_mutex_unlock(&adev->lock);
@@ -5014,6 +5239,81 @@
     return;
 }
 
+/* out and adev lock held */
+static int check_a2dp_restore_l(struct audio_device *adev, struct stream_out *out, bool restore)
+{
+    struct audio_usecase *uc_info;
+    float left_p;
+    float right_p;
+    audio_devices_t devices;
+
+    uc_info = get_usecase_from_list(adev, out->usecase);
+    if (uc_info == NULL) {
+        ALOGE("%s: Could not find the usecase (%d) in the list",
+              __func__, out->usecase);
+        return -EINVAL;
+    }
+
+    ALOGD("%s: enter: usecase(%d: %s)", __func__,
+          out->usecase, use_case_table[out->usecase]);
+
+    if (restore) {
+        // restore A2DP device for active usecases and unmute if required
+        if ((out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
+            !is_a2dp_device(uc_info->out_snd_device)) {
+            ALOGD("%s: restoring A2DP and unmuting stream", __func__);
+            select_devices(adev, uc_info->id);
+            pthread_mutex_lock(&out->compr_mute_lock);
+            if ((out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
+                (out->a2dp_compress_mute)) {
+                out->a2dp_compress_mute = false;
+                set_compr_volume(&out->stream, out->volume_l, out->volume_r);
+            }
+            pthread_mutex_unlock(&out->compr_mute_lock);
+        }
+    } else {
+        // mute compress stream if suspended
+        pthread_mutex_lock(&out->compr_mute_lock);
+        if ((out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
+            (!out->a2dp_compress_mute)) {
+            if (!out->standby) {
+                ALOGD("%s: selecting speaker and muting stream", __func__);
+                devices = out->devices;
+                out->devices = AUDIO_DEVICE_OUT_SPEAKER;
+                left_p = out->volume_l;
+                right_p = out->volume_r;
+                if (out->offload_state == OFFLOAD_STATE_PLAYING)
+                    compress_pause(out->compr);
+                set_compr_volume(&out->stream, 0.0f, 0.0f);
+                out->a2dp_compress_mute = true;
+                select_devices(adev, out->usecase);
+                if (out->offload_state == OFFLOAD_STATE_PLAYING)
+                    compress_resume(out->compr);
+                out->devices = devices;
+                out->volume_l = left_p;
+                out->volume_r = right_p;
+            }
+        }
+        pthread_mutex_unlock(&out->compr_mute_lock);
+    }
+    ALOGV("%s: exit", __func__);
+    return 0;
+}
+
+int check_a2dp_restore(struct audio_device *adev, struct stream_out *out, bool restore)
+{
+    int ret = 0;
+
+    lock_output_stream(out);
+    pthread_mutex_lock(&adev->lock);
+
+    ret = check_a2dp_restore_l(adev, out, restore);
+
+    pthread_mutex_unlock(&adev->lock);
+    pthread_mutex_unlock(&out->lock);
+    return ret;
+}
+
 static int adev_open(const hw_module_t *module, const char *name,
                      hw_device_t **device)
 {
diff --git a/hal/audio_hw.h b/hal/audio_hw.h
index 06cacc2..bc15915 100644
--- a/hal/audio_hw.h
+++ b/hal/audio_hw.h
@@ -181,6 +181,7 @@
     struct audio_stream_out stream;
     pthread_mutex_t lock; /* see note below on mutex acquisition order */
     pthread_mutex_t pre_lock; /* acquire before lock to avoid DOS by playback thread */
+    pthread_mutex_t compr_mute_lock; /* acquire before setting compress volume */
     pthread_cond_t  cond;
     struct pcm_config config;
     struct compr_config compr_config;
@@ -218,6 +219,9 @@
     int af_period_multiplier;
     struct audio_device *dev;
     card_status_t card_status;
+    bool a2dp_compress_mute;
+    float volume_l;
+    float volume_r;
 
     error_log_t *error_log;
 
@@ -380,6 +384,8 @@
 struct audio_usecase *get_usecase_from_list(struct audio_device *adev,
                                             audio_usecase_t uc_id);
 
+int check_a2dp_restore(struct audio_device *adev, struct stream_out *out, bool restore);
+
 #define LITERAL_TO_STRING(x) #x
 #define CHECK(condition) LOG_ALWAYS_FATAL_IF(!(condition), "%s",\
             __FILE__ ":" LITERAL_TO_STRING(__LINE__)\
diff --git a/hal/msm8916/platform.c b/hal/msm8916/platform.c
index a0a7442..e405495 100644
--- a/hal/msm8916/platform.c
+++ b/hal/msm8916/platform.c
@@ -211,6 +211,8 @@
     [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = "speaker-and-hdmi",
     [SND_DEVICE_OUT_BT_SCO] = "bt-sco-headset",
     [SND_DEVICE_OUT_BT_SCO_WB] = "bt-sco-headset-wb",
+    [SND_DEVICE_OUT_BT_A2DP] = "bt-a2dp",
+    [SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP] = "speaker-and-bt-a2dp",
     [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = "voice-tty-full-headphones",
     [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = "voice-tty-vco-headphones",
     [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = "voice-tty-hco-handset",
@@ -302,6 +304,8 @@
     [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = 14,
     [SND_DEVICE_OUT_BT_SCO] = 22,
     [SND_DEVICE_OUT_BT_SCO_WB] = 39,
+    [SND_DEVICE_OUT_BT_A2DP] = 20,
+    [SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP] = 14,
     [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = 17,
     [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = 17,
     [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = 37,
@@ -400,6 +404,8 @@
     {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HDMI)},
     {TO_NAME_INDEX(SND_DEVICE_OUT_BT_SCO)},
     {TO_NAME_INDEX(SND_DEVICE_OUT_BT_SCO_WB)},
+    {TO_NAME_INDEX(SND_DEVICE_OUT_BT_A2DP)},
+    {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP)},
     {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES)},
     {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES)},
     {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET)},
@@ -671,6 +677,8 @@
     backend_table[SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = strdup("bt-sco-wb");
     backend_table[SND_DEVICE_OUT_BT_SCO] = strdup("bt-sco");
     backend_table[SND_DEVICE_OUT_BT_SCO_WB] = strdup("bt-sco-wb");
+    backend_table[SND_DEVICE_OUT_BT_A2DP] = strdup("bt-a2dp");
+    backend_table[SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP] = strdup("speaker-and-bt-a2dp");
     backend_table[SND_DEVICE_OUT_HDMI] = strdup("hdmi");
     backend_table[SND_DEVICE_OUT_SPEAKER_AND_HDMI] = strdup("speaker-and-hdmi");
     backend_table[SND_DEVICE_OUT_VOICE_TX] = strdup("afe-proxy");
@@ -1056,6 +1064,8 @@
     resolve_config_file(platform_info_path);
     platform_info_init(platform_info_path, my_data);
 
+    /*init a2dp*/
+    audio_extn_a2dp_init(adev);
 
     /* Read one time ssr property */
     audio_extn_spkr_prot_init(adev);
@@ -1618,6 +1628,9 @@
         } else if (devices == (AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET |
                                AUDIO_DEVICE_OUT_SPEAKER)) {
             snd_device = SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET;
+        } else if ((devices & AUDIO_DEVICE_OUT_SPEAKER) &&
+                   (devices & AUDIO_DEVICE_OUT_ALL_A2DP)) {
+            snd_device = SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP;
         } else {
             ALOGE("%s: Invalid combo device(%#x)", __func__, devices);
             goto exit;
@@ -1661,6 +1674,8 @@
                 snd_device = SND_DEVICE_OUT_BT_SCO_WB;
             else
                 snd_device = SND_DEVICE_OUT_BT_SCO;
+        } else if (devices & AUDIO_DEVICE_OUT_ALL_A2DP) {
+                snd_device = SND_DEVICE_OUT_BT_A2DP;
         } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) {
             if (audio_extn_hfp_is_active(adev))
                 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER_HFP;
@@ -1694,6 +1709,8 @@
             snd_device = SND_DEVICE_OUT_BT_SCO_WB;
         else
             snd_device = SND_DEVICE_OUT_BT_SCO;
+    } else if (devices & AUDIO_DEVICE_OUT_ALL_A2DP) {
+        snd_device = SND_DEVICE_OUT_BT_A2DP;
     } else if (devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
         snd_device = SND_DEVICE_OUT_HDMI ;
     } else if (devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET ||
diff --git a/hal/msm8916/platform.h b/hal/msm8916/platform.h
index 937cfc4..d828f6b 100644
--- a/hal/msm8916/platform.h
+++ b/hal/msm8916/platform.h
@@ -71,6 +71,8 @@
     SND_DEVICE_OUT_SPEAKER_AND_HDMI,
     SND_DEVICE_OUT_BT_SCO,
     SND_DEVICE_OUT_BT_SCO_WB,
+    SND_DEVICE_OUT_BT_A2DP,
+    SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP,
     SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES,
     SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES,
     SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET,
diff --git a/hal/msm8960/platform.h b/hal/msm8960/platform.h
index 974b369..b0bd98a 100644
--- a/hal/msm8960/platform.h
+++ b/hal/msm8960/platform.h
@@ -48,6 +48,8 @@
     SND_DEVICE_OUT_SPEAKER_AND_HDMI,
     SND_DEVICE_OUT_BT_SCO,
     SND_DEVICE_OUT_BT_SCO_WB,
+    SND_DEVICE_OUT_BT_A2DP,
+    SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP,
     SND_DEVICE_OUT_VOICE_HANDSET_TMUS,
     SND_DEVICE_OUT_VOICE_HANDSET,
     SND_DEVICE_OUT_VOICE_HAC_HANDSET,
diff --git a/hal/msm8974/platform.c b/hal/msm8974/platform.c
index fea0d06..cb07986 100644
--- a/hal/msm8974/platform.c
+++ b/hal/msm8974/platform.c
@@ -236,6 +236,8 @@
     [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = "speaker-and-hdmi",
     [SND_DEVICE_OUT_BT_SCO] = "bt-sco-headset",
     [SND_DEVICE_OUT_BT_SCO_WB] = "bt-sco-headset-wb",
+    [SND_DEVICE_OUT_BT_A2DP] = "bt-a2dp",
+    [SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP] = "speaker-and-bt-a2dp",
     [SND_DEVICE_OUT_VOICE_HANDSET_TMUS] = "voice-handset-tmus",
     [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = "voice-tty-full-headphones",
     [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = "voice-tty-vco-headphones",
@@ -350,6 +352,8 @@
     [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = 15,
     [SND_DEVICE_OUT_BT_SCO] = 22,
     [SND_DEVICE_OUT_BT_SCO_WB] = 39,
+    [SND_DEVICE_OUT_BT_A2DP] = 20,
+    [SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP] = 14,
     [SND_DEVICE_OUT_VOICE_HANDSET_TMUS] = ACDB_ID_VOICE_HANDSET_TMUS,
     [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = 17,
     [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = 17,
@@ -470,6 +474,8 @@
     {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_HDMI)},
     {TO_NAME_INDEX(SND_DEVICE_OUT_BT_SCO)},
     {TO_NAME_INDEX(SND_DEVICE_OUT_BT_SCO_WB)},
+    {TO_NAME_INDEX(SND_DEVICE_OUT_BT_A2DP)},
+    {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP)},
     {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_HANDSET_TMUS)},
     {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_HAC_HANDSET)},
     {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES)},
@@ -1041,6 +1047,9 @@
     backend_tag_table[SND_DEVICE_IN_UNPROCESSED_USB_HEADSET_MIC] = strdup("usb-headset-mic");
     backend_tag_table[SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MIC] = strdup("usb-headset-mic");
     backend_tag_table[SND_DEVICE_IN_USB_HEADSET_MIC_AEC] = strdup("usb-headset-mic");
+    backend_tag_table[SND_DEVICE_OUT_BT_A2DP] = strdup("bt-a2dp");
+    backend_tag_table[SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP] = strdup("speaker-and-bt-a2dp");
+
     hw_interface_table[SND_DEVICE_OUT_HANDSET] = strdup("SLIMBUS_0_RX");
     hw_interface_table[SND_DEVICE_OUT_SPEAKER] = strdup("SLIMBUS_0_RX");
     hw_interface_table[SND_DEVICE_OUT_SPEAKER_REVERSE] = strdup("SLIMBUS_0_RX");
@@ -1060,6 +1069,9 @@
     hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_HDMI] = strdup("SLIMBUS_0_RX-and-HDMI_RX");
     hw_interface_table[SND_DEVICE_OUT_BT_SCO] = strdup("SEC_AUX_PCM_RX");
     hw_interface_table[SND_DEVICE_OUT_BT_SCO_WB] = strdup("SEC_AUX_PCM_RX");
+    hw_interface_table[SND_DEVICE_OUT_BT_A2DP] = strdup("SLIMBUS_7_RX");
+    hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP] =
+        strdup("SLIMBUS_0_RX-and-SLIMBUS_7_RX");
     hw_interface_table[SND_DEVICE_OUT_VOICE_HANDSET_TMUS] = strdup("SLIMBUS_0_RX");
     hw_interface_table[SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = strdup("SLIMBUS_0_RX");
     hw_interface_table[SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = strdup("SLIMBUS_0_RX");
@@ -1075,6 +1087,9 @@
     hw_interface_table[SND_DEVICE_OUT_VOICE_TX] = strdup("AFE_PCM_RX");
     hw_interface_table[SND_DEVICE_OUT_SPEAKER_PROTECTED] = strdup("SLIMBUS_0_RX");
     hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED] = strdup("SLIMBUS_0_RX");
+    hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_HFP] = strdup("SLIMBUS_0_RX");
+    hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_BT_SCO] = strdup("SLIMBUS_0_RX-and-SEC_AUX_PCM_RX");
+    hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_BT_SCO_WB] = strdup("SLIMBUS_0_RX-and-SEC_AUX_PCM_RX");
     hw_interface_table[SND_DEVICE_IN_USB_HEADSET_MIC] = strdup("USB_AUDIO_TX");
     hw_interface_table[SND_DEVICE_IN_VOICE_USB_HEADSET_MIC] = strdup("USB_AUDIO_TX");
     hw_interface_table[SND_DEVICE_IN_USB_HEADSET_MIC_AEC] =  strdup("USB_AUDIO_TX");
@@ -1082,13 +1097,22 @@
     hw_interface_table[SND_DEVICE_IN_VOICE_RECOG_USB_HEADSET_MIC] = strdup("USB_AUDIO_TX");
     hw_interface_table[SND_DEVICE_IN_VOICE_TTY_FULL_USB_MIC] = strdup("USB_AUDIO_TX");
     hw_interface_table[SND_DEVICE_IN_VOICE_TTY_HCO_USB_MIC] = strdup("USB_AUDIO_TX");
-    hw_interface_table[SND_DEVICE_IN_SPEAKER_MIC] = strdup("SLIMBUS_0_TX");
     hw_interface_table[SND_DEVICE_IN_HANDSET_MIC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_HANDSET_MIC_AEC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_HANDSET_MIC_NS] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_HANDSET_DMIC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_HANDSET_DMIC_AEC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_HANDSET_DMIC_NS] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_HANDSET_DMIC_STEREO] = strdup("SLIMBUS_0_TX");
     hw_interface_table[SND_DEVICE_IN_HEADSET_MIC] = strdup("SLIMBUS_0_TX");
-    hw_interface_table[SND_DEVICE_IN_UNPROCESSED_MIC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_HEADSET_MIC_AEC] = strdup("SLIMBUS_0_TX");
     hw_interface_table[SND_DEVICE_IN_CAMCORDER_MIC] = strdup("SLIMBUS_0_TX");
     hw_interface_table[SND_DEVICE_IN_VOICE_REC_MIC] = strdup("SLIMBUS_0_TX");
     hw_interface_table[SND_DEVICE_IN_VOICE_REC_MIC_NS] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_VOICE_REC_MIC_AEC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_VOICE_REC_MIC_AEC_NS] = strdup("SLIMBUS_0_TX");
     hw_interface_table[SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = strdup("SLIMBUS_0_TX");
     hw_interface_table[SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = strdup("SLIMBUS_0_TX");
     hw_interface_table[SND_DEVICE_IN_UNPROCESSED_MIC] = strdup("SLIMBUS_0_TX");
@@ -1104,8 +1128,28 @@
     hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_AEC] = strdup("SLIMBUS_0_TX");
     hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_NS] = strdup("SLIMBUS_0_TX");
     hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_SPEAKER_DMIC_STEREO] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_VOICE_DMIC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_VOICE_DMIC_TMUS] = strdup("SLIMBUS_0_TX");
     hw_interface_table[SND_DEVICE_IN_VOICE_SPEAKER_MIC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_VOICE_SPEAKER_MIC_HFP] = strdup("SLIMBUS_0_TX");
     hw_interface_table[SND_DEVICE_IN_VOICE_HEADSET_MIC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_VOICE_REC_HEADSET_MIC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_BT_SCO_MIC] = strdup("SEC_AUX_PCM_TX");
+    hw_interface_table[SND_DEVICE_IN_BT_SCO_MIC_NREC] = strdup("SEC_AUX_PCM_TX");
+    hw_interface_table[SND_DEVICE_IN_BT_SCO_MIC_WB] = strdup("SEC_AUX_PCM_TX");
+    hw_interface_table[SND_DEVICE_IN_BT_SCO_MIC_WB_NREC] = strdup("SEC_AUX_PCM_TX");
+    hw_interface_table[SND_DEVICE_IN_VOICE_RX] = strdup("AFE_PCM_TX");
+    hw_interface_table[SND_DEVICE_IN_THREE_MIC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_QUAD_MIC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_HANDSET_TMIC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_HANDSET_QMIC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_HANDSET_TMIC_AEC] = strdup("SLIMBUS_0_TX");
+    hw_interface_table[SND_DEVICE_IN_HANDSET_QMIC_AEC] = strdup("SLIMBUS_0_TX");
     my_data->max_mic_count = PLATFORM_DEFAULT_MIC_COUNT;
 }
 
@@ -1525,6 +1569,9 @@
     /* init usb */
     audio_extn_usb_init(adev);
 
+    /* init a2dp */
+    audio_extn_a2dp_init(adev);
+
     audio_extn_spkr_prot_init(adev);
 
     audio_extn_hwdep_cal_send(adev->snd_card, my_data->acdb_handle);
@@ -2300,7 +2347,15 @@
         new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER_SAFE;
         new_snd_devices[1] = SND_DEVICE_OUT_USB_HEADSET;
         ret = 0;
+    } else if (SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP == snd_device &&
+               !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER,
+                                              SND_DEVICE_OUT_BT_A2DP)) {
+        *num_devices = 2;
+        new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
+        new_snd_devices[1] = SND_DEVICE_OUT_BT_A2DP;
+        ret = 0;
     }
+
     return ret;
 }
 
@@ -2353,6 +2408,9 @@
                 (devices == (AUDIO_DEVICE_OUT_USB_HEADSET |
                                                AUDIO_DEVICE_OUT_SPEAKER_SAFE))) {
             snd_device = SND_DEVICE_OUT_SPEAKER_SAFE_AND_USB_HEADSET;
+        } else if ((devices & AUDIO_DEVICE_OUT_SPEAKER) &&
+                   (devices & AUDIO_DEVICE_OUT_ALL_A2DP)) {
+            snd_device = SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP;
         } else {
             ALOGE("%s: Invalid combo device(%#x)", __func__, devices);
             goto exit;
@@ -2417,6 +2475,8 @@
             } else {
                 snd_device = SND_DEVICE_OUT_BT_SCO;
             }
+        } else if (devices & AUDIO_DEVICE_OUT_ALL_A2DP) {
+            snd_device = SND_DEVICE_OUT_BT_A2DP;
         } else if (devices & (AUDIO_DEVICE_OUT_SPEAKER | AUDIO_DEVICE_OUT_SPEAKER_SAFE)) {
             if (!adev->enable_hfp) {
                 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER;
@@ -2456,6 +2516,8 @@
         } else {
             snd_device = SND_DEVICE_OUT_BT_SCO;
         }
+    } else if (devices & AUDIO_DEVICE_OUT_ALL_A2DP) {
+        snd_device = SND_DEVICE_OUT_BT_A2DP;
     } else if (devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
         snd_device = SND_DEVICE_OUT_HDMI ;
     } else if (audio_is_usb_out_device(devices)) {
diff --git a/hal/msm8974/platform.h b/hal/msm8974/platform.h
index 3e31639..8f16802 100644
--- a/hal/msm8974/platform.h
+++ b/hal/msm8974/platform.h
@@ -78,6 +78,8 @@
     SND_DEVICE_OUT_SPEAKER_AND_HDMI,
     SND_DEVICE_OUT_BT_SCO,
     SND_DEVICE_OUT_BT_SCO_WB,
+    SND_DEVICE_OUT_BT_A2DP,
+    SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP,
     SND_DEVICE_OUT_VOICE_HANDSET_TMUS,
     SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES,
     SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES,