Merge "hal: support for sound trigger"

9 files changed, 467 insertions, 10 deletions

diff --git a/hal/Android.mk b/hal/Android.mk
index 3f4e4943..907e5e71 100644
--- a/hal/Android.mk
+++ b/hal/Android.mk
@@ -162,6 +162,13 @@ ifeq ($(strip $(AUDIO_FEATURE_ENABLED_LISTEN)),true)
     LOCAL_SRC_FILES += audio_extn/listen.c
 endif
 
+ifeq ($(strip $(BOARD_SUPPORTS_SOUND_TRIGGER)),true)
+    LOCAL_CFLAGS += -DSOUND_TRIGGER_ENABLED
+    LOCAL_CFLAGS += -DSOUND_TRIGGER_PLATFORM_NAME=$(TARGET_BOARD_PLATFORM)
+    LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/sound_trigger
+    LOCAL_SRC_FILES += audio_extn/soundtrigger.c
+endif
+
 ifeq ($(strip $(AUDIO_FEATURE_ENABLED_AUXPCM_BT)),true)
     LOCAL_CFLAGS += -DAUXPCM_BT_ENABLED
 endif
diff --git a/hal/audio_extn/audio_extn.c b/hal/audio_extn/audio_extn.c
index 6c158795..5ca892df 100644
--- a/hal/audio_extn/audio_extn.c
+++ b/hal/audio_extn/audio_extn.c
@@ -406,6 +406,7 @@ void audio_extn_set_parameters(struct audio_device *adev,
    audio_extn_set_fluence_parameters(adev, parms);
    audio_extn_set_afe_proxy_parameters(parms);
    audio_extn_fm_set_parameters(adev, parms);
+   audio_extn_sound_trigger_set_parameters(adev, parms);
    audio_extn_listen_set_parameters(adev, parms);
    audio_extn_hfp_set_parameters(adev, parms);
    audio_extn_ddp_set_parameters(adev, parms);
diff --git a/hal/audio_extn/audio_extn.h b/hal/audio_extn/audio_extn.h
index e6d28f7c..1900d64f 100644
--- a/hal/audio_extn/audio_extn.h
+++ b/hal/audio_extn/audio_extn.h
@@ -159,6 +159,36 @@ void audio_extn_listen_set_parameters(struct audio_device *adev,
                                       struct str_parms *parms);
 #endif /* AUDIO_LISTEN_ENABLED */
 
+#ifndef SOUND_TRIGGER_ENABLED
+#define audio_extn_sound_trigger_init(adev)                            (0)
+#define audio_extn_sound_trigger_deinit(adev)                          (0)
+#define audio_extn_sound_trigger_update_device_status(snd_dev, event)  (0)
+#define audio_extn_sound_trigger_update_stream_status(uc_info, event)  (0)
+#define audio_extn_sound_trigger_set_parameters(adev, parms)           (0)
+#define audio_extn_sound_trigger_check_and_get_session(in)             (0)
+#define audio_extn_sound_trigger_stop_lab(in)                          (0)
+#else
+
+enum st_event_type {
+    ST_EVENT_SND_DEVICE_FREE,
+    ST_EVENT_SND_DEVICE_BUSY,
+    ST_EVENT_STREAM_FREE,
+    ST_EVENT_STREAM_BUSY
+};
+typedef enum st_event_type st_event_type_t;
+
+int audio_extn_sound_trigger_init(struct audio_device *adev);
+void audio_extn_sound_trigger_deinit(struct audio_device *adev);
+void audio_extn_sound_trigger_update_device_status(snd_device_t snd_device,
+                                     st_event_type_t event);
+void audio_extn_sound_trigger_update_stream_status(struct audio_usecase *uc_info,
+                                     st_event_type_t event);
+void audio_extn_sound_trigger_set_parameters(struct audio_device *adev,
+                                             struct str_parms *parms);
+void audio_extn_sound_trigger_check_and_get_session(struct stream_in *in);
+void audio_extn_sound_trigger_stop_lab(struct stream_in *in);
+#endif
+
 #ifndef AUXPCM_BT_ENABLED
 #define audio_extn_read_xml(adev, mixer_card, MIXER_XML_PATH, \
                             MIXER_XML_PATH_AUXPCM)               (-ENOSYS)
diff --git a/hal/audio_extn/soundtrigger.c b/hal/audio_extn/soundtrigger.c
new file mode 100644
index 00000000..c6d7077e
--- /dev/null
+++ b/hal/audio_extn/soundtrigger.c
@@ -0,0 +1,352 @@
+/* Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#define LOG_TAG "soundtrigger"
+/* #define LOG_NDEBUG 0 */
+#define LOG_NDDEBUG 0
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+#include <cutils/log.h>
+#include "audio_hw.h"
+#include "audio_extn.h"
+#include "platform.h"
+#include "platform_api.h"
+#include "sound_trigger_prop_intf.h"
+
+#define XSTR(x) STR(x)
+#define STR(x) #x
+
+struct sound_trigger_info  {
+    struct sound_trigger_session_info st_ses;
+    bool lab_stopped;
+    struct listnode list;
+};
+
+struct sound_trigger_audio_device {
+    void *lib_handle;
+    struct audio_device *adev;
+    sound_trigger_hw_call_back_t st_callback;
+    struct listnode st_ses_list;
+    pthread_mutex_t lock;
+};
+
+static struct sound_trigger_audio_device *st_dev;
+
+static struct sound_trigger_info *
+get_sound_trigger_info(int capture_handle)
+{
+    struct sound_trigger_info  *st_ses_info = NULL;
+    struct listnode *node;
+    ALOGD("%s: list %d capture_handle %d", __func__,
+           list_empty(&st_dev->st_ses_list), capture_handle);
+    list_for_each(node, &st_dev->st_ses_list) {
+        st_ses_info = node_to_item(node, struct sound_trigger_info , list);
+        if (st_ses_info->st_ses.capture_handle == capture_handle)
+            return st_ses_info;
+    }
+    return NULL;
+}
+
+int audio_hw_call_back(sound_trigger_event_type_t event,
+                       sound_trigger_event_info_t* config)
+{
+    int status = 0;
+    struct sound_trigger_info  *st_ses_info;
+
+    if (!st_dev)
+       return -EINVAL;
+
+    pthread_mutex_lock(&st_dev->lock);
+    switch (event) {
+    case ST_EVENT_SESSION_REGISTER:
+        if (!config) {
+            ALOGE("%s: NULL config", __func__);
+            status = -EINVAL;
+            break;
+        }
+        st_ses_info= calloc(1, sizeof(struct sound_trigger_info ));
+        if (!st_ses_info) {
+            ALOGE("%s: st_ses_info alloc failed", __func__);
+            status = -ENOMEM;
+            break;
+        }
+        memcpy(&st_ses_info->st_ses, &config->st_ses, sizeof (config->st_ses));
+        ALOGV("%s: add capture_handle %d pcm %p", __func__,
+              st_ses_info->st_ses.capture_handle, st_ses_info->st_ses.pcm);
+        list_add_tail(&st_dev->st_ses_list, &st_ses_info->list);
+        break;
+
+    case ST_EVENT_SESSION_DEREGISTER:
+        if (!config) {
+            ALOGE("%s: NULL config", __func__);
+            status = -EINVAL;
+            break;
+        }
+        st_ses_info = get_sound_trigger_info(config->st_ses.capture_handle);
+        if (!st_ses_info) {
+            ALOGE("%s: pcm %p not in the list!", __func__, config->st_ses.pcm);
+            status = -EINVAL;
+            break;
+        }
+        ALOGV("%s: remove capture_handle %d pcm %p", __func__,
+              st_ses_info->st_ses.capture_handle, st_ses_info->st_ses.pcm);
+        list_remove(&st_ses_info->list);
+        free(st_ses_info);
+        break;
+    default:
+        ALOGW("%s: Unknown event %d", __func__, event);
+        break;
+    }
+    pthread_mutex_unlock(&st_dev->lock);
+    return status;
+}
+
+void audio_extn_sound_trigger_stop_lab(struct stream_in *in)
+{
+    int status = 0;
+    struct sound_trigger_info  *st_ses_info = NULL;
+    audio_event_info_t event;
+
+    if (!st_dev || !in)
+       return;
+
+    pthread_mutex_lock(&st_dev->lock);
+    st_ses_info = get_sound_trigger_info(in->capture_handle);
+    if (st_ses_info) {
+        event.u.ses_info = st_ses_info->st_ses;
+        ALOGV("%s: AUDIO_EVENT_STOP_LAB pcm %p", __func__, st_ses_info->st_ses.pcm);
+        st_dev->st_callback(AUDIO_EVENT_STOP_LAB, &event);
+    }
+    pthread_mutex_unlock(&st_dev->lock);
+}
+void audio_extn_sound_trigger_check_and_get_session(struct stream_in *in)
+{
+    struct sound_trigger_info  *st_ses_info = NULL;
+    struct listnode *node;
+
+    if (!st_dev || !in)
+       return;
+
+    pthread_mutex_lock(&st_dev->lock);
+    in->is_st_session = false;
+    ALOGV("%s: list %d capture_handle %d", __func__,
+          list_empty(&st_dev->st_ses_list), in->capture_handle);
+    list_for_each(node, &st_dev->st_ses_list) {
+        st_ses_info = node_to_item(node, struct sound_trigger_info , list);
+        if (st_ses_info->st_ses.capture_handle == in->capture_handle) {
+            in->pcm = st_ses_info->st_ses.pcm;
+            in->config = st_ses_info->st_ses.config;
+            in->channel_mask = audio_channel_in_mask_from_count(in->config.channels);
+            in->is_st_session = true;
+            ALOGD("%s: capture_handle %d is sound trigger", __func__, in->capture_handle);
+            break;
+        }
+    }
+    pthread_mutex_unlock(&st_dev->lock);
+}
+
+void audio_extn_sound_trigger_update_device_status(snd_device_t snd_device,
+                                     st_event_type_t event)
+{
+    bool raise_event = false;
+    int device_type = -1;
+
+    if (!st_dev)
+       return;
+
+    if (snd_device >= SND_DEVICE_OUT_BEGIN &&
+        snd_device < SND_DEVICE_OUT_END)
+        device_type = PCM_PLAYBACK;
+    else if (snd_device >= SND_DEVICE_IN_BEGIN &&
+        snd_device < SND_DEVICE_IN_END)
+        device_type = PCM_CAPTURE;
+    else {
+        ALOGE("%s: invalid device 0x%x, for event %d",
+                           __func__, snd_device, event);
+        return;
+    }
+
+    raise_event = platform_sound_trigger_device_needs_event(snd_device);
+    ALOGI("%s: device 0x%x of type %d for Event %d, with Raise=%d",
+        __func__, snd_device, device_type, event, raise_event);
+    if (raise_event && (device_type == PCM_CAPTURE)) {
+        switch(event) {
+        case ST_EVENT_SND_DEVICE_FREE:
+            st_dev->st_callback(AUDIO_EVENT_CAPTURE_DEVICE_INACTIVE, NULL);
+            break;
+        case ST_EVENT_SND_DEVICE_BUSY:
+            st_dev->st_callback(AUDIO_EVENT_CAPTURE_DEVICE_ACTIVE, NULL);
+            break;
+        default:
+            ALOGW("%s:invalid event %d for device 0x%x",
+                                  __func__, event, snd_device);
+        }
+    }/*Events for output device, if required can be placed here in else*/
+}
+
+void audio_extn_sound_trigger_update_stream_status(struct audio_usecase *uc_info,
+                                     st_event_type_t event)
+{
+    bool raise_event = false;
+    audio_usecase_t uc_id;
+    int usecase_type = -1;
+
+    if (!st_dev) {
+        return;
+    }
+
+    if (uc_info == NULL) {
+        ALOGE("%s: usecase is NULL!!!", __func__);
+        return;
+    }
+    uc_id = uc_info->id;
+    usecase_type = uc_info->type;
+
+    raise_event = platform_sound_trigger_usecase_needs_event(uc_id);
+    ALOGD("%s: uc_id %d of type %d for Event %d, with Raise=%d",
+        __func__, uc_id, usecase_type, event, raise_event);
+    if (raise_event && (usecase_type == PCM_PLAYBACK)) {
+        switch(event) {
+        case ST_EVENT_STREAM_FREE:
+            st_dev->st_callback(AUDIO_EVENT_PLAYBACK_STREAM_INACTIVE, NULL);
+            break;
+        case ST_EVENT_STREAM_BUSY:
+            st_dev->st_callback(AUDIO_EVENT_PLAYBACK_STREAM_ACTIVE, NULL);
+            break;
+        default:
+            ALOGW("%s:invalid event %d, for usecase %d",
+                                  __func__, event, uc_id);
+        }
+    }/*Events for capture usecase, if required can be placed here in else*/
+}
+
+void audio_extn_sound_trigger_set_parameters(struct audio_device *adev __unused,
+                               struct str_parms *params)
+{
+    audio_event_info_t event;
+    char value[32];
+    int ret;
+
+    if(!st_dev || !params) {
+        ALOGE("%s: str_params NULL", __func__);
+        return;
+    }
+
+    ret = str_parms_get_str(params, "SND_CARD_STATUS", value,
+                            sizeof(value));
+    if (ret > 0) {
+        if (strstr(value, "OFFLINE")) {
+            event.u.status = SND_CARD_STATUS_OFFLINE;
+            st_dev->st_callback(AUDIO_EVENT_SSR, &event);
+        }
+        else if (strstr(value, "ONLINE")) {
+            event.u.status = SND_CARD_STATUS_ONLINE;
+            st_dev->st_callback(AUDIO_EVENT_SSR, &event);
+        }
+        else
+            ALOGE("%s: unknown snd_card_status", __func__);
+    }
+
+    ret = str_parms_get_str(params, "CPE_STATUS", value, sizeof(value));
+    if (ret > 0) {
+        if (strstr(value, "OFFLINE")) {
+            event.u.status = CPE_STATUS_OFFLINE;
+            st_dev->st_callback(AUDIO_EVENT_SSR, &event);
+        }
+        else if (strstr(value, "ONLINE")) {
+            event.u.status = CPE_STATUS_ONLINE;
+            st_dev->st_callback(AUDIO_EVENT_SSR, &event);
+        }
+        else
+            ALOGE("%s: unknown CPE status", __func__);
+    }
+}
+
+int audio_extn_sound_trigger_init(struct audio_device *adev)
+{
+    int status = 0;
+    char sound_trigger_lib[100];
+    void *lib_handle;
+
+    ALOGI("%s: Enter", __func__);
+
+    st_dev = (struct sound_trigger_audio_device*)
+                        calloc(1, sizeof(struct sound_trigger_audio_device));
+    if (!st_dev) {
+        ALOGE("%s: ERROR. sound trigger alloc failed", __func__);
+        return -ENOMEM;
+    }
+
+    snprintf(sound_trigger_lib, sizeof(sound_trigger_lib),
+             "/system/vendor/lib/hw/sound_trigger.primary.%s.so",
+              XSTR(SOUND_TRIGGER_PLATFORM_NAME));
+
+    st_dev->lib_handle = dlopen(sound_trigger_lib, RTLD_NOW);
+
+    if (st_dev->lib_handle == NULL) {
+        ALOGE("%s: DLOPEN failed for %s. error = %s", __func__, sound_trigger_lib,
+                dlerror());
+        status = -EINVAL;
+        goto cleanup;
+    }
+    ALOGI("%s: DLOPEN successful for %s", __func__, sound_trigger_lib);
+
+    st_dev->st_callback = (sound_trigger_hw_call_back_t)
+              dlsym(st_dev->lib_handle, "sound_trigger_hw_call_back");
+
+    if (st_dev->st_callback == NULL) {
+       ALOGE("%s: ERROR. dlsym Error:%s sound_trigger_hw_call_back", __func__,
+               dlerror());
+       goto cleanup;
+    }
+
+    st_dev->adev = adev;
+    list_init(&st_dev->st_ses_list);
+
+    return 0;
+
+cleanup:
+    if (st_dev->lib_handle)
+        dlclose(st_dev->lib_handle);
+    free(st_dev);
+    st_dev = NULL;
+    return status;
+
+}
+
+void audio_extn_sound_trigger_deinit(struct audio_device *adev)
+{
+    ALOGI("%s: Enter", __func__);
+    if (st_dev && (st_dev->adev == adev) && st_dev->lib_handle) {
+        dlclose(st_dev->lib_handle);
+        free(st_dev);
+        st_dev = NULL;
+    }
+}
diff --git a/hal/audio_hw.c b/hal/audio_hw.c
index 5ecaa8fe..545a5484 100644
--- a/hal/audio_hw.c
+++ b/hal/audio_hw.c
@@ -285,6 +285,7 @@ int enable_audio_route(struct audio_device *adev,
 #ifdef DS2_DOLBY_DAP_ENABLED
     audio_extn_dolby_ds2_set_endpoint(adev);
 #endif
+    audio_extn_sound_trigger_update_stream_status(usecase, ST_EVENT_STREAM_BUSY);
     strcpy(mixer_path, use_case_table[usecase->id]);
     platform_add_backend_name(mixer_path, snd_device);
     ALOGV("%s: apply mixer and update path: %s", __func__, mixer_path);
@@ -311,6 +312,7 @@ int disable_audio_route(struct audio_device *adev,
     platform_add_backend_name(mixer_path, snd_device);
     ALOGV("%s: reset and update mixer path: %s", __func__, mixer_path);
     audio_route_reset_and_update_path(adev->audio_route, mixer_path);
+    audio_extn_sound_trigger_update_stream_status(usecase, ST_EVENT_STREAM_FREE);
     ALOGV("%s: exit", __func__);
     return 0;
 }
@@ -361,10 +363,15 @@ int enable_snd_device(struct audio_device *adev,
             and audio, notify listen hal before audio calibration is sent */
         audio_extn_listen_update_status(snd_device,
                        LISTEN_EVENT_SND_DEVICE_BUSY);
+        audio_extn_sound_trigger_update_device_status(snd_device,
+                                        ST_EVENT_SND_DEVICE_BUSY);
+
         if (platform_send_audio_calibration(adev->platform, snd_device) < 0) {
             adev->snd_dev_ref_cnt[snd_device]--;
             audio_extn_listen_update_status(snd_device,
                            LISTEN_EVENT_SND_DEVICE_FREE);
+            audio_extn_sound_trigger_update_device_status(snd_device,
+                                            ST_EVENT_SND_DEVICE_FREE);
             return -EINVAL;
         }
 
@@ -416,6 +423,8 @@ int disable_snd_device(struct audio_device *adev,
 
         audio_extn_listen_update_status(snd_device,
                                         LISTEN_EVENT_SND_DEVICE_FREE);
+        audio_extn_sound_trigger_update_device_status(snd_device,
+                                        ST_EVENT_SND_DEVICE_FREE);
     }
 
     return 0;
@@ -2066,6 +2075,12 @@ static int in_standby(struct audio_stream *stream)
     }
 
     pthread_mutex_lock(&in->lock);
+    if (!in->standby && in->is_st_session) {
+        ALOGD("%s: sound trigger pcm stop lab", __func__);
+        audio_extn_sound_trigger_stop_lab(in);
+        in->standby = 1;
+    }
+
     if (!in->standby) {
         pthread_mutex_lock(&adev->lock);
         in->standby = true;
@@ -2128,7 +2143,7 @@ static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
         if (((int)in->device != val) && (val != 0)) {
             in->device = val;
             /* If recording is in progress, change the tx device to new device */
-            if (!in->standby)
+            if (!in->standby && !in->is_st_session)
                 ret = select_devices(adev, in->usecase);
         }
     }
@@ -2183,14 +2198,16 @@ static ssize_t in_read(struct audio_stream_in *stream, void *buffer,
 
     pthread_mutex_lock(&in->lock);
     if (in->standby) {
-        pthread_mutex_lock(&adev->lock);
-        if (in->usecase == USECASE_COMPRESS_VOIP_CALL)
-            ret = voice_extn_compress_voip_start_input_stream(in);
-        else
-            ret = start_input_stream(in);
-        pthread_mutex_unlock(&adev->lock);
-        if (ret != 0) {
-            goto exit;
+        if (!in->is_st_session) {
+            pthread_mutex_lock(&adev->lock);
+            if (in->usecase == USECASE_COMPRESS_VOIP_CALL)
+                ret = voice_extn_compress_voip_start_input_stream(in);
+            else
+                ret = start_input_stream(in);
+            pthread_mutex_unlock(&adev->lock);
+            if (ret != 0) {
+                goto exit;
+            }
         }
         in->standby = 0;
     }
@@ -2219,7 +2236,7 @@ exit:
 
     if (ret != 0) {
         in_standby(&in->stream.common);
-        ALOGV("%s: read failed - sleeping for buffer duration", __func__);
+        ALOGV("%s: read failed status %d- sleeping for buffer duration", __func__, ret);
         usleep(bytes * 1000000 / audio_stream_in_frame_size(stream) /
                in_get_sample_rate(&in->stream.common));
     }
@@ -2802,6 +2819,15 @@ static int adev_open_input_stream(struct audio_hw_device *dev,
 
     in = (struct stream_in *)calloc(1, sizeof(struct stream_in));
 
+    if (!in) {
+        ALOGE("failed to allocate input stream");
+        return -ENOMEM;
+    }
+
+    ALOGD("%s: enter: sample_rate(%d) channel_mask(%#x) devices(%#x)\
+        stream_handle(%p) io_handle(%d)",__func__, config->sample_rate, config->channel_mask,
+        devices, &in->stream, handle);
+
     pthread_mutex_init(&in->lock, (const pthread_mutexattr_t *) NULL);
 
     in->stream.common.get_sample_rate = in_get_sample_rate;
@@ -2825,6 +2851,7 @@ static int adev_open_input_stream(struct audio_hw_device *dev,
     in->dev = adev;
     in->standby = 1;
     in->channel_mask = config->channel_mask;
+    in->capture_handle = handle;
 
     /* Update config params with the requested sample rate and channels */
     in->usecase = USECASE_AUDIO_RECORD;
@@ -2876,6 +2903,10 @@ static int adev_open_input_stream(struct audio_hw_device *dev,
         in->config.period_size = buffer_size / frame_size;
     }
 
+    /* This stream could be for sound trigger lab,
+       get sound trigger pcm if present */
+    audio_extn_sound_trigger_check_and_get_session(in);
+
     *stream_in = &in->stream;
     ALOGV("%s: exit", __func__);
     return ret;
@@ -2934,6 +2965,7 @@ static int adev_close(hw_device_t *device)
     pthread_mutex_lock(&adev_init_lock);
 
     if ((--audio_device_ref_count) == 0) {
+        audio_extn_sound_trigger_deinit(adev);
         audio_extn_listen_deinit(adev);
         audio_route_free(adev->audio_route);
         free(adev->snd_dev_ref_cnt);
@@ -3029,6 +3061,7 @@ static int adev_open(const hw_module_t *module, const char *name,
         }
     }
     audio_extn_listen_init(adev, adev->snd_card);
+    audio_extn_sound_trigger_init(adev);
 
     if (access(OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH, R_OK) == 0) {
         adev->offload_effects_lib = dlopen(OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH, RTLD_NOW);
diff --git a/hal/audio_hw.h b/hal/audio_hw.h
index 024960f3..6af17b07 100644
--- a/hal/audio_hw.h
+++ b/hal/audio_hw.h
@@ -195,6 +195,8 @@ struct stream_in {
     bool enable_aec;
     bool enable_ns;
     audio_format_t format;
+    audio_io_handle_t capture_handle;
+    bool is_st_session;
 
     struct audio_device *dev;
 };
diff --git a/hal/msm8960/platform.c b/hal/msm8960/platform.c
index 01d5fd80..cb4398db 100644
--- a/hal/msm8960/platform.c
+++ b/hal/msm8960/platform.c
@@ -1088,3 +1088,14 @@ int platform_set_snd_device_backend(snd_device_t snd_device __unused,
 {
     return -ENOSYS;
 }
+
+bool platform_sound_trigger_device_needs_event(snd_device_t snd_device __unused)
+{
+    return false;
+}
+
+bool platform_sound_trigger_usecase_needs_event(audio_usecase_t uc_id  __unused)
+{
+    return false;
+}
+
diff --git a/hal/msm8974/platform.c b/hal/msm8974/platform.c
index 8a9079cd..42fa6c03 100644
--- a/hal/msm8974/platform.c
+++ b/hal/msm8974/platform.c
@@ -2032,6 +2032,24 @@ bool platform_listen_update_status(snd_device_t snd_device)
         return false;
 }
 
+bool platform_sound_trigger_device_needs_event(snd_device_t snd_device)
+{
+    bool needs_event = false;
+
+    if ((snd_device >= SND_DEVICE_IN_BEGIN) &&
+        (snd_device < SND_DEVICE_IN_END) &&
+        (snd_device != SND_DEVICE_IN_CAPTURE_FM) &&
+        (snd_device != SND_DEVICE_IN_CAPTURE_VI_FEEDBACK))
+        needs_event = true;
+
+    return needs_event;
+}
+
+bool platform_sound_trigger_usecase_needs_event(audio_usecase_t uc_id __unused)
+{
+    return false;
+}
+
 /* Read  offload buffer size from a property.
  * If value is not power of 2  round it to
  * power of 2.
diff --git a/hal/platform_api.h b/hal/platform_api.h
index f91c1d85..26196cf7 100644
--- a/hal/platform_api.h
+++ b/hal/platform_api.h
@@ -71,6 +71,9 @@ bool platform_listen_update_status(snd_device_t snd_device);
 
 int platform_set_snd_device_backend(snd_device_t snd_device, const char * backend);
 
+bool platform_sound_trigger_device_needs_event(snd_device_t snd_device);
+bool platform_sound_trigger_usecase_needs_event(audio_usecase_t uc_id);
+
 /* From platform_info_parser.c */
 int platform_info_init(const char *filename);