diff --git a/hal/audio_extn/soundtrigger.c b/hal/audio_extn/soundtrigger.c
index b7f5af7..0fa30d0 100644
--- a/hal/audio_extn/soundtrigger.c
+++ b/hal/audio_extn/soundtrigger.c
@@ -436,9 +436,6 @@
     if (!st_dev)
        return;
 
-    if (st_dev->sthal_prop_api_version >= STHAL_PROP_API_VERSION_1_0)
-        return;
-
     if (snd_device >= SND_DEVICE_OUT_BEGIN &&
         snd_device < SND_DEVICE_OUT_END)
         device_type = PCM_PLAYBACK;
@@ -481,14 +478,15 @@
     if (!st_dev)
        return;
 
-    if (st_dev->sthal_prop_api_version < STHAL_PROP_API_VERSION_1_0)
-        return;
-
     if (uc_info == NULL) {
         ALOGE("%s: usecase is NULL!!!", __func__);
         return;
     }
 
+    if ((st_dev->sthal_prop_api_version < STHAL_PROP_API_VERSION_1_0) &&
+        (uc_info->type != PCM_PLAYBACK))
+        return;
+
     if ((uc_info->in_snd_device >= SND_DEVICE_IN_BEGIN &&
         uc_info->in_snd_device < SND_DEVICE_IN_END)) {
         if (is_same_as_st_device(uc_info->in_snd_device))
