diff --git a/hal_mpq/Android.mk b/hal_mpq/Android.mk
deleted file mode 100644
index 1cb7e60..0000000
--- a/hal_mpq/Android.mk
+++ /dev/null
@@ -1,59 +0,0 @@
-ifeq ($(strip $(BOARD_USES_ALSA_AUDIO)),true)
-
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_ARM_MODE := arm
-
-AUDIO_PLATFORM := $(TARGET_BOARD_PLATFORM)
-
-LOCAL_SRC_FILES := \
-	audio_hw.c \
-	audio_stream_out.c \
-	audio_bitstream_sm.c \
-	$(AUDIO_PLATFORM)/hw_info.c \
-	$(AUDIO_PLATFORM)/platform.c
-
-ifneq ($(strip $(AUDIO_FEATURE_DISABLED_ANC_HEADSET)),true)
-    LOCAL_CFLAGS += -DANC_HEADSET_ENABLED
-endif
-
-ifneq ($(strip $(AUDIO_FEATURE_DISABLED_PROXY_DEVICE)),true)
-    LOCAL_CFLAGS += -DAFE_PROXY_ENABLED
-endif
-
-
-ifdef MULTIPLE_HW_VARIANTS_ENABLED
-  LOCAL_CFLAGS += -DHW_VARIANTS_ENABLED
-  LOCAL_SRC_FILES += $(AUDIO_PLATFORM)/hw_info.c
-endif
-
-LOCAL_SHARED_LIBRARIES := \
-	liblog \
-	libcutils \
-	libtinyalsa \
-	libtinycompress \
-	libaudioroute \
-	libdl
-
-LOCAL_C_INCLUDES := \
-	external/tinyalsa/include \
-	external/tinycompress/include \
-	$(call include-path-for, audio-route) \
-	$(call include-path-for, audio-effects) \
-	$(LOCAL_PATH)/$(AUDIO_PLATFORM)
-
-
-LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
-LOCAL_ADDITIONAL_DEPENDENCIES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
-
-LOCAL_MODULE := audio.primary.$(TARGET_BOARD_PLATFORM)
-
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
-
-LOCAL_MODULE_TAGS := optional
-
-include $(BUILD_SHARED_LIBRARY)
-
-endif
diff --git a/hal_mpq/audio_bitstream_sm.c b/hal_mpq/audio_bitstream_sm.c
deleted file mode 100644
index d2e4e6e..0000000
--- a/hal_mpq/audio_bitstream_sm.c
+++ /dev/null
@@ -1,485 +0,0 @@
-/*
- * Copyright (C) 2011 The Android Open Source Project
- * Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
- * Not a Contribution.
- *
- * 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.
- */
-
-#include <errno.h>
-#include <stdarg.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <dlfcn.h>
-#include <math.h>
-
-#define LOG_TAG "AudioBitstreamStateMachine"
-#define LOG_NDEBUG 0
-#define LOG_NDDEBUG 0
-#include <utils/Log.h>
-
-#include <cutils/properties.h>
-#include "audio_hw.h"
-#include "platform_api.h"
-#include <platform.h>
-// ----------------------------------------------------------------------------
-
-/*
-Initialize all input and output pointers
-Allocate twice the max buffer size of input and output for sufficient buffering
-*/
-int audio_bitstream_init(struct audio_bitstream_sm *bstream, int buffering_factor)
-{
-    bstream->buffering_factor = buffering_factor;
-    bstream->buffering_factor_cnt = 0;
-    bstream->inp_buf_size = SAMPLES_PER_CHANNEL *
-                        MAX_INPUT_CHANNELS_SUPPORTED*
-                        (bstream->buffering_factor+1);
-    bstream->inp_buf = (char *)malloc( bstream->inp_buf_size);
-
-                                // multiplied by 2 to convert to bytes
-    if(bstream->inp_buf != NULL) {
-        bstream->inp_buf_curr_ptr = bstream->inp_buf;
-        bstream->inp_buf_write_ptr = bstream->inp_buf;
-    } else {
-        ALOGE("MS11 input buffer not allocated");
-        bstream->inp_buf_size = 0;
-        return 0;
-    }
-
-    bstream->enc_out_buf_size = SAMPLES_PER_CHANNEL * MAX_INPUT_CHANNELS_SUPPORTED*
-                        FACTOR_FOR_BUFFERING;
-    bstream->enc_out_buf =(char *)malloc(bstream->enc_out_buf_size);
-
-    if(bstream->enc_out_buf) {
-        bstream->enc_out_buf_write_ptr = bstream->enc_out_buf;
-    } else {
-        ALOGE("MS11 Enc output buffer not allocated");
-        bstream->enc_out_buf_size = 0;
-        return 0;
-    }
-    bstream->pcm_2_out_buf_size =  SAMPLES_PER_CHANNEL*STEREO_CHANNELS *
-                    FACTOR_FOR_BUFFERING;
-    bstream->pcm_2_out_buf =(char *)malloc(bstream->pcm_2_out_buf_size);
-    if(bstream->pcm_2_out_buf) {
-        bstream->pcm_2_out_buf_write_ptr = bstream->pcm_2_out_buf;
-    } else {
-        ALOGE("MS11 PCM2Ch output buffer not allocated");
-        bstream->pcm_2_out_buf_size = 0;
-        return 0;
-    }
-    bstream->pcm_mch_out_buf_size = SAMPLES_PER_CHANNEL * MAX_OUTPUT_CHANNELS_SUPPORTED *
-                     FACTOR_FOR_BUFFERING;
-
-    bstream->pcm_mch_out_buf =(char *)malloc(bstream->pcm_mch_out_buf_size);
-    if(bstream->pcm_mch_out_buf) {
-        bstream->pcm_mch_out_buf_write_ptr = bstream->pcm_mch_out_buf;
-    } else {
-        ALOGE("MS11 PCMMCh output buffer not allocated");
-        bstream->pcm_mch_out_buf_size = 0;
-        return 0;
-    }
-    bstream->passt_out_buf_size =SAMPLES_PER_CHANNEL *
-                       MAX_INPUT_CHANNELS_SUPPORTED *
-                       FACTOR_FOR_BUFFERING;
-    bstream->passt_out_buf =(char *)malloc(bstream->passt_out_buf_size);
-    if(bstream->passt_out_buf) {
-        bstream->passt_out_buf_write_ptr = bstream->passt_out_buf;
-    } else {
-        ALOGE("MS11 Enc output buffer not allocated");
-        bstream->passt_out_buf_size  = 0;
-        return 0;
-    }
-    return 1;
-}
-
-/*
-Free the allocated memory
-*/
-int audio_bitstream_close(struct audio_bitstream_sm *bstream)
-{
-    if(bstream->inp_buf != NULL) {
-       free(bstream->inp_buf);
-       bstream->inp_buf = NULL;
-    }
-    if(bstream->enc_out_buf != NULL) {
-       free(bstream->enc_out_buf);
-       bstream->enc_out_buf = NULL;
-    }
-    if(bstream->pcm_2_out_buf != NULL) {
-       free(bstream->pcm_2_out_buf);
-       bstream->pcm_2_out_buf = NULL;
-    }
-    if(bstream->pcm_mch_out_buf != NULL) {
-        free(bstream->pcm_mch_out_buf);
-        bstream->pcm_mch_out_buf = NULL;
-    }
-    if(bstream->passt_out_buf != NULL) {
-       free(bstream->passt_out_buf);
-       bstream->passt_out_buf = NULL;
-    }
-    bstream->buffering_factor = 1;
-    bstream->buffering_factor_cnt = 0;
-    return 0;
-}
-
-/*
-Reset the buffer pointers to start for. This will be help in flush and close
-*/
-void audio_bitstream_reset_ptr( struct audio_bitstream_sm *bstream)
-{
-    bstream->inp_buf_curr_ptr = bstream->inp_buf_write_ptr = bstream->inp_buf;
-    bstream->enc_out_buf_write_ptr = bstream->enc_out_buf;
-    bstream->pcm_2_out_buf_write_ptr = bstream->pcm_2_out_buf;
-    bstream->pcm_mch_out_buf_write_ptr = bstream->pcm_mch_out_buf;
-    bstream->passt_out_buf_write_ptr = bstream->passt_out_buf;
-    bstream->buffering_factor_cnt = 0;
-}
-
-/*
-Reset the output buffer pointers to start for port reconfiguration
-*/
-void audio_bitstream_reset_output_bitstream_ptr(
-                            struct audio_bitstream_sm *bstream)
-{
-    bstream->enc_out_buf_write_ptr = bstream->enc_out_buf;
-    bstream->pcm_2_out_buf_write_ptr = bstream->pcm_2_out_buf;
-    bstream->pcm_mch_out_buf_write_ptr = bstream->pcm_mch_out_buf;
-    bstream->passt_out_buf_write_ptr = bstream->passt_out_buf;
-}
-
-/*
-Copy the bitstream/pcm from Player to internal buffer.
-The incoming bitstream is appended to existing bitstream
-*/
-void audio_bitstream_copy_to_internal_buffer(
-                    struct audio_bitstream_sm *bstream,
-                    char *buf_ptr, size_t bytes)
-{
-    // flush the input buffer if input is not consumed
-    if( (bstream->inp_buf_write_ptr+bytes) > (bstream->inp_buf+bstream->inp_buf_size) ) {
-        ALOGE("Input bitstream is not consumed");
-        return;
-    }
-
-    memcpy(bstream->inp_buf_write_ptr, buf_ptr, bytes);
-    bstream->inp_buf_write_ptr += bytes;
-    if(bstream->buffering_factor_cnt < bstream->buffering_factor)
-        bstream->buffering_factor_cnt++;
-}
-
-/*
-Append zeros to the bitstream, so that the entire bitstream in ADIF is pushed
-out for decoding
-*/
-void audio_bitstream_append_silence_internal_buffer(
-                    struct audio_bitstream_sm *bstream,
-                    uint32_t bytes, unsigned char value)
-{
-    int32_t bufLen = SAMPLES_PER_CHANNEL*MAX_INPUT_CHANNELS_SUPPORTED*
-			(bstream->buffering_factor+1);
-    uint32_t i = 0;
-    if( (bstream->inp_buf_write_ptr+bytes) > (bstream->inp_buf+bufLen) ) {
-        bytes = bufLen + bstream->inp_buf - bstream->inp_buf_write_ptr;
-    }
-    for(i=0; i< bytes; i++)
-        *bstream->inp_buf_write_ptr++ = value;
-    if(bstream->buffering_factor_cnt < bstream->buffering_factor)
-        bstream->buffering_factor_cnt++;
-}
-
-/*
-Flags if sufficient bitstream is available to proceed to decode based on
-the threshold
-*/
-int audio_bitstream_sufficient_buffer_to_decode(
-                        struct audio_bitstream_sm *bstream,
-                        int min_bytes_to_decode)
-{
-    int proceed_decode = 0;
-    if( (bstream->inp_buf_write_ptr -\
-		bstream->inp_buf_curr_ptr) > min_bytes_to_decode)
-        proceed_decode = 1;
-    return proceed_decode;
-}
-
-/*
-Gets the start address of the bitstream buffer. This is used for start of decode
-*/
-char* audio_bitstream_get_input_buffer_ptr(
-                        struct audio_bitstream_sm *bstream)
-{
-    return bstream->inp_buf_curr_ptr;
-}
-
-/*
-Gets the writePtr of the bitstream buffer. This is used for calculating length of
-bitstream
-*/
-char* audio_bitstream_get_input_buffer_write_ptr(
-                        struct audio_bitstream_sm *bstream)
-{
-    return bstream->inp_buf_write_ptr;
-}
-
-int audio_bitstream_set_input_buffer_ptr(
-                        struct audio_bitstream_sm *bstream, int bytes)
-{
-    if(((bstream->inp_buf_curr_ptr + bytes) <=
-                        (bstream->inp_buf + bstream->inp_buf_size)) &&
-        ((bstream->inp_buf_curr_ptr + bytes) >= bstream->inp_buf))
-
-        bstream->inp_buf_curr_ptr += bytes;
-     else {
-        ALOGE("Invalid input buffer size %d bytes", bytes);
-        return -EINVAL;
-     }
-
-    return 0;
-}
-
-int audio_bitstream_set_input_buffer_write_ptr(
-                        struct audio_bitstream_sm *bstream, int bytes)
-{
-    if(((bstream->inp_buf_write_ptr + bytes) <=
-                        (bstream->inp_buf + bstream->inp_buf_size)) &&
-        ((bstream->inp_buf_write_ptr + bytes) >= bstream->inp_buf))
-
-        bstream->inp_buf_write_ptr += bytes;
-     else {
-        ALOGE("Invalid input buffer size %d bytes", bytes);
-        return -EINVAL;
-     }
-
-    return 0;
-}
-
-/*
-Get the output buffer start pointer to start rendering the pcm sampled to driver
-*/
-char* audio_bitstream_get_output_buffer_ptr(
-                        struct audio_bitstream_sm *bstream,
-                        int format)
-{
-    switch(format) {
-    case PCM_MCH_OUT:
-        return bstream->pcm_mch_out_buf;
-    case PCM_2CH_OUT:
-        return bstream->pcm_2_out_buf;
-    case COMPRESSED_OUT:
-        return bstream->enc_out_buf;
-    case TRANSCODE_OUT:
-        return bstream->passt_out_buf;
-    default:
-        return NULL;
-    }
-}
-
-/*
-Output the pointer from where the next PCM samples can be copied to buffer
-*/
-char* audio_bitstream_get_output_buffer_write_ptr(
-                        struct audio_bitstream_sm *bstream,
-                        int format)
-{
-    switch(format) {
-    case PCM_MCH_OUT:
-        return bstream->pcm_mch_out_buf_write_ptr;
-    case PCM_2CH_OUT:
-        return bstream->pcm_2_out_buf_write_ptr;
-    case COMPRESSED_OUT:
-        return bstream->enc_out_buf_write_ptr;
-    case TRANSCODE_OUT:
-        return bstream->passt_out_buf_write_ptr;
-    default:
-        return NULL;
-    }
-}
-
-/*
-Provides the bitstream size available in the internal buffer
-*/
-size_t audio_bitstream_get_size(struct audio_bitstream_sm *bstream)
-{
-    return (bstream->inp_buf_write_ptr-bstream->inp_buf_curr_ptr);
-}
-
-/*
-After decode, the residue bitstream in the buffer is moved to start, so as to
-avoid circularity constraints
-*/
-void audio_bitstream_copy_residue_to_start(
-                    struct audio_bitstream_sm *bstream,
-                    size_t bytes_consumed_in_decode)
-{
-    size_t remaining_curr_valid_bytes = bstream->inp_buf_write_ptr -
-                              (bytes_consumed_in_decode+bstream->inp_buf_curr_ptr);
-    size_t remainingTotalBytes = bstream->inp_buf_write_ptr -
-                              (bytes_consumed_in_decode+bstream->inp_buf);
-    if(bstream->buffering_factor_cnt == bstream->buffering_factor) {
-        memcpy(bstream->inp_buf, bstream->inp_buf+bytes_consumed_in_decode, remainingTotalBytes);
-        bstream->inp_buf_write_ptr = bstream->inp_buf+remainingTotalBytes;
-        bstream->inp_buf_curr_ptr = bstream->inp_buf_write_ptr-remaining_curr_valid_bytes;
-    } else {
-        bstream->inp_buf_curr_ptr += bytes_consumed_in_decode;
-    }
-}
-
-/*
-Remaing samples less than the one period size required for the pcm driver
-is moved to start of the buffer
-*/
-void audio_bitstream_copy_residue_output_start(
-                    struct audio_bitstream_sm *bstream,
-                    int format,
-                    size_t samplesRendered)
-{
-    size_t remaining_bytes;
-    switch(format) {
-    case PCM_MCH_OUT:
-        remaining_bytes = bstream->pcm_mch_out_buf_write_ptr-\
-                        (bstream->pcm_mch_out_buf+samplesRendered);
-        memcpy(bstream->pcm_mch_out_buf,
-                    bstream->pcm_mch_out_buf+samplesRendered,
-                    remaining_bytes);
-        bstream->pcm_mch_out_buf_write_ptr = \
-                    bstream->pcm_mch_out_buf + remaining_bytes;
-        break;
-    case PCM_2CH_OUT:
-        remaining_bytes = bstream->pcm_2_out_buf_write_ptr-\
-                        (bstream->pcm_2_out_buf+samplesRendered);
-        memcpy(bstream->pcm_2_out_buf,
-                        bstream->pcm_2_out_buf+samplesRendered,
-                        remaining_bytes);
-        bstream->pcm_2_out_buf_write_ptr = \
-                        bstream->pcm_2_out_buf + remaining_bytes;
-        break;
-    case COMPRESSED_OUT:
-        remaining_bytes = bstream->enc_out_buf_write_ptr-\
-                        (bstream->enc_out_buf+samplesRendered);
-        memcpy(bstream->enc_out_buf,
-                        bstream->enc_out_buf+samplesRendered,
-                        remaining_bytes);
-        bstream->enc_out_buf_write_ptr = \
-                            bstream->enc_out_buf + remaining_bytes;
-        break;
-    case TRANSCODE_OUT:
-        remaining_bytes = bstream->passt_out_buf_write_ptr-\
-                                        (bstream->passt_out_buf+samplesRendered);
-        memcpy(bstream->passt_out_buf,
-                bstream->passt_out_buf+samplesRendered,
-                remaining_bytes);
-        bstream->passt_out_buf_write_ptr = \
-                bstream->passt_out_buf + remaining_bytes;
-        break;
-    default:
-        break;
-    }
-}
-
-/*
-The write pointer is updated after the incoming PCM samples are copied to the
-output buffer
-*/
-void audio_bitstream_set_output_buffer_write_ptr(
-                struct audio_bitstream_sm *bstream,
-                int format, size_t output_pcm_sample)
-{
-    int alloc_bytes;
-    switch(format) {
-    case PCM_MCH_OUT:
-        alloc_bytes = SAMPLES_PER_CHANNEL*\
-                        MAX_OUTPUT_CHANNELS_SUPPORTED*FACTOR_FOR_BUFFERING;
-        if (bstream->pcm_mch_out_buf + alloc_bytes >\
-                         bstream->pcm_mch_out_buf_write_ptr + output_pcm_sample)
-            bstream->pcm_mch_out_buf_write_ptr += output_pcm_sample;
-        break;
-    case PCM_2CH_OUT:
-        alloc_bytes = SAMPLES_PER_CHANNEL*STEREO_CHANNELS*FACTOR_FOR_BUFFERING;
-        if(bstream->pcm_2_out_buf + alloc_bytes > \
-                         bstream->pcm_2_out_buf_write_ptr + output_pcm_sample)
-            bstream->pcm_2_out_buf_write_ptr += output_pcm_sample;
-        break;
-    case COMPRESSED_OUT:
-        alloc_bytes = SAMPLES_PER_CHANNEL*\
-                        MAX_INPUT_CHANNELS_SUPPORTED*FACTOR_FOR_BUFFERING;
-        if (bstream->enc_out_buf + alloc_bytes > \
-                        bstream->enc_out_buf_write_ptr + output_pcm_sample)
-            bstream->enc_out_buf_write_ptr += output_pcm_sample;
-        break;
-    case TRANSCODE_OUT:
-        alloc_bytes = SAMPLES_PER_CHANNEL*\
-                        MAX_INPUT_CHANNELS_SUPPORTED*FACTOR_FOR_BUFFERING;
-        if (bstream->passt_out_buf + alloc_bytes > \
-                        bstream->passt_out_buf_write_ptr + output_pcm_sample)
-            bstream->passt_out_buf_write_ptr += output_pcm_sample;
-        break;
-    default:
-        break;
-    }
-}
-
-/*
-Flags if sufficient samples are available to render to PCM driver
-*/
-int audio_bitstream_sufficient_sample_to_render(
-                        struct audio_bitstream_sm *bstream,
-                        int format, int mid_size_reqd)
-{
-    int status = 0;
-    char *buf_ptr = NULL, *buf_write_ptr = NULL;
-    switch(format) {
-    case PCM_MCH_OUT:
-        buf_ptr = bstream->pcm_mch_out_buf;
-        buf_write_ptr = bstream->pcm_mch_out_buf_write_ptr;
-        break;
-    case PCM_2CH_OUT:
-        buf_ptr = bstream->pcm_2_out_buf;
-        buf_write_ptr = bstream->pcm_2_out_buf_write_ptr;
-        break;
-    case COMPRESSED_OUT:
-        buf_ptr = bstream->enc_out_buf;
-        buf_write_ptr = bstream->enc_out_buf_write_ptr;
-        break;
-    case TRANSCODE_OUT:
-        buf_ptr = bstream->passt_out_buf;
-        buf_write_ptr = bstream->passt_out_buf_write_ptr;
-        break;
-    default:
-        break;
-    }
-    if( (buf_write_ptr-buf_ptr) >= mid_size_reqd )
-        status = 1;
-    return status;
-}
-
-void audio_bitstream_start_input_buffering_mode(
-                        struct audio_bitstream_sm *bstream)
-{
-    bstream->buffering_factor_cnt = 0;
-}
-
-void audio_bitstream_stop_input_buffering_mode(
-                        struct audio_bitstream_sm *bstream)
-{
-    size_t remaining_curr_valid_bytes = \
-                    bstream->inp_buf_write_ptr - bstream->inp_buf_curr_ptr;
-    bstream->buffering_factor_cnt = bstream->buffering_factor;
-    memcpy(bstream->inp_buf,
-                bstream->inp_buf_curr_ptr,
-                remaining_curr_valid_bytes);
-    bstream->inp_buf_curr_ptr = bstream->inp_buf;
-    bstream->inp_buf_write_ptr = bstream->inp_buf + remaining_curr_valid_bytes;
-}
diff --git a/hal_mpq/audio_bitstream_sm.h b/hal_mpq/audio_bitstream_sm.h
deleted file mode 100644
index db03bf5..0000000
--- a/hal_mpq/audio_bitstream_sm.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (C) 2011 The Android Open Source Project
- * Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
- * Not a Contribution.
- *
- * 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.
- */
-
-#ifndef QCOM_AUDIO_BITSTRM_SM_H
-#define QCOM_AUDIO_BITSTRM_SM_H
-int audio_bitstream_init(struct audio_bitstream_sm *bstream, int buffering_factor);
-int audio_bitstream_close(struct audio_bitstream_sm *bstream);
-int audio_bitstream_with_buffering_factor(struct audio_bitstream_sm *bstream,
-                       int in_buffering_factor);
-void audio_bitstream_reset_ptr( struct audio_bitstream_sm *bstream);
-void audio_bitstream_reset_output_bitstream_ptr(
-                            struct audio_bitstream_sm *bstream);
-void audio_bitstream_copy_to_internal_buffer(
-                    struct audio_bitstream_sm *bstream,
-                    char *buf_ptr, size_t bytes);
-void audio_bitstream_append_silence_internal_buffer(
-                    struct audio_bitstream_sm *bstream,
-                    uint32_t bytes, unsigned char value);
-int audio_bitstream_sufficient_buffer_to_decode(
-                        struct audio_bitstream_sm *bstream,
-                        int min_bytes_to_decode);
-char* audio_bitstream_get_input_buffer_ptr(
-                        struct audio_bitstream_sm *bstream);
-char* audio_bitstream_get_input_buffer_write_ptr(
-                        struct audio_bitstream_sm *bstream);
-char* audio_bitstream_get_output_buffer_ptr(
-                        struct audio_bitstream_sm *bstream,
-                        int format);
-char* audio_bitstream_get_output_buffer_write_ptr(
-                        struct audio_bitstream_sm *bstream,
-                        int format);
-size_t audio_bitstream_get_size(struct audio_bitstream_sm *bstream);
-void audio_bitstream_copy_residue_to_start(
-                    struct audio_bitstream_sm *bstream,
-                    size_t bytes_consumed_in_decode);
-void audio_bitstream_copy_residue_output_start(
-                    struct audio_bitstream_sm *bstream,
-                    int format,
-                    size_t samplesRendered);
-void audio_bitstream_set_output_buffer_write_ptr(
-                struct audio_bitstream_sm *bstream,
-                int format, size_t output_pcm_sample);
-int audio_bitstream_sufficient_sample_to_render(
-                        struct audio_bitstream_sm *bstream,
-                        int format, int mid_size_reqd);
-void audio_bitstream_start_input_buffering_mode(
-                        struct audio_bitstream_sm *bstream);
-void audio_bitstream_stop_input_buffering_mode(
-                        struct audio_bitstream_sm *bstream);
-#endif
diff --git a/hal_mpq/audio_hw.c b/hal_mpq/audio_hw.c
deleted file mode 100644
index fb83245..0000000
--- a/hal_mpq/audio_hw.c
+++ /dev/null
@@ -1,1240 +0,0 @@
-/*
- * Copyright (c) 2013, The Linux Foundation. All rights reserved.
- * Not a Contribution.
- *
- * Copyright (C) 2013 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 "audio_hw_primary"
-/*#define LOG_NDEBUG 0*/
-/*#define VERY_VERY_VERBOSE_LOGGING*/
-#ifdef VERY_VERY_VERBOSE_LOGGING
-#define ALOGVV ALOGV
-#else
-#define ALOGVV(a...) do { } while(0)
-#endif
-
-#include <errno.h>
-#include <pthread.h>
-#include <stdint.h>
-#include <sys/time.h>
-#include <stdlib.h>
-#include <math.h>
-#include <dlfcn.h>
-#include <sys/resource.h>
-#include <sys/prctl.h>
-
-#include <cutils/log.h>
-#include <cutils/str_parms.h>
-#include <cutils/properties.h>
-#include <cutils/atomic.h>
-
-#include <hardware/audio_effect.h>
-#include <audio_effects/effect_aec.h>
-#include <audio_effects/effect_ns.h>
-#include "audio_hw.h"
-#include "platform_api.h"
-#include <platform.h>
-
-struct pcm_config pcm_config_audio_capture = {
-    .channels = 2,
-    .period_count = AUDIO_CAPTURE_PERIOD_COUNT,
-    .format = PCM_FORMAT_S16_LE,
-};
-
-static struct audio_device *adev = NULL;
-static pthread_mutex_t adev_init_lock;
-static unsigned int audio_device_ref_count;
-
-static int set_voice_volume_l(struct audio_device *adev, float volume);
-
-int enable_audio_route(struct audio_device *adev,
-                              struct audio_usecase *usecase,
-                              bool update_mixer)
-{
-    snd_device_t snd_device;
-    char mixer_path[MIXER_PATH_MAX_LENGTH];
-
-    if (usecase == NULL)
-        return -EINVAL;
-
-    ALOGV("%s: enter: usecase(%d)", __func__, usecase->id);
-
-    if (usecase->type == PCM_CAPTURE)
-        snd_device = usecase->in_snd_device;
-    else
-        snd_device = usecase->out_snd_device;
-
-    strlcpy(mixer_path, use_case_table[usecase->id], sizeof(mixer_path));
-    platform_add_backend_name(mixer_path, snd_device);
-    ALOGV("%s: apply mixer path: %s", __func__, mixer_path);
-    audio_route_apply_path(adev->audio_route, mixer_path);
-    if (update_mixer)
-        audio_route_update_mixer(adev->audio_route);
-
-    ALOGV("%s: exit", __func__);
-    return 0;
-}
-
-int disable_audio_route(struct audio_device *adev,
-                        struct audio_usecase *usecase,
-                        bool update_mixer)
-{
-    snd_device_t snd_device;
-    char mixer_path[MIXER_PATH_MAX_LENGTH];
-
-    if (usecase == NULL)
-        return -EINVAL;
-
-    ALOGV("%s: enter: usecase(%d)", __func__, usecase->id);
-    if (usecase->type == PCM_CAPTURE)
-        snd_device = usecase->in_snd_device;
-    else
-        snd_device = usecase->out_snd_device;
-    strlcpy(mixer_path, use_case_table[usecase->id], sizeof(mixer_path));
-    platform_add_backend_name(mixer_path, snd_device);
-    ALOGV("%s: reset mixer path: %s", __func__, mixer_path);
-    audio_route_reset_path(adev->audio_route, mixer_path);
-    if (update_mixer)
-        audio_route_update_mixer(adev->audio_route);
-
-    ALOGV("%s: exit", __func__);
-    return 0;
-}
-
-int enable_snd_device(struct audio_device *adev,
-                             snd_device_t snd_device,
-                             bool update_mixer)
-{
-    char device_name[DEVICE_NAME_MAX_SIZE] = {0};
-
-    if (snd_device < SND_DEVICE_MIN ||
-        snd_device >= SND_DEVICE_MAX) {
-        ALOGE("%s: Invalid sound device %d", __func__, snd_device);
-        return -EINVAL;
-    }
-
-    adev->snd_dev_ref_cnt[snd_device]++;
-
-    if(platform_get_snd_device_name_extn(adev->platform, snd_device, device_name) < 0 ) {
-        ALOGE("%s: Invalid sound device returned", __func__);
-        return -EINVAL;
-    }
-    if (adev->snd_dev_ref_cnt[snd_device] > 1) {
-        ALOGV("%s: snd_device(%d: %s) is already active",
-              __func__, snd_device, device_name);
-        return 0;
-    }
-
-    {
-        ALOGV("%s: snd_device(%d: %s)", __func__,
-        snd_device, device_name);
-        if (platform_send_audio_calibration(adev->platform, snd_device) < 0) {
-            adev->snd_dev_ref_cnt[snd_device]--;
-            return -EINVAL;
-        }
-        audio_route_apply_path(adev->audio_route, device_name);
-    }
-    if (update_mixer)
-        audio_route_update_mixer(adev->audio_route);
-
-    return 0;
-}
-
-int disable_snd_device(struct audio_device *adev,
-                       snd_device_t snd_device,
-                       bool update_mixer)
-{
-    char device_name[DEVICE_NAME_MAX_SIZE] = {0};
-
-    if (snd_device < SND_DEVICE_MIN ||
-        snd_device >= SND_DEVICE_MAX) {
-        ALOGE("%s: Invalid sound device %d", __func__, snd_device);
-        return -EINVAL;
-    }
-    if (adev->snd_dev_ref_cnt[snd_device] <= 0) {
-        ALOGE("%s: device ref cnt is already 0", __func__);
-        return -EINVAL;
-    }
-
-    adev->snd_dev_ref_cnt[snd_device]--;
-
-    if(platform_get_snd_device_name_extn(adev->platform, snd_device, device_name) < 0) {
-        ALOGE("%s: Invalid sound device returned", __func__);
-        return -EINVAL;
-    }
-
-    if (adev->snd_dev_ref_cnt[snd_device] == 0) {
-        ALOGV("%s: snd_device(%d: %s)", __func__,
-              snd_device, device_name);
-        audio_route_reset_path(adev->audio_route, device_name);
-
-        if (update_mixer)
-            audio_route_update_mixer(adev->audio_route);
-    }
-
-    return 0;
-}
-
-static void check_usecases_codec_backend(struct audio_device *adev,
-                                          struct audio_usecase *uc_info,
-                                          snd_device_t snd_device)
-{
-    struct listnode *node;
-    struct audio_usecase *usecase;
-    bool switch_device[AUDIO_USECASE_MAX];
-    int i, num_uc_to_switch = 0;
-
-    /*
-     * 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
-     * handled by the hardware codec.
-     * For example, if low-latency and deep-buffer usecases are currently active
-     * on speaker and out_set_parameters(headset) is received on low-latency
-     * output, then we have to make sure deep-buffer is also switched to headset,
-     * because of the limitation that both the devices cannot be enabled
-     * at the same time as they share the same backend.
-     */
-    /* Disable all the usecases on the shared backend other than the
-       specified usecase */
-    for (i = 0; i < AUDIO_USECASE_MAX; i++)
-        switch_device[i] = false;
-
-    list_for_each(node, &adev->usecase_list) {
-        usecase = node_to_item(node, struct audio_usecase, list);
-        if (usecase->type == PCM_PLAYBACK &&
-                usecase != uc_info &&
-                usecase->out_snd_device != snd_device &&
-                usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) {
-            ALOGV("%s: Usecase (%s) is active on (%s) - disabling ..",
-                  __func__, use_case_table[usecase->id],
-                  platform_get_snd_device_name(usecase->out_snd_device));
-            disable_audio_route(adev, usecase, false);
-            switch_device[usecase->id] = true;
-            num_uc_to_switch++;
-        }
-    }
-
-    if (num_uc_to_switch) {
-        /* Make sure all the streams are de-routed before disabling the device */
-        audio_route_update_mixer(adev->audio_route);
-
-        list_for_each(node, &adev->usecase_list) {
-            usecase = node_to_item(node, struct audio_usecase, list);
-            if (switch_device[usecase->id]) {
-                disable_snd_device(adev, usecase->out_snd_device, false);
-            }
-        }
-
-        list_for_each(node, &adev->usecase_list) {
-            usecase = node_to_item(node, struct audio_usecase, list);
-            if (switch_device[usecase->id]) {
-                enable_snd_device(adev, snd_device, false);
-            }
-        }
-        /* Make sure new snd device is enabled before re-routing the streams */
-        audio_route_update_mixer(adev->audio_route);
-
-        /* Re-route all the usecases on the shared backend other than the
-           specified usecase to new snd devices */
-        list_for_each(node, &adev->usecase_list) {
-            usecase = node_to_item(node, struct audio_usecase, list);
-            /* Update the out_snd_device only before enabling the audio route */
-            if (switch_device[usecase->id] ) {
-                usecase->out_snd_device = snd_device;
-                enable_audio_route(adev, usecase, false);
-            }
-        }
-
-        audio_route_update_mixer(adev->audio_route);
-    }
-}
-
-static void check_and_route_capture_usecases(struct audio_device *adev,
-                                             struct audio_usecase *uc_info,
-                                             snd_device_t snd_device)
-{
-    struct listnode *node;
-    struct audio_usecase *usecase;
-    bool switch_device[AUDIO_USECASE_MAX];
-    int i, num_uc_to_switch = 0;
-
-    /*
-     * This function is to make sure that all the active capture usecases
-     * are always routed to the same input sound device.
-     * For example, if audio-record and voice-call usecases are currently
-     * active on speaker(rx) and speaker-mic (tx) and out_set_parameters(earpiece)
-     * is received for voice call then we have to make sure that audio-record
-     * usecase is also switched to earpiece i.e. voice-dmic-ef,
-     * because of the limitation that two devices cannot be enabled
-     * at the same time if they share the same backend.
-     */
-    for (i = 0; i < AUDIO_USECASE_MAX; i++)
-        switch_device[i] = false;
-
-    list_for_each(node, &adev->usecase_list) {
-        usecase = node_to_item(node, struct audio_usecase, list);
-        if (usecase->type == PCM_CAPTURE &&
-                usecase != uc_info &&
-                usecase->in_snd_device != snd_device) {
-            ALOGV("%s: Usecase (%s) is active on (%s) - disabling ..",
-                  __func__, use_case_table[usecase->id],
-                  platform_get_snd_device_name(usecase->in_snd_device));
-            disable_audio_route(adev, usecase, false);
-            switch_device[usecase->id] = true;
-            num_uc_to_switch++;
-        }
-    }
-
-    if (num_uc_to_switch) {
-        /* Make sure all the streams are de-routed before disabling the device */
-        audio_route_update_mixer(adev->audio_route);
-
-        list_for_each(node, &adev->usecase_list) {
-            usecase = node_to_item(node, struct audio_usecase, list);
-            if (switch_device[usecase->id]) {
-                disable_snd_device(adev, usecase->in_snd_device, false);
-                enable_snd_device(adev, snd_device, false);
-            }
-        }
-
-        /* Make sure new snd device is enabled before re-routing the streams */
-        audio_route_update_mixer(adev->audio_route);
-
-        /* Re-route all the usecases on the shared backend other than the
-           specified usecase to new snd devices */
-        list_for_each(node, &adev->usecase_list) {
-            usecase = node_to_item(node, struct audio_usecase, list);
-            /* Update the in_snd_device only before enabling the audio route */
-            if (switch_device[usecase->id] ) {
-                usecase->in_snd_device = snd_device;
-                enable_audio_route(adev, usecase, false);
-            }
-        }
-
-        audio_route_update_mixer(adev->audio_route);
-    }
-}
-
-static int disable_all_usecases_of_type(struct audio_device *adev,
-                                        usecase_type_t usecase_type,
-                                        bool update_mixer)
-{
-    struct audio_usecase *usecase;
-    struct listnode *node;
-    int ret = 0;
-
-    list_for_each(node, &adev->usecase_list) {
-        usecase = node_to_item(node, struct audio_usecase, list);
-        if (usecase->type == usecase_type) {
-            ALOGV("%s: usecase id %d", __func__, usecase->id);
-            ret = disable_audio_route(adev, usecase, update_mixer);
-            if (ret) {
-                ALOGE("%s: Failed to disable usecase id %d",
-                      __func__, usecase->id);
-            }
-        }
-    }
-
-    return ret;
-}
-
-static int enable_all_usecases_of_type(struct audio_device *adev,
-                                       usecase_type_t usecase_type,
-                                       bool update_mixer)
-{
-    struct audio_usecase *usecase;
-    struct listnode *node;
-    int ret = 0;
-
-    list_for_each(node, &adev->usecase_list) {
-        usecase = node_to_item(node, struct audio_usecase, list);
-        if (usecase->type == usecase_type) {
-            ALOGV("%s: usecase id %d", __func__, usecase->id);
-            ret = enable_audio_route(adev, usecase, update_mixer);
-            if (ret) {
-                ALOGE("%s: Failed to enable usecase id %d",
-                      __func__, usecase->id);
-            }
-        }
-    }
-
-    return ret;
-}
-
-static audio_usecase_t get_voice_usecase_id_from_list(struct audio_device *adev)
-{
-    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 == VOICE_CALL) {
-            ALOGV("%s: usecase id %d", __func__, usecase->id);
-            return usecase->id;
-        }
-    }
-    return USECASE_INVALID;
-}
-
-struct audio_usecase *get_usecase_from_list(struct audio_device *adev,
-                                            audio_usecase_t uc_id)
-{
-    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->id == uc_id)
-            return usecase;
-    }
-    return NULL;
-}
-
-int select_devices(struct audio_device *adev, audio_usecase_t uc_id)
-{
-    snd_device_t out_snd_device = SND_DEVICE_NONE;
-    snd_device_t in_snd_device = SND_DEVICE_NONE;
-    struct audio_usecase *usecase = NULL;
-    struct audio_usecase *vc_usecase = NULL;
-    struct audio_usecase *voip_usecase = NULL;
-    struct listnode *node;
-    int status = 0;
-
-    usecase = get_usecase_from_list(adev, uc_id);
-    if (usecase == NULL) {
-        ALOGE("%s: Could not find the usecase(%d)", __func__, uc_id);
-        return -EINVAL;
-    }
-
-    if ((usecase->type == VOICE_CALL) ||
-        (usecase->type == VOIP_CALL)) {
-        out_snd_device = platform_get_output_snd_device(adev->platform,
-                                                        usecase->stream.out->devices);
-        in_snd_device = platform_get_input_snd_device(adev->platform, usecase->stream.out->devices);
-        usecase->devices = usecase->stream.out->devices;
-    } else {
-        /*
-         * If the voice call is active, use the sound devices of voice call usecase
-         * so that it would not result any device switch. All the usecases will
-         * be switched to new device when select_devices() is called for voice call
-         * usecase. This is to avoid switching devices for voice call when
-         * check_usecases_codec_backend() is called below.
-         */
-        if (usecase->type == PCM_PLAYBACK) {
-            usecase->devices = usecase->stream.out->devices;
-            in_snd_device = SND_DEVICE_NONE;
-            if (out_snd_device == SND_DEVICE_NONE) {
-                out_snd_device = platform_get_output_snd_device(adev->platform,
-                                            usecase->stream.out->devices);
-                if (usecase->stream.out == adev->primary_output &&
-                        adev->active_input &&
-                        adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION) {
-                    select_devices(adev, adev->active_input->usecase);
-                }
-            }
-        } else if (usecase->type == PCM_CAPTURE) {
-            usecase->devices = usecase->stream.in->device;
-            out_snd_device = SND_DEVICE_NONE;
-            if (in_snd_device == SND_DEVICE_NONE) {
-                if (adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION &&
-                        adev->primary_output && !adev->primary_output->standby) {
-                    in_snd_device = platform_get_input_snd_device(adev->platform,
-                                        adev->primary_output->devices);
-                } else {
-                    in_snd_device = platform_get_input_snd_device(adev->platform,
-                                                                  AUDIO_DEVICE_NONE);
-                }
-            }
-        }
-    }
-
-    if (out_snd_device == usecase->out_snd_device &&
-        in_snd_device == usecase->in_snd_device) {
-        return 0;
-    }
-
-    ALOGD("%s: out_snd_device(%d: %s) in_snd_device(%d: %s)", __func__,
-          out_snd_device, platform_get_snd_device_name(out_snd_device),
-          in_snd_device,  platform_get_snd_device_name(in_snd_device));
-
-    /*
-     * Limitation: While in call, to do a device switch we need to disable
-     * and enable both RX and TX devices though one of them is same as current
-     * device.
-     */
-    if (usecase->type == VOICE_CALL || usecase->type == VOIP_CALL) {
-        status = platform_switch_voice_call_device_pre(adev->platform);
-        disable_all_usecases_of_type(adev, VOICE_CALL, true);
-    }
-
-    /* Disable current sound devices */
-    if (usecase->out_snd_device != SND_DEVICE_NONE) {
-        disable_audio_route(adev, usecase, true);
-        disable_snd_device(adev, usecase->out_snd_device, false);
-    }
-
-    if (usecase->in_snd_device != SND_DEVICE_NONE) {
-        disable_audio_route(adev, usecase, true);
-        disable_snd_device(adev, usecase->in_snd_device, false);
-    }
-
-    /* Enable new sound devices */
-    if (out_snd_device != SND_DEVICE_NONE) {
-        if (usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND)
-            check_usecases_codec_backend(adev, usecase, out_snd_device);
-        enable_snd_device(adev, out_snd_device, false);
-    }
-
-    if (in_snd_device != SND_DEVICE_NONE) {
-        check_and_route_capture_usecases(adev, usecase, in_snd_device);
-        enable_snd_device(adev, in_snd_device, false);
-    }
-
-    if (usecase->type == VOICE_CALL || usecase->type == VOIP_CALL)
-        status = platform_switch_voice_call_device_post(adev->platform,
-                                                        out_snd_device,
-                                                        in_snd_device);
-
-    audio_route_update_mixer(adev->audio_route);
-
-    usecase->in_snd_device = in_snd_device;
-    usecase->out_snd_device = out_snd_device;
-
-    if (usecase->type == VOICE_CALL || usecase->type == VOIP_CALL)
-        enable_all_usecases_of_type(adev, usecase->type, true);
-    else
-        enable_audio_route(adev, usecase, true);
-
-    /* Applicable only on the targets that has external modem.
-     * Enable device command should be sent to modem only after
-     * enabling voice call mixer controls
-     */
-    if (usecase->type == VOICE_CALL)
-        status = platform_switch_voice_call_usecase_route_post(adev->platform,
-                                                               out_snd_device,
-                                                               in_snd_device);
-
-    return status;
-}
-
-static int stop_input_stream(struct stream_in *in)
-{
-    int i, ret = 0;
-    struct audio_usecase *uc_info;
-    struct audio_device *adev = in->dev;
-
-    adev->active_input = NULL;
-
-    ALOGV("%s: enter: usecase(%d: %s)", __func__,
-          in->usecase, use_case_table[in->usecase]);
-    uc_info = get_usecase_from_list(adev, in->usecase);
-    if (uc_info == NULL) {
-        ALOGE("%s: Could not find the usecase (%d) in the list",
-              __func__, in->usecase);
-        return -EINVAL;
-    }
-
-    /* 1. Disable stream specific mixer controls */
-    disable_audio_route(adev, uc_info, true);
-
-    /* 2. Disable the tx device */
-    disable_snd_device(adev, uc_info->in_snd_device, true);
-
-    list_remove(&uc_info->list);
-    free(uc_info);
-
-    ALOGV("%s: exit: status(%d)", __func__, ret);
-    return ret;
-}
-
-int start_input_stream(struct stream_in *in)
-{
-    /* 1. Enable output device and stream routing controls */
-    int ret = 0;
-    struct audio_usecase *uc_info;
-    struct audio_device *adev = in->dev;
-
-    in->usecase = platform_update_usecase_from_source(in->source,in->usecase);
-    ALOGV("%s: enter: usecase(%d)", __func__, in->usecase);
-
-    in->pcm_device_id = platform_get_pcm_device_id(in->usecase, PCM_CAPTURE);
-    if (in->pcm_device_id < 0) {
-        ALOGE("%s: Could not find PCM device id for the usecase(%d)",
-              __func__, in->usecase);
-        ret = -EINVAL;
-        goto error_config;
-    }
-
-    adev->active_input = in;
-    uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
-    uc_info->id = in->usecase;
-    uc_info->type = PCM_CAPTURE;
-    uc_info->stream.in = in;
-    uc_info->devices = in->device;
-    uc_info->in_snd_device = SND_DEVICE_NONE;
-    uc_info->out_snd_device = SND_DEVICE_NONE;
-
-    list_add_tail(&adev->usecase_list, &uc_info->list);
-    select_devices(adev, in->usecase);
-
-    ALOGV("%s: Opening PCM device card_id(%d) device_id(%d), channels %d",
-          __func__, SOUND_CARD, in->pcm_device_id, in->config.channels);
-    in->pcm = pcm_open(SOUND_CARD, in->pcm_device_id,
-                           PCM_IN, &in->config);
-    if (in->pcm && !pcm_is_ready(in->pcm)) {
-        ALOGE("%s: %s", __func__, pcm_get_error(in->pcm));
-        pcm_close(in->pcm);
-        in->pcm = NULL;
-        ret = -EIO;
-        goto error_open;
-    }
-    ALOGV("%s: exit", __func__);
-    return ret;
-
-error_open:
-    stop_input_stream(in);
-
-error_config:
-    adev->active_input = NULL;
-    ALOGD("%s: exit: status(%d)", __func__, ret);
-
-    return ret;
-}
-
-static int check_input_parameters(uint32_t sample_rate,
-                                  audio_format_t format,
-                                  int channel_count)
-{
-    int ret = 0;
-
-    if ((format != AUDIO_FORMAT_PCM_16_BIT))  ret = -EINVAL;
-
-    switch (channel_count) {
-    case 1:
-    case 2:
-    case 6:
-        break;
-    default:
-        ret = -EINVAL;
-    }
-
-    switch (sample_rate) {
-    case 8000:
-    case 11025:
-    case 12000:
-    case 16000:
-    case 22050:
-    case 24000:
-    case 32000:
-    case 44100:
-    case 48000:
-        break;
-    default:
-        ret = -EINVAL;
-    }
-
-    return ret;
-}
-
-static size_t get_input_buffer_size(uint32_t sample_rate,
-                                    audio_format_t format,
-                                    int channel_count)
-{
-    size_t size = 0;
-
-    if (check_input_parameters(sample_rate, format, channel_count) != 0)
-        return 0;
-
-    size = (sample_rate * AUDIO_CAPTURE_PERIOD_DURATION_MSEC) / 1000;
-    /* ToDo: should use frame_size computed based on the format and
-       channel_count here. */
-    size *= sizeof(short) * channel_count;
-
-    /* make sure the size is multiple of 64 */
-    size += 0x3f;
-    size &= ~0x3f;
-
-    return size;
-}
-
-/** audio_stream_in implementation **/
-static uint32_t in_get_sample_rate(const struct audio_stream *stream)
-{
-    struct stream_in *in = (struct stream_in *)stream;
-
-    return in->config.rate;
-}
-
-static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
-{
-    return -ENOSYS;
-}
-
-static size_t in_get_buffer_size(const struct audio_stream *stream)
-{
-    struct stream_in *in = (struct stream_in *)stream;
-
-    return in->config.period_size * audio_stream_frame_size(stream);
-}
-
-static uint32_t in_get_channels(const struct audio_stream *stream)
-{
-    struct stream_in *in = (struct stream_in *)stream;
-
-    return in->channel_mask;
-}
-
-static audio_format_t in_get_format(const struct audio_stream *stream)
-{
-    struct stream_in *in = (struct stream_in *)stream;
-
-    return in->format;
-}
-
-static int in_set_format(struct audio_stream *stream, audio_format_t format)
-{
-    return -ENOSYS;
-}
-
-static int in_standby(struct audio_stream *stream)
-{
-    struct stream_in *in = (struct stream_in *)stream;
-    struct audio_device *adev = in->dev;
-    int status = 0;
-    ALOGV("%s: enter", __func__);
-
-    if (in->usecase == USECASE_COMPRESS_VOIP_CALL) {
-        /* Ignore standby in case of voip call because the voip input
-         * stream is closed in adev_close_input_stream()
-         */
-        ALOGV("%s: Ignore Standby in VOIP call", __func__);
-        return status;
-    }
-
-    pthread_mutex_lock(&in->lock);
-    if (!in->standby) {
-        in->standby = true;
-        if (in->pcm) {
-            pcm_close(in->pcm);
-            in->pcm = NULL;
-        }
-        pthread_mutex_lock(&adev->lock);
-        status = stop_input_stream(in);
-        pthread_mutex_unlock(&adev->lock);
-    }
-    pthread_mutex_unlock(&in->lock);
-    ALOGV("%s: exit:  status(%d)", __func__, status);
-    return status;
-}
-
-static int in_dump(const struct audio_stream *stream, int fd)
-{
-    return 0;
-}
-
-static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
-{
-    struct stream_in *in = (struct stream_in *)stream;
-    struct audio_device *adev = in->dev;
-    struct str_parms *parms;
-    char *str;
-    char value[32];
-    int ret, val = 0;
-
-    ALOGV("%s: enter: kvpairs=%s", __func__, kvpairs);
-    parms = str_parms_create_str(kvpairs);
-
-    ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_INPUT_SOURCE, value, sizeof(value));
-
-    pthread_mutex_lock(&in->lock);
-    pthread_mutex_lock(&adev->lock);
-    if (ret >= 0) {
-        val = atoi(value);
-        /* no audio source uses val == 0 */
-        if ((in->source != val) && (val != 0)) {
-            in->source = val;
-        }
-    }
-
-    ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
-    if (ret >= 0) {
-        val = atoi(value);
-        if ((in->device != val) && (val != 0)) {
-            in->device = val;
-            /* If recording is in progress, change the tx device to new device */
-            if (!in->standby)
-                ret = select_devices(adev, in->usecase);
-        }
-    }
-
-    pthread_mutex_unlock(&adev->lock);
-    pthread_mutex_unlock(&in->lock);
-
-    str_parms_destroy(parms);
-    ALOGV("%s: exit: status(%d)", __func__, ret);
-    return ret;
-}
-
-static char* in_get_parameters(const struct audio_stream *stream,
-                               const char *keys)
-{
-    struct stream_in *in = (struct stream_in *)stream;
-    struct str_parms *query = str_parms_create_str(keys);
-    char *str;
-    char value[256];
-    struct str_parms *reply = str_parms_create();
-    ALOGV("%s: enter: keys - %s", __func__, keys);
-
-    str = str_parms_to_str(reply);
-    str_parms_destroy(query);
-    str_parms_destroy(reply);
-
-    ALOGV("%s: exit: returns - %s", __func__, str);
-    return str;
-}
-
-static int in_set_gain(struct audio_stream_in *stream, float gain)
-{
-    return 0;
-}
-
-static ssize_t in_read(struct audio_stream_in *stream, void *buffer,
-                       size_t bytes)
-{
-    struct stream_in *in = (struct stream_in *)stream;
-    struct audio_device *adev = in->dev;
-    int i, ret = -1;
-
-    pthread_mutex_lock(&in->lock);
-    if (in->standby) {
-        pthread_mutex_lock(&adev->lock);
-            ret = start_input_stream(in);
-        pthread_mutex_unlock(&adev->lock);
-        if (ret != 0) {
-            goto exit;
-        }
-        in->standby = 0;
-    }
-
-    if (in->pcm) {
-         ret = pcm_read(in->pcm, buffer, bytes);
-    }
-
-exit:
-    pthread_mutex_unlock(&in->lock);
-
-    if (ret != 0) {
-        in_standby(&in->stream.common);
-        ALOGV("%s: read failed - sleeping for buffer duration", __func__);
-        usleep(bytes * 1000000 / audio_stream_frame_size(&in->stream.common) /
-               in_get_sample_rate(&in->stream.common));
-    }
-    return bytes;
-}
-
-static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
-{
-    return 0;
-}
-
-static int add_remove_audio_effect(const struct audio_stream *stream,
-                                   effect_handle_t effect,
-                                   bool enable)
-{
-    struct stream_in *in = (struct stream_in *)stream;
-    int status = 0;
-
-    return 0;
-}
-
-static int in_add_audio_effect(const struct audio_stream *stream,
-                               effect_handle_t effect)
-{
-    ALOGV("%s: effect %p", __func__, effect);
-    return add_remove_audio_effect(stream, effect, true);
-}
-
-static int in_remove_audio_effect(const struct audio_stream *stream,
-                                  effect_handle_t effect)
-{
-    ALOGV("%s: effect %p", __func__, effect);
-    return add_remove_audio_effect(stream, effect, false);
-}
-
-static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
-{
-    struct audio_device *adev = (struct audio_device *)dev;
-    struct str_parms *parms;
-    char *str;
-    char value[32];
-    int val;
-    int ret;
-
-    ALOGD("%s: enter: %s", __func__, kvpairs);
-
-    pthread_mutex_lock(&adev->lock);
-    parms = str_parms_create_str(kvpairs);
-
-    platform_set_parameters(adev->platform, parms);
-
-    ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_NREC, value, sizeof(value));
-    if (ret >= 0) {
-        /* When set to false, HAL should disable EC and NS
-         * But it is currently not supported.
-         */
-        if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
-            adev->bluetooth_nrec = true;
-        else
-            adev->bluetooth_nrec = false;
-    }
-
-    ret = str_parms_get_str(parms, "screen_state", value, sizeof(value));
-    if (ret >= 0) {
-        if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
-            adev->screen_off = false;
-        else
-            adev->screen_off = true;
-    }
-
-    ret = str_parms_get_int(parms, "rotation", &val);
-    if (ret >= 0) {
-        bool reverse_speakers = false;
-        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.
-        case 270:
-            reverse_speakers = true;
-            break;
-        case 0:
-        case 90:
-        case 180:
-            break;
-        default:
-            ALOGE("%s: unexpected rotation of %d", __func__, val);
-        }
-        if (adev->speaker_lr_swap != reverse_speakers) {
-            adev->speaker_lr_swap = reverse_speakers;
-            // only update the selected device if there is active pcm playback
-            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) {
-                    select_devices(adev, usecase->id);
-                    break;
-                }
-            }
-        }
-    }
-
-    str_parms_destroy(parms);
-
-    pthread_mutex_unlock(&adev->lock);
-    ALOGV("%s: exit with code(%d)", __func__, ret);
-    return ret;
-}
-
-static char* adev_get_parameters(const struct audio_hw_device *dev,
-                                 const char *keys)
-{
-    struct audio_device *adev = (struct audio_device *)dev;
-    struct str_parms *reply = str_parms_create();
-    struct str_parms *query = str_parms_create_str(keys);
-    char *str;
-
-    pthread_mutex_lock(&adev->lock);
-
-    platform_get_parameters(adev->platform, query, reply);
-    str = str_parms_to_str(reply);
-    str_parms_destroy(query);
-    str_parms_destroy(reply);
-
-    pthread_mutex_unlock(&adev->lock);
-    ALOGV("%s: exit: returns - %s", __func__, str);
-    return str;
-}
-
-static int adev_init_check(const struct audio_hw_device *dev)
-{
-    return 0;
-}
-
-static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
-{
-    int ret = 0;
-    return ret;
-}
-
-static int adev_set_master_volume(struct audio_hw_device *dev, float volume)
-{
-    return -ENOSYS;
-}
-
-static int adev_get_master_volume(struct audio_hw_device *dev,
-                                  float *volume)
-{
-    return -ENOSYS;
-}
-
-static int adev_set_master_mute(struct audio_hw_device *dev, bool muted)
-{
-    return -ENOSYS;
-}
-
-static int adev_get_master_mute(struct audio_hw_device *dev, bool *muted)
-{
-    return -ENOSYS;
-}
-
-static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode)
-{
-    struct audio_device *adev = (struct audio_device *)dev;
-    pthread_mutex_lock(&adev->lock);
-    if (adev->mode != mode) {
-        ALOGD("%s mode %d\n", __func__, mode);
-        adev->mode = mode;
-    }
-    pthread_mutex_unlock(&adev->lock);
-    return 0;
-}
-
-static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
-{
-    int ret = 0;
-
-    return ret;
-}
-
-static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
-{
-    return 0;
-}
-
-static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
-                                         const struct audio_config *config)
-{
-    int channel_count = popcount(config->channel_mask);
-
-    return get_input_buffer_size(config->sample_rate, config->format, channel_count);
-}
-
-static int adev_open_input_stream(struct audio_hw_device *dev,
-                                  audio_io_handle_t handle,
-                                  audio_devices_t devices,
-                                  struct audio_config *config,
-                                  struct audio_stream_in **stream_in)
-{
-    struct audio_device *adev = (struct audio_device *)dev;
-    struct stream_in *in;
-    int ret = 0, buffer_size, frame_size;
-    int channel_count = popcount(config->channel_mask);
-
-    ALOGV("%s: enter", __func__);
-    *stream_in = NULL;
-    if (check_input_parameters(config->sample_rate, config->format, channel_count) != 0)
-        return -EINVAL;
-
-    in = (struct stream_in *)calloc(1, sizeof(struct stream_in));
-
-    in->stream.common.get_sample_rate = in_get_sample_rate;
-    in->stream.common.set_sample_rate = in_set_sample_rate;
-    in->stream.common.get_buffer_size = in_get_buffer_size;
-    in->stream.common.get_channels = in_get_channels;
-    in->stream.common.get_format = in_get_format;
-    in->stream.common.set_format = in_set_format;
-    in->stream.common.standby = in_standby;
-    in->stream.common.dump = in_dump;
-    in->stream.common.set_parameters = in_set_parameters;
-    in->stream.common.get_parameters = in_get_parameters;
-    in->stream.common.add_audio_effect = in_add_audio_effect;
-    in->stream.common.remove_audio_effect = in_remove_audio_effect;
-    in->stream.set_gain = in_set_gain;
-    in->stream.read = in_read;
-    in->stream.get_input_frames_lost = in_get_input_frames_lost;
-
-    in->device = devices;
-    in->source = AUDIO_SOURCE_DEFAULT;
-    in->dev = adev;
-    in->standby = 1;
-    in->channel_mask = config->channel_mask;
-
-    /* Update config params with the requested sample rate and channels */
-    in->usecase = USECASE_AUDIO_RECORD;
-    in->config = pcm_config_audio_capture;
-    in->config.rate = config->sample_rate;
-    in->format = config->format;
-
-    {
-        in->config.channels = channel_count;
-        frame_size = audio_stream_frame_size((struct audio_stream *)in);
-        buffer_size = get_input_buffer_size(config->sample_rate,
-                                            config->format,
-                                            channel_count);
-        in->config.period_size = buffer_size / frame_size;
-    }
-
-    *stream_in = &in->stream;
-    ALOGV("%s: exit", __func__);
-    return ret;
-
-err_open:
-    free(in);
-    *stream_in = NULL;
-    return ret;
-}
-
-static void adev_close_input_stream(struct audio_hw_device *dev,
-                                    struct audio_stream_in *stream)
-{
-    int ret;
-    struct stream_in *in = (struct stream_in *)stream;
-    ALOGV("%s", __func__);
-
-    in_standby(&stream->common);
-
-    free(stream);
-
-    return;
-}
-
-static int adev_dump(const audio_hw_device_t *device, int fd)
-{
-    return 0;
-}
-
-static int adev_close(hw_device_t *device)
-{
-    struct audio_device *adev = (struct audio_device *)device;
-
-    if (!adev)
-        return 0;
-
-    pthread_mutex_lock(&adev_init_lock);
-
-    if ((--audio_device_ref_count) == 0) {
-        audio_route_free(adev->audio_route);
-        free(adev->snd_dev_ref_cnt);
-        platform_deinit(adev->platform);
-        free(device);
-        adev = NULL;
-    }
-    pthread_mutex_unlock(&adev_init_lock);
-    return 0;
-}
-
-static int adev_open(const hw_module_t *module, const char *name,
-                     hw_device_t **device)
-{
-    int i, ret;
-
-    ALOGD("%s: enter", __func__);
-    if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0) return -EINVAL;
-
-    pthread_mutex_lock(&adev_init_lock);
-    if (audio_device_ref_count != 0){
-            *device = &adev->device.common;
-            audio_device_ref_count++;
-            ALOGD("%s: returning existing instance of adev", __func__);
-            ALOGD("%s: exit", __func__);
-            pthread_mutex_unlock(&adev_init_lock);
-            return 0;
-    }
-
-    adev = calloc(1, sizeof(struct audio_device));
-
-    adev->device.common.tag = HARDWARE_DEVICE_TAG;
-    adev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
-    adev->device.common.module = (struct hw_module_t *)module;
-    adev->device.common.close = adev_close;
-
-    adev->device.init_check = adev_init_check;
-    adev->device.set_voice_volume = adev_set_voice_volume;
-    adev->device.set_master_volume = adev_set_master_volume;
-    adev->device.get_master_volume = adev_get_master_volume;
-    adev->device.set_master_mute = adev_set_master_mute;
-    adev->device.get_master_mute = adev_get_master_mute;
-    adev->device.set_mode = adev_set_mode;
-    adev->device.set_mic_mute = adev_set_mic_mute;
-    adev->device.get_mic_mute = adev_get_mic_mute;
-    adev->device.set_parameters = adev_set_parameters;
-    adev->device.get_parameters = adev_get_parameters;
-    adev->device.get_input_buffer_size = adev_get_input_buffer_size;
-    adev->device.open_output_stream = adev_open_output_stream;
-    adev->device.close_output_stream = adev_close_output_stream;
-    adev->device.open_input_stream = adev_open_input_stream;
-    adev->device.close_input_stream = adev_close_input_stream;
-    adev->device.dump = adev_dump;
-
-    /* Set the default route before the PCM stream is opened */
-    adev->mode = AUDIO_MODE_NORMAL;
-    adev->active_input = NULL;
-    adev->primary_output = NULL;
-    adev->out_device = AUDIO_DEVICE_NONE;
-    adev->bluetooth_nrec = true;
-    adev->acdb_settings = TTY_MODE_OFF;
-    /* adev->cur_hdmi_channels = 0;  by calloc() */
-    adev->snd_dev_ref_cnt = calloc(SND_DEVICE_MAX, sizeof(int));
-    list_init(&adev->usecase_list);
-
-    /* Loads platform specific libraries dynamically */
-    adev->platform = platform_init(adev);
-    if (!adev->platform) {
-        free(adev->snd_dev_ref_cnt);
-        free(adev);
-        ALOGE("%s: Failed to init platform data, aborting.", __func__);
-        *device = NULL;
-        return -EINVAL;
-    }
-
-    if (access(VISUALIZER_LIBRARY_PATH, R_OK) == 0) {
-        adev->visualizer_lib = dlopen(VISUALIZER_LIBRARY_PATH, RTLD_NOW);
-        if (adev->visualizer_lib == NULL) {
-            ALOGE("%s: DLOPEN failed for %s", __func__, VISUALIZER_LIBRARY_PATH);
-        } else {
-            ALOGV("%s: DLOPEN successful for %s", __func__, VISUALIZER_LIBRARY_PATH);
-            adev->visualizer_start_output =
-                        (int (*)(audio_io_handle_t))dlsym(adev->visualizer_lib,
-                                                        "visualizer_hal_start_output");
-            adev->visualizer_stop_output =
-                        (int (*)(audio_io_handle_t))dlsym(adev->visualizer_lib,
-                                                        "visualizer_hal_stop_output");
-        }
-    }
-    *device = &adev->device.common;
-
-    audio_device_ref_count++;
-    pthread_mutex_unlock(&adev_init_lock);
-
-    ALOGV("%s: exit", __func__);
-    return 0;
-}
-
-static struct hw_module_methods_t hal_module_methods = {
-    .open = adev_open,
-};
-
-struct audio_module HAL_MODULE_INFO_SYM = {
-    .common = {
-        .tag = HARDWARE_MODULE_TAG,
-        .module_api_version = AUDIO_MODULE_API_VERSION_0_1,
-        .hal_api_version = HARDWARE_HAL_API_VERSION,
-        .id = AUDIO_HARDWARE_MODULE_ID,
-        .name = "MPQ Audio HAL",
-        .author = "The Linux Foundation",
-        .methods = &hal_module_methods,
-    },
-};
diff --git a/hal_mpq/audio_hw.h b/hal_mpq/audio_hw.h
deleted file mode 100644
index 7814d95..0000000
--- a/hal_mpq/audio_hw.h
+++ /dev/null
@@ -1,384 +0,0 @@
-/*
- * Copyright (c) 2013, The Linux Foundation. All rights reserved.
- * Not a contribution.
- *
- * Copyright (C) 2013 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.
- */
-
-#ifndef QCOM_AUDIO_HW_H
-#define QCOM_AUDIO_HW_H
-
-#include <cutils/list.h>
-#include <hardware/audio.h>
-#include <tinyalsa/asoundlib.h>
-#include <tinycompress/tinycompress.h>
-#include "sound/compress_params.h"
-#include <audio_route/audio_route.h>
-
-#define VISUALIZER_LIBRARY_PATH "/system/lib/soundfx/libqcomvisualizer.so"
-
-/* Flags used to initialize acdb_settings variable that goes to ACDB library */
-#define DMIC_FLAG       0x00000002
-#define QMIC_FLAG       0x00000004
-#define TTY_MODE_OFF    0x00000010
-#define TTY_MODE_FULL   0x00000020
-#define TTY_MODE_VCO    0x00000040
-#define TTY_MODE_HCO    0x00000080
-#define TTY_MODE_CLEAR  0xFFFFFF0F
-
-#define ACDB_DEV_TYPE_OUT 1
-#define ACDB_DEV_TYPE_IN 2
-
-#define MAX_SUPPORTED_CHANNEL_MASKS 2
-#define DEFAULT_HDMI_OUT_CHANNELS   2
-
-typedef int snd_device_t;
-#include <platform.h>
-
-/* These are the supported use cases by the hardware.
- * Each usecase is mapped to a specific PCM device.
- * Refer to pcm_device_table[].
- */
-typedef enum {
-    USECASE_INVALID = -1,
-    /* Playback usecases */
-    USECASE_AUDIO_PLAYBACK_DEEP_BUFFER = 0,
-    USECASE_AUDIO_PLAYBACK_LOW_LATENCY,
-    USECASE_AUDIO_PLAYBACK_MULTI_CH,
-    USECASE_AUDIO_PLAYBACK_FM,
-    USECASE_AUDIO_PLAYBACK_OFFLOAD,
-    USECASE_AUDIO_PLAYBACK_OFFLOAD1,
-    USECASE_AUDIO_PLAYBACK_OFFLOAD2,
-    USECASE_AUDIO_PLAYBACK_OFFLOAD3,
-    /* Capture usecases */
-    USECASE_AUDIO_RECORD,
-    USECASE_AUDIO_RECORD_COMPRESS,
-    USECASE_AUDIO_RECORD_LOW_LATENCY,
-    USECASE_AUDIO_RECORD_FM_VIRTUAL,
-
-    /* Voice usecase */
-    USECASE_VOICE_CALL,
-
-    /* Voice extension usecases */
-    USECASE_VOICE2_CALL,
-    USECASE_VOLTE_CALL,
-    USECASE_QCHAT_CALL,
-    USECASE_COMPRESS_VOIP_CALL,
-
-    USECASE_INCALL_REC_UPLINK,
-    USECASE_INCALL_REC_DOWNLINK,
-    USECASE_INCALL_REC_UPLINK_AND_DOWNLINK,
-
-    USECASE_INCALL_MUSIC_UPLINK,
-    USECASE_INCALL_MUSIC_UPLINK2,
-
-    USECASE_AUDIO_SPKR_CALIB_RX,
-    USECASE_AUDIO_SPKR_CALIB_TX,
-    AUDIO_USECASE_MAX
-} audio_usecase_t;
-
-typedef enum {
-    DEEP_BUFFER_PLAYBACK_STREAM = 0,
-    LOW_LATENCY_PLAYBACK_STREAM,
-    MCH_PCM_PLAYBACK_STREAM,
-    OFFLOAD_PLAYBACK_STREAM,
-    LOW_LATENCY_RECORD_STREAM,
-    RECORD_STREAM,
-    VOICE_CALL_STREAM
-} audio_usecase_stream_type_t;
-
-#define STRING_TO_ENUM(string) { #string, string }
-struct string_to_enum {
-    const char *name;
-    uint32_t value;
-};
-
-static const struct string_to_enum out_channels_name_to_enum_table[] = {
-    STRING_TO_ENUM(AUDIO_CHANNEL_OUT_STEREO),
-    STRING_TO_ENUM(AUDIO_CHANNEL_OUT_5POINT1),
-    STRING_TO_ENUM(AUDIO_CHANNEL_OUT_7POINT1),
-};
-
-#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
-
-/*
- * tinyAlsa library interprets period size as number of frames
- * one frame = channel_count * sizeof (pcm sample)
- * so if format = 16-bit PCM and channels = Stereo, frame size = 2 ch * 2 = 4 bytes
- * DEEP_BUFFER_OUTPUT_PERIOD_SIZE = 1024 means 1024 * 4 = 4096 bytes
- * We should take care of returning proper size when AudioFlinger queries for
- * the buffer size of an input/output stream
- */
-
-enum {
-    OFFLOAD_CMD_EXIT,               /* exit compress offload thread loop*/
-    OFFLOAD_CMD_DRAIN,              /* send a full drain request to DSP */
-    OFFLOAD_CMD_PARTIAL_DRAIN,      /* send a partial drain request to DSP */
-    OFFLOAD_CMD_WAIT_FOR_BUFFER,    /* wait for buffer released by DSP */
-};
-
-enum {
-    OFFLOAD_STATE_IDLE,
-    OFFLOAD_STATE_PLAYING,
-    OFFLOAD_STATE_PAUSED,
-};
-
-struct offload_cmd {
-    struct listnode node;
-    int cmd;
-    int data[];
-};
-
-struct alsa_handle {
-
-    struct listnode list;
-//Parameters of the stream
-    struct pcm *pcm;
-    struct pcm_config config;
-
-    struct compress *compr;
-    struct compr_config compr_config;
-
-    struct stream_out *out;
-
-    audio_usecase_t usecase;
-    int device_id;
-    unsigned int sample_rate;
-    audio_channel_mask_t channel_mask;
-    audio_format_t input_format;
-    audio_format_t output_format;
-    audio_devices_t devices;
-
-    route_format_t route_format;
-    int decoder_type;
-
-    bool cmd_pending ;
-};
-
-struct stream_out {
-    struct audio_stream_out stream;
-    pthread_mutex_t lock; /* see note below on mutex acquisition order */
-    pthread_cond_t  cond;
-    /* TODO remove this */
-    /*
-    struct pcm_config config;
-    struct compr_config compr_config;
-    struct pcm *pcm;
-    struct compress *compr;
-    */
-    int standby;
-    int pcm_device_id;
-    unsigned int sample_rate;
-    audio_channel_mask_t channel_mask;
-    audio_format_t format;
-    audio_devices_t devices;
-    audio_output_flags_t flags;
-    audio_usecase_t usecase;
-    /* Array of supported channel mask configurations. +1 so that the last entry is always 0 */
-    audio_channel_mask_t supported_channel_masks[MAX_SUPPORTED_CHANNEL_MASKS + 1];
-    bool muted;
-    uint64_t written; /* total frames written, not cleared when entering standby */
-    audio_io_handle_t handle;
-
-    int non_blocking;
-    int playback_started;
-    int offload_state;
-    pthread_cond_t offload_cond;
-    pthread_t offload_thread;
-    struct listnode offload_cmd_list;
-    bool offload_thread_blocked;
-
-    stream_callback_t offload_callback;
-    void *offload_cookie;
-    struct compr_gapless_mdata gapless_mdata;
-    int send_new_metadata;
-
-    struct audio_device *dev;
-
-    /*devices configuration */
-    int left_volume;
-    int right_volume;
-    audio_usecase_stream_type_t uc_strm_type;
-    int hdmi_format;
-    int spdif_format;
-    int* device_formats;   //TODO:Needs to come from AudioRutingManager
-    struct audio_config *config;
-
-    /* list of the session handles */
-    struct listnode session_list;
-
-    /* /MS11 instance */
-    int use_ms11_decoder;
-    void  *ms11_decoder;
-    struct compr_config compr_config;
-
-    int channels;
-
-    /* Buffering utility */
-    struct audio_bitstream_sm    *bitstrm;
-
-    int                 buffer_size;
-    int                 decoder_type;
-    bool                dec_conf_set;
-    uint32_t            min_bytes_req_to_dec;
-    bool                is_m11_file_mode;
-    void                *dec_conf_buf;
-    int32_t             dec_conf_bufLength;
-    bool                first_bitstrm_buf;
-
-    bool                open_dec_route;
-    int                 dec_format_devices;
-    bool                open_dec_mch_route;
-    int                 dec_mch_format_devices;
-    bool                open_passt_route;
-    int                 passt_format_devices;
-    bool                sw_open_trans_route;
-    int                 sw_trans_format_devices;
-    bool                hw_open_trans_route;
-    int                 hw_trans_format_devices;
-    bool                channel_status_set;
-    unsigned char       channel_status[24];
-    int                 route_audio_to_a2dp;
-    int                 is_ms11_file_playback_mode;
-    char *              write_temp_buf;
-    struct output_metadata  output_meta_data;
-};
-
-struct stream_in {
-    struct audio_stream_in stream;
-    pthread_mutex_t lock; /* see note below on mutex acquisition order */
-    struct pcm_config config;
-    struct pcm *pcm;
-    int standby;
-    int source;
-    int pcm_device_id;
-    int device;
-    audio_channel_mask_t channel_mask;
-    audio_usecase_t usecase;
-    bool enable_aec;
-    bool enable_ns;
-    audio_format_t format;
-
-    struct audio_device *dev;
-};
-
-typedef enum {
-    PCM_PLAYBACK,
-    PCM_CAPTURE,
-    VOICE_CALL,
-    VOIP_CALL
-} usecase_type_t;
-
-union stream_ptr {
-    struct stream_in *in;
-    struct stream_out *out;
-};
-
-struct audio_usecase {
-    struct listnode list;
-    audio_usecase_t id;
-    usecase_type_t  type;
-    audio_devices_t devices;
-    snd_device_t out_snd_device;
-    snd_device_t in_snd_device;
-    union stream_ptr stream;
-    struct alsa_handle *handle;
-};
-
-struct audio_device {
-    struct audio_hw_device device;
-    pthread_mutex_t lock; /* see note below on mutex acquisition order */
-    struct mixer *mixer;
-    audio_mode_t mode;
-    audio_devices_t out_device;
-    struct stream_in *active_input;
-    struct stream_out *primary_output;
-    bool bluetooth_nrec;
-    bool screen_off;
-    int *snd_dev_ref_cnt;
-    struct listnode usecase_list;
-    struct audio_route *audio_route;
-    int acdb_settings;
-    bool speaker_lr_swap;
-    unsigned int cur_hdmi_channels;
-
-    void *platform;
-
-    void *visualizer_lib;
-    int (*visualizer_start_output)(audio_io_handle_t);
-    int (*visualizer_stop_output)(audio_io_handle_t);
-};
-
-static const char * const use_case_table[AUDIO_USECASE_MAX] = {
-    [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = "deep-buffer-playback",
-    [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = "low-latency-playback",
-    [USECASE_AUDIO_PLAYBACK_MULTI_CH] = "multi-channel-playback",
-    [USECASE_AUDIO_PLAYBACK_OFFLOAD] = "compress-offload-playback",
-    [USECASE_AUDIO_PLAYBACK_OFFLOAD1] = "compress-offload-playback1",
-    [USECASE_AUDIO_PLAYBACK_OFFLOAD2] = "compress-offload-playback2",
-    [USECASE_AUDIO_PLAYBACK_OFFLOAD3] = "compress-offload-playback3",
-    [USECASE_AUDIO_RECORD] = "audio-record",
-    [USECASE_AUDIO_RECORD_COMPRESS] = "audio-record-compress",
-    [USECASE_AUDIO_RECORD_LOW_LATENCY] = "low-latency-record",
-    [USECASE_AUDIO_RECORD_FM_VIRTUAL] = "fm-virtual-record",
-    [USECASE_AUDIO_PLAYBACK_FM] = "play-fm",
-    [USECASE_VOICE_CALL] = "voice-call",
-
-    [USECASE_VOICE2_CALL] = "voice2-call",
-    [USECASE_VOLTE_CALL] = "volte-call",
-    [USECASE_QCHAT_CALL] = "qchat-call",
-    [USECASE_COMPRESS_VOIP_CALL] = "compress-voip-call",
-    [USECASE_INCALL_REC_UPLINK] = "incall-rec-uplink",
-    [USECASE_INCALL_REC_DOWNLINK] = "incall-rec-downlink",
-    [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK] = "incall-rec-uplink-and-downlink",
-    [USECASE_INCALL_MUSIC_UPLINK] = "incall_music_uplink",
-    [USECASE_INCALL_MUSIC_UPLINK2] = "incall_music_uplink2",
-    [USECASE_AUDIO_SPKR_CALIB_RX] = "spkr-rx-calib",
-    [USECASE_AUDIO_SPKR_CALIB_TX] = "spkr-vi-record",
-};
-
-
-int adev_open_output_stream(struct audio_hw_device *dev,
-                                   audio_io_handle_t handle,
-                                   audio_devices_t devices,
-                                   audio_output_flags_t flags,
-                                   struct audio_config *config,
-                                   struct audio_stream_out **stream_out);
-
-void adev_close_output_stream(struct audio_hw_device *dev,
-                                     struct audio_stream_out *stream);
-
-int select_devices(struct audio_device *adev,
-                          audio_usecase_t uc_id);
-int disable_audio_route(struct audio_device *adev,
-                               struct audio_usecase *usecase,
-                               bool update_mixer);
-int disable_snd_device(struct audio_device *adev,
-                              snd_device_t snd_device,
-                              bool update_mixer);
-int enable_snd_device(struct audio_device *adev,
-                             snd_device_t snd_device,
-                             bool update_mixer);
-int enable_audio_route(struct audio_device *adev,
-                              struct audio_usecase *usecase,
-                              bool update_mixer);
-struct audio_usecase *get_usecase_from_list(struct audio_device *adev,
-                                                   audio_usecase_t uc_id);
-/*
- * NOTE: when multiple mutexes have to be acquired, always take the
- * stream_in or stream_out mutex first, followed by the audio_device mutex.
- */
-
-#endif // QCOM_AUDIO_HW_H
diff --git a/hal_mpq/audio_stream_out.c b/hal_mpq/audio_stream_out.c
deleted file mode 100644
index 454b1d6..0000000
--- a/hal_mpq/audio_stream_out.c
+++ /dev/null
@@ -1,2898 +0,0 @@
-/* audio_stream_out.c
- **
- ** Copyright 2008-2009 Wind River Systems
- ** Copyright (c) 2011-2013, The Linux Foundation. All rights reserved
- ** Not a Contribution, Apache license notifications and license are retained
- ** for attribution purposes only.
- **
- ** 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 "audio_stream_out"
-/*#define LOG_NDEBUG 0*/
-/*#define VERY_VERY_VERBOSE_LOGGING*/
-#ifdef VERY_VERY_VERBOSE_LOGGING
-#define ALOGVV ALOGV
-#else
-#define ALOGVV(a...) do { } while(0)
-#endif
-
-#include <errno.h>
-#include <pthread.h>
-#include <stdint.h>
-#include <sys/time.h>
-#include <stdlib.h>
-#include <math.h>
-#include <dlfcn.h>
-#include <sys/resource.h>
-#include <sys/prctl.h>
-
-#include <cutils/log.h>
-#include <cutils/str_parms.h>
-#include <cutils/properties.h>
-#include <cutils/atomic.h>
-#include <cutils/sched_policy.h>
-
-#include <system/thread_defs.h>
-#include "audio_hw.h"
-#include "platform_api.h"
-#include <platform.h>
-
-#include "sound/compress_params.h"
-#include "audio_bitstream_sm.h"
-
-//TODO: enable sw_decode if required
-#define USE_SWDECODE 0
-
-#if USE_SWDECODE
-#include "SoftMS11.h"
-#endif
-
-#define COMPRESS_OFFLOAD_FRAGMENT_SIZE (32 * 1024)
-#define COMPRESS_OFFLOAD_NUM_FRAGMENTS 4
-/* ToDo: Check and update a proper value in msec */
-#define COMPRESS_OFFLOAD_PLAYBACK_LATENCY 96
-#define COMPRESS_PLAYBACK_VOLUME_MAX 0x2000
-#define STRING_LENGTH_OF_INTEGER 12
-
-static int send_offload_cmd_l(struct stream_out* out, int command);
-static int get_snd_codec_id(audio_format_t format);
-
-struct pcm_config pcm_config_deep_buffer = {
-    .channels = 2,
-    .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
-    .period_size = DEEP_BUFFER_OUTPUT_PERIOD_SIZE,
-    .period_count = DEEP_BUFFER_OUTPUT_PERIOD_COUNT,
-    .format = PCM_FORMAT_S16_LE,
-    .start_threshold = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4,
-    .stop_threshold = INT_MAX,
-    .avail_min = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4,
-};
-
-struct pcm_config pcm_config_low_latency = {
-    .channels = 2,
-    .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
-    .period_size = LOW_LATENCY_OUTPUT_PERIOD_SIZE,
-    .period_count = LOW_LATENCY_OUTPUT_PERIOD_COUNT,
-    .format = PCM_FORMAT_S16_LE,
-    .start_threshold = LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
-    .stop_threshold = INT_MAX,
-    .avail_min = LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
-};
-
-struct pcm_config pcm_config_hdmi_multi = {
-    .channels = HDMI_MULTI_DEFAULT_CHANNEL_COUNT, /* changed when the stream is opened */
-    .rate = DEFAULT_OUTPUT_SAMPLING_RATE, /* changed when the stream is opened */
-    .period_size = HDMI_MULTI_PERIOD_SIZE,
-    .period_count = HDMI_MULTI_PERIOD_COUNT,
-    .format = PCM_FORMAT_S16_LE,
-    .start_threshold = 0,
-    .stop_threshold = INT_MAX,
-    .avail_min = 0,
-};
-
-inline int nextMultiple(int n, int m) {
-    return ((n/m) + 1) * m;
-}
-
-/*******************************************************************************
-Description: check for MS11 supported formats
-*******************************************************************************/
-//TODO: enable sw_decode if required
-#if USE_SWDECODE
-int is_ms11_supported_fromats(int format)
-{
-    ALOGVV("is_ms11_supported_fromats");
-    int main_format = format & AUDIO_FORMAT_MAIN_MASK;
-    if(((main_format == AUDIO_FORMAT_AAC) ||
-        (main_format == AUDIO_FORMAT_HE_AAC_V1) ||
-        (main_format == AUDIO_FORMAT_HE_AAC_V2) ||
-        (main_format == AUDIO_FORMAT_AC3) ||
-        (main_format == AUDIO_FORMAT_AC3_PLUS) ||
-        (main_format == AUDIO_FORMAT_EAC3))) {
-        return 1;
-    } else {
-        return 0;
-    }
-}
-#endif
-
-/*******************************************************************************
-Description: check if ac3 can played as pass through without MS11 decoder
-*******************************************************************************/
-//TODO: enable sw_decode if required
-#if USE_SWDECODE
-int can_ac3_passthrough_without_ms11(struct stream_out *out, int format)
-{
-    ALOGVV("can_ac3_passthrough_without_ms11");
-    int main_format = format & AUDIO_FORMAT_MAIN_MASK;
-    if(main_format == AUDIO_FORMAT_AC3) {
-        if(((out->hdmi_format == COMPRESSED) ||
-            (out->hdmi_format == AUTO_DEVICE_FORMAT) ||
-            (out->hdmi_format == COMPRESSED_CONVERT_EAC3_AC3) ||
-            (out->hdmi_format == COMPRESSED_CONVERT_ANY_AC3)) &&
-            ((out->spdif_format == COMPRESSED) ||
-             (out->spdif_format == AUTO_DEVICE_FORMAT) ||
-             (out->spdif_format == COMPRESSED_CONVERT_EAC3_AC3) ||
-             (out->spdif_format == COMPRESSED_CONVERT_ANY_AC3))) {
-                return 1;
-        }
-    }
-    return 0;
-}
-#endif
-
-/*******************************************************************************
-Description: get levels of buffering, interms of number of buffers
-*******************************************************************************/
-int get_buffering_factor(struct stream_out *out)
-{
-    ALOGVV("get_buffering_factor");
-    if((out->format == AUDIO_FORMAT_PCM_16_BIT) ||
-       (out->format == AUDIO_FORMAT_PCM_24_BIT))
-        return 1;
-    else
-        return NUM_OF_PERIODS;
-}
-
-/*******************************************************************************
-Description: get the buffer size based on format and device format type
-*******************************************************************************/
-void get_fragment_size_and_format(struct stream_out *out, int routeFormat, int *fragment_size,
-                                       int *fragment_count, int *format)
-{
-    ALOGV("get_fragment_size_and_format");
-
-    int frame_size = 0;
-    *format = out->format;
-    *fragment_count = NUM_OF_PERIODS;
-    switch(out->format) {
-    case AUDIO_FORMAT_PCM_16_BIT:
-        frame_size = PCM_16_BITS_PER_SAMPLE * out->channels;
-        /*TODO: do we need below calculation */
-        *fragment_size = nextMultiple(((frame_size * out->sample_rate * TIME_PER_BUFFER)/1000) + MIN_SIZE_FOR_METADATA , frame_size * 32);
-        break;
-    case AUDIO_FORMAT_PCM_24_BIT:
-        frame_size = PCM_24_BITS_PER_SAMPLE * out->channels;
-        *fragment_size = nextMultiple(((frame_size * out->sample_rate * TIME_PER_BUFFER)/1000) + MIN_SIZE_FOR_METADATA, frame_size * 32);
-        break;
-    case AUDIO_FORMAT_AAC:
-    case AUDIO_FORMAT_HE_AAC_V1:
-    case AUDIO_FORMAT_HE_AAC_V2:
-    case AUDIO_FORMAT_AAC_ADIF:
-    case AUDIO_FORMAT_AC3:
-    case AUDIO_FORMAT_AC3_DM:
-    case AUDIO_FORMAT_EAC3:
-    case AUDIO_FORMAT_EAC3_DM:
-        if(routeFormat == ROUTE_UNCOMPRESSED_MCH) {
-            frame_size = PCM_16_BITS_PER_SAMPLE * out->channels;
-            *fragment_size = nextMultiple(AC3_PERIOD_SIZE * out->channels + MIN_SIZE_FOR_METADATA, frame_size * 32);
-            *format = AUDIO_FORMAT_PCM_16_BIT;
-        } else if(routeFormat == ROUTE_UNCOMPRESSED) {
-            frame_size = PCM_16_BITS_PER_SAMPLE * 2;
-            *fragment_size = nextMultiple(AC3_PERIOD_SIZE * 2 + MIN_SIZE_FOR_METADATA, frame_size * 32);
-            *format = AUDIO_FORMAT_PCM_16_BIT;
-        } else {
-            *fragment_size = PERIOD_SIZE_COMPR;
-        }
-        break;
-    case AUDIO_FORMAT_DTS:
-    case AUDIO_FORMAT_DTS_LBR:
-    case AUDIO_FORMAT_MP3:
-    case AUDIO_FORMAT_WMA:
-    case AUDIO_FORMAT_WMA_PRO:
-    case AUDIO_FORMAT_MP2:
-        *fragment_size = PERIOD_SIZE_COMPR;
-        break;
-    default:
-        *fragment_size = PERIOD_SIZE_COMPR;
-        *format = out->format;
-    }
-
-    /*TODO: remove this if fragement count needs to be decided based on the format*/
-    *fragment_count = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
-    fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
-
-    ALOGV("fragment_size: %d, fragment_count: %d", *fragment_size, *fragment_count);
-    return;
-}
-
-/*******************************************************************************
-Description: buffer length updated to player
-*******************************************************************************/
-int get_buffer_length(struct stream_out *out)
-{
-    /* TODO: Do we need below */
-    ALOGV("get_buffer_length");
-    int buffer_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
-    switch(out->format) {
-    case AUDIO_FORMAT_PCM_16_BIT:
-        buffer_size = ((PCM_16_BITS_PER_SAMPLE * out->channels * out->sample_rate * TIME_PER_BUFFER)/1000);
-        break;
-    case AUDIO_FORMAT_PCM_24_BIT:
-        buffer_size = ((PCM_24_BITS_PER_SAMPLE * out->channels * out->sample_rate * TIME_PER_BUFFER)/1000);
-        break;
-    case AUDIO_FORMAT_AAC:
-    case AUDIO_FORMAT_HE_AAC_V1:
-    case AUDIO_FORMAT_HE_AAC_V2:
-    case AUDIO_FORMAT_AAC_ADIF:
-        buffer_size = AAC_BLOCK_PER_CHANNEL_MS11 * out->channels;
-        break;
-    case AUDIO_FORMAT_AC3:
-    case AUDIO_FORMAT_AC3_DM:
-    case AUDIO_FORMAT_EAC3:
-    case AUDIO_FORMAT_EAC3_DM:
-        buffer_size = AC3_BUFFER_SIZE;
-        break;
-    case AUDIO_FORMAT_DTS:
-    case AUDIO_FORMAT_DTS_LBR:
-    case AUDIO_FORMAT_MP3:
-    case AUDIO_FORMAT_WMA:
-    case AUDIO_FORMAT_WMA_PRO:
-    case AUDIO_FORMAT_MP2:
-        buffer_size = COMPR_INPUT_BUFFER_SIZE;
-        break;
-    default:
-        buffer_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
-    }
-
-    /*TODO: remove this if fragement count needs to be decided based on the format*/
-    buffer_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
-    return buffer_size;
-}
-
-/* TODO: Uncomment this when enabling A2DP
- TODO: add support for the 24 bit playback*/
-#if 0
-/*******************************************************************************
-Description: fix up devices for supporting A2DP playback
-*******************************************************************************/
-void fixUpDevicesForA2DPPlayback(struct stream_out *out)
-{
-    ALOGVV("fixUpDevicesForA2DPPlayback");
-    if(out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) {
-        out->route_audio_to_a2dp = 1;
-        out->devices  &= ~AUDIO_DEVICE_OUT_ALL_A2DP;
-        //TODO: add spdif and proxy
-        //out->devices  &= ~AUDIO_DEVICE_OUT_SPDIF;
-        //out->devices |=  AudioSystem::DEVICE_OUT_PROXY;
-    }
-}
-#endif
-
-/*******************************************************************************
-Description: open temp buffer so that meta data mode can be updated properly
-*******************************************************************************/
-int  open_temp_buf_for_metadata(struct stream_out *out)
-{
-    ALOGV("%s", __func__);
-    if (out->write_temp_buf == NULL) {
-        /*Max Period size which is exposed by the compr driver
-        The value needs to be modified when the period size is modified*/
-        out->write_temp_buf = (char *) malloc(PLAYBACK_MAX_PERIOD_SIZE);
-        if (out->write_temp_buf == NULL) {
-            ALOGE("Memory allocation of temp buffer to write pcm to driver failed");
-            return -EINVAL;
-        }
-    }
-    return 0;
-}
-
-/*******************************************************************************
-Description: get index of handle based on device handle device
-*******************************************************************************/
-struct alsa_handle * get_handle_based_on_devices(struct stream_out *out, int handleDevices)
-{
-    ALOGVV("get_handle_based_on_devices");
-    struct listnode *node;
-    struct alsa_handle *handle = NULL;
-
-    list_for_each(node, &out->session_list) {
-            handle = node_to_item(node, struct alsa_handle, list);
-            if(handle->devices & handleDevices)
-                break;
-    }
-    return handle;
-}
-
-void reset_out_parameters(struct stream_out *out) {
-
-    out->hdmi_format = UNCOMPRESSED;
-    out->spdif_format = UNCOMPRESSED;
-    out->decoder_type = UNCOMPRESSED ;
-    out->dec_conf_set = false;
-    out->min_bytes_req_to_dec = 0;
-    out->is_m11_file_mode = false;
-    out->dec_conf_bufLength = 0;
-    out->first_bitstrm_buf = false;
-    out->open_dec_route = false;
-    out->dec_format_devices = AUDIO_DEVICE_NONE;
-    out->open_dec_mch_route = false;
-    out->dec_mch_format_devices =AUDIO_DEVICE_NONE;
-    out->open_passt_route = false;
-    out->passt_format_devices = AUDIO_DEVICE_NONE;
-    out->sw_open_trans_route = false;
-    out->sw_trans_format_devices = AUDIO_DEVICE_NONE;
-    out->hw_open_trans_route =false ;
-    out->hw_trans_format_devices = AUDIO_DEVICE_NONE;
-    out->channel_status_set = false;
-    out->route_audio_to_a2dp = false;
-    out->is_ms11_file_playback_mode = false;
-    out->write_temp_buf = NULL;
-    return;
-}
-
-struct alsa_handle *get_alsa_handle() {
-
-    struct alsa_handle *handle;
-        handle = (struct alsa_handle *)calloc(1, sizeof(struct alsa_handle));
-        if(handle == NULL) {
-            ALOGE("%s calloc failed for handle", __func__);
-        } else {
-            ALOGE("%s handle is 0x%x", __func__,(uint32_t)handle);
-        }
-
-        return handle;
-}
-
-void free_alsa_handle(struct alsa_handle *handle) {
-
-    if(handle == NULL) {
-        ALOGE("%s Invalid handle", __func__);
-    }
-    free(handle);
-
-    return;
-}
-
-
-struct alsa_handle *get_handle_by_route_format(struct stream_out *out,
-                            int route_format)
-{
-    struct listnode *node;
-    struct alsa_handle *handle = NULL;
-    ALOGV("%s",__func__);
-    list_for_each(node, &out->session_list)  {
-        handle = node_to_item(node, struct alsa_handle, list);
-        if(handle->route_format & route_format) {
-            ALOGV("%s found handle %x",__func__,(uint32_t)handle);
-            break;
-        }
-    }
-
-    return handle;
-}
-
-/*******************************************************************************
-Description: get the format index
-*******************************************************************************/
-int get_format_index(int format)
-{
-    ALOGVV("get_format_index");
-    int idx = 0,i;
-    for(i=0; i<NUM_SUPPORTED_CODECS; i++) {
-        if(format == format_index[i][0]) {
-            idx = format_index[i][1];
-            break;
-        }
-    }
-   return idx;
-}
-
-int get_compress_available_space(struct alsa_handle *handle)
-{
-   uint32_t ret;
-   size_t avail = 0;
-   struct timespec tstamp;
-   ret = compress_get_hpointer(handle->compr,&avail, &tstamp);
-   if(ret!=0) {
-       ALOGE("cannot get available space\n");
-    } else
-        ret = (int)avail;
-    return ret;
-}
-
-
-/*******************************************************************************
-Description: validate if the decoder requires configuration to be set as first
-             buffer
-*******************************************************************************/
-int is_decoder_config_required(struct stream_out *out)
-{
-    ALOGVV("is_decoder_config_required");
-    int main_format = out->format & AUDIO_FORMAT_MAIN_MASK;
-    uint32_t i;
-    if(!out->is_ms11_file_playback_mode)
-        return 0;
-    for(i=0; i<sizeof(decodersRequireConfig)/sizeof(int); i++)
-        if(main_format == decodersRequireConfig[i])
-            return 1;
-    return 0;
-}
-
-/*******************************************************************************
-Description: query if input buffering mode require
-*******************************************************************************/
-int is_input_buffering_mode_reqd(struct stream_out *out)
-{
-    ALOGVV("is_input_buffering_mode_reqd");
-    if((out->decoder_type == SW_PASSTHROUGH) ||
-       (out->decoder_type == DSP_PASSTHROUGH))
-        return 1;
-    else
-        return 0;
-}
-
-
-
-/*******************************************************************************
-Description: update use case and routing flags
-*******************************************************************************/
-void update_decode_type_and_routing_states(struct stream_out *out)
-{
-    ALOGV("%s", __func__);
-
-    int format_index = get_format_index(out->format);
-    int decodeType, idx;
-
-    out->open_dec_route = false;
-    out->open_dec_mch_route = false;
-    out->open_passt_route = false;
-    out->sw_open_trans_route = false;
-    out->hw_open_trans_route = false;
-    out->dec_format_devices = out->devices;
-    out->dec_mch_format_devices = AUDIO_DEVICE_NONE;
-    out->passt_format_devices = AUDIO_DEVICE_NONE;
-    out->sw_trans_format_devices = AUDIO_DEVICE_NONE;
-    out->hw_trans_format_devices = AUDIO_DEVICE_NONE;
-    out->decoder_type = 0;
-
-//TODO: enable sw_decode if required
-#if USE_SWDECODE
-    if(is_ms11_supported_fromats(out->format))
-        out->use_ms11_decoder = true;
-#endif
-
-    ALOGV("format_index: %d devices %x", format_index,out->devices);
-    if(out->devices & AUDIO_DEVICE_OUT_SPDIF) {
-        decodeType = usecase_docode_hdmi_spdif[NUM_STATES_FOR_EACH_DEVICE_FMT*format_index]
-            [out->spdif_format];
-        ALOGV("SPDIF: decoderType: %d", decodeType);
-        out->decoder_type = decodeType;
-        for(idx=0; idx<NUM_DECODE_PATH; idx++) {
-            if(route_to_driver[idx][DECODER_TYPE_IDX] == decodeType) {
-                switch(route_to_driver[idx][ROUTE_FORMAT_IDX]) {
-                    case ROUTE_UNCOMPRESSED:
-                        ALOGVV("ROUTE_UNCOMPRESSED");
-                        ALOGVV("SPDIF opened with stereo decode");
-                        out->open_dec_route = true;
-                        break;
-                    case ROUTE_UNCOMPRESSED_MCH:
-                        ALOGVV("ROUTE_UNCOMPRESSED_MCH");
-                        ALOGVV("SPDIF opened with multichannel decode");
-                        out->open_dec_mch_route = true;
-                        out->dec_format_devices &= ~AUDIO_DEVICE_OUT_SPDIF;
-                        out->dec_mch_format_devices |= AUDIO_DEVICE_OUT_SPDIF;
-                        break;
-                    case ROUTE_COMPRESSED:
-                        ALOGVV("ROUTE_COMPRESSED");
-                        out->open_passt_route = true;
-                        out->dec_format_devices &= ~AUDIO_DEVICE_OUT_SPDIF;
-                        out->passt_format_devices = AUDIO_DEVICE_OUT_SPDIF;
-                        break;
-                    case ROUTE_DSP_TRANSCODED_COMPRESSED:
-                        ALOGVV("ROUTE_DSP_TRANSCODED_COMPRESSED");
-                        out->hw_open_trans_route = true;
-                        out->hw_trans_format_devices = AUDIO_DEVICE_OUT_SPDIF;
-                        break;
-                    case ROUTE_SW_TRANSCODED_COMPRESSED:
-                        ALOGVV("ROUTE_SW_TRANSCODED_COMPRESSED");
-                        out->sw_open_trans_route = true;
-                        out->dec_format_devices &= ~AUDIO_DEVICE_OUT_SPDIF;
-                        out->sw_trans_format_devices = AUDIO_DEVICE_OUT_SPDIF;
-                        break;
-                    default:
-                        ALOGW("INVALID ROUTE for SPDIF, decoderType %d, routeFormat %d",
-                                decodeType, route_to_driver[idx][ROUTE_FORMAT_IDX]);
-                        break;
-                }
-            }
-        }
-    }
-    if(out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
-        decodeType = usecase_docode_hdmi_spdif[NUM_STATES_FOR_EACH_DEVICE_FMT*format_index]
-            [out->hdmi_format];
-        ALOGV("HDMI: decoderType: %d", decodeType);
-        out->decoder_type |= decodeType;
-        for(idx=0; idx<NUM_DECODE_PATH; idx++) {
-            if(route_to_driver[idx][DECODER_TYPE_IDX] == decodeType) {
-                switch(route_to_driver[idx][ROUTE_FORMAT_IDX]) {
-                    case ROUTE_UNCOMPRESSED:
-                        ALOGVV("ROUTE_UNCOMPRESSED");
-                        ALOGVV("HDMI opened with stereo decode");
-                        out->open_dec_route = true;
-                        break;
-                    case ROUTE_UNCOMPRESSED_MCH:
-                        ALOGVV("ROUTE_UNCOMPRESSED_MCH");
-                        ALOGVV("HDMI opened with multichannel decode");
-                        out->open_dec_mch_route = true;
-                        out->dec_format_devices &= ~AUDIO_DEVICE_OUT_AUX_DIGITAL;
-                        out->dec_mch_format_devices |= AUDIO_DEVICE_OUT_AUX_DIGITAL;
-                        break;
-                    case ROUTE_COMPRESSED:
-                        ALOGVV("ROUTE_COMPRESSED");
-                        out->open_passt_route = true;
-                        out->dec_format_devices &= ~AUDIO_DEVICE_OUT_AUX_DIGITAL;
-                        out->passt_format_devices |= AUDIO_DEVICE_OUT_AUX_DIGITAL;
-                        break;
-                    case ROUTE_DSP_TRANSCODED_COMPRESSED:
-                        ALOGVV("ROUTE_DSP_TRANSCODED_COMPRESSED");
-                        out->hw_open_trans_route = true;
-                        out->hw_trans_format_devices |= AUDIO_DEVICE_OUT_AUX_DIGITAL;
-                        break;
-                    case ROUTE_SW_TRANSCODED_COMPRESSED:
-                        ALOGVV("ROUTE_SW_TRANSCODED_COMPRESSED");
-                        out->sw_open_trans_route = true;
-                        out->dec_format_devices &= ~AUDIO_DEVICE_OUT_AUX_DIGITAL;
-                        out->sw_trans_format_devices |= AUDIO_DEVICE_OUT_AUX_DIGITAL;
-                        break;
-                    default:
-                        ALOGW("INVALID ROUTE for HDMI, decoderType %d, routeFormat %d",
-                                decodeType, route_to_driver[idx][ROUTE_FORMAT_IDX]);
-                        break;
-                }
-            }
-        }
-    }
-    if(out->devices & ~(AUDIO_DEVICE_OUT_AUX_DIGITAL |
-                AUDIO_DEVICE_OUT_SPDIF)) {
-        decodeType = usecase_decode_format[NUM_STATES_FOR_EACH_DEVICE_FMT*format_index];
-        ALOGV("Other Devices: decoderType: %d", decodeType);
-        out->decoder_type |= decodeType;
-        for(idx=0; idx<NUM_DECODE_PATH; idx++) {
-            if(route_to_driver[idx][DECODER_TYPE_IDX] == decodeType) {
-                switch(route_to_driver[idx][ROUTE_FORMAT_IDX]) {
-                    case ROUTE_UNCOMPRESSED:
-                        ALOGVV("ROUTE_UNCOMPRESSED");
-                        ALOGVV("Other Devices opened with stereo decode");
-                        out->open_dec_route = true;
-                        break;
-                    case ROUTE_UNCOMPRESSED_MCH:
-                        ALOGVV("ROUTE_UNCOMPRESSED_MCH");
-                        ALOGVV("Other Devices opened with multichannel decode");
-                        out->open_dec_mch_route = true;
-                        out->dec_format_devices &= ~(out->devices &
-                                ~(AUDIO_DEVICE_OUT_SPDIF |
-                                    AUDIO_DEVICE_OUT_AUX_DIGITAL));
-                        out->dec_mch_format_devices |= (out->devices &
-                                ~(AUDIO_DEVICE_OUT_SPDIF |
-                                    AUDIO_DEVICE_OUT_AUX_DIGITAL));
-                        break;
-                    default:
-                        ALOGW("INVALID ROUTE for Other Devices, decoderType %d, routeFormat %d",
-                                decodeType, route_to_driver[idx][ROUTE_FORMAT_IDX]);
-                        break;
-                }
-            }
-        }
-    }
-}
-
-/*******************************************************************************
-Description: update handle states
-*******************************************************************************/
-int update_alsa_handle_state(struct stream_out *out)
-{
-    ALOGV("%s", __func__);
-
-    struct alsa_handle *handle = NULL;
-    struct listnode *node;
-
-    if(out->open_dec_route) {
-        if((handle = get_alsa_handle())== NULL)
-            goto error;
-        list_add_tail(&out->session_list, &handle->list);
-        handle->route_format = ROUTE_UNCOMPRESSED;
-        handle->devices = out->dec_format_devices;
-        handle->usecase = platform_get_usecase(USECASE_AUDIO_PLAYBACK_OFFLOAD);
-        handle->out = out;
-        handle->cmd_pending = false;
-        ALOGD("open_dec_route: routeformat: %d, devices: 0x%x: "
-                ,handle->route_format, handle->devices);
-    }
-    if(out->open_dec_mch_route) {
-        if((handle = get_alsa_handle())== NULL)
-            goto error;
-        list_add_tail(&out->session_list, &handle->list);
-        handle->route_format = ROUTE_UNCOMPRESSED_MCH;
-        handle->devices = out->dec_mch_format_devices;
-        handle->usecase = platform_get_usecase(USECASE_AUDIO_PLAYBACK_OFFLOAD);
-        handle->out = out;
-        handle->cmd_pending = false;
-        ALOGD("OpenMCHDecodeRoute: routeformat: %d, devices: 0x%x: "
-               ,handle->route_format, handle->devices);
-    }
-    if(out->open_passt_route) {
-        if((handle = get_alsa_handle())== NULL)
-            goto error;
-        list_add_tail(&out->session_list, &handle->list);
-        handle->route_format = ROUTE_COMPRESSED;
-        handle->devices = out->passt_format_devices;
-        handle->usecase = platform_get_usecase(USECASE_AUDIO_PLAYBACK_OFFLOAD);
-        handle->out = out;
-        handle->cmd_pending = false;
-        ALOGD("open_passt_route: routeformat: %d, devices: 0x%x: "
-               ,handle->route_format, handle->devices);
-    }
-    if(out->sw_open_trans_route) {
-        if((handle = get_alsa_handle())== NULL)
-            goto error;
-        handle->route_format = ROUTE_SW_TRANSCODED_COMPRESSED;
-        handle->devices = out->sw_trans_format_devices;
-        handle->usecase = platform_get_usecase(USECASE_AUDIO_PLAYBACK_OFFLOAD);
-        handle->out = out;
-        handle->cmd_pending = false;
-        ALOGD("OpenTranscodeRoute: routeformat: %d, devices: 0x%x: "
-               ,handle->route_format, handle->devices);
-    }
-    if(out->hw_open_trans_route) {
-        if((handle = get_alsa_handle())== NULL)
-            goto error;
-        handle->route_format = ROUTE_DSP_TRANSCODED_COMPRESSED;
-        handle->devices = out->hw_trans_format_devices;
-        handle->usecase = platform_get_usecase(USECASE_AUDIO_PLAYBACK_OFFLOAD);
-        handle->out = out;
-        handle->cmd_pending = false;
-        ALOGD("OpenTranscodeRoute: routeformat: %d, devices: 0x%x: "
-               ,handle->route_format, handle->devices);
-    }
-
-return 0;
-
-error:
-    list_for_each(node, &out->session_list) {
-        handle = node_to_item(node, struct alsa_handle, list);
-        free_alsa_handle(handle);
-    }
-
-    return -ENOMEM;
-}
-
-/*******************************************************************************
-Description: setup input path
-*******************************************************************************/
-int allocate_internal_buffers(struct stream_out *out)
-{
-    ALOGV("%s",__func__);
-    int ret = 0;
-    int main_format = out->format & AUDIO_FORMAT_MAIN_MASK;
-
-    /*
-    setup the bitstream state machine
-    */
-    out->bitstrm = ( struct audio_bitstream_sm *)calloc(1,
-            sizeof(struct audio_bitstream_sm));
-    if(!audio_bitstream_init(out->bitstrm, get_buffering_factor(out))) {
-        ALOGE("%s Unable to allocate bitstream buffering for MS11",__func__);
-        free(out->bitstrm);
-        out->bitstrm  = NULL;
-        return -EINVAL;
-    }
-
-    if(is_input_buffering_mode_reqd(out))
-        audio_bitstream_start_input_buffering_mode(out->bitstrm);
-
-    /*
-       setup the buffering data required for decode to start
-       AAC_ADIF would require worst case frame size before decode starts
-       other decoder formats handles the partial data, hence threshold is zero.
-     */
-
-    if(main_format == AUDIO_FORMAT_AAC_ADIF)
-        out->min_bytes_req_to_dec = AAC_BLOCK_PER_CHANNEL_MS11*out->channels-1;
-    else
-        out->min_bytes_req_to_dec = 0;
-
-    ret = open_temp_buf_for_metadata(out);
-    if(ret < 0) {
-        free(out->bitstrm);
-        out->bitstrm  = NULL;
-    }
-    out->buffer_size = get_buffer_length(out);
-
-    return ret;
-}
-
-/*******************************************************************************
-Description: setup input path
-*******************************************************************************/
-int free_internal_buffers(struct stream_out *out)
-{
-    if(out->bitstrm) {
-        free(out->bitstrm);
-        out->bitstrm  = NULL;
-    }
-
-    if(out->write_temp_buf) {
-        free(out->write_temp_buf);
-        out->write_temp_buf = NULL;
-    }
-
-    if(out->dec_conf_buf) {
-        free(out->dec_conf_buf);
-        out->dec_conf_buf = NULL;
-    }
-    return 0;
-}
-
-/*******************************************************************************
-Description: open MS11 instance
-*******************************************************************************/
-//TODO: enable sw_decode if required
-#if USE_SWDECODE
-static int open_ms11_instance(struct stream_out *out)
-{
-    ALOGV("openMS11Instance");
-    int32_t formatMS11;
-    int main_format = out->format & AUDIO_FORMAT_MAIN_MASK;
-    out->ms11_decoder = get_soft_ms11();
-    if(!out->ms11_decoder) {
-        ALOGE("Could not resolve all symbols Required for MS11");
-        return -EINVAL;
-    }
-    /*
-    MS11 created
-    */
-    if(initialize_ms11_function_pointers(out->ms11_decoder) == false) {
-        ALOGE("Could not resolve all symbols Required for MS11");
-        free_soft_ms11(out->ms11_decoder);
-        return -EINVAL;
-    }
-    /*
-    update format
-    */
-    if((main_format == AUDIO_FORMAT_AC3) ||
-       (main_format == AUDIO_FORMAT_EAC3)) {
-        /*TODO: who wil setCOMPRESSED_CONVERT_AC3_ASSOC */
-        if (out->spdif_format == COMPRESSED_CONVERT_AC3_ASSOC)
-            formatMS11 = FORMAT_DOLBY_DIGITAL_PLUS_MAIN_ASSOC;
-        else
-            formatMS11 = FORMAT_DOLBY_DIGITAL_PLUS_MAIN;
-    } else
-        formatMS11 = FORMAT_DOLBY_PULSE_MAIN;
-    /*
-    set the use case to the MS11 decoder and open the stream for decoding
-    */
-    if(ms11_set_usecase_and_open_stream_with_mode(out->ms11_decoder,
-                                    formatMS11, out->channels, out->sample_rate,
-                                    out->is_m11_file_mode)) {
-        ALOGE("SetUseCaseAndOpen MS11 failed");
-        free_soft_ms11(out->ms11_decoder);
-        return EINVAL;
-    }
-    if(is_decoder_config_required(out) && out->dec_conf_buf && out->dec_conf_bufLength) {
-        if(ms11_set_aac_config(out->ms11_decoder, (unsigned char *)out->dec_conf_buf,
-                                out->dec_conf_bufLength) == true) {
-            out->dec_conf_set = true;
-        }
-    }
-
-    return 0;
-}
-#endif
-/*******************************************************************************
-Description: copy input to internal buffer
-*******************************************************************************/
-void copy_bitstream_internal_buffer(struct audio_bitstream_sm *bitstrm,
-                    char *buffer, size_t bytes)
-{
-    // copy bitstream to internal buffer
-    audio_bitstream_copy_to_internal_buffer(bitstrm, (char *)buffer, bytes);
-#ifdef DEBUG
-    dumpInputOutput(INPUT, buffer, bytes, 0);
-#endif
-}
-
-/*******************************************************************************
-Description: set decoder config
-*******************************************************************************/
-//TODO: enable sw_decode if required
-#if USE_SWDECODE
-int setDecodeConfig(struct stream_out *out, char *buffer, size_t bytes)
-{
-    ALOGV("%s ", __func__);
-
-    int main_format = out->format & AUDIO_FORMAT_MAIN_MASK;
-    if(!out->dec_conf_set) {
-        if(main_format == AUDIO_FORMAT_AAC ||
-                  main_format == AUDIO_FORMAT_HE_AAC_V1 ||
-                  main_format == AUDIO_FORMAT_AAC_ADIF ||
-                  main_format == AUDIO_FORMAT_HE_AAC_V2) {
-            if(out->ms11_decoder != NULL) {
-                if(ms11_set_aac_config(out->ms11_decoder,(unsigned char *)buffer,
-                            bytes) == false) {
-                    ALOGE("AAC decoder config fail");
-                    return 0;
-                }
-            }
-        }
-
-        out->dec_conf_bufLength = bytes;
-        if(out->dec_conf_buf)
-            free(out->dec_conf_buf);
-
-        out->dec_conf_buf = malloc(out->dec_conf_bufLength);
-        memcpy(out->dec_conf_buf,
-                buffer,
-                out->dec_conf_bufLength);
-        out->dec_conf_set = true;
-    }
-    out->dec_conf_set = true;
-    return bytes;
-}
-#endif
-
-//TODO: enable sw_decode if required
-#if USE_SWDECODE
-int validate_sw_free_space(struct stream_out* out, int bytes_consumed_in_decode, int *pcm_2ch_len,
-        int *pcm_mch_len, int *passthru_len, int *transcode_len, bool *wait_for_write_done) {
-
-    struct alsa_handle *handle = NULL;
-    char    *bufPtr;
-    int copy_output_buffer_size;
-
-    *pcm_2ch_len = *pcm_mch_len = *passthru_len = *transcode_len = *wait_for_write_done = 0;
-
-    if(out->decoder_type & SW_DECODE) {
-        bufPtr = audio_bitstream_get_output_buffer_write_ptr(out->bitstrm,
-                                                                PCM_2CH_OUT);
-        /*TODO: there is chance of illegale access if ms11 output exceeds bitstream
-            output buffer boudary */
-        copy_output_buffer_size = ms11_copy_output_from_ms11buf(out->ms11_decoder,
-                                                            PCM_2CH_OUT,
-                                                            bufPtr);
-        handle = get_handle_by_route_format(out, ROUTE_UNCOMPRESSED);
-        if(handle == NULL) {
-           ALOGE("%s Invalid handle", __func__);
-           return -EINVAL;
-        }
-        if(get_compress_available_space(handle) < copy_output_buffer_size) {
-            handle->cmd_pending = true;
-            *wait_for_write_done = true;
-        }
-        *pcm_2ch_len = copy_output_buffer_size;
-
-    }
-    if(out->decoder_type & SW_DECODE_MCH) {
-        bufPtr=audio_bitstream_get_output_buffer_write_ptr(out->bitstrm,
-                                                PCM_MCH_OUT);
-        copy_output_buffer_size = ms11_copy_output_from_ms11buf(out->ms11_decoder,
-                                                PCM_MCH_OUT,
-                                                bufPtr);
-        handle = get_handle_by_route_format(out, ROUTE_UNCOMPRESSED_MCH);
-        if(handle == NULL) {
-           ALOGE("%s Invalid handle", __func__);
-           return -EINVAL;
-        }
-
-        if(get_compress_available_space(handle) < copy_output_buffer_size) {
-            handle->cmd_pending = true;
-            *wait_for_write_done = true;
-        }
-        *pcm_mch_len = copy_output_buffer_size;
-    }
-    if(out->decoder_type & SW_PASSTHROUGH) {
-        bufPtr = audio_bitstream_get_output_buffer_write_ptr(out->bitstrm, COMPRESSED_OUT);
-        copy_output_buffer_size = bytes_consumed_in_decode;
-        memcpy(bufPtr, audio_bitstream_get_input_buffer_ptr(out->bitstrm), copy_output_buffer_size);
-
-        handle = get_handle_by_route_format(out, ROUTE_COMPRESSED);
-        if(handle == NULL) {
-           ALOGE("%s Invalid handle", __func__);
-           return -EINVAL;
-        }
-
-        if(get_compress_available_space(handle) < copy_output_buffer_size) {
-            handle->cmd_pending = true;
-            *wait_for_write_done = true;
-        }
-        *passthru_len = copy_output_buffer_size;
-    }
-    if(out->decoder_type & SW_TRANSCODE) {
-        bufPtr = audio_bitstream_get_output_buffer_write_ptr(out->bitstrm,
-                                                         TRANSCODE_OUT);
-        copy_output_buffer_size = ms11_copy_output_from_ms11buf(out->bitstrm,
-                                                         COMPRESSED_OUT,
-                                                         bufPtr);
-        handle = get_handle_by_route_format(out, ROUTE_SW_TRANSCODED_COMPRESSED);
-        if(handle == NULL) {
-           ALOGE("%s Invalid handle", __func__);
-           return -EINVAL;
-        }
-        if(get_compress_available_space(handle) < copy_output_buffer_size) {
-            handle->cmd_pending = true;
-            *wait_for_write_done = true;
-        }
-        *transcode_len = copy_output_buffer_size;
-    }
-    return 0;
-}
-#endif
-
-int validate_hw_free_space(struct stream_out *out, int bytes_consumed_in_decode, int *pcm_2ch_len,
-        int *pcm_mch_len, int *passthru_len, int *transcode_len, bool *wait_for_write_done) {
-
-    struct alsa_handle *handle = NULL;
-    char    *bufPtr;
-    int copy_output_buffer_size;
-    *pcm_2ch_len = *pcm_mch_len = *passthru_len = *transcode_len = *wait_for_write_done = 0;
-    if(out->decoder_type & DSP_DECODE) {
-        ALOGVV("DSP_DECODE");
-        bufPtr = audio_bitstream_get_output_buffer_write_ptr(out->bitstrm,
-                            PCM_MCH_OUT);
-        copy_output_buffer_size = bytes_consumed_in_decode;
-        memcpy(bufPtr, audio_bitstream_get_input_buffer_ptr(out->bitstrm),
-                    copy_output_buffer_size);
-        ALOGVV("%s  bytes_consumed %d out bufPtr %x, pcm_mch_out_buf_size%d",
-                __func__,bytes_consumed_in_decode,bufPtr,
-                out->bitstrm->pcm_mch_out_buf_size);
-        handle = get_handle_by_route_format(out, ROUTE_UNCOMPRESSED);/*TODO: revisit */
-        if(handle == NULL) {
-            ALOGE("%s Invalid handle", __func__);
-            return -EINVAL;
-        }
-        if(get_compress_available_space(handle) < copy_output_buffer_size) {
-            handle->cmd_pending = true;
-            *wait_for_write_done = true;
-            /*reset input buffer pointer as flinger will resend the data back */
-            audio_bitstream_set_input_buffer_write_ptr(out->bitstrm,
-                        -copy_output_buffer_size);
-            *pcm_mch_len = copy_output_buffer_size;
-        }
-        else
-            *pcm_mch_len = copy_output_buffer_size;
-    }
-    if(out->decoder_type & DSP_PASSTHROUGH) {
-        ALOGVV("DSP_PASSTHROUGH");
-        bufPtr = audio_bitstream_get_output_buffer_write_ptr(out->bitstrm, COMPRESSED_OUT);
-        copy_output_buffer_size = bytes_consumed_in_decode;
-        memcpy(bufPtr, audio_bitstream_get_input_buffer_ptr(out->bitstrm), copy_output_buffer_size);
-        handle = get_handle_by_route_format(out, ROUTE_COMPRESSED);
-        if(handle == NULL) {
-            ALOGE("%s Invalid handle", __func__);
-            return -EINVAL;
-        }
-        if(get_compress_available_space(handle) < copy_output_buffer_size) {
-            handle->cmd_pending = true;
-             *wait_for_write_done = true;
-            *passthru_len = copy_output_buffer_size;
-            /*reset input buffer pointer as flinger will resend the data back */
-            audio_bitstream_set_input_buffer_ptr(out->bitstrm, -copy_output_buffer_size);
-        }
-        else
-            *passthru_len = copy_output_buffer_size;
-    }
-    /*TODO: handle DSP Transcode usecase */
-    return 0;
-}
-
-int update_bitstrm_pointers(struct stream_out *out, int pcm_2ch_len,
-                                int pcm_mch_len, int passthru_len, int transcode_len) {
-
-    if(out->decoder_type & SW_DECODE) {
-            audio_bitstream_set_output_buffer_write_ptr(out->bitstrm, PCM_2CH_OUT,
-                        pcm_2ch_len);
-
-    }
-    if(out->decoder_type & SW_DECODE_MCH || out->decoder_type & DSP_DECODE) {
-            audio_bitstream_set_output_buffer_write_ptr(out->bitstrm, PCM_MCH_OUT, pcm_mch_len);
-    }
-    if(out->decoder_type & SW_PASSTHROUGH || out->decoder_type & DSP_PASSTHROUGH) {
-            audio_bitstream_set_output_buffer_write_ptr(out->bitstrm, COMPRESSED_OUT, passthru_len);
-    }
-    if(out->decoder_type & SW_TRANSCODE) {
-            audio_bitstream_set_output_buffer_write_ptr(out->bitstrm,
-                                TRANSCODE_OUT,
-                                 transcode_len);
-    }
-    return 0;
-}
-
-/*TODO correct it */
-static int configure_compr(struct stream_out *out,
-        struct alsa_handle *handle) {
-    handle->compr_config.codec = (struct snd_codec *)
-        calloc(1, sizeof(struct snd_codec));
-    handle->compr_config.codec->id =
-        get_snd_codec_id(out->format); /*TODO: correct this based on format*/
-    handle->compr_config.fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
-    handle->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
-    handle->compr_config.codec->sample_rate =
-        compress_get_alsa_rate(out->sample_rate);
-    handle->compr_config.codec->bit_rate = out->compr_config.codec->bit_rate;
-    handle->compr_config.codec->ch_in =
-        popcount(out->channel_mask);
-    handle->compr_config.codec->ch_out = handle->compr_config.codec->ch_in;
-    handle->compr_config.codec->format = out->compr_config.codec->format;
-    memcpy(&handle->compr_config.codec->options,
-                    &out->compr_config.codec->options,
-                     sizeof(union snd_codec_options));
-    return 0;
-}
-
-/*TODO: do we need to apply volume at the session open*/
-static int set_compress_volume(struct alsa_handle *handle, float left, float right)
-{
-
-    struct audio_device *adev = handle->out->dev;
-    struct mixer_ctl *ctl;
-    int volume[2];
-
-    char mixer_ctl_name[MIXER_PATH_MAX_LENGTH];
-    ALOGV("%s:setting volume l %f r %f ", __func__, left, right);
-
-    memset(mixer_ctl_name, 0, sizeof(mixer_ctl_name));
-    snprintf(mixer_ctl_name, sizeof(mixer_ctl_name),
-          "Compress Playback %d Volume", handle->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;
-    }
-    volume[0] = (int)(left * (float) COMPRESS_PLAYBACK_VOLUME_MAX);
-    volume[1] = (int)(right * (float) COMPRESS_PLAYBACK_VOLUME_MAX);
-    mixer_ctl_set_array(ctl, volume, sizeof(volume)/sizeof(volume[0]));
-
-    return 0;
-
-}
-
-/*******************************************************************************
-Description: software decode handling
-*******************************************************************************/
-//TODO: enable sw_decode if required
-#if USE_SWDECODE
-static int sw_decode(struct stream_out *out,
-                                char *buffer,
-                                size_t bytes,
-                                size_t *bytes_consumed,
-                                bool *continueDecode)
-{
-    /* bytes pending to be decoded in current buffer*/
-    bool wait_for_write_done = false;
-    int bytes_pending_for_decode = 0;
-    /* bytes consumed in current write  buffer */
-    int total_bytes_consumed = 0;
-    size_t  copyBytesMS11 = 0;
-    size_t  bytes_consumed_in_decode = 0;
-    size_t  copy_output_buffer_size = 0;
-    uint32_t outSampleRate = out->sample_rate;
-    uint32_t outChannels = out->channels;
-    char * bufPtr;
-    int pcm_2ch_len, pcm_mch_len, passthru_len, transcode_len;
-    struct alsa_handle *handle = NULL;
-
-    ALOGVV("sw Decode");
-    // eos handling
-    if(bytes == 0) {
-        if(out->format == AUDIO_FORMAT_AAC_ADIF)
-            audio_bitstream_append_silence_internal_buffer(out->bitstrm,
-                                                  out->min_bytes_req_to_dec,0x0);
-        else
-            return false;
-    }
-    /*
-    check for sync word, if present then configure MS11 for fileplayback mode
-    OFF. This is specifically done to handle Widevine usecase, in which the
-    ADTS HEADER is not stripped off by the Widevine parser
-    */
-    if(out->first_bitstrm_buf == true) {
-        uint16_t uData = (*((char *)buffer) << 8) + *((char *)buffer + 1) ;
-        if(ADTS_HEADER_SYNC_RESULT == (uData & ADTS_HEADER_SYNC_MASK)) {
-            ALOGD("Sync word found hence configure MS11 in file_playback Mode OFF");
-            free_soft_ms11(out->ms11_decoder);
-            out->is_m11_file_mode = false;
-            open_ms11_instance(out);
-        }
-        out->first_bitstrm_buf = false;
-    }
-    //decode
-    if(out->decoder_type == SW_PASSTHROUGH) {
-        /*TODO: check if correct */
-        bytes_consumed_in_decode = audio_bitstream_get_size(out->bitstrm);
-    } else {
-        if(audio_bitstream_sufficient_buffer_to_decode(out->bitstrm,
-                                out->min_bytes_req_to_dec) == true) {
-            bufPtr = audio_bitstream_get_input_buffer_ptr(out->bitstrm);
-            copyBytesMS11 = audio_bitstream_get_size(out->bitstrm);
-            ms11_copy_bitstream_to_ms11_inpbuf(out->ms11_decoder, bufPtr,copyBytesMS11);
-            bytes_consumed_in_decode = ms11_stream_decode(out->ms11_decoder,
-                                            &outSampleRate, &outChannels);
-        }
-    }
-
-    if((out->sample_rate != outSampleRate) || (out->channels != outChannels)) {
-        ALOGD("Change in sample rate. New sample rate: %d", outSampleRate);
-        out->sample_rate = outSampleRate;
-        out->channels = outChannels;
-        handle = get_handle_by_route_format(out, ROUTE_UNCOMPRESSED);
-        if(handle !=NULL) {
-            configure_compr(out, handle);
-            handle->compr = compress_open(SOUND_CARD, handle->device_id,
-                    COMPRESS_IN, &handle->compr_config);
-            if (handle->compr && !is_compress_ready(handle->compr)) {
-                ALOGE("%s: %s", __func__, compress_get_error(handle->compr));
-                compress_close(handle->compr);
-                handle->compr = NULL;
-            }
-            if (out->offload_callback)
-                compress_nonblock(handle->compr, out->non_blocking);
-
-            set_compress_volume(handle, out->left_volume, out->right_volume);
-        }
-
-        handle = get_handle_by_route_format(out, ROUTE_UNCOMPRESSED_MCH);
-        if(handle !=NULL) {
-            configure_compr(out, handle);
-            handle->compr = compress_open(SOUND_CARD, handle->device_id,
-                    COMPRESS_IN, &handle->compr_config);
-            if (handle->compr && !is_compress_ready(handle->compr)) {
-                ALOGE("%s: %s", __func__, compress_get_error(handle->compr));
-                compress_close(handle->compr);
-                handle->compr = NULL;
-            }
-            if (out->offload_callback)
-                compress_nonblock(handle->compr, out->non_blocking);
-            set_compress_volume(handle, out->left_volume, out->right_volume);
-            out->channel_status_set = false;
-        }
-    }
-
-
-    validate_sw_free_space(out, bytes_consumed_in_decode, &pcm_2ch_len, &pcm_mch_len,
-            &passthru_len, &transcode_len, &wait_for_write_done);
-
-    if(wait_for_write_done && out->non_blocking) {
-        send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER);
-        *continueDecode = false;
-        *bytes_consumed = 0;
-        return 0;
-    } else {
-        update_bitstrm_pointers(out, pcm_2ch_len, pcm_mch_len,
-                passthru_len, transcode_len);
-        audio_bitstream_copy_residue_to_start(out->bitstrm, bytes_consumed_in_decode);
-        *bytes_consumed = bytes_consumed_in_decode;
-    }
-
-    copy_output_buffer_size = pcm_2ch_len + pcm_mch_len + passthru_len + transcode_len;
-    if(copy_output_buffer_size &&
-       audio_bitstream_sufficient_buffer_to_decode(out->bitstrm, out->min_bytes_req_to_dec) == true) {
-        *continueDecode = true;
-        return 0;
-    }
-    return 0;
-}
-#endif
-
-/*******************************************************************************
-Description: dsp decode handling
-*******************************************************************************/
-static bool dsp_decode(struct stream_out *out, char *buffer, size_t bytes,
-                      size_t *bytes_consumed, bool *continueDecode)
-{
-    char    *bufPtr;
-    size_t  bytes_consumed_in_decode = 0;
-
-    bool wait_for_write_done = false;
-    int pcm_2ch_len, pcm_mch_len, passthru_len, transcode_len;
-
-    ALOGVV("dsp_decode");
-    // decode
-    {
-        bytes_consumed_in_decode = audio_bitstream_get_size(out->bitstrm);
-    }
-    // handle change in sample rate
-    {
-    }
-    //TODO: check if the copy of the buffers can be avoided
-    /* can be removed as its not required for dsp decode usecase */
-    *continueDecode = false;
-    validate_hw_free_space(out, bytes_consumed_in_decode, &pcm_2ch_len, &pcm_mch_len,
-            &passthru_len, &transcode_len, &wait_for_write_done);
-
-    if(wait_for_write_done && out->non_blocking) {
-        send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER);
-        *bytes_consumed = 0;
-        return 0;
-    } else {
-        update_bitstrm_pointers(out, pcm_2ch_len, pcm_mch_len,
-                passthru_len, transcode_len);
-        audio_bitstream_copy_residue_to_start(out->bitstrm, bytes_consumed_in_decode);
-        *bytes_consumed = bytes_consumed_in_decode;
-        ALOGV("%s bytes_consumed_in_decode =%d",__func__,bytes_consumed_in_decode);
-    }
-
-    return 0;
-}
-
-static bool decode(struct stream_out *out, char * buffer, size_t bytes,
-                    size_t *bytes_consumed, bool *continuedecode)
-{
-    ALOGV("decode");
-    bool    continueDecode = false;
-    int ret  = 0;
-
-    // TODO: enable software decode if required
-    /*if (out->use_ms11_decoder) {
-        ret = sw_decode(out, buffer, bytes,
-                                bytes_consumed, continuedecode);
-
-        // set channel status
-        // Set the channel status after first frame decode/transcode
-        //TODO: set the SPDIF channel status bits
-      if(out->channel_status_set == false)
-            setSpdifchannel_status(
-                    audio_bitstream_get_output_buffer_ptr(out->bitstrm, COMPRESSED_OUT),
-                    bytes, AUDIO_PARSER_CODEC_AC3);
-
-    } else */{
-        ret = dsp_decode(out, buffer, bytes,
-                                bytes_consumed, continuedecode);
-        // set channel status
-        // Set the channel status after first frame decode/transcode
-        //TODO: set the SPDIF channel status bits
-/*        if(out->channel_status_set == false)
-            setSpdifchannel_status(
-                    audio_bitstream_get_output_buffer_ptr(out->bitstrm, COMPRESSED_OUT),
-                    bytes, AUDIO_PARSER_CODEC_DTS);
-*/
-    }
-    return ret;
-}
-
-/*******************************************************************************
-Description: fixup sample rate and channel info based on format
-*******************************************************************************/
-void fixupSampleRateChannelModeMS11Formats(struct stream_out *out)
-{
-    ALOGV("fixupSampleRateChannelModeMS11Formats");
-    int main_format = out->format & AUDIO_FORMAT_MAIN_MASK;
-    int subFormat = out->format & AUDIO_FORMAT_SUB_MASK;
-/*
-NOTE: For AAC, the output of MS11 is 48000 for the sample rates greater than
-      24000. The samples rates <= 24000 will be at their native sample rate
-      For AC3, the PCM output is at its native sample rate if the decoding is
-      single decode usecase for MS11.
-*/
-    if(main_format == AUDIO_FORMAT_AAC ||
-       main_format == AUDIO_FORMAT_HE_AAC_V1 ||
-       main_format == AUDIO_FORMAT_HE_AAC_V2 ||
-       main_format == AUDIO_FORMAT_AAC_ADIF) {
-        out->sample_rate = out->sample_rate > 24000 ? 48000 : out->sample_rate;
-        out->channels       = 6;
-    } else if (main_format == AUDIO_FORMAT_AC3 ||
-               main_format == AUDIO_FORMAT_EAC3) {
-        /* transcode AC3/EAC3 44.1K to 48K AC3 for non dual-mono clips */
-        if (out->sample_rate == 44100 &&
-            (subFormat != AUDIO_FORMAT_DOLBY_SUB_DM) &&
-            (out->spdif_format == COMPRESSED ||
-             out->spdif_format == AUTO_DEVICE_FORMAT ||
-             out->spdif_format == COMPRESSED_CONVERT_EAC3_AC3) &&
-             (out->hdmi_format == UNCOMPRESSED ||
-              out->hdmi_format == UNCOMPRESSED_MCH)) {
-            out->sample_rate = 48000;
-            out->spdif_format = COMPRESSED_CONVERT_AC3_ASSOC;
-        } else if (out->sample_rate == 44100) {
-            out->spdif_format = UNCOMPRESSED;
-        }
-        out->channels   = 6;
-    }
-    ALOGD("ms11 format fixup: out->spdif_format %d, out->hdmi_format %d",
-                                     out->spdif_format, out->hdmi_format);
-}
-
-static bool is_supported_format(audio_format_t format)
-{
-    switch (format) {
-    case AUDIO_FORMAT_PCM_16_BIT:
-    case AUDIO_FORMAT_MP3:
-    case AUDIO_FORMAT_AAC:
-    case AUDIO_FORMAT_WMA:
-    case AUDIO_FORMAT_WMA_PRO:
-    case AUDIO_FORMAT_MP2:
-        return true;
-    default:
-        ALOGE("%s: Unsupported audio format: %x", __func__, format);
-        break;
-    }
-
-    return false;
-}
-
-static int get_snd_codec_id(audio_format_t format)
-{
-    int id = 0;
-
-    switch (format) {
-    case AUDIO_FORMAT_PCM_16_BIT:
-        id = SND_AUDIOCODEC_PCM;
-        break;
-    case AUDIO_FORMAT_MP3:
-        id = SND_AUDIOCODEC_MP3;
-        break;
-    case AUDIO_FORMAT_AAC:
-        id = SND_AUDIOCODEC_AAC;
-        break;
-    case AUDIO_FORMAT_WMA:
-        id = SND_AUDIOCODEC_WMA;
-        break;
-    case AUDIO_FORMAT_WMA_PRO:
-        id = SND_AUDIOCODEC_WMA_PRO;
-        break;
-    case AUDIO_FORMAT_MP2:
-        id = SND_AUDIOCODEC_MP2;
-        break;
-    default:
-        ALOGE("%s: Unsupported audio format %x", __func__, format);
-    }
-
-    return id;
-}
-
-/* must be called with hw device mutex locked */
-static int read_hdmi_channel_masks(struct stream_out *out)
-{
-    int ret = 0;
-    int channels = platform_edid_get_max_channels(out->dev->platform);
-
-    switch (channels) {
-        /*
-         * Do not handle stereo output in Multi-channel cases
-         * Stereo case is handled in normal playback path
-         */
-    case 6:
-        ALOGV("%s: HDMI supports 5.1", __func__);
-        out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1;
-        break;
-    case 8:
-        ALOGV("%s: HDMI supports 5.1 and 7.1 channels", __func__);
-        out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1;
-        out->supported_channel_masks[1] = AUDIO_CHANNEL_OUT_7POINT1;
-        break;
-    default:
-        ALOGE("HDMI does not support multi channel playback");
-        ret = -ENOSYS;
-        break;
-    }
-    return ret;
-}
-
-/* must be called with out->lock locked */
-static int send_offload_cmd_l(struct stream_out* out, int command)
-{
-    struct offload_cmd *cmd = (struct offload_cmd *)calloc(1, sizeof(struct offload_cmd));
-
-    ALOGVV("%s %d", __func__, command);
-
-    cmd->cmd = command;
-    list_add_tail(&out->offload_cmd_list, &cmd->node);
-    pthread_cond_signal(&out->offload_cond);
-    return 0;
-}
-
-/* must be called iwth out->lock locked */
-static void stop_compressed_output_l(struct stream_out *out)
-{
-    struct listnode *node;
-    struct alsa_handle *handle;
-    bool is_compr_out = false;
-
-    ALOGV("%s", __func__);
-    out->offload_state = OFFLOAD_STATE_IDLE;
-    out->playback_started = 0;
-    out->send_new_metadata = 1;
-    list_for_each(node, &out->session_list) {
-        handle = node_to_item(node, struct alsa_handle, list);
-        if (handle->compr != NULL) {
-            compress_stop(handle->compr);
-            is_compr_out = true;
-        }
-    }
-    if (is_compr_out) {
-        while (out->offload_thread_blocked)
-            pthread_cond_wait(&out->cond, &out->lock);
-    }
-}
-
-static void *offload_thread_loop(void *context)
-{
-    struct stream_out *out = (struct stream_out *) context;
-    struct listnode *item;
-    struct listnode *node;
-    struct alsa_handle *handle;
-
-    out->offload_state = OFFLOAD_STATE_IDLE;
-    out->playback_started = 0;
-
-    setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_AUDIO);
-    set_sched_policy(0, SP_FOREGROUND);
-    prctl(PR_SET_NAME, (unsigned long)"Offload Callback", 0, 0, 0);
-
-    ALOGV("%s", __func__);
-    pthread_mutex_lock(&out->lock);
-    for (;;) {
-        struct offload_cmd *cmd = NULL;
-        stream_callback_event_t event;
-        bool send_callback = false;
-
-        ALOGVV("%s offload_cmd_list %d out->offload_state %d",
-              __func__, list_empty(&out->offload_cmd_list),
-              out->offload_state);
-        if (list_empty(&out->offload_cmd_list)) {
-            ALOGV("%s SLEEPING", __func__);
-            pthread_cond_wait(&out->offload_cond, &out->lock);
-            ALOGV("%s RUNNING", __func__);
-            continue;
-        }
-
-        item = list_head(&out->offload_cmd_list);
-        cmd = node_to_item(item, struct offload_cmd, node);
-        list_remove(item);
-
-        ALOGVV("%s STATE %d CMD %d",
-               __func__, out->offload_state, cmd->cmd);
-
-        if (cmd->cmd == OFFLOAD_CMD_EXIT) {
-            free(cmd);
-            break;
-        }
-
-        if (list_empty(&out->session_list)) {
-            ALOGE("%s: Compress handle is NULL", __func__);
-            pthread_cond_signal(&out->cond);
-            continue;
-        }
-        out->offload_thread_blocked = true;
-        pthread_mutex_unlock(&out->lock);
-        send_callback = false;
-        switch(cmd->cmd) {
-        case OFFLOAD_CMD_WAIT_FOR_BUFFER:
-            list_for_each(node, &out->session_list) {
-                handle = node_to_item(node, struct alsa_handle, list);
-                if (handle->compr && handle->cmd_pending) {
-                    compress_wait(handle->compr, -1);
-                    handle->cmd_pending = false;
-                }
-            }
-            send_callback = true;
-            event = STREAM_CBK_EVENT_WRITE_READY;
-            break;
-        case OFFLOAD_CMD_PARTIAL_DRAIN:
-            list_for_each(node, &out->session_list) {
-                handle = node_to_item(node, struct alsa_handle, list);
-                if (handle->compr) {
-                    compress_next_track(handle->compr);
-                    compress_partial_drain(handle->compr);
-                }
-            }
-            send_callback = true;
-            event = STREAM_CBK_EVENT_DRAIN_READY;
-            break;
-        case OFFLOAD_CMD_DRAIN:
-            list_for_each(node, &out->session_list) {
-                handle = node_to_item(node, struct alsa_handle, list);
-                if (handle->compr) {
-                    compress_drain(handle->compr);
-                }
-            }
-            send_callback = true;
-            event = STREAM_CBK_EVENT_DRAIN_READY;
-            break;
-        default:
-            ALOGE("%s unknown command received: %d", __func__, cmd->cmd);
-            break;
-        }
-        pthread_mutex_lock(&out->lock);
-        out->offload_thread_blocked = false;
-        pthread_cond_signal(&out->cond);
-        if (send_callback) {
-            out->offload_callback(event, NULL, out->offload_cookie);
-        }
-        free(cmd);
-    }
-
-    pthread_cond_signal(&out->cond);
-    while (!list_empty(&out->offload_cmd_list)) {
-        item = list_head(&out->offload_cmd_list);
-        list_remove(item);
-        free(node_to_item(item, struct offload_cmd, node));
-    }
-    pthread_mutex_unlock(&out->lock);
-
-    return NULL;
-}
-
-static int create_offload_callback_thread(struct stream_out *out)
-{
-    pthread_cond_init(&out->offload_cond, (const pthread_condattr_t *) NULL);
-    list_init(&out->offload_cmd_list);
-    pthread_create(&out->offload_thread, (const pthread_attr_t *) NULL,
-                    offload_thread_loop, out);
-    return 0;
-}
-
-static int destroy_offload_callback_thread(struct stream_out *out)
-{
-    pthread_mutex_lock(&out->lock);
-    stop_compressed_output_l(out);
-    send_offload_cmd_l(out, OFFLOAD_CMD_EXIT);
-
-    pthread_mutex_unlock(&out->lock);
-    pthread_join(out->offload_thread, (void **) NULL);
-    pthread_cond_destroy(&out->offload_cond);
-
-    return 0;
-}
-
-static bool allow_hdmi_channel_config(struct audio_device *adev)
-{
-    struct listnode *node;
-    struct audio_usecase *usecase;
-    bool ret = true;
-
-    list_for_each(node, &adev->usecase_list) {
-        usecase = node_to_item(node, struct audio_usecase, list);
-        if (usecase->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
-            /*
-             * If voice call is already existing, do not proceed further to avoid
-             * disabling/enabling both RX and TX devices, CSD calls, etc.
-             * Once the voice call done, the HDMI channels can be configured to
-             * max channels of remaining use cases.
-             */
-            if (usecase->id == USECASE_VOICE_CALL) {
-                ALOGD("%s: voice call is active, no change in HDMI channels",
-                      __func__);
-                ret = false;
-                break;
-            } else if (usecase->id == USECASE_AUDIO_PLAYBACK_MULTI_CH) {
-                ALOGD("%s: multi channel playback is active, "
-                      "no change in HDMI channels", __func__);
-                ret = false;
-                break;
-            }
-        }
-    }
-    return ret;
-}
-
-static int check_and_set_hdmi_channels(struct audio_device *adev,
-                                       unsigned int channels)
-{
-    struct listnode *node;
-    struct audio_usecase *usecase;
-
-    /* Check if change in HDMI channel config is allowed */
-    if (!allow_hdmi_channel_config(adev))
-        return 0;
-
-    if (channels == adev->cur_hdmi_channels) {
-        ALOGD("%s: Requested channels are same as current", __func__);
-        return 0;
-    }
-
-    platform_set_hdmi_channels(adev->platform, channels);
-    adev->cur_hdmi_channels = channels;
-
-    /*
-     * Deroute all the playback streams routed to HDMI so that
-     * the back end is deactivated. Note that backend will not
-     * be deactivated if any one stream is connected to it.
-     */
-    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_AUX_DIGITAL) {
-            disable_audio_route(adev, usecase, true);
-        }
-    }
-
-    /*
-     * Enable all the streams disabled above. Now the HDMI backend
-     * will be activated with new channel configuration
-     */
-    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_AUX_DIGITAL) {
-            enable_audio_route(adev, usecase, true);
-        }
-    }
-
-    return 0;
-}
-
-static int stop_output_stream(struct stream_out *out, struct alsa_handle *handle)
-{
-    int i, ret = 0;
-    struct audio_usecase *uc_info;
-    struct audio_device *adev = out->dev;
-
-    ALOGV("%s: enter: usecase(%d: %s)", __func__,
-          handle->usecase, use_case_table[handle->usecase]);
-    uc_info = get_usecase_from_list(adev, handle->usecase);
-    if (uc_info == NULL) {
-        ALOGE("%s: Could not find the usecase (%d) in the list",
-              __func__, handle->usecase);
-        return -EINVAL;
-    }
-
-    if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD &&
-            adev->visualizer_stop_output != NULL)
-        adev->visualizer_stop_output(out->handle);
-
-    /* 1. Get and set stream specific mixer controls */
-    disable_audio_route(adev, uc_info, true);
-
-    /* 2. Disable the rx device */
-    disable_snd_device(adev, uc_info->out_snd_device, true);
-
-    list_remove(&uc_info->list);
-    free(uc_info);
-
-    /* Must be called after removing the usecase from list */
-    if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)
-        check_and_set_hdmi_channels(adev, DEFAULT_HDMI_OUT_CHANNELS);
-
-    ALOGV("%s: exit: status(%d)", __func__, ret);
-    return ret;
-}
-
-int start_output_stream(struct stream_out *out, struct alsa_handle *handle)
-{
-    int ret = 0;
-    struct audio_usecase *uc_info;
-    struct audio_device *adev = out->dev;
-
-    ALOGV("%s: enter: usecase(%d: %s) devices(%#x)",
-          __func__, handle->usecase, use_case_table[handle->usecase], handle->devices);
-    handle->device_id = platform_get_pcm_device_id(handle->usecase, PCM_PLAYBACK);
-    if (handle->device_id < 0) {
-        ALOGE("%s: Invalid PCM device id(%d) for the usecase(%d)",
-              __func__, handle->device_id, handle->usecase);
-        ret = -EINVAL;
-        goto error_config;
-    }
-
-    uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
-    uc_info->id = handle->usecase;
-    uc_info->handle = handle;
-    uc_info->type = PCM_PLAYBACK;
-    uc_info->stream.out = out;
-    uc_info->devices = handle->devices;
-    uc_info->in_snd_device = SND_DEVICE_NONE;
-    uc_info->out_snd_device = SND_DEVICE_NONE;
-
-    /* This must be called before adding this usecase to the list */
-    if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)
-        check_and_set_hdmi_channels(adev, handle->config.channels);
-
-    list_add_tail(&adev->usecase_list, &uc_info->list);
-
-    select_devices(adev, handle->usecase);
-
-    ALOGV("%s: Opening PCM device card_id(%d) device_id(%d)",
-          __func__, 0, handle->device_id);
-    if (out->uc_strm_type != OFFLOAD_PLAYBACK_STREAM) {
-        handle->compr = NULL;
-        handle->pcm = pcm_open(SOUND_CARD, handle->device_id,
-                               PCM_OUT | PCM_MONOTONIC, &handle->config);
-        if (handle->pcm && !pcm_is_ready(handle->pcm)) {
-            ALOGE("%s: %s", __func__, pcm_get_error(handle->pcm));
-            pcm_close(handle->pcm);
-            handle->pcm = NULL;
-            ret = -EIO;
-            goto error_open;
-        }
-    } else {
-        handle->pcm = NULL;
-        configure_compr(out, handle);
-        handle->compr = compress_open(SOUND_CARD, handle->device_id,
-                                   COMPRESS_IN, &handle->compr_config);
-        if (handle->compr && !is_compress_ready(handle->compr)) {
-            ALOGE("%s: %s", __func__, compress_get_error(handle->compr));
-            compress_close(handle->compr);
-            handle->compr = NULL;
-            ret = -EIO;
-            goto error_open;
-        }
-        if (out->offload_callback)
-            compress_nonblock(handle->compr, out->non_blocking);
-
-        if (adev->visualizer_start_output != NULL)
-            adev->visualizer_start_output(out->handle);
-    }
-    ALOGV("%s: exit", __func__);
-    return 0;
-error_open:
-    stop_output_stream(out, handle);
-error_config:
-    return ret;
-}
-
-static uint32_t out_get_sample_rate(const struct audio_stream *stream)
-{
-    struct stream_out *out = (struct stream_out *)stream;
-
-    return out->sample_rate;
-}
-
-static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
-{
-    return -ENOSYS;
-}
-
-static size_t out_get_buffer_size(const struct audio_stream *stream)
-{
-    struct stream_out *out = (struct stream_out *)stream;
-
-    /*if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD)
-        return out->compr_config.fragment_size;
-    */
-    return (size_t)out->buffer_size;
-
-    //return out->config.period_size * audio_stream_frame_size(stream);
-}
-
-static uint32_t out_get_channels(const struct audio_stream *stream)
-{
-    struct stream_out *out = (struct stream_out *)stream;
-
-    return out->channel_mask;
-}
-
-static audio_format_t out_get_format(const struct audio_stream *stream)
-{
-    struct stream_out *out = (struct stream_out *)stream;
-
-    return out->format;
-}
-
-static int out_set_format(struct audio_stream *stream, audio_format_t format)
-{
-    return -ENOSYS;
-}
-
-static int out_standby(struct audio_stream *stream)
-{
-    struct stream_out *out = (struct stream_out *)stream;
-    struct audio_device *adev = out->dev;
-    struct listnode *node;
-    struct alsa_handle *handle;
-
-    ALOGV("%s: enter: usecase(%d: %s)", __func__,
-          out->usecase, use_case_table[out->usecase]);
-    if (out->usecase == USECASE_COMPRESS_VOIP_CALL) {
-        /* Ignore standby in case of voip call because the voip output
-         * stream is closed in adev_close_output_stream()
-         */
-        ALOGV("%s: Ignore Standby in VOIP call", __func__);
-        return 0;
-    }
-
-    pthread_mutex_lock(&out->lock);
-    pthread_mutex_lock(&adev->lock);
-    if (!out->standby) {
-        out->standby = true;
-        stop_compressed_output_l(out);
-        out->gapless_mdata.encoder_delay = 0;
-        out->gapless_mdata.encoder_padding = 0;
-
-        list_for_each(node, &out->session_list) {
-            handle = node_to_item(node, struct alsa_handle, list);
-            if (handle->compr != NULL) {
-                compress_close(handle->compr);
-                handle->compr = NULL;
-            } else if (handle->pcm) {
-                pcm_close(handle->pcm);
-                handle->pcm = NULL;
-            }
-            stop_output_stream(out, handle);
-        }
-    }
-    pthread_mutex_unlock(&adev->lock);
-    pthread_mutex_unlock(&out->lock);
-    ALOGV("%s: exit", __func__);
-    return 0;
-}
-
-static int out_dump(const struct audio_stream *stream, int fd)
-{
-    return 0;
-}
-
-static int parse_compress_metadata(struct stream_out *out, struct str_parms *parms)
-{
-    int ret = 0;
-    char value[32];
-    struct compr_gapless_mdata tmp_mdata;
-    bool gapless_meta_set = true;
-
-    if (!out || !parms) {
-        return -EINVAL;
-    }
-
-    ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_DELAY_SAMPLES, value, sizeof(value));
-    if (ret >= 0) {
-        tmp_mdata.encoder_delay = atoi(value); //whats a good limit check?
-    } else {
-        gapless_meta_set = false;
-    }
-
-    ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_PADDING_SAMPLES, value, sizeof(value));
-    if (ret >= 0) {
-        tmp_mdata.encoder_padding = atoi(value);
-    } else {
-        gapless_meta_set = false;
-    }
-
-    if (gapless_meta_set) {
-        out->gapless_mdata = tmp_mdata;
-        out->send_new_metadata = 1;
-        ALOGV("%s new encoder delay %u and padding %u", __func__,
-            out->gapless_mdata.encoder_delay, out->gapless_mdata.encoder_padding);
-    }
-
-    if(out->format == AUDIO_FORMAT_WMA || out->format == AUDIO_FORMAT_WMA_PRO) {
-        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_FORMAT_TAG, value, sizeof(value));
-        if (ret >= 0) {
-            out->compr_config.codec->format = atoi(value);
-        }
-        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_BLOCK_ALIGN, value, sizeof(value));
-        if (ret >= 0) {
-            out->compr_config.codec->options.wma.super_block_align = atoi(value);
-        }
-        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_BIT_PER_SAMPLE, value, sizeof(value));
-        if (ret >= 0) {
-            out->compr_config.codec->options.wma.bits_per_sample = atoi(value);
-        }
-        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_CHANNEL_MASK, value, sizeof(value));
-        if (ret >= 0) {
-            out->compr_config.codec->options.wma.channelmask = atoi(value);
-        }
-        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_ENCODE_OPTION, value, sizeof(value));
-        if (ret >= 0) {
-            out->compr_config.codec->options.wma.encodeopt = atoi(value);
-        }
-        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_ENCODE_OPTION1, value, sizeof(value));
-        if (ret >= 0) {
-            out->compr_config.codec->options.wma.encodeopt1 = atoi(value);
-        }
-        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_ENCODE_OPTION2, value, sizeof(value));
-        if (ret >= 0) {
-            out->compr_config.codec->options.wma.encodeopt2 = atoi(value);
-        }
-        ALOGV("WMA params: fmt %x, balgn %x, sr %d, chmsk %x, encop %x, op1 %x, op2 %x",
-                                out->compr_config.codec->format,
-                                out->compr_config.codec->options.wma.super_block_align,
-                                out->compr_config.codec->options.wma.bits_per_sample,
-                                out->compr_config.codec->options.wma.channelmask,
-                                out->compr_config.codec->options.wma.encodeopt,
-                                out->compr_config.codec->options.wma.encodeopt1,
-                                out->compr_config.codec->options.wma.encodeopt2);
-    }
-    return 0;
-}
-
-static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
-{
-    struct stream_out *out = (struct stream_out *)stream;
-    struct audio_device *adev = out->dev;
-    struct audio_usecase *usecase;
-    struct listnode *node;
-    struct str_parms *parms;
-    char value[32];
-    int ret, val = 0;
-    bool select_new_device = false;
-
-    ALOGD("%s: enter: kvpairs: %s", __func__, kvpairs);
-    parms = str_parms_create_str(kvpairs);
-    ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
-    if (ret >= 0) {
-        val = atoi(value);
-        pthread_mutex_lock(&out->lock);
-        pthread_mutex_lock(&adev->lock);
-
-        /*
-         * When HDMI cable is unplugged the music playback is paused and
-         * the policy manager sends routing=0. But the audioflinger
-         * continues to write data until standby time (3sec).
-         * As the HDMI core is turned off, the write gets blocked.
-         * Avoid this by routing audio to speaker until standby.
-         */
-        if (out->devices == AUDIO_DEVICE_OUT_AUX_DIGITAL &&
-                val == AUDIO_DEVICE_NONE) {
-            val = AUDIO_DEVICE_OUT_SPEAKER;
-        }
-
-        /*
-         * select_devices() call below switches all the usecases on the same
-         * backend to the new device. Refer to check_usecases_codec_backend() in
-         * the select_devices(). But how do we undo this?
-         *
-         * For example, music playback is active on headset (deep-buffer usecase)
-         * and if we go to ringtones and select a ringtone, low-latency usecase
-         * will be started on headset+speaker. As we can't enable headset+speaker
-         * and headset devices at the same time, select_devices() switches the music
-         * playback to headset+speaker while starting low-lateny usecase for ringtone.
-         * So when the ringtone playback is completed, how do we undo the same?
-         *
-         * We are relying on the out_set_parameters() call on deep-buffer output,
-         * once the ringtone playback is ended.
-         * NOTE: We should not check if the current devices are same as new devices.
-         *       Because select_devices() must be called to switch back the music
-         *       playback to headset.
-         */
-        if (val != 0) {
-            out->devices = val;
-
-            if (!out->standby)
-                select_devices(adev, out->usecase);
-        }
-//TODO:
-//Get the device and device format mapping from the RoutingManager.
-//Decide which streams need to be derouted and which need to opened/closed
-//Update the respective device in each of the handles
-#if 0
-        if (out->uc_strm_type == OFFLOAD_PLAYBACK_STREAM) {
-
-            /* TODO get format form routing manager */
-            update_decode_type_and_routing_states(out);
-
-            if(is_input_buffering_mode_reqd(out))
-                audio_bitstream_start_input_buffering_mode(out->bitstrm);
-            else
-                audio_bitstream_stop_input_buffering_mode(out->bitstrm);
-            /*
-               For the runtime format change, close the device first to avoid any
-               concurrent PCM + Compressed sessions on the same device.
-             */
-             close_handles_for_device_switch(out);
-            if(!out->mopen_dec_route)
-                handleCloseForDeviceSwitch(ROUTE_UNCOMPRESSED);
-
-            if(!out->mopen_dec_mch_route)
-                handleCloseForDeviceSwitch(ROUTE_UNCOMPRESSED_MCH);
-
-            if(!out->mopen_passt_route)
-                handleCloseForDeviceSwitch(ROUTE_COMPRESSED);
-
-            if(!msw_open_trans_route)
-                handleCloseForDeviceSwitch(ROUTE_SW_TRANSCODED_COMPRESSED);
-
-            if(!mhw_open_trans_route)
-                handleCloseForDeviceSwitch(ROUTE_DSP_TRANSCODED_COMPRESSED);
-
-            if(out->mopen_dec_route)
-                handleSwitchAndOpenForDeviceSwitch(mdec_format_devices,
-                        ROUTE_UNCOMPRESSED);
-            if(out->mopen_dec_mch_route)
-                handleSwitchAndOpenForDeviceSwitch(mdec_mch_format_devices,
-                        ROUTE_UNCOMPRESSED_MCH);
-            if(out->mopen_passt_route)
-                handleSwitchAndOpenForDeviceSwitch(mpasst_format_devices,
-                        ROUTE_COMPRESSED);
-            if(out->msw_open_trans_route)
-                handleSwitchAndOpenForDeviceSwitch(msw_trans_format_devices,
-                        ROUTE_SW_TRANSCODED_COMPRESSED);
-            if(out->mhw_open_trans_route)
-                handleSwitchAndOpenForDeviceSwitch(mhw_trans_format_devices,
-                        ROUTE_DSP_TRANSCODED_COMPRESSED);
-        }
-#endif
-
-        pthread_mutex_unlock(&adev->lock);
-        pthread_mutex_unlock(&out->lock);
-    }
-
-    if (out->uc_strm_type == OFFLOAD_PLAYBACK_STREAM) {
-        ret = parse_compress_metadata(out, parms);
-    }
-
-    str_parms_destroy(parms);
-    ALOGV("%s: exit: code(%d)", __func__, ret);
-    return ret;
-}
-
-static char* out_get_parameters(const struct audio_stream *stream, const char *keys)
-{
-    struct stream_out *out = (struct stream_out *)stream;
-    struct str_parms *query = str_parms_create_str(keys);
-    char *str;
-    char value[256];
-    struct str_parms *reply = str_parms_create();
-    size_t i, j;
-    int ret;
-    bool first = true;
-    ALOGV("%s: enter: keys - %s", __func__, keys);
-    ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value, sizeof(value));
-    if (ret >= 0) {
-        value[0] = '\0';
-        i = 0;
-        while (out->supported_channel_masks[i] != 0) {
-            for (j = 0; j < ARRAY_SIZE(out_channels_name_to_enum_table); j++) {
-                if (out_channels_name_to_enum_table[j].value == out->supported_channel_masks[i]) {
-                    if (!first) {
-                        strlcat(value, "|", sizeof(value));
-                    }
-                    strlcat(value, out_channels_name_to_enum_table[j].name, sizeof(value));
-                    first = false;
-                    break;
-                }
-            }
-            i++;
-        }
-        str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value);
-        str = str_parms_to_str(reply);
-    }
-    str_parms_destroy(query);
-    str_parms_destroy(reply);
-    ALOGV("%s: exit: returns - %s", __func__, str);
-    return str;
-}
-
-static uint32_t out_get_latency(const struct audio_stream_out *stream)
-{
-    struct stream_out *out = (struct stream_out *)stream;
-    struct listnode *item;
-    struct alsa_handle *handle;
-
-    //TODO: decide based on the clip properties
-    if (out->uc_strm_type == OFFLOAD_PLAYBACK_STREAM)
-        return COMPRESS_OFFLOAD_PLAYBACK_LATENCY;
-
-    item = list_head(&out->session_list);
-    handle = node_to_item(item, struct alsa_handle, list);
-    if(!handle) {
-        ALOGE("%s: error pcm handle NULL", __func__);
-        return -EINVAL;
-    }
-
-    return (handle->config.period_count * handle->config.period_size * 1000) /
-        (handle->config.rate);
-}
-
-static int out_set_volume(struct audio_stream_out *stream, float left,
-                          float right)
-{
-    struct stream_out *out = (struct stream_out *)stream;
-    struct listnode *node;
-    struct alsa_handle *handle;
-    struct audio_device *adev = out->dev;
-    int ret = -ENOSYS;
-    ALOGV("%s:setting volume l %f r %f ", __func__, left, right);
-    pthread_mutex_lock(&out->lock);
-    list_for_each(node, &out->session_list) {
-        handle = node_to_item(node, struct alsa_handle, list);
-        if (handle->pcm && (out->usecase == USECASE_AUDIO_PLAYBACK_MULTI_CH)){
-            /* only take left channel into account: the API is for stereo anyway */
-            out->muted = (left == 0.0f);
-            ret = 0;
-        } else if (handle->compr) {
-
-            out->left_volume = left;
-            out->right_volume = right;
-
-            ret = set_compress_volume(handle, left, right);
-        }
-    }
-    pthread_mutex_unlock(&out->lock);
-
-    return ret;
-}
-
-static int write_data(struct stream_out *out, struct alsa_handle *handle,
-                   const void *buffer, int bytes) {
-
-    int ret = 0;
-    if (out->uc_strm_type == OFFLOAD_PLAYBACK_STREAM) {
-        ALOGV("%s: writing buffer (%d bytes) to compress device", __func__, bytes);
-
-        ret = compress_write(handle->compr, buffer, bytes);
-        ALOGV("%s: writing buffer (%d bytes) to compress device returned %d",
-                    __func__, bytes, ret);
-        /* TODO:disnable this if ms12 */
-
-        if (ret >= 0 && ret < (ssize_t)bytes) {
-            handle->cmd_pending = true;
-            send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER);
-        }
-        return ret;
-    } else {
-        if (handle->pcm) {
-            if (out->muted)
-                memset((void *)buffer, 0, bytes);
-            ALOGV("%s: writing buffer (%d bytes) to pcm device", __func__, bytes);
-            ret = pcm_write(handle->pcm, (void *)buffer, bytes);
-        }
-    }
-
-    if (ret != 0) {
-        if ((handle && handle->pcm))
-            ALOGE("%s: error %d - %s", __func__, ret, pcm_get_error(handle->pcm));
-        out_standby(&out->stream.common);
-        usleep(bytes * 1000000 / audio_stream_frame_size(&out->stream.common) /
-                out_get_sample_rate(&out->stream.common));
-    }
-    return bytes;
-}
-
-/*******************************************************************************
-Description: render
-*******************************************************************************/
-size_t render_offload_data(struct stream_out *out, const void *buffer, size_t bytes)
-{
-    int ret =0;
-    uint32_t renderedPcmBytes = 0;
-    int      fragment_size;
-    uint32_t availableSize;
-    int bytes_to_write = bytes;
-    int renderType;
-    /*int metadataLength = sizeof(out->output_meta_data);*/
-    struct listnode *node;
-    struct alsa_handle *handle;
-
-    ALOGV("%s", __func__);
-
-    list_for_each(node, &out->session_list) {
-        handle = node_to_item(node, struct alsa_handle, list);
-        if (out->send_new_metadata) {
-            ALOGVV("send new gapless metadata");
-            compress_set_gapless_metadata(handle->compr, &out->gapless_mdata);
-        }
-
-        switch(handle->route_format) {
-        case ROUTE_UNCOMPRESSED:
-            ALOGVV("ROUTE_UNCOMPRESSED");
-            renderType = PCM_2CH_OUT;
-            break;
-        case ROUTE_UNCOMPRESSED_MCH:
-            ALOGVV("ROUTE_UNCOMPRESSED_MCH");
-            renderType = PCM_MCH_OUT;
-            break;
-        case ROUTE_COMPRESSED:
-            ALOGVV("ROUTE_COMPRESSED");
-            renderType = COMPRESSED_OUT;
-            break;
-        case ROUTE_SW_TRANSCODED_COMPRESSED:
-            ALOGVV("ROUTE_SW_TRANSCODED_COMPRESSED");
-            renderType = TRANSCODE_OUT;
-            break;
-        case ROUTE_DSP_TRANSCODED_COMPRESSED:
-            ALOGVV("ROUTE_DSP_TRANSCODED_COMPRESSED");
-            continue;
-        default:
-            continue;
-        };
-
-        fragment_size = handle->compr_config.fragment_size;
-        /*TODO handle timestamp case */
-#if USE_SWDECODE
-        while(audio_bitstream_sufficient_sample_to_render(out->bitstrm,
-                                                renderType, 1) == true) {
-            availableSize = audio_bitstream_get_output_buffer_write_ptr(out->bitstrm, renderType) -
-                audio_bitstream_get_output_buffer_ptr(out->bitstrm, renderType);
-            buffer = audio_bitstream_get_output_buffer_ptr(out->bitstrm, renderType);
-            bytes_to_write   = availableSize;
-
-            TODO: meta data is only neded for TS mode
-            out->output_meta_data.metadataLength = metadataLength;
-            out->output_meta_data.bufferLength = (availableSize >=
-                                             (fragment_size - metadataLength)) ?
-                                           fragment_size - metadataLength :
-                                           availableSize;
-            bytes_to_write = metadataLength +out->output_meta_data.bufferLength;
-            out->output_meta_data.timestamp = 0;
-            memcpy(out->write_temp_buf, &out->output_meta_data, metadataLength);
-            memcpy(out->write_temp_buf+metadataLength,
-                   audio_bitstream_get_output_buffer_ptr(out->bitstrm, renderType),
-                   out->output_meta_data.bufferLength);
-            ret = write_data(out, handle, out->write_temp_buf, bytes_to_write);
-#endif
-
-            ret = write_data(out, handle, buffer, bytes_to_write);
-            ALOGD("write_data returned with %d", ret);
-            if(ret < 0) {
-                ALOGE("write_data returned ret < 0");
-                return ret;
-            } else {
-                if (!out->playback_started) {
-                    compress_start(handle->compr);
-                }
-                /*TODO:Do we need this
-                if(renderType == ROUTE_UNCOMPRESSED ||
-                   (renderType == ROUTE_UNCOMPRESSED_MCH && !out->open_dec_route)) {
-                    mFrameCount++;
-                renderedPcmBytes += out->output_meta_data.bufferLength;
-                }*/
-                renderedPcmBytes += ret;
-#if USE_SWDECODE
-                 /*iTODO: enable for MS11
-                audio_bitstream_copy_residue_output_start(out->bitstrm, renderType,
-                        bytes_to_write);
-                TODO:what if ret<bytes_to_write*/
-#endif
-            }
-#if USE_SWDECODE
-        }
-#endif
-    }
-    out->playback_started = 1;
-    out->offload_state = OFFLOAD_STATE_PLAYING;
-    out->send_new_metadata = 0;
-    return renderedPcmBytes;
-}
-
-size_t render_pcm_data(struct stream_out *out, const void *buffer, size_t bytes)
-{
-    ALOGV("%s", __func__);
-    size_t ret = 0;
-    struct listnode *node;
-    struct alsa_handle *handle;
-    list_for_each(node, &out->session_list) {
-        handle = node_to_item(node, struct alsa_handle, list);
-        ALOGV("%s handle is 0x%x", __func__,(uint32_t)handle);
-        ret = write_data(out, handle, buffer, bytes);
-    }
-    return ret;
-}
-
-static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
-                         size_t bytes)
-{
-    struct stream_out *out = (struct stream_out *)stream;
-    struct audio_device *adev = out->dev;
-    ssize_t ret = 0;
-    struct listnode *node;
-    bool continueDecode;
-    struct alsa_handle *handle;
-    size_t bytes_consumed;
-    size_t total_bytes_consumed = 0;
-
-    ALOGV("%s bytes =%d", __func__, bytes);
-
-    pthread_mutex_lock(&out->lock);
-
-//TODO: handle a2dp
-/*      if (mRouteAudioToA2dp &&
-                        mA2dpUseCase == AudioHardwareALSA::USECASE_NONE) {
-                a2dpRenderingControl(A2DP_RENDER_SETUP);
-        }
-*/
-   /* TODO: meta data comes in set_parameter it will be passed in compre_open
-      for all format exxce ms11 format
-     and  for ms11 it will be set sdecode fucntion while opneing ms11 instance
-     hence below piece of  code is no required*/
-   /*
-   if(!out->dec_conf_set && is_decoder_config_required(out)) {
-        if (setDecodeConfig(out, (char *)buffer, bytes))
-            ALOGD("decoder configuration set");
-    }
-    */
-
-    if (out->standby) {
-        out->standby = false;
-        list_for_each(node, &out->session_list) {
-            handle = node_to_item(node, struct alsa_handle, list);
-            pthread_mutex_lock(&adev->lock);
-            ret = start_output_stream(out, handle);
-            pthread_mutex_unlock(&adev->lock);
-            /* ToDo: If use case is compress offload should return 0 */
-            if (ret != 0) {
-                out->standby = true;
-                goto exit;
-            }
-        }
-    }
-
-    if (out->uc_strm_type == OFFLOAD_PLAYBACK_STREAM) {
-#if USE_SWDECODE
-        //TODO: Enable for MS11
-        copy_bitstream_internal_buffer(out->bitstrm, (char *)buffer, bytes);
-        //DO check if timestamp mode handle partial buffer
-        do {
-
-            bytes_consumed = 0;
-            ret = decode(out, (char *)buffer, bytes, &bytes_consumed, &continueDecode);
-            if(ret < 0)
-                goto exit;
-            /*TODO: check for return size from write when ms11 is removed*/
-            render_offload_data(out, continueDecode);
-            total_bytes_consumed += bytes_consumed;
-
-        } while(continueDecode == true);
-#endif
-#if 0
-        ALOGVV("%s: writing buffer (%d bytes) to compress device", __func__, bytes);
-        if (out->send_new_metadata) {
-            ALOGVV("send new gapless metadata");
-            compress_set_gapless_metadata(out->compr, &out->gapless_mdata);
-            out->send_new_metadata = 0;
-        }
-
-        ret = compress_write(out->compr, buffer, bytes);
-        ALOGVV("%s: writing buffer (%d bytes) to compress device returned %d", __func__, bytes, ret);
-        if (ret >= 0 && ret < (ssize_t)bytes) {
-            send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER);
-        }
-        if (!out->playback_started) {
-            compress_start(out->compr);
-            out->playback_started = 1;
-            out->offload_state = OFFLOAD_STATE_PLAYING;
-        }
-        pthread_mutex_unlock(&out->lock);
-        return ret;
-    } else {
-        if (out->pcm) {
-            if (out->muted)
-                memset((void *)buffer, 0, bytes);
-            ALOGVV("%s: writing buffer (%d bytes) to pcm device", __func__, bytes);
-            ret = pcm_write(out->pcm, (void *)buffer, bytes);
-            if (ret == 0)
-                out->written += bytes / (out->config.channels * sizeof(short));
-        }
-    }
-
-exit:
-    pthread_mutex_unlock(&out->lock);
-
-    if (ret != 0) {
-        if (out->pcm)
-            ALOGE("%s: error %d - %s", __func__, ret, pcm_get_error(out->pcm));
-        out_standby(&out->stream.common);
-        usleep(bytes * 1000000 / audio_stream_frame_size(&out->stream.common) /
-               out_get_sample_rate(&out->stream.common));
-    }
-    return bytes;
-#endif
-        ret = render_offload_data(out, buffer, bytes);
-        total_bytes_consumed = ret;
-    } else {
-        ret = render_pcm_data(out, buffer, bytes);
-        total_bytes_consumed = ret;
-    }
-
-exit:
-    pthread_mutex_unlock(&out->lock);
-    ALOGV("total_bytes_consumed %d",total_bytes_consumed);
-    return total_bytes_consumed;
-}
-
-static int out_get_render_position(const struct audio_stream_out *stream,
-                                   uint32_t *dsp_frames)
-{
-    struct listnode *node;
-    struct alsa_handle *handle;
-    struct stream_out *out = (struct stream_out *)stream;
-    struct audio_device *adev = out->dev;
-    *dsp_frames = 0;
-    ALOGV("%s", __func__);
-    pthread_mutex_lock(&out->lock);
-    if ((out->uc_strm_type == OFFLOAD_PLAYBACK_STREAM) && (dsp_frames != NULL)) {
-        list_for_each(node, &out->session_list) {
-            handle = node_to_item(node, struct alsa_handle, list);
-            if ((handle && handle->compr &&
-                        handle->route_format != ROUTE_DSP_TRANSCODED_COMPRESSED)){
-                compress_get_tstamp(handle->compr, (unsigned long *)dsp_frames,
-                        &out->sample_rate);
-                ALOGV("%s rendered frames %d sample_rate %d",
-                        __func__, *dsp_frames, out->sample_rate);
-            }
-            pthread_mutex_unlock(&out->lock);
-            return 0;
-        }
-    }
-    else {
-        pthread_mutex_unlock(&out->lock);
-        return -EINVAL;
-    }
-    return 0;
-#if 0
-    struct stream_out *out = (struct stream_out *)stream;
-    *dsp_frames = 0;
-    if ((out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) && (dsp_frames != NULL)) {
-        pthread_mutex_lock(&out->lock);
-        if (out->compr != NULL) {
-            compress_get_tstamp(out->compr, (unsigned long *)dsp_frames,
-                    &out->sample_rate);
-            ALOGVV("%s rendered frames %d sample_rate %d",
-                   __func__, *dsp_frames, out->sample_rate);
-        }
-        pthread_mutex_unlock(&out->lock);
-        return 0;
-    } else
-        return -EINVAL;
-#endif
-}
-
-static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
-{
-    return 0;
-}
-
-static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
-{
-    return 0;
-}
-
-static int out_get_next_write_timestamp(const struct audio_stream_out *stream,
-                                        int64_t *timestamp)
-{
-    return -EINVAL;
-}
-
-static int out_get_presentation_position(const struct audio_stream_out *stream,
-                                   uint64_t *frames, struct timespec *timestamp)
-{
-    struct listnode *node;
-    struct alsa_handle *handle;
-    struct stream_out *out = (struct stream_out *)stream;
-    struct audio_device *adev = out->dev;
-    *frames = 0;
-    ALOGV("%s", __func__);
-    pthread_mutex_lock(&out->lock);
-    if ((frames != NULL)) {
-        list_for_each(node, &out->session_list) {
-            handle = node_to_item(node, struct alsa_handle, list);
-            if ((handle && handle->compr &&
-                        handle->route_format != ROUTE_DSP_TRANSCODED_COMPRESSED)){
-                compress_get_tstamp(handle->compr, (unsigned long *)frames,
-                        &out->sample_rate);
-            clock_gettime(CLOCK_MONOTONIC, timestamp);
-                ALOGV("%s rendered frames %d sample_rate %d",
-                        __func__, *frames, out->sample_rate);
-            }
-        else if (handle->pcm) {
-            size_t avail;
-            if (pcm_get_htimestamp(handle->pcm, &avail, timestamp) == 0) {
-                size_t kernel_buffer_size = handle->config.period_size * handle->config.period_count;
-                int64_t signed_frames = out->written - kernel_buffer_size + avail;
-                // This adjustment accounts for buffering after app processor.
-                // It is based on estimated DSP latency per use case, rather than exact.
-                signed_frames -=
-                    (platform_render_latency(handle->usecase) * out->sample_rate / 1000000LL);
-
-                // It would be unusual for this value to be negative, but check just in case ...
-                if (signed_frames >= 0) {
-                    *frames = signed_frames;
-                }
-            }
-        }
-
-        }
-    }
-        pthread_mutex_unlock(&out->lock);
-        return -EINVAL;
-#if 0
-    struct stream_out *out = (struct stream_out *)stream;
-    int ret = -1;
-    unsigned long dsp_frames;
-
-    pthread_mutex_lock(&out->lock);
-
-    if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
-        if (out->compr != NULL) {
-            compress_get_tstamp(out->compr, &dsp_frames,
-                    &out->sample_rate);
-            ALOGVV("%s rendered frames %ld sample_rate %d",
-                   __func__, dsp_frames, out->sample_rate);
-            *frames = dsp_frames;
-            ret = 0;
-            /* this is the best we can do */
-            clock_gettime(CLOCK_MONOTONIC, timestamp);
-        }
-    } else {
-        if (out->pcm) {
-            size_t avail;
-            if (pcm_get_htimestamp(out->pcm, &avail, timestamp) == 0) {
-                size_t kernel_buffer_size = out->config.period_size * out->config.period_count;
-                int64_t signed_frames = out->written - kernel_buffer_size + avail;
-                // This adjustment accounts for buffering after app processor.
-                // It is based on estimated DSP latency per use case, rather than exact.
-                signed_frames -=
-                    (platform_render_latency(out->usecase) * out->sample_rate / 1000000LL);
-
-                // It would be unusual for this value to be negative, but check just in case ...
-                if (signed_frames >= 0) {
-                    *frames = signed_frames;
-                    ret = 0;
-                }
-            }
-        }
-    }
-
-    pthread_mutex_unlock(&out->lock);
-
-    return ret;
-#endif
-}
-
-static int out_set_callback(struct audio_stream_out *stream,
-            stream_callback_t callback, void *cookie)
-{
-    struct stream_out *out = (struct stream_out *)stream;
-
-    ALOGV("%s", __func__);
-    pthread_mutex_lock(&out->lock);
-    out->offload_callback = callback;
-    out->offload_cookie = cookie;
-    pthread_mutex_unlock(&out->lock);
-    return 0;
-}
-
-static int out_pause(struct audio_stream_out* stream)
-{
-    struct listnode *node;
-    struct alsa_handle *handle;
-    struct stream_out *out = (struct stream_out *)stream;
-    int status = -ENOSYS;
-    ALOGV("%s", __func__);
-    pthread_mutex_lock(&out->lock);
-    list_for_each(node, &out->session_list) {
-        handle = node_to_item(node, struct alsa_handle, list);
-        if (handle->compr != NULL && out->offload_state ==
-                OFFLOAD_STATE_PLAYING) {
-            status = compress_pause(handle->compr);
-            out->offload_state = OFFLOAD_STATE_PAUSED;
-        }
-    }
-    pthread_mutex_unlock(&out->lock);
-    return status;
-}
-
-static int out_resume(struct audio_stream_out* stream)
-{
-    struct listnode *node;
-    struct alsa_handle *handle;
-    struct stream_out *out = (struct stream_out *)stream;
-    int status = -ENOSYS;
-    ALOGV("%s", __func__);
-    pthread_mutex_lock(&out->lock);
-    list_for_each(node, &out->session_list) {
-        handle = node_to_item(node, struct alsa_handle, list);
-            status = 0;
-            if (handle->compr != NULL && out->offload_state ==
-                    OFFLOAD_STATE_PAUSED) {
-                status = compress_resume(handle->compr);
-                out->offload_state = OFFLOAD_STATE_PLAYING;
-            }
-    }
-    pthread_mutex_unlock(&out->lock);
-    return status;
-}
-
-static int out_drain(struct audio_stream_out* stream, audio_drain_type_t type )
-{
-    struct listnode *node;
-    struct alsa_handle *handle;
-    struct stream_out *out = (struct stream_out *)stream;
-    int status = -ENOSYS;
-    ALOGV("%s", __func__);
-    pthread_mutex_lock(&out->lock);
-    list_for_each(node, &out->session_list) {
-        handle = node_to_item(node, struct alsa_handle, list);
-        status = 0;
-        if (handle->compr != NULL) {
-            if (type == AUDIO_DRAIN_EARLY_NOTIFY)
-                status = send_offload_cmd_l(out, OFFLOAD_CMD_PARTIAL_DRAIN);
-            else
-                status = send_offload_cmd_l(out, OFFLOAD_CMD_DRAIN);
-        }
-    }
-    pthread_mutex_unlock(&out->lock);
-    return status;
-}
-
-static int out_flush(struct audio_stream_out* stream)
-{
-    struct listnode *node;
-    struct alsa_handle *handle;
-    struct stream_out *out = (struct stream_out *)stream;
-    int status = -ENOSYS;
-    ALOGV("%s", __func__);
-    pthread_mutex_lock(&out->lock);
-    list_for_each(node, &out->session_list) {
-        handle = node_to_item(node, struct alsa_handle, list);
-        status = 0;
-        if (handle->compr != NULL) {
-            stop_compressed_output_l(out);
-        }
-    }
-    pthread_mutex_unlock(&out->lock);
-    return status;
-}
-
-int adev_open_output_stream(struct audio_hw_device *dev,
-                                   audio_io_handle_t handle,
-                                   audio_devices_t devices,
-                                   audio_output_flags_t flags,
-                                   struct audio_config *config,
-                                   struct audio_stream_out **stream_out)
-{
-    struct audio_device *adev = (struct audio_device *)dev;
-    struct stream_out *out;
-    struct alsa_handle *device_handle = NULL;
-    int i, ret, channels;
-    struct listnode *item;
-
-    ALOGV("%s: enter: sample_rate(%d) channel_mask(%#x) devices(%#x) flags(%#x)",
-          __func__, config->sample_rate, config->channel_mask, devices, flags);
-    *stream_out = NULL;
-    out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
-
-    if (devices == AUDIO_DEVICE_NONE)
-        devices = AUDIO_DEVICE_OUT_SPEAKER;
-    list_init(&out->session_list);
-
-    reset_out_parameters(out);
-    out->flags = flags;
-    out->devices = devices;
-    out->dev = adev;
-    out->format = config->format;
-    out->sample_rate = config->sample_rate;
-    out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
-    out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO;
-    out->config = config;
-    out->handle = handle;
-
-//*TODO: get hdmi/spdif format/channels from routing manager and intialize out->spdif_format & out->hdmi_format*/
-    /* Init use case and pcm_config */
-    out->hdmi_format = UNCOMPRESSED;
-    out->spdif_format = UNCOMPRESSED;
-    out->stream.common.get_sample_rate = out_get_sample_rate;
-    out->stream.common.set_sample_rate = out_set_sample_rate;
-    out->stream.common.get_buffer_size = out_get_buffer_size;
-    out->stream.common.get_channels = out_get_channels;
-    out->stream.common.get_format = out_get_format;
-    out->stream.common.set_format = out_set_format;
-    out->stream.common.standby = out_standby;
-    out->stream.common.dump = out_dump;
-    out->stream.common.set_parameters = out_set_parameters;
-    out->stream.common.get_parameters = out_get_parameters;
-    out->stream.common.add_audio_effect = out_add_audio_effect;
-    out->stream.common.remove_audio_effect = out_remove_audio_effect;
-    out->stream.get_latency = out_get_latency;
-    out->stream.set_volume = out_set_volume;
-    out->stream.write = out_write;
-    out->stream.get_render_position = out_get_render_position;
-    out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
-    out->stream.get_presentation_position = out_get_presentation_position;
-
-    out->standby = 1;
-    /* out->muted = false; by calloc() */
-    /* out->written = 0; by calloc() */
-
-    pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL);
-    pthread_cond_init(&out->cond, (const pthread_condattr_t *) NULL);
-
-    if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
-        ALOGE("%s: Usecase is OFFLOAD", __func__);
-        if (config->offload_info.version != AUDIO_INFO_INITIALIZER.version ||
-            config->offload_info.size != AUDIO_INFO_INITIALIZER.size) {
-            ALOGE("%s: Unsupported Offload information", __func__);
-            ret = -EINVAL;
-            goto error_open;
-        }
-
-        if (!is_supported_format(config->offload_info.format)) {
-            ALOGE("%s: Unsupported audio format", __func__);
-            ret = -EINVAL;
-            goto error_open;
-        }
-        out->compr_config.codec = (struct snd_codec *)
-                calloc(1, sizeof(struct snd_codec));
-        //Session/clip config.
-        out->format = config->offload_info.format;
-        out->sample_rate = config->offload_info.sample_rate;
-        out->compr_config.codec->id =
-                get_snd_codec_id(config->offload_info.format);
-        out->compr_config.fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
-        out->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
-        out->compr_config.codec->sample_rate =
-                    compress_get_alsa_rate(config->offload_info.sample_rate);
-        out->compr_config.codec->bit_rate =
-                    config->offload_info.bit_rate;
-        out->compr_config.codec->ch_in =
-                    popcount(config->channel_mask);
-        out->compr_config.codec->ch_out = out->compr_config.codec->ch_in;
-
-        if (config->offload_info.channel_mask)
-            out->channel_mask = config->offload_info.channel_mask;
-        else if (config->channel_mask)
-            out->channel_mask = config->channel_mask;
-        out->uc_strm_type = OFFLOAD_PLAYBACK_STREAM;
-
-        //Initialize the handles
-        /* ------------------------------------------------------------------------
-        Update use decoder type and routing flags and corresponding states
-        decoderType will cache the decode types such as decode/passthrough/transcode
-        and in s/w or dsp. Besides, the states to open decode/passthrough/transcode
-        handles with the corresponding devices and device formats are updated
-           -------------------------------------------------------------------------*/
-        update_decode_type_and_routing_states(out);
-
-        /* ------------------------------------------------------------------------
-        Update rxHandle states
-        Based on the states, we open the driver and store the handle at appropriate
-        index
-        -------------------------------------------------------------------------*/
-        update_alsa_handle_state(out);
-
-        /* ------------------------------------------------------------------------
-        setup routing
-        -------------------------------------------------------------------------*/
-        ret = allocate_internal_buffers(out);
-        if(ret < 0) {
-            ALOGE("%s:Error %d",__func__, ret);
-            goto error_handle;
-        }
-
-        //Callbacks
-        out->stream.set_callback = out_set_callback;
-        out->stream.pause = out_pause;
-        out->stream.resume = out_resume;
-        out->stream.drain = out_drain;
-        out->stream.flush = out_flush;
-
-        if (flags & AUDIO_OUTPUT_FLAG_NON_BLOCKING)
-            out->non_blocking = 1;
-
-        out->send_new_metadata = 1;
-        create_offload_callback_thread(out);
-        ALOGV("%s: offloaded output offload_info version %04x bit rate %d",
-                __func__, config->offload_info.version,
-                config->offload_info.bit_rate);
-    } else { //if (out->flags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) {
-        ALOGE("%s: Usecase is DEEP_BUFFER", __func__);
-        if((device_handle = get_alsa_handle())== NULL)
-            goto error_handle;
-        list_add_tail(&out->session_list, &device_handle->list);
-        device_handle->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER;
-        device_handle->config = pcm_config_deep_buffer;
-        device_handle->out = out;
-        device_handle->cmd_pending = false;
-        out->sample_rate = device_handle->config.rate;
-        out->uc_strm_type = DEEP_BUFFER_PLAYBACK_STREAM;
-        out->buffer_size = device_handle->config.period_size *
-                            audio_stream_frame_size(&out->stream.common);
-    }/* else {
-        if((device_handle = get_alsa_handle())== NULL)
-            goto error_handle;
-        list_add_tail(&out->session_list, &device_handle->list);
-        device_handle->usecase = USECASE_AUDIO_PLAYBACK_LOW_LATENCY;
-        device_handle->config = pcm_config_low_latency;
-        device_handle->sample_rate = device_handle->config.rate;
-        device_handle->out = out;
-        device_handle->cmd_pending = false;
-        out->uc_strm_type  = LOW_LATENCY_PLAYBACK_STREAM;
-        out->buffer_size = device_handle->config.period_size *
-                            audio_stream_frame_size(&out->stream.common);
-    }*/
-
-    if (flags & AUDIO_OUTPUT_FLAG_PRIMARY) {
-        ALOGE("%s: Usecase is primary ", __func__);
-        if(adev->primary_output == NULL)
-            adev->primary_output = out;
-        else {
-            ALOGE("%s: Primary output is already opened", __func__);
-            ret = -EEXIST;
-            goto error_open;
-        }
-    }
-
-    /* Check if this usecase is already existing */
-    pthread_mutex_lock(&adev->lock);
-    if (out->uc_strm_type != OFFLOAD_PLAYBACK_STREAM) {
-        if (get_usecase_from_list(adev, device_handle->usecase) != NULL) {
-            ALOGE("%s: Usecase (%d) is already present", __func__,
-                        device_handle->usecase);
-            pthread_mutex_unlock(&adev->lock);
-            ret = -EEXIST;
-            goto error_open;
-        }
-    }
-    pthread_mutex_unlock(&adev->lock);
-
-
-    /* out->muted = false; by calloc() */
-
-
-    config->format = out->stream.common.get_format(&out->stream.common);
-    config->channel_mask = out->stream.common.get_channels(&out->stream.common);
-    config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common);
-
-    *stream_out = &out->stream;
-    ALOGV("%s: exit", __func__);
-    return 0;
-
-error_handle:
-    ret = -EINVAL;
-    ALOGE("%s: exit: error handle %d", __func__, ret);
-    while (!list_empty(&out->session_list)) {
-        item = list_head(&out->session_list);
-        list_remove(item);
-        device_handle  = node_to_item(item, struct alsa_handle, list);
-        platform_free_usecase(device_handle->usecase);
-        free_alsa_handle(device_handle);
-    }
-
-error_open:
-    free(out);
-    *stream_out = NULL;
-    ALOGD("%s: exit: ret %d", __func__, ret);
-    return ret;
-}
-
-void adev_close_output_stream(struct audio_hw_device *dev,
-                                     struct audio_stream_out *stream)
-{
-    struct stream_out *out = (struct stream_out *)stream;
-    struct audio_device *adev = out->dev;
-    struct listnode *item;
-    struct alsa_handle *handle;
-
-    ALOGV("%s", __func__);
-
-    out_standby(&stream->common);
-    if (out->uc_strm_type == OFFLOAD_PLAYBACK_STREAM) {
-        destroy_offload_callback_thread(out);
-
-        while (!list_empty(&out->session_list)) {
-            item = list_head(&out->session_list);
-            list_remove(item);
-            handle  = node_to_item(item, struct alsa_handle, list);
-                if(handle->compr_config.codec != NULL)
-                    free(handle->compr_config.codec);
-            platform_free_usecase(handle->usecase);
-            free_alsa_handle(handle);
-        }
-        free(out->compr_config.codec);
-    }
-
-    free_internal_buffers(out);
-    pthread_cond_destroy(&out->cond);
-    pthread_mutex_destroy(&out->lock);
-    free(stream);
-    ALOGV("%s: exit", __func__);
-}
diff --git a/hal_mpq/mpq8092/hw_info.c b/hal_mpq/mpq8092/hw_info.c
deleted file mode 100644
index 2a0231f..0000000
--- a/hal_mpq/mpq8092/hw_info.c
+++ /dev/null
@@ -1,325 +0,0 @@
-/*
- * Copyright (c) 2013, 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 "hardware_info"
-/*#define LOG_NDEBUG 0*/
-#define LOG_NDDEBUG 0
-
-#include <stdlib.h>
-#include <dlfcn.h>
-#include <cutils/log.h>
-#include <cutils/str_parms.h>
-#include "audio_hw.h"
-#include "platform.h"
-#include "platform_api.h"
-
-
-struct hardware_info {
-    char name[HW_INFO_ARRAY_MAX_SIZE];
-    char type[HW_INFO_ARRAY_MAX_SIZE];
-    /* variables for handling target variants */
-    uint32_t num_snd_devices;
-    char dev_extn[HW_INFO_ARRAY_MAX_SIZE];
-    snd_device_t  *snd_devices;
-};
-
-#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
-
-#define LITERAL_TO_STRING(x) #x
-#define CHECK(condition) LOG_ALWAYS_FATAL_IF(!(condition), "%s",\
-            __FILE__ ":" LITERAL_TO_STRING(__LINE__)\
-            " ASSERT_FATAL(" #condition ") failed.")
-
-static const snd_device_t tabla_cdp_variant_devices[] = {
-    SND_DEVICE_OUT_SPEAKER,
-    SND_DEVICE_OUT_HEADPHONES,
-    SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES,
-};
-
-static const snd_device_t taiko_fluid_variant_devices[] = {
-    SND_DEVICE_OUT_SPEAKER,
-    SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES,
-    SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET,
-};
-
-static const snd_device_t taiko_CDP_variant_devices[] = {
-    SND_DEVICE_OUT_SPEAKER,
-    SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES,
-    SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET,
-    SND_DEVICE_IN_QUAD_MIC,
-};
-
-static const snd_device_t taiko_liquid_variant_devices[] = {
-    SND_DEVICE_OUT_SPEAKER,
-    SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES,
-    SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET,
-    SND_DEVICE_IN_SPEAKER_MIC,
-    SND_DEVICE_IN_HEADSET_MIC,
-    SND_DEVICE_IN_VOICE_DMIC,
-    SND_DEVICE_IN_VOICE_SPEAKER_DMIC,
-    SND_DEVICE_IN_VOICE_REC_DMIC_STEREO,
-    SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE,
-    SND_DEVICE_IN_QUAD_MIC,
-    SND_DEVICE_IN_HANDSET_STEREO_DMIC,
-    SND_DEVICE_IN_SPEAKER_STEREO_DMIC,
-};
-
-static const snd_device_t taiko_DB_variant_devices[] = {
-    SND_DEVICE_OUT_SPEAKER,
-    SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES,
-    SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET,
-    SND_DEVICE_IN_SPEAKER_MIC,
-    SND_DEVICE_IN_HEADSET_MIC,
-    SND_DEVICE_IN_QUAD_MIC,
-};
-
-static const snd_device_t tapan_lite_variant_devices[] = {
-    SND_DEVICE_OUT_SPEAKER,
-    SND_DEVICE_OUT_HEADPHONES,
-    SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES,
-    SND_DEVICE_OUT_VOICE_HEADPHONES,
-    SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES,
-    SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES,
-};
-
-static const snd_device_t tapan_skuf_variant_devices[] = {
-    SND_DEVICE_OUT_SPEAKER,
-    SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES,
-    SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET,
-    /*SND_DEVICE_OUT_SPEAKER_AND_ANC_FB_HEADSET,*/
-};
-
-static const snd_device_t tapan_lite_skuf_variant_devices[] = {
-    SND_DEVICE_OUT_SPEAKER,
-    SND_DEVICE_OUT_HEADPHONES,
-    SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES,
-    SND_DEVICE_OUT_VOICE_HEADPHONES,
-    SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES,
-    SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES,
-};
-
-static const snd_device_t helicon_skuab_variant_devices[] = {
-    SND_DEVICE_OUT_SPEAKER,
-    SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES,
-    SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET,
-};
-
-static void  update_hardware_info_8092(struct hardware_info *hw_info, const char *snd_card_name)
-{
-    if (!strcmp(snd_card_name, "mpq8092-tabla-cdp-snd-card")) {
-        strlcpy(hw_info->type, "cdp", sizeof(hw_info->type));
-        strlcpy(hw_info->name, "mpq8092", sizeof(hw_info->name));
-        hw_info->snd_devices = NULL;
-        hw_info->num_snd_devices = 0;
-        strlcpy(hw_info->dev_extn, "", sizeof(hw_info->dev_extn));
-    } else {
-        ALOGW("%s: Not an 8084 device", __func__);
-    }
-}
-
-static void  update_hardware_info_8084(struct hardware_info *hw_info, const char *snd_card_name)
-{
-    if (!strcmp(snd_card_name, "apq8084-taiko-mtp-snd-card")) {
-        strlcpy(hw_info->type, "mtp", sizeof(hw_info->type));
-        strlcpy(hw_info->name, "apq8084", sizeof(hw_info->name));
-        hw_info->snd_devices = NULL;
-        hw_info->num_snd_devices = 0;
-        strlcpy(hw_info->dev_extn, "", sizeof(hw_info->dev_extn));
-    } else if (!strcmp(snd_card_name, "apq8084-taiko-cdp-snd-card")) {
-        strlcpy(hw_info->type, " cdp", sizeof(hw_info->type));
-        strlcpy(hw_info->name, "apq8084", sizeof(hw_info->name));
-        hw_info->snd_devices = (snd_device_t *)taiko_CDP_variant_devices;
-        hw_info->num_snd_devices = ARRAY_SIZE(taiko_CDP_variant_devices);
-        strlcpy(hw_info->dev_extn, "", sizeof(hw_info->dev_extn));
-    } else if (!strcmp(snd_card_name, "apq8084-taiko-liquid-snd-card")) {
-        strlcpy(hw_info->type , " liquid", sizeof(hw_info->type));
-        strlcpy(hw_info->name, "apq8084", sizeof(hw_info->type));
-        hw_info->snd_devices = (snd_device_t *)taiko_liquid_variant_devices;
-        hw_info->num_snd_devices = ARRAY_SIZE(taiko_liquid_variant_devices);
-        strlcpy(hw_info->dev_extn, "", sizeof(hw_info->dev_extn));
-    } else {
-        ALOGW("%s: Not an 8084 device", __func__);
-    }
-}
-
-static void  update_hardware_info_8974(struct hardware_info *hw_info, const char *snd_card_name)
-{
-    if (!strcmp(snd_card_name, "msm8974-taiko-mtp-snd-card")) {
-        strlcpy(hw_info->type, " mtp", sizeof(hw_info->type));
-        strlcpy(hw_info->name, "msm8974", sizeof(hw_info->name));
-        hw_info->snd_devices = NULL;
-        hw_info->num_snd_devices = 0;
-        strlcpy(hw_info->dev_extn, "", sizeof(hw_info->dev_extn));
-    } else if (!strcmp(snd_card_name, "msm8974-taiko-cdp-snd-card")) {
-        strlcpy(hw_info->type, " cdp", sizeof(hw_info->type));
-        strlcpy(hw_info->name, "msm8974", sizeof(hw_info->name));
-        hw_info->snd_devices = (snd_device_t *)taiko_CDP_variant_devices;
-        hw_info->num_snd_devices = ARRAY_SIZE(taiko_CDP_variant_devices);
-        strlcpy(hw_info->dev_extn, "-cdp", sizeof(hw_info->dev_extn));
-    } else if (!strcmp(snd_card_name, "msm8974-taiko-fluid-snd-card")) {
-        strlcpy(hw_info->type, " fluid", sizeof(hw_info->type));
-        strlcpy(hw_info->name, "msm8974", sizeof(hw_info->name));
-        hw_info->snd_devices = (snd_device_t *) taiko_fluid_variant_devices;
-        hw_info->num_snd_devices = ARRAY_SIZE(taiko_fluid_variant_devices);
-        strlcpy(hw_info->dev_extn, "-fluid", sizeof(hw_info->dev_extn));
-    } else if (!strcmp(snd_card_name, "msm8974-taiko-liquid-snd-card")) {
-        strlcpy(hw_info->type, " liquid", sizeof(hw_info->type));
-        strlcpy(hw_info->name, "msm8974", sizeof(hw_info->name));
-        hw_info->snd_devices = (snd_device_t *)taiko_liquid_variant_devices;
-        hw_info->num_snd_devices = ARRAY_SIZE(taiko_liquid_variant_devices);
-        strlcpy(hw_info->dev_extn, "-liquid", sizeof(hw_info->dev_extn));
-    } else if (!strcmp(snd_card_name, "apq8074-taiko-db-snd-card")) {
-        strlcpy(hw_info->type, " dragon-board", sizeof(hw_info->type));
-        strlcpy(hw_info->name, "msm8974", sizeof(hw_info->name));
-        hw_info->snd_devices = (snd_device_t *)taiko_DB_variant_devices;
-        hw_info->num_snd_devices = ARRAY_SIZE(taiko_DB_variant_devices);
-        strlcpy(hw_info->dev_extn, "-DB", sizeof(hw_info->dev_extn));
-    } else {
-        ALOGW("%s: Not an 8974 device", __func__);
-    }
-}
-
-static void update_hardware_info_8610(struct hardware_info *hw_info, const char *snd_card_name)
-{
-    if (!strcmp(snd_card_name, "msm8x10-snd-card")) {
-        strlcpy(hw_info->type, "", sizeof(hw_info->type));
-        strlcpy(hw_info->name, "msm8x10", sizeof(hw_info->name));
-        hw_info->snd_devices = NULL;
-        hw_info->num_snd_devices = 0;
-        strlcpy(hw_info->dev_extn, "", sizeof(hw_info->dev_extn));
-    } else if (!strcmp(snd_card_name, "msm8x10-skuab-snd-card")) {
-        strlcpy(hw_info->type, "skuab", sizeof(hw_info->type));
-        strlcpy(hw_info->name, "msm8x10", sizeof(hw_info->name));
-        hw_info->snd_devices = (snd_device_t *)helicon_skuab_variant_devices;
-        hw_info->num_snd_devices = ARRAY_SIZE(helicon_skuab_variant_devices);
-        strlcpy(hw_info->dev_extn, "-skuab", sizeof(hw_info->dev_extn));
-    } else if (!strcmp(snd_card_name, "msm8x10-skuaa-snd-card")) {
-        strlcpy(hw_info->type, " skuaa", sizeof(hw_info->type));
-        strlcpy(hw_info->name, "msm8x10", sizeof(hw_info->name));
-        hw_info->snd_devices = NULL;
-        hw_info->num_snd_devices = 0;
-        strlcpy(hw_info->dev_extn, "", sizeof(hw_info->dev_extn));
-    } else {
-        ALOGW("%s: Not an  8x10 device", __func__);
-    }
-}
-
-static void update_hardware_info_8226(struct hardware_info *hw_info, const char *snd_card_name)
-{
-    if (!strcmp(snd_card_name, "msm8226-tapan-snd-card")) {
-        strlcpy(hw_info->type, "", sizeof(hw_info->type));
-        strlcpy(hw_info->name, "msm8226", sizeof(hw_info->name));
-        hw_info->snd_devices = NULL;
-        hw_info->num_snd_devices = 0;
-        strlcpy(hw_info->dev_extn, "", sizeof(hw_info->dev_extn));
-    } else if (!strcmp(snd_card_name, "msm8226-tapan9302-snd-card")) {
-        strlcpy(hw_info->type, "tapan_lite", sizeof(hw_info->type));
-        strlcpy(hw_info->name, "msm8226", sizeof(hw_info->name));
-        hw_info->snd_devices = (snd_device_t *)tapan_lite_variant_devices;
-        hw_info->num_snd_devices = ARRAY_SIZE(tapan_lite_variant_devices);
-        strlcpy(hw_info->dev_extn, "-lite", sizeof(hw_info->dev_extn));
-    } else if (!strcmp(snd_card_name, "msm8226-tapan-skuf-snd-card")) {
-        strlcpy(hw_info->type, " skuf", sizeof(hw_info->type));
-        strlcpy(hw_info->name, "msm8226", sizeof(hw_info->name));
-        hw_info->snd_devices = (snd_device_t *) tapan_skuf_variant_devices;
-        hw_info->num_snd_devices = ARRAY_SIZE(tapan_skuf_variant_devices);
-        strlcpy(hw_info->dev_extn, "-skuf", sizeof(hw_info->dev_extn));
-    } else if (!strcmp(snd_card_name, "msm8226-tapan9302-skuf-snd-card")) {
-        strlcpy(hw_info->type, " tapan9302-skuf", sizeof(hw_info->type));
-        strlcpy(hw_info->name, "msm8226", sizeof(hw_info->name));
-        hw_info->snd_devices = (snd_device_t *)tapan_lite_skuf_variant_devices;
-        hw_info->num_snd_devices = ARRAY_SIZE(tapan_lite_skuf_variant_devices);
-        strlcpy(hw_info->dev_extn, "-skuf-lite", sizeof(hw_info->dev_extn));
-    } else {
-        ALOGW("%s: Not an  8x26 device", __func__);
-    }
-}
-
-void *hw_info_init(const char *snd_card_name)
-{
-    struct hardware_info *hw_info;
-
-    hw_info = malloc(sizeof(struct hardware_info));
-
-    if(strstr(snd_card_name, "mpq8092") ||
-              strstr(snd_card_name, "mpq8092")) {
-        ALOGV("8092 - variant soundcard");
-        update_hardware_info_8092(hw_info, snd_card_name);
-    } else if(strstr(snd_card_name, "msm8974") ||
-              strstr(snd_card_name, "apq8074")) {
-        ALOGV("8974 - variant soundcard");
-        update_hardware_info_8974(hw_info, snd_card_name);
-    } else if(strstr(snd_card_name, "msm8226")) {
-        ALOGV("8x26 - variant soundcard");
-        update_hardware_info_8226(hw_info, snd_card_name);
-    } else if(strstr(snd_card_name, "msm8x10")) {
-        ALOGV("8x10 - variant soundcard");
-        update_hardware_info_8610(hw_info, snd_card_name);
-    } else if(strstr(snd_card_name, "apq8084")) {
-        ALOGV("8084 - variant soundcard");
-        update_hardware_info_8084(hw_info, snd_card_name);
-    } else {
-        ALOGE("%s: Unsupported target %s:",__func__, snd_card_name);
-        free(hw_info);
-        hw_info = NULL;
-    }
-
-    return hw_info;
-}
-
-void hw_info_deinit(void *hw_info)
-{
-    struct hardware_info *my_data = (struct hardware_info*) hw_info;
-
-    if(!my_data)
-        free(my_data);
-}
-
-void hw_info_append_hw_type(void *hw_info, snd_device_t snd_device,
-                            char *device_name)
-{
-    struct hardware_info *my_data = (struct hardware_info*) hw_info;
-    uint32_t i = 0;
-
-    snd_device_t *snd_devices =
-            (snd_device_t *) my_data->snd_devices;
-
-    if(snd_devices != NULL) {
-        for (i = 0; i <  my_data->num_snd_devices; i++) {
-            if (snd_device == (snd_device_t)snd_devices[i]) {
-                ALOGV("extract dev_extn device %d, extn = %s",
-                        (snd_device_t)snd_devices[i],  my_data->dev_extn);
-                CHECK(strlcat(device_name,  my_data->dev_extn,
-                        DEVICE_NAME_MAX_SIZE) < DEVICE_NAME_MAX_SIZE);
-                break;
-            }
-        }
-    }
-    ALOGD("%s : device_name = %s", __func__,device_name);
-}
diff --git a/hal_mpq/mpq8092/platform.c b/hal_mpq/mpq8092/platform.c
deleted file mode 100644
index 6c50034..0000000
--- a/hal_mpq/mpq8092/platform.c
+++ /dev/null
@@ -1,1325 +0,0 @@
-/*
- * Copyright (c) 2013, The Linux Foundation. All rights reserved.
- * Not a Contribution.
- *
- * Copyright (C) 2013 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 "msm8974_platform"
-/*#define LOG_NDEBUG 0*/
-#define LOG_NDDEBUG 0
-
-#include <stdlib.h>
-#include <dlfcn.h>
-#include <cutils/log.h>
-#include <cutils/properties.h>
-#include <cutils/str_parms.h>
-#include <audio_hw.h>
-#include <platform_api.h>
-#include "platform.h"
-
-#define MIXER_XML_PATH "/system/etc/mixer_paths.xml"
-#define MIXER_XML_PATH_AUXPCM "/system/etc/mixer_paths_auxpcm.xml"
-#define LIB_ACDB_LOADER "libacdbloader.so"
-#define AUDIO_DATA_BLOCK_MIXER_CTL "HDMI EDID"
-
-/*
- * This file will have a maximum of 38 bytes:
- *
- * 4 bytes: number of audio blocks
- * 4 bytes: total length of Short Audio Descriptor (SAD) blocks
- * Maximum 10 * 3 bytes: SAD blocks
- */
-#define MAX_SAD_BLOCKS      10
-#define SAD_BLOCK_SIZE      3
-
-/* EDID format ID for LPCM audio */
-#define EDID_FORMAT_LPCM    1
-
-/* Retry for delay in FW loading*/
-#define RETRY_NUMBER 10
-#define RETRY_US 500000
-
-#define SAMPLE_RATE_8KHZ  8000
-#define SAMPLE_RATE_16KHZ 16000
-
-#define AUDIO_PARAMETER_KEY_FLUENCE_TYPE  "fluence"
-#define AUDIO_PARAMETER_KEY_BTSCO         "bt_samplerate"
-#define AUDIO_PARAMETER_KEY_SLOWTALK      "st_enable"
-
-struct audio_block_header
-{
-    int reserved;
-    int length;
-};
-
-/* Audio calibration related functions */
-typedef void (*acdb_deallocate_t)();
-typedef int  (*acdb_init_t)();
-typedef void (*acdb_send_audio_cal_t)(int, int);
-typedef void (*acdb_send_voice_cal_t)(int, int);
-
-struct platform_data {
-    struct audio_device *adev;
-    bool fluence_in_spkr_mode;
-    bool fluence_in_voice_call;
-    bool fluence_in_voice_rec;
-    bool fluence_in_audio_rec;
-    int  fluence_type;
-    int  btsco_sample_rate;
-    bool slowtalk;
-    /* Audio calibration related functions */
-    void *acdb_handle;
-    acdb_init_t acdb_init;
-    acdb_deallocate_t acdb_deallocate;
-    acdb_send_audio_cal_t acdb_send_audio_cal;
-    acdb_send_voice_cal_t acdb_send_voice_cal;
-
-    void *hw_info;
-    struct csd_data *csd;
-};
-
-static int pcm_device_table[AUDIO_USECASE_MAX][4] = {
-    [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = {USECASE_AUDIO_PLAYBACK_DEEP_BUFFER,
-                                            DEEP_BUFFER_PCM_DEVICE,
-                                            DEEP_BUFFER_PCM_DEVICE, 0},
-    [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = {USECASE_AUDIO_PLAYBACK_LOW_LATENCY,
-                                           LOWLATENCY_PCM_DEVICE,
-                                           LOWLATENCY_PCM_DEVICE, 0},
-    [USECASE_AUDIO_PLAYBACK_MULTI_CH] = {USECASE_AUDIO_PLAYBACK_MULTI_CH,
-                                        MULTIMEDIA2_PCM_DEVICE,
-                                        MULTIMEDIA2_PCM_DEVICE, 0},
-    [USECASE_AUDIO_PLAYBACK_MULTI_CH] =    {USECASE_AUDIO_PLAYBACK_MULTI_CH,
-                                            MULTI_CHANNEL_PCM_DEVICE,
-                                            MULTI_CHANNEL_PCM_DEVICE, 0},
-    [USECASE_AUDIO_PLAYBACK_OFFLOAD] =
-                     {USECASE_AUDIO_PLAYBACK_OFFLOAD, PLAYBACK_OFFLOAD_DEVICE1,
-                     PLAYBACK_OFFLOAD_DEVICE1, 0},
-    [USECASE_AUDIO_PLAYBACK_OFFLOAD1] =    {USECASE_AUDIO_PLAYBACK_OFFLOAD,
-                                            PLAYBACK_OFFLOAD_DEVICE2,
-                                            PLAYBACK_OFFLOAD_DEVICE2, 0},
-    [USECASE_AUDIO_PLAYBACK_OFFLOAD2] =    {USECASE_AUDIO_PLAYBACK_OFFLOAD,
-                                            PLAYBACK_OFFLOAD_DEVICE3,
-                                            PLAYBACK_OFFLOAD_DEVICE3, 0},
-    [USECASE_AUDIO_PLAYBACK_OFFLOAD3] =    {USECASE_AUDIO_PLAYBACK_OFFLOAD,
-                                            PLAYBACK_OFFLOAD_DEVICE4,
-                                            PLAYBACK_OFFLOAD_DEVICE4, 0},
-    [USECASE_AUDIO_RECORD] = {USECASE_AUDIO_RECORD, AUDIO_RECORD_PCM_DEVICE,
-                             AUDIO_RECORD_PCM_DEVICE, 0},
-    [USECASE_AUDIO_RECORD_COMPRESS] = {USECASE_AUDIO_RECORD_COMPRESS, COMPRESS_CAPTURE_DEVICE,
-                                       COMPRESS_CAPTURE_DEVICE, 0},
-    [USECASE_AUDIO_RECORD_LOW_LATENCY] = {USECASE_AUDIO_RECORD_LOW_LATENCY,
-                                          LOWLATENCY_PCM_DEVICE,
-                                          LOWLATENCY_PCM_DEVICE, 0},
-   /* [USECASE_AUDIO_RECORD_FM_VIRTUAL] = {,
-                                  MULTIMEDIA2_PCM_DEVICE},
-    [USECASE_AUDIO_PLAYBACK_FM] = {FM_PLAYBACK_PCM_DEVICE, FM_CAPTURE_PCM_DEVICE},
-    [USECASE_VOICE_CALL] = {VOICE_CALL_PCM_DEVICE, VOICE_CALL_PCM_DEVICE},
-    [USECASE_VOICE2_CALL] = {VOICE2_CALL_PCM_DEVICE, VOICE2_CALL_PCM_DEVICE},
-    [USECASE_VOLTE_CALL] = {VOLTE_CALL_PCM_DEVICE, VOLTE_CALL_PCM_DEVICE},
-    [USECASE_QCHAT_CALL] = {QCHAT_CALL_PCM_DEVICE, QCHAT_CALL_PCM_DEVICE},
-    [USECASE_COMPRESS_VOIP_CALL] = {COMPRESS_VOIP_CALL_PCM_DEVICE, COMPRESS_VOIP_CALL_PCM_DEVICE},
-    [USECASE_INCALL_REC_UPLINK] = {AUDIO_RECORD_PCM_DEVICE,
-                                   AUDIO_RECORD_PCM_DEVICE},
-    [USECASE_INCALL_REC_DOWNLINK] = {AUDIO_RECORD_PCM_DEVICE,
-                                     AUDIO_RECORD_PCM_DEVICE},
-    [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK] = {AUDIO_RECORD_PCM_DEVICE,
-                                                AUDIO_RECORD_PCM_DEVICE},
-    [USECASE_INCALL_MUSIC_UPLINK] = {INCALL_MUSIC_UPLINK_PCM_DEVICE,
-                                     INCALL_MUSIC_UPLINK_PCM_DEVICE},
-    [USECASE_INCALL_MUSIC_UPLINK2] = {INCALL_MUSIC_UPLINK2_PCM_DEVICE,
-                                      INCALL_MUSIC_UPLINK2_PCM_DEVICE},
-    [USECASE_AUDIO_SPKR_CALIB_RX] = {SPKR_PROT_CALIB_RX_PCM_DEVICE, -1},
-    [USECASE_AUDIO_SPKR_CALIB_TX] = {-1, SPKR_PROT_CALIB_TX_PCM_DEVICE},
-*/
-};
-
-/* Array to store sound devices */
-static const char * const device_table[SND_DEVICE_MAX] = {
-    [SND_DEVICE_NONE] = "none",
-    /* Playback sound devices */
-    [SND_DEVICE_OUT_HANDSET] = "handset",
-    [SND_DEVICE_OUT_SPEAKER] = "speaker",
-    [SND_DEVICE_OUT_SPEAKER_REVERSE] = "speaker-reverse",
-    [SND_DEVICE_OUT_HEADPHONES] = "headphones",
-    [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = "speaker-and-headphones",
-    [SND_DEVICE_OUT_VOICE_HANDSET] = "voice-handset",
-    [SND_DEVICE_OUT_VOICE_SPEAKER] = "voice-speaker",
-    [SND_DEVICE_OUT_VOICE_HEADPHONES] = "voice-headphones",
-    [SND_DEVICE_OUT_HDMI] = "hdmi",
-    [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_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",
-    [SND_DEVICE_OUT_AFE_PROXY] = "afe-proxy",
-    [SND_DEVICE_OUT_USB_HEADSET] = "usb-headphones",
-    [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = "speaker-and-usb-headphones",
-    [SND_DEVICE_OUT_TRANSMISSION_FM] = "transmission-fm",
-    [SND_DEVICE_OUT_ANC_HEADSET] = "anc-headphones",
-    [SND_DEVICE_OUT_ANC_FB_HEADSET] = "anc-fb-headphones",
-    [SND_DEVICE_OUT_VOICE_ANC_HEADSET] = "voice-anc-headphones",
-    [SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET] = "voice-anc-fb-headphones",
-    [SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET] = "speaker-and-anc-headphones",
-    [SND_DEVICE_OUT_ANC_HANDSET] = "anc-handset",
-    [SND_DEVICE_OUT_SPEAKER_PROTECTED] = "speaker-protected",
-    [SND_DEVICE_OUT_SPDIF] = "spdif",
-
-    /* Capture sound devices */
-    [SND_DEVICE_IN_HANDSET_MIC] = "handset-mic",
-    [SND_DEVICE_IN_HANDSET_MIC_AEC] = "handset-mic",
-    [SND_DEVICE_IN_HANDSET_MIC_NS] = "handset-mic",
-    [SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = "handset-mic",
-    [SND_DEVICE_IN_HANDSET_DMIC] = "dmic-endfire",
-    [SND_DEVICE_IN_HANDSET_DMIC_AEC] = "dmic-endfire",
-    [SND_DEVICE_IN_HANDSET_DMIC_NS] = "dmic-endfire",
-    [SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = "dmic-endfire",
-    [SND_DEVICE_IN_SPEAKER_MIC] = "speaker-mic",
-    [SND_DEVICE_IN_SPEAKER_MIC_AEC] = "speaker-mic",
-    [SND_DEVICE_IN_SPEAKER_MIC_NS] = "speaker-mic",
-    [SND_DEVICE_IN_SPEAKER_MIC_AEC_NS] = "speaker-mic",
-    [SND_DEVICE_IN_SPEAKER_DMIC] = "speaker-dmic-endfire",
-    [SND_DEVICE_IN_SPEAKER_DMIC_AEC] = "speaker-dmic-endfire",
-    [SND_DEVICE_IN_SPEAKER_DMIC_NS] = "speaker-dmic-endfire",
-    [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = "speaker-dmic-endfire",
-    [SND_DEVICE_IN_HEADSET_MIC] = "headset-mic",
-    [SND_DEVICE_IN_HEADSET_MIC_FLUENCE] = "headset-mic",
-    [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = "voice-speaker-mic",
-    [SND_DEVICE_IN_VOICE_HEADSET_MIC] = "voice-headset-mic",
-    [SND_DEVICE_IN_HDMI_MIC] = "hdmi-mic",
-    [SND_DEVICE_IN_BT_SCO_MIC] = "bt-sco-mic",
-    [SND_DEVICE_IN_BT_SCO_MIC_WB] = "bt-sco-mic-wb",
-    [SND_DEVICE_IN_CAMCORDER_MIC] = "camcorder-mic",
-    [SND_DEVICE_IN_VOICE_DMIC] = "voice-dmic-ef",
-    [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = "voice-speaker-dmic-ef",
-    [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = "voice-tty-full-headset-mic",
-    [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = "voice-tty-vco-handset-mic",
-    [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = "voice-tty-hco-headset-mic",
-    [SND_DEVICE_IN_VOICE_REC_MIC] = "voice-rec-mic",
-    [SND_DEVICE_IN_VOICE_REC_MIC_NS] = "voice-rec-mic",
-    [SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = "voice-rec-dmic-ef",
-    [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = "voice-rec-dmic-ef-fluence",
-    [SND_DEVICE_IN_USB_HEADSET_MIC] = "usb-headset-mic",
-    [SND_DEVICE_IN_CAPTURE_FM] = "capture-fm",
-    [SND_DEVICE_IN_AANC_HANDSET_MIC] = "aanc-handset-mic",
-    [SND_DEVICE_IN_QUAD_MIC] = "quad-mic",
-    [SND_DEVICE_IN_HANDSET_STEREO_DMIC] = "handset-stereo-dmic-ef",
-    [SND_DEVICE_IN_SPEAKER_STEREO_DMIC] = "speaker-stereo-dmic-ef",
-    [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = "vi-feedback",
-};
-
-/* ACDB IDs (audio DSP path configuration IDs) for each sound device */
-static const int acdb_device_table[SND_DEVICE_MAX] = {
-    [SND_DEVICE_NONE] = -1,
-    [SND_DEVICE_OUT_HANDSET] = 7,
-    [SND_DEVICE_OUT_SPEAKER] = 14,
-    [SND_DEVICE_OUT_SPEAKER_REVERSE] = 14,
-    [SND_DEVICE_OUT_HEADPHONES] = 10,
-    [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = 10,
-    [SND_DEVICE_OUT_VOICE_HANDSET] = 7,
-    [SND_DEVICE_OUT_VOICE_SPEAKER] = 14,
-    [SND_DEVICE_OUT_VOICE_HEADPHONES] = 10,
-    [SND_DEVICE_OUT_HDMI] = 18,
-    [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = 14,
-    [SND_DEVICE_OUT_BT_SCO] = 22,
-    [SND_DEVICE_OUT_BT_SCO_WB] = 39,
-    [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = 17,
-    [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = 17,
-    [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = 37,
-    [SND_DEVICE_OUT_AFE_PROXY] = 0,
-    [SND_DEVICE_OUT_USB_HEADSET] = 0,
-    [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = 14,
-    [SND_DEVICE_OUT_TRANSMISSION_FM] = 0,
-    [SND_DEVICE_OUT_ANC_HEADSET] = 26,
-    [SND_DEVICE_OUT_ANC_FB_HEADSET] = 27,
-    [SND_DEVICE_OUT_VOICE_ANC_HEADSET] = 26,
-    [SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET] = 27,
-    [SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET] = 26,
-    [SND_DEVICE_OUT_ANC_HANDSET] = 103,
-    [SND_DEVICE_OUT_SPEAKER_PROTECTED] = 101,
-    [SND_DEVICE_OUT_SPDIF] = 18,
-
-    [SND_DEVICE_IN_HANDSET_MIC] = 4,
-    [SND_DEVICE_IN_HANDSET_MIC_AEC] = 106,
-    [SND_DEVICE_IN_HANDSET_MIC_NS] = 107,
-    [SND_DEVICE_IN_HANDSET_MIC_AEC_NS] = 108,
-    [SND_DEVICE_IN_HANDSET_DMIC] = 41,
-    [SND_DEVICE_IN_HANDSET_DMIC_AEC] = 109,
-    [SND_DEVICE_IN_HANDSET_DMIC_NS] = 110,
-    [SND_DEVICE_IN_HANDSET_DMIC_AEC_NS] = 111,
-    [SND_DEVICE_IN_SPEAKER_MIC] = 11,
-    [SND_DEVICE_IN_SPEAKER_MIC_AEC] = 112,
-    [SND_DEVICE_IN_SPEAKER_MIC_NS] = 113,
-    [SND_DEVICE_IN_SPEAKER_MIC_AEC_NS] = 114,
-    [SND_DEVICE_IN_SPEAKER_DMIC] = 43,
-    [SND_DEVICE_IN_SPEAKER_DMIC_AEC] = 115,
-    [SND_DEVICE_IN_SPEAKER_DMIC_NS] = 116,
-    [SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS] = 117,
-    [SND_DEVICE_IN_HEADSET_MIC] = 8,
-    [SND_DEVICE_IN_HEADSET_MIC_FLUENCE] = 47,
-    [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = 11,
-    [SND_DEVICE_IN_VOICE_HEADSET_MIC] = 8,
-    [SND_DEVICE_IN_HDMI_MIC] = 4,
-    [SND_DEVICE_IN_BT_SCO_MIC] = 21,
-    [SND_DEVICE_IN_BT_SCO_MIC_WB] = 38,
-    [SND_DEVICE_IN_CAMCORDER_MIC] = 4,
-    [SND_DEVICE_IN_VOICE_DMIC] = 41,
-    [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = 43,
-    [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = 16,
-    [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = 36,
-    [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = 16,
-    [SND_DEVICE_IN_VOICE_REC_MIC] = 4,
-    [SND_DEVICE_IN_VOICE_REC_MIC_NS] = 107,
-    [SND_DEVICE_IN_VOICE_REC_DMIC_STEREO] = 34,
-    [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = 41,
-    [SND_DEVICE_IN_USB_HEADSET_MIC] = 44,
-    [SND_DEVICE_IN_CAPTURE_FM] = 0,
-    [SND_DEVICE_IN_AANC_HANDSET_MIC] = 104,
-    [SND_DEVICE_IN_QUAD_MIC] = 46,
-    [SND_DEVICE_IN_HANDSET_STEREO_DMIC] = 34,
-    [SND_DEVICE_IN_SPEAKER_STEREO_DMIC] = 35,
-    [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = 102,
-};
-
-#define DEEP_BUFFER_PLATFORM_DELAY (29*1000LL)
-#define LOW_LATENCY_PLATFORM_DELAY (13*1000LL)
-
-static int set_echo_reference(struct mixer *mixer, const char* ec_ref)
-{
-    struct mixer_ctl *ctl;
-    const char *mixer_ctl_name = "EC_REF_RX";
-
-    ctl = mixer_get_ctl_by_name(mixer, mixer_ctl_name);
-    if (!ctl) {
-        ALOGE("%s: Could not get ctl for mixer cmd - %s",
-              __func__, mixer_ctl_name);
-        return -EINVAL;
-    }
-    ALOGV("Setting EC Reference: %s", ec_ref);
-    mixer_ctl_set_enum_by_string(ctl, ec_ref);
-    return 0;
-}
-
-static struct csd_data *open_csd_client()
-{
-    struct csd_data *csd = calloc(1, sizeof(struct csd_data));
-
-    csd->csd_client = dlopen(LIB_CSD_CLIENT, RTLD_NOW);
-    if (csd->csd_client == NULL) {
-        ALOGE("%s: DLOPEN failed for %s", __func__, LIB_CSD_CLIENT);
-        goto error;
-    } else {
-        ALOGV("%s: DLOPEN successful for %s", __func__, LIB_CSD_CLIENT);
-
-        csd->deinit = (deinit_t)dlsym(csd->csd_client,
-                                             "csd_client_deinit");
-        if (csd->deinit == NULL) {
-            ALOGE("%s: dlsym error %s for csd_client_deinit", __func__,
-                  dlerror());
-            goto error;
-        }
-        csd->disable_device = (disable_device_t)dlsym(csd->csd_client,
-                                             "csd_client_disable_device");
-        if (csd->disable_device == NULL) {
-            ALOGE("%s: dlsym error %s for csd_client_disable_device",
-                  __func__, dlerror());
-            goto error;
-        }
-        csd->enable_device = (enable_device_t)dlsym(csd->csd_client,
-                                             "csd_client_enable_device");
-        if (csd->enable_device == NULL) {
-            ALOGE("%s: dlsym error %s for csd_client_enable_device",
-                  __func__, dlerror());
-            goto error;
-        }
-        csd->start_voice = (start_voice_t)dlsym(csd->csd_client,
-                                             "csd_client_start_voice");
-        if (csd->start_voice == NULL) {
-            ALOGE("%s: dlsym error %s for csd_client_start_voice",
-                  __func__, dlerror());
-            goto error;
-        }
-        csd->stop_voice = (stop_voice_t)dlsym(csd->csd_client,
-                                             "csd_client_stop_voice");
-        if (csd->stop_voice == NULL) {
-            ALOGE("%s: dlsym error %s for csd_client_stop_voice",
-                  __func__, dlerror());
-            goto error;
-        }
-        csd->volume = (volume_t)dlsym(csd->csd_client,
-                                             "csd_client_volume");
-        if (csd->volume == NULL) {
-            ALOGE("%s: dlsym error %s for csd_client_volume",
-                  __func__, dlerror());
-            goto error;
-        }
-        csd->mic_mute = (mic_mute_t)dlsym(csd->csd_client,
-                                             "csd_client_mic_mute");
-        if (csd->mic_mute == NULL) {
-            ALOGE("%s: dlsym error %s for csd_client_mic_mute",
-                  __func__, dlerror());
-            goto error;
-        }
-        csd->slow_talk = (slow_talk_t)dlsym(csd->csd_client,
-                                             "csd_client_slow_talk");
-        if (csd->slow_talk == NULL) {
-            ALOGE("%s: dlsym error %s for csd_client_slow_talk",
-                  __func__, dlerror());
-            goto error;
-        }
-        csd->start_playback = (start_playback_t)dlsym(csd->csd_client,
-                                             "csd_client_start_playback");
-        if (csd->start_playback == NULL) {
-            ALOGE("%s: dlsym error %s for csd_client_start_playback",
-                  __func__, dlerror());
-            goto error;
-        }
-        csd->stop_playback = (stop_playback_t)dlsym(csd->csd_client,
-                                             "csd_client_stop_playback");
-        if (csd->stop_playback == NULL) {
-            ALOGE("%s: dlsym error %s for csd_client_stop_playback",
-                  __func__, dlerror());
-            goto error;
-        }
-        csd->start_record = (start_record_t)dlsym(csd->csd_client,
-                                             "csd_client_start_record");
-        if (csd->start_record == NULL) {
-            ALOGE("%s: dlsym error %s for csd_client_start_record",
-                  __func__, dlerror());
-            goto error;
-        }
-        csd->stop_record = (stop_record_t)dlsym(csd->csd_client,
-                                             "csd_client_stop_record");
-        if (csd->stop_record == NULL) {
-            ALOGE("%s: dlsym error %s for csd_client_stop_record",
-                  __func__, dlerror());
-            goto error;
-        }
-        csd->init = (init_t)dlsym(csd->csd_client, "csd_client_init");
-
-        if (csd->init == NULL) {
-            ALOGE("%s: dlsym error %s for csd_client_init",
-                  __func__, dlerror());
-            goto error;
-        } else {
-            csd->init();
-        }
-    }
-    return csd;
-
-error:
-    free(csd);
-    csd = NULL;
-    return csd;
-}
-
-void close_csd_client(struct csd_data *csd)
-{
-    if (csd != NULL) {
-        csd->deinit();
-        dlclose(csd->csd_client);
-        free(csd);
-        csd = NULL;
-    }
-}
-
-void *platform_init(struct audio_device *adev)
-{
-    char platform[PROPERTY_VALUE_MAX];
-    char baseband[PROPERTY_VALUE_MAX];
-    char value[PROPERTY_VALUE_MAX];
-    struct platform_data *my_data;
-    int retry_num = 0;
-    const char *snd_card_name;
-
-    adev->mixer = mixer_open(MIXER_CARD);
-
-    while (!adev->mixer && retry_num < RETRY_NUMBER) {
-        usleep(RETRY_US);
-        adev->mixer = mixer_open(MIXER_CARD);
-        retry_num++;
-    }
-
-    if (!adev->mixer) {
-        ALOGE("Unable to open the mixer, aborting.");
-        return NULL;
-    }
-
-    adev->audio_route = audio_route_init(MIXER_CARD, MIXER_XML_PATH);
-
-    if (!adev->audio_route) {
-        ALOGE("%s: Failed to init audio route controls, aborting.", __func__);
-        return NULL;
-    }
-
-    my_data = calloc(1, sizeof(struct platform_data));
-
-    snd_card_name = mixer_get_name(adev->mixer);
-    my_data->hw_info = hw_info_init(snd_card_name);
-    if (!my_data->hw_info) {
-        ALOGE("%s: Failed to init hardware info", __func__);
-    }
-
-    my_data->adev = adev;
-    my_data->btsco_sample_rate = SAMPLE_RATE_8KHZ;
-    my_data->fluence_in_spkr_mode = false;
-    my_data->fluence_in_voice_call = false;
-    my_data->fluence_in_voice_rec = false;
-    my_data->fluence_in_audio_rec = false;
-    my_data->fluence_type = FLUENCE_NONE;
-
-    property_get("ro.qc.sdk.audio.fluencetype", value, "");
-    if (!strncmp("fluencepro", value, sizeof("fluencepro"))) {
-        my_data->fluence_type = FLUENCE_QUAD_MIC | FLUENCE_DUAL_MIC;
-    } else if (!strncmp("fluence", value, sizeof("fluence"))) {
-        my_data->fluence_type = FLUENCE_DUAL_MIC;
-    } else {
-        my_data->fluence_type = FLUENCE_NONE;
-    }
-
-    if (my_data->fluence_type != FLUENCE_NONE) {
-        property_get("persist.audio.fluence.voicecall",value,"");
-        if (!strncmp("true", value, sizeof("true"))) {
-            my_data->fluence_in_voice_call = true;
-        }
-
-        property_get("persist.audio.fluence.voicerec",value,"");
-        if (!strncmp("true", value, sizeof("true"))) {
-            my_data->fluence_in_voice_rec = true;
-        }
-
-        property_get("persist.audio.fluence.audiorec",value,"");
-        if (!strncmp("true", value, sizeof("true"))) {
-            my_data->fluence_in_audio_rec = true;
-        }
-
-        property_get("persist.audio.fluence.speaker",value,"");
-        if (!strncmp("true", value, sizeof("true"))) {
-            my_data->fluence_in_spkr_mode = true;
-        }
-    }
-
-    my_data->acdb_handle = dlopen(LIB_ACDB_LOADER, RTLD_NOW);
-    if (my_data->acdb_handle == NULL) {
-        ALOGE("%s: DLOPEN failed for %s", __func__, LIB_ACDB_LOADER);
-    } else {
-        ALOGV("%s: DLOPEN successful for %s", __func__, LIB_ACDB_LOADER);
-        my_data->acdb_deallocate = (acdb_deallocate_t)dlsym(my_data->acdb_handle,
-                                                    "acdb_loader_deallocate_ACDB");
-        my_data->acdb_send_audio_cal = (acdb_send_audio_cal_t)dlsym(my_data->acdb_handle,
-                                                    "acdb_loader_send_audio_cal");
-        if (!my_data->acdb_send_audio_cal)
-            ALOGW("%s: Could not find the symbol acdb_send_audio_cal from %s",
-                  __func__, LIB_ACDB_LOADER);
-        my_data->acdb_send_voice_cal = (acdb_send_voice_cal_t)dlsym(my_data->acdb_handle,
-                                                    "acdb_loader_send_voice_cal");
-        my_data->acdb_init = (acdb_init_t)dlsym(my_data->acdb_handle,
-                                                    "acdb_loader_init_ACDB");
-        if (my_data->acdb_init == NULL)
-            ALOGE("%s: dlsym error %s for acdb_loader_init_ACDB", __func__, dlerror());
-        else
-            my_data->acdb_init();
-    }
-
-    /* If platform is apq8084 and baseband is MDM, load CSD Client specific
-     * symbols. Voice call is handled by MDM and apps processor talks to
-     * MDM through CSD Client
-     */
-    property_get("ro.board.platform", platform, "");
-    property_get("ro.baseband", baseband, "");
-    if (!strncmp("apq8084", platform, sizeof("apq8084")) &&
-        !strncmp("mdm", baseband, sizeof("mdm"))) {
-         my_data->csd = open_csd_client();
-    }
-
-    return my_data;
-}
-
-void platform_deinit(void *platform)
-{
-    struct platform_data *my_data = (struct platform_data *)platform;
-
-    hw_info_deinit(my_data->hw_info);
-    close_csd_client(my_data->csd);
-
-    free(platform);
-}
-
-const char *platform_get_snd_device_name(snd_device_t snd_device)
-{
-    if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX)
-        return device_table[snd_device];
-    else
-        return "";
-}
-
-int platform_get_snd_device_name_extn(void *platform, snd_device_t snd_device,
-                                      char *device_name)
-{
-    struct platform_data *my_data = (struct platform_data *)platform;
-
-    if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX) {
-        strlcpy(device_name, device_table[snd_device], DEVICE_NAME_MAX_SIZE);
-        hw_info_append_hw_type(my_data->hw_info, snd_device, device_name);
-    } else {
-        strlcpy(device_name, "", DEVICE_NAME_MAX_SIZE);
-        return -EINVAL;
-    }
-
-    return 0;
-}
-
-void platform_add_backend_name(char *mixer_path, snd_device_t snd_device)
-{
-    if (snd_device == SND_DEVICE_IN_BT_SCO_MIC)
-        strlcat(mixer_path, " bt-sco", MIXER_PATH_MAX_LENGTH);
-    else if (snd_device == SND_DEVICE_IN_BT_SCO_MIC_WB)
-        strlcat(mixer_path, " bt-sco-wb", MIXER_PATH_MAX_LENGTH);
-    else if(snd_device == SND_DEVICE_OUT_BT_SCO)
-        strlcat(mixer_path, " bt-sco", MIXER_PATH_MAX_LENGTH);
-    else if(snd_device == SND_DEVICE_OUT_BT_SCO_WB)
-        strlcat(mixer_path, " bt-sco-wb", MIXER_PATH_MAX_LENGTH);
-    else if (snd_device == SND_DEVICE_OUT_HDMI)
-        strlcat(mixer_path, " hdmi", MIXER_PATH_MAX_LENGTH);
-    else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_HDMI)
-        strlcat(mixer_path, " speaker-and-hdmi", MIXER_PATH_MAX_LENGTH);
-    else if (snd_device == SND_DEVICE_OUT_AFE_PROXY)
-        strlcat(mixer_path, " afe-proxy", MIXER_PATH_MAX_LENGTH);
-    else if (snd_device == SND_DEVICE_OUT_USB_HEADSET)
-        strlcat(mixer_path, " usb-headphones", MIXER_PATH_MAX_LENGTH);
-    else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET)
-        strlcat(mixer_path, " speaker-and-usb-headphones",
-                MIXER_PATH_MAX_LENGTH);
-    else if (snd_device == SND_DEVICE_IN_USB_HEADSET_MIC)
-        strlcat(mixer_path, " usb-headset-mic", MIXER_PATH_MAX_LENGTH);
-    else if (snd_device == SND_DEVICE_IN_CAPTURE_FM)
-        strlcat(mixer_path, " capture-fm", MIXER_PATH_MAX_LENGTH);
-    else if (snd_device == SND_DEVICE_OUT_TRANSMISSION_FM)
-        strlcat(mixer_path, " transmission-fm", MIXER_PATH_MAX_LENGTH);
-    else if (snd_device == SND_DEVICE_OUT_SPDIF)
-        strlcat(mixer_path, " spdif", MIXER_PATH_MAX_LENGTH);
-}
-
-int platform_get_pcm_device_id(audio_usecase_t usecase, int device_type)
-{
-    int device_id;
-    if (device_type == PCM_PLAYBACK)
-        device_id = pcm_device_table[usecase][1];
-    else
-        device_id = pcm_device_table[usecase][2];
-    return device_id;
-}
-
-audio_usecase_t platform_get_usecase(
-        audio_usecase_stream_type_t uc_type)
-{
-    int i = 0;
-    for(i =0;i<AUDIO_USECASE_MAX; i++)
-        if((pcm_device_table[i][0] == (int)uc_type) &&
-                (pcm_device_table[i][3] == 0)) {
-            pcm_device_table[i][3] = 1;
-            break;
-        }
-
-    if(i == AUDIO_USECASE_MAX)
-        return -EINVAL;
-    else
-        return (audio_usecase_t)i;
-}
-
-int platform_free_usecase(audio_usecase_t uc_id)
-{
-    if(uc_id >= AUDIO_USECASE_MAX) {
-        ALOGV("%s: enter: invalid usecase(%d)", __func__, uc_id);
-        return -EINVAL;
-    }
-    pcm_device_table[uc_id][3] = 0;
-    return 0;
-}
-
-int platform_send_audio_calibration(void *platform, snd_device_t snd_device)
-{
-    struct platform_data *my_data = (struct platform_data *)platform;
-    int acdb_dev_id, acdb_dev_type;
-
-    acdb_dev_id = acdb_device_table[snd_device];
-    if (acdb_dev_id < 0) {
-        ALOGE("%s: Could not find acdb id for device(%d)",
-              __func__, snd_device);
-        return -EINVAL;
-    }
-    if (my_data->acdb_send_audio_cal) {
-        ("%s: sending audio calibration for snd_device(%d) acdb_id(%d)",
-              __func__, snd_device, acdb_dev_id);
-        if (snd_device >= SND_DEVICE_OUT_BEGIN &&
-                snd_device < SND_DEVICE_OUT_END)
-            acdb_dev_type = ACDB_DEV_TYPE_OUT;
-        else
-            acdb_dev_type = ACDB_DEV_TYPE_IN;
-        my_data->acdb_send_audio_cal(acdb_dev_id, acdb_dev_type);
-    }
-    return 0;
-}
-
-int platform_switch_voice_call_device_pre(void *platform)
-{
-    struct platform_data *my_data = (struct platform_data *)platform;
-    int ret = 0;
-
-    if (my_data->csd != NULL &&
-        my_data->adev->mode == AUDIO_MODE_IN_CALL) {
-        /* This must be called before disabling mixer controls on APQ side */
-        ret = my_data->csd->disable_device();
-        if (ret < 0) {
-            ALOGE("%s: csd_client_disable_device, failed, error %d",
-                  __func__, ret);
-        }
-    }
-    return ret;
-}
-
-int platform_switch_voice_call_device_post(void *platform,
-                                           snd_device_t out_snd_device,
-                                           snd_device_t in_snd_device)
-{
-    struct platform_data *my_data = (struct platform_data *)platform;
-    int acdb_rx_id, acdb_tx_id;
-
-    if (my_data->acdb_send_voice_cal == NULL) {
-        ALOGE("%s: dlsym error for acdb_send_voice_call", __func__);
-    } else {
-        acdb_rx_id = acdb_device_table[out_snd_device];
-        acdb_tx_id = acdb_device_table[in_snd_device];
-
-        if (acdb_rx_id > 0 && acdb_tx_id > 0)
-            my_data->acdb_send_voice_cal(acdb_rx_id, acdb_tx_id);
-        else
-            ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__,
-                  acdb_rx_id, acdb_tx_id);
-    }
-
-    return 0;
-}
-
-int platform_switch_voice_call_usecase_route_post(void *platform,
-                                                  snd_device_t out_snd_device,
-                                                  snd_device_t in_snd_device)
-{
-    struct platform_data *my_data = (struct platform_data *)platform;
-    int acdb_rx_id, acdb_tx_id;
-    int ret = 0;
-
-    acdb_rx_id = acdb_device_table[out_snd_device];
-    acdb_tx_id = acdb_device_table[in_snd_device];
-
-    if (my_data->csd != NULL) {
-        if (acdb_rx_id > 0 && acdb_tx_id > 0) {
-            ret = my_data->csd->enable_device(acdb_rx_id, acdb_tx_id,
-                                              my_data->adev->acdb_settings);
-            if (ret < 0) {
-                ALOGE("%s: csd_enable_device, failed, error %d",
-                      __func__, ret);
-            }
-        } else {
-            ALOGE("%s: Incorrect ACDB IDs (rx: %d tx: %d)", __func__,
-                  acdb_rx_id, acdb_tx_id);
-        }
-    }
-    return ret;
-}
-
-int platform_start_voice_call(void *platform, uint32_t vsid)
-{
-    struct platform_data *my_data = (struct platform_data *)platform;
-    int ret = 0;
-
-    if (my_data->csd != NULL) {
-        ret = my_data->csd->start_voice(vsid);
-        if (ret < 0) {
-            ALOGE("%s: csd_start_voice error %d\n", __func__, ret);
-        }
-    }
-    return ret;
-}
-
-int platform_stop_voice_call(void *platform, uint32_t vsid)
-{
-    struct platform_data *my_data = (struct platform_data *)platform;
-    int ret = 0;
-
-    if (my_data->csd != NULL) {
-        ret = my_data->csd->stop_voice(vsid);
-        if (ret < 0) {
-            ALOGE("%s: csd_stop_voice error %d\n", __func__, ret);
-        }
-    }
-    return ret;
-}
-
-int platform_set_voice_volume(void *platform, int volume)
-{
-    struct platform_data *my_data = (struct platform_data *)platform;
-    struct audio_device *adev = my_data->adev;
-    struct mixer_ctl *ctl;
-    const char *mixer_ctl_name = "Voice Rx Gain";
-    int vol_index = 0, ret = 0;
-    uint32_t set_values[ ] = {0,
-                              ALL_SESSION_VSID,
-                              DEFAULT_VOLUME_RAMP_DURATION_MS};
-
-    // Voice volume levels are mapped to adsp volume levels as follows.
-    // 100 -> 5, 80 -> 4, 60 -> 3, 40 -> 2, 20 -> 1  0 -> 0
-    // But this values don't changed in kernel. So, below change is need.
-    vol_index = (int)percent_to_index(volume, MIN_VOL_INDEX, MAX_VOL_INDEX);
-    set_values[0] = vol_index;
-
-    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("Setting voice volume index: %d", set_values[0]);
-    mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
-
-    if (my_data->csd != NULL) {
-        ret = my_data->csd->volume(ALL_SESSION_VSID, volume);
-        if (ret < 0) {
-            ALOGE("%s: csd_volume error %d", __func__, ret);
-        }
-    }
-    return ret;
-}
-
-int platform_set_mic_mute(void *platform, bool state)
-{
-    struct platform_data *my_data = (struct platform_data *)platform;
-    struct audio_device *adev = my_data->adev;
-    struct mixer_ctl *ctl;
-    const char *mixer_ctl_name = "Voice Tx Mute";
-    int ret = 0;
-    uint32_t set_values[ ] = {0,
-                              ALL_SESSION_VSID,
-                              DEFAULT_VOLUME_RAMP_DURATION_MS};
-
-    set_values[0] = state;
-    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("Setting voice mute state: %d", state);
-    mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
-
-    if (my_data->csd != NULL) {
-        ret = my_data->csd->mic_mute(ALL_SESSION_VSID, state);
-        if (ret < 0) {
-            ALOGE("%s: csd_mic_mute error %d", __func__, ret);
-        }
-    }
-    return ret;
-}
-
-snd_device_t platform_get_output_snd_device(void *platform, audio_devices_t devices)
-{
-    struct platform_data *my_data = (struct platform_data *)platform;
-    struct audio_device *adev = my_data->adev;
-    audio_mode_t mode = adev->mode;
-    snd_device_t snd_device = SND_DEVICE_NONE;
-
-    audio_channel_mask_t channel_mask = (adev->active_input == NULL) ?
-                                AUDIO_CHANNEL_IN_MONO : adev->active_input->channel_mask;
-    int channel_count = popcount(channel_mask);
-
-    ALOGV("%s: enter: output devices(%#x)", __func__, devices);
-    if (devices == AUDIO_DEVICE_NONE ||
-        devices & AUDIO_DEVICE_BIT_IN) {
-        ALOGV("%s: Invalid output devices (%#x)", __func__, devices);
-        goto exit;
-    }
-
-    if (popcount(devices) == 2) {
-        if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
-                        AUDIO_DEVICE_OUT_SPEAKER)) {
-            snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES;
-        } else if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADSET |
-                               AUDIO_DEVICE_OUT_SPEAKER)) {
-            snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES;
-        } else if (devices == (AUDIO_DEVICE_OUT_AUX_DIGITAL |
-                               AUDIO_DEVICE_OUT_SPEAKER)) {
-            snd_device = SND_DEVICE_OUT_SPEAKER_AND_HDMI;
-        } else if (devices == (AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET |
-                               AUDIO_DEVICE_OUT_SPEAKER)) {
-            snd_device = SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET;
-        } else {
-            ALOGE("%s: Invalid combo device(%#x)", __func__, devices);
-            goto exit;
-        }
-        if (snd_device != SND_DEVICE_NONE) {
-            goto exit;
-        }
-    }
-
-    if (popcount(devices) != 1) {
-        ALOGE("%s: Invalid output devices(%#x)", __func__, devices);
-        goto exit;
-    }
-
-    if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
-        devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
-        snd_device = SND_DEVICE_OUT_HEADPHONES;
-    } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) {
-        if (adev->speaker_lr_swap)
-            snd_device = SND_DEVICE_OUT_SPEAKER_REVERSE;
-        else
-            snd_device = SND_DEVICE_OUT_SPEAKER;
-    } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) {
-        if (my_data->btsco_sample_rate == SAMPLE_RATE_16KHZ)
-            snd_device = SND_DEVICE_OUT_BT_SCO_WB;
-        else
-            snd_device = SND_DEVICE_OUT_BT_SCO;
-    } else if (devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
-        snd_device = SND_DEVICE_OUT_HDMI ;
-    } else if (devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET ||
-               devices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) {
-        snd_device = SND_DEVICE_OUT_USB_HEADSET;
-    } else if (devices & AUDIO_DEVICE_OUT_FM_TX) {
-        snd_device = SND_DEVICE_OUT_TRANSMISSION_FM;
-    } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) {
-        snd_device = SND_DEVICE_OUT_HANDSET;
-    } else if (devices & AUDIO_DEVICE_OUT_SPDIF) {
-        snd_device = SND_DEVICE_OUT_SPDIF;
-    } else {
-        ALOGE("%s: Unknown device(s) %#x", __func__, devices);
-    }
-exit:
-    ALOGV("%s: exit: snd_device(%s)", __func__, device_table[snd_device]);
-    return snd_device;
-}
-
-snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_device)
-{
-    struct platform_data *my_data = (struct platform_data *)platform;
-    struct audio_device *adev = my_data->adev;
-    audio_source_t  source = (adev->active_input == NULL) ?
-                                AUDIO_SOURCE_DEFAULT : adev->active_input->source;
-
-    audio_mode_t    mode   = adev->mode;
-    audio_devices_t in_device = ((adev->active_input == NULL) ?
-                                    AUDIO_DEVICE_NONE : adev->active_input->device)
-                                & ~AUDIO_DEVICE_BIT_IN;
-    audio_channel_mask_t channel_mask = (adev->active_input == NULL) ?
-                                AUDIO_CHANNEL_IN_MONO : adev->active_input->channel_mask;
-    snd_device_t snd_device = SND_DEVICE_NONE;
-    int channel_count = popcount(channel_mask);
-
-    ALOGV("%s: enter: out_device(%#x) in_device(%#x)",
-          __func__, out_device, in_device);
-    if (source == AUDIO_SOURCE_CAMCORDER) {
-        if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC ||
-            in_device & AUDIO_DEVICE_IN_BACK_MIC) {
-            snd_device = SND_DEVICE_IN_CAMCORDER_MIC;
-        }
-    } else if (source == AUDIO_SOURCE_VOICE_RECOGNITION) {
-        if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
-            if (channel_count == 2) {
-                snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_STEREO;
-                adev->acdb_settings |= DMIC_FLAG;
-            } else if (adev->active_input->enable_ns)
-                snd_device = SND_DEVICE_IN_VOICE_REC_MIC_NS;
-            else if (my_data->fluence_type != FLUENCE_NONE &&
-                     my_data->fluence_in_voice_rec) {
-                snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE;
-                adev->acdb_settings |= DMIC_FLAG;
-            } else {
-                snd_device = SND_DEVICE_IN_VOICE_REC_MIC;
-            }
-        }
-    } else if (source == AUDIO_SOURCE_VOICE_COMMUNICATION) {
-        if (out_device & AUDIO_DEVICE_OUT_SPEAKER)
-            in_device = AUDIO_DEVICE_IN_BACK_MIC;
-        if (adev->active_input) {
-            if (adev->active_input->enable_aec &&
-                    adev->active_input->enable_ns) {
-                if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
-                    if (my_data->fluence_type & FLUENCE_DUAL_MIC &&
-                       my_data->fluence_in_spkr_mode) {
-                        snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS;
-                        adev->acdb_settings |= DMIC_FLAG;
-                    } else
-                        snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC_NS;
-                } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
-                    if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
-                        snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC_NS;
-                        adev->acdb_settings |= DMIC_FLAG;
-                    } else
-                        snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC_NS;
-                } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
-                    snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE;
-                }
-                set_echo_reference(adev->mixer, "SLIM_RX");
-            } else if (adev->active_input->enable_aec) {
-                if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
-                    if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
-                        snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC;
-                        adev->acdb_settings |= DMIC_FLAG;
-                    } else
-                        snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC;
-                } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
-                    if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
-                        snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC;
-                        adev->acdb_settings |= DMIC_FLAG;
-                    } else
-                        snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC;
-                } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
-                    snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE;
-                }
-                set_echo_reference(adev->mixer, "SLIM_RX");
-            } else if (adev->active_input->enable_ns) {
-                if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
-                    if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
-                        snd_device = SND_DEVICE_IN_SPEAKER_DMIC_NS;
-                        adev->acdb_settings |= DMIC_FLAG;
-                    } else
-                        snd_device = SND_DEVICE_IN_SPEAKER_MIC_NS;
-                } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
-                    if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
-                        snd_device = SND_DEVICE_IN_HANDSET_DMIC_NS;
-                        adev->acdb_settings |= DMIC_FLAG;
-                    } else
-                        snd_device = SND_DEVICE_IN_HANDSET_MIC_NS;
-                } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
-                    snd_device = SND_DEVICE_IN_HEADSET_MIC_FLUENCE;
-                }
-                set_echo_reference(adev->mixer, "NONE");
-            } else
-                set_echo_reference(adev->mixer, "NONE");
-        }
-    } else if (source == AUDIO_SOURCE_MIC) {
-        if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC &&
-                channel_count == 1 ) {
-            if(my_data->fluence_type & FLUENCE_DUAL_MIC &&
-                    my_data->fluence_in_audio_rec)
-                snd_device = SND_DEVICE_IN_HANDSET_DMIC;
-        }
-    } else if (source == AUDIO_SOURCE_FM_RX ||
-               source == AUDIO_SOURCE_FM_RX_A2DP) {
-        snd_device = SND_DEVICE_IN_CAPTURE_FM;
-    } else if (source == AUDIO_SOURCE_DEFAULT) {
-        goto exit;
-    }
-
-
-    if (snd_device != SND_DEVICE_NONE) {
-        goto exit;
-    }
-
-    if (in_device != AUDIO_DEVICE_NONE &&
-            !(in_device & AUDIO_DEVICE_IN_VOICE_CALL) &&
-            !(in_device & AUDIO_DEVICE_IN_COMMUNICATION)) {
-        if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
-            if (channel_count == 2)
-                snd_device = SND_DEVICE_IN_HANDSET_STEREO_DMIC;
-            else
-                snd_device = SND_DEVICE_IN_HANDSET_MIC;
-        } else if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
-            snd_device = SND_DEVICE_IN_SPEAKER_MIC;
-        } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
-            snd_device = SND_DEVICE_IN_HEADSET_MIC;
-        } else if (in_device & AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) {
-            if (my_data->btsco_sample_rate == SAMPLE_RATE_16KHZ)
-                snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB;
-            else
-                snd_device = SND_DEVICE_IN_BT_SCO_MIC;
-        } else if (in_device & AUDIO_DEVICE_IN_AUX_DIGITAL) {
-            snd_device = SND_DEVICE_IN_HDMI_MIC;
-        } else if (in_device & AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET ||
-                   in_device & AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET) {
-            snd_device = SND_DEVICE_IN_USB_HEADSET_MIC;
-        } else if (in_device & AUDIO_DEVICE_IN_FM_RX) {
-            snd_device = SND_DEVICE_IN_CAPTURE_FM;
-        } else {
-            ALOGE("%s: Unknown input device(s) %#x", __func__, in_device);
-            ALOGW("%s: Using default handset-mic", __func__);
-            snd_device = SND_DEVICE_IN_HANDSET_MIC;
-        }
-    } else {
-        if (out_device & AUDIO_DEVICE_OUT_EARPIECE) {
-            snd_device = SND_DEVICE_IN_HANDSET_MIC;
-        } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
-            snd_device = SND_DEVICE_IN_HEADSET_MIC;
-        } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) {
-            if (channel_count > 1)
-                snd_device = SND_DEVICE_IN_SPEAKER_STEREO_DMIC;
-            else
-                snd_device = SND_DEVICE_IN_SPEAKER_MIC;
-        } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) {
-            snd_device = SND_DEVICE_IN_HANDSET_MIC;
-        } else if (out_device & AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET) {
-            if (my_data->btsco_sample_rate == SAMPLE_RATE_16KHZ)
-                snd_device = SND_DEVICE_IN_BT_SCO_MIC_WB;
-            else
-                snd_device = SND_DEVICE_IN_BT_SCO_MIC;
-        } else if (out_device & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
-            snd_device = SND_DEVICE_IN_HDMI_MIC;
-        } else if (out_device & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET ||
-                   out_device & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) {
-            snd_device = SND_DEVICE_IN_USB_HEADSET_MIC;
-        } else {
-            ALOGE("%s: Unknown output device(s) %#x", __func__, out_device);
-            ALOGW("%s: Using default handset-mic", __func__);
-            snd_device = SND_DEVICE_IN_HANDSET_MIC;
-        }
-    }
-exit:
-    ALOGV("%s: exit: in_snd_device(%s)", __func__, device_table[snd_device]);
-    return snd_device;
-}
-
-int platform_set_hdmi_channels(void *platform,  int channel_count)
-{
-    struct platform_data *my_data = (struct platform_data *)platform;
-    struct audio_device *adev = my_data->adev;
-    struct mixer_ctl *ctl;
-    const char *channel_cnt_str = NULL;
-    const char *mixer_ctl_name = "HDMI_RX Channels";
-    switch (channel_count) {
-    case 8:
-        channel_cnt_str = "Eight"; break;
-    case 7:
-        channel_cnt_str = "Seven"; break;
-    case 6:
-        channel_cnt_str = "Six"; break;
-    case 5:
-        channel_cnt_str = "Five"; break;
-    case 4:
-        channel_cnt_str = "Four"; break;
-    case 3:
-        channel_cnt_str = "Three"; break;
-    default:
-        channel_cnt_str = "Two"; break;
-    }
-    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("HDMI channel count: %s", channel_cnt_str);
-    mixer_ctl_set_enum_by_string(ctl, channel_cnt_str);
-    return 0;
-}
-
-int platform_edid_get_max_channels(void *platform)
-{
-    struct platform_data *my_data = (struct platform_data *)platform;
-    struct audio_device *adev = my_data->adev;
-    char block[MAX_SAD_BLOCKS * SAD_BLOCK_SIZE];
-    char *sad = block;
-    int num_audio_blocks;
-    int channel_count;
-    int max_channels = 0;
-    int i, ret, count;
-
-    struct mixer_ctl *ctl;
-
-    ctl = mixer_get_ctl_by_name(adev->mixer, AUDIO_DATA_BLOCK_MIXER_CTL);
-    if (!ctl) {
-        ALOGE("%s: Could not get ctl for mixer cmd - %s",
-              __func__, AUDIO_DATA_BLOCK_MIXER_CTL);
-        return 0;
-    }
-
-    mixer_ctl_update(ctl);
-
-    count = mixer_ctl_get_num_values(ctl);
-
-    /* Read SAD blocks, clamping the maximum size for safety */
-    if (count > (int)sizeof(block))
-        count = (int)sizeof(block);
-
-    ret = mixer_ctl_get_array(ctl, block, count);
-    if (ret != 0) {
-        ALOGE("%s: mixer_ctl_get_array() failed to get EDID info", __func__);
-        return 0;
-    }
-
-    /* Calculate the number of SAD blocks */
-    num_audio_blocks = count / SAD_BLOCK_SIZE;
-
-    for (i = 0; i < num_audio_blocks; i++) {
-        /* Only consider LPCM blocks */
-        if ((sad[0] >> 3) != EDID_FORMAT_LPCM) {
-            sad += 3;
-            continue;
-        }
-
-        channel_count = (sad[0] & 0x7) + 1;
-        if (channel_count > max_channels)
-            max_channels = channel_count;
-
-        /* Advance to next block */
-        sad += 3;
-    }
-
-    return max_channels;
-}
-
-static int platform_set_slowtalk(struct platform_data *my_data, bool state)
-{
-    int ret = 0;
-    struct audio_device *adev = my_data->adev;
-    struct mixer_ctl *ctl;
-    const char *mixer_ctl_name = "Slowtalk Enable";
-    uint32_t set_values[ ] = {0,
-                              ALL_SESSION_VSID};
-
-    set_values[0] = state;
-    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);
-        ret = -EINVAL;
-    } else {
-        ALOGV("Setting slowtalk state: %d", state);
-        ret = mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
-        my_data->slowtalk = state;
-    }
-
-    if (my_data->csd != NULL) {
-        ret = my_data->csd->slow_talk(ALL_SESSION_VSID, state);
-        if (ret < 0) {
-            ALOGE("%s: csd_client_disable_device, failed, error %d",
-                  __func__, ret);
-        }
-    }
-    return ret;
-}
-
-int platform_set_parameters(void *platform, struct str_parms *parms)
-{
-    struct platform_data *my_data = (struct platform_data *)platform;
-    char *str;
-    char value[32];
-    int val;
-    int ret = 0;
-
-    ALOGV("%s: enter: %s", __func__, str_parms_to_str(parms));
-
-    ret = str_parms_get_int(parms, AUDIO_PARAMETER_KEY_BTSCO, &val);
-    if (ret >= 0) {
-        str_parms_del(parms, AUDIO_PARAMETER_KEY_BTSCO);
-        my_data->btsco_sample_rate = val;
-    }
-
-    ret = str_parms_get_int(parms, AUDIO_PARAMETER_KEY_SLOWTALK, &val);
-    if (ret >= 0) {
-        str_parms_del(parms, AUDIO_PARAMETER_KEY_SLOWTALK);
-        ret = platform_set_slowtalk(my_data, val);
-        if (ret)
-            ALOGE("%s: Failed to set slow talk err: %d", __func__, ret);
-    }
-
-    ALOGV("%s: exit with code(%d)", __func__, ret);
-    return ret;
-}
-
-int platform_set_incall_recoding_session_id(void *platform,
-                                            uint32_t session_id)
-{
-    int ret = 0;
-    struct platform_data *my_data = (struct platform_data *)platform;
-    struct audio_device *adev = my_data->adev;
-    struct mixer_ctl *ctl;
-    const char *mixer_ctl_name = "Voc VSID";
-    int num_ctl_values;
-    int i;
-
-    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);
-        ret = -EINVAL;
-    } else {
-        num_ctl_values = mixer_ctl_get_num_values(ctl);
-        for (i = 0; i < num_ctl_values; i++) {
-            if (mixer_ctl_set_value(ctl, i, session_id)) {
-                ALOGV("Error: invalid session_id: %x", session_id);
-                ret = -EINVAL;
-                break;
-            }
-        }
-    }
-
-    return ret;
-}
-
-void platform_get_parameters(void *platform,
-                            struct str_parms *query,
-                            struct str_parms *reply)
-{
-    struct platform_data *my_data = (struct platform_data *)platform;
-    char *str = NULL;
-    char value[256] = {0};
-    int ret;
-    int fluence_type;
-
-    ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_FLUENCE_TYPE,
-                            value, sizeof(value));
-    if (ret >= 0) {
-        if (my_data->fluence_type & FLUENCE_QUAD_MIC) {
-            strlcpy(value, "fluencepro", sizeof(value));
-        } else if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
-            strlcpy(value, "fluence", sizeof(value));
-        } else {
-            strlcpy(value, "none", sizeof(value));
-        }
-
-        str_parms_add_str(reply, AUDIO_PARAMETER_KEY_FLUENCE_TYPE, value);
-    }
-
-    memset(value, 0, sizeof(value));
-    ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_SLOWTALK,
-                            value, sizeof(value));
-    if (ret >= 0) {
-        str_parms_add_int(reply, AUDIO_PARAMETER_KEY_SLOWTALK,
-                          my_data->slowtalk);
-    }
-
-    ALOGV("%s: exit: returns - %s", __func__, str_parms_to_str(reply));
-}
-
-/* Delay in Us */
-int64_t platform_render_latency(audio_usecase_t usecase)
-{
-    switch (usecase) {
-        case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER:
-            return DEEP_BUFFER_PLATFORM_DELAY;
-        case USECASE_AUDIO_PLAYBACK_LOW_LATENCY:
-            return LOW_LATENCY_PLATFORM_DELAY;
-        default:
-            return 0;
-    }
-}
-
-int platform_update_usecase_from_source(int source, int usecase)
-{
-    ALOGV("%s: input source :%d", __func__, source);
-    if(source == AUDIO_SOURCE_FM_RX_A2DP)
-        usecase = USECASE_AUDIO_RECORD_FM_VIRTUAL;
-    return usecase;
-}
diff --git a/hal_mpq/mpq8092/platform.h b/hal_mpq/mpq8092/platform.h
deleted file mode 100644
index 562f979..0000000
--- a/hal_mpq/mpq8092/platform.h
+++ /dev/null
@@ -1,671 +0,0 @@
-/*
- * Copyright (c) 2013, The Linux Foundation. All rights reserved.
- * Not a Contribution.
- *
- * Copyright (C) 2013 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.
- */
-
-#ifndef QCOM_AUDIO_PLATFORM_H
-#define QCOM_AUDIO_PLATFORM_H
-
-enum {
-    FLUENCE_NONE,
-    FLUENCE_DUAL_MIC = 0x1,
-    FLUENCE_QUAD_MIC = 0x2,
-};
-
-#include <hardware/audio.h>
-/*
- * Below are the devices for which is back end is same, SLIMBUS_0_RX.
- * All these devices are handled by the internal HW codec. We can
- * enable any one of these devices at any time
- */
-#define AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND \
-    (AUDIO_DEVICE_OUT_EARPIECE | AUDIO_DEVICE_OUT_SPEAKER | \
-     AUDIO_DEVICE_OUT_WIRED_HEADSET | AUDIO_DEVICE_OUT_WIRED_HEADPHONE)
-/*TODO remove this once define in audio.h */
-#define AUDIO_DEVICE_OUT_SPDIF 0x4000
-
-/* Sound devices specific to the platform
- * The DEVICE_OUT_* and DEVICE_IN_* should be mapped to these sound
- * devices to enable corresponding mixer paths
- */
-enum {
-    SND_DEVICE_NONE = 0,
-
-    /* Playback devices */
-    SND_DEVICE_MIN,
-    SND_DEVICE_OUT_BEGIN = SND_DEVICE_MIN,
-    SND_DEVICE_OUT_HANDSET = SND_DEVICE_OUT_BEGIN,
-    SND_DEVICE_OUT_SPEAKER,
-    SND_DEVICE_OUT_SPEAKER_REVERSE,
-    SND_DEVICE_OUT_HEADPHONES,
-    SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES,
-    SND_DEVICE_OUT_VOICE_HANDSET,
-    SND_DEVICE_OUT_VOICE_SPEAKER,
-    SND_DEVICE_OUT_VOICE_HEADPHONES,
-    SND_DEVICE_OUT_HDMI,
-    SND_DEVICE_OUT_SPEAKER_AND_HDMI,
-    SND_DEVICE_OUT_BT_SCO,
-    SND_DEVICE_OUT_BT_SCO_WB,
-    SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES,
-    SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES,
-    SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET,
-    SND_DEVICE_OUT_AFE_PROXY,
-    SND_DEVICE_OUT_USB_HEADSET,
-    SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET,
-    SND_DEVICE_OUT_TRANSMISSION_FM,
-    SND_DEVICE_OUT_ANC_HEADSET,
-    SND_DEVICE_OUT_ANC_FB_HEADSET,
-    SND_DEVICE_OUT_VOICE_ANC_HEADSET,
-    SND_DEVICE_OUT_VOICE_ANC_FB_HEADSET,
-    SND_DEVICE_OUT_SPEAKER_AND_ANC_HEADSET,
-    SND_DEVICE_OUT_ANC_HANDSET,
-    SND_DEVICE_OUT_SPEAKER_PROTECTED,
-    SND_DEVICE_OUT_SPDIF,
-    SND_DEVICE_OUT_END,
-
-    /*
-     * Note: IN_BEGIN should be same as OUT_END because total number of devices
-     * SND_DEVICES_MAX should not exceed MAX_RX + MAX_TX devices.
-     */
-    /* Capture devices */
-    SND_DEVICE_IN_BEGIN = SND_DEVICE_OUT_END,
-    SND_DEVICE_IN_HANDSET_MIC  = SND_DEVICE_IN_BEGIN,
-    SND_DEVICE_IN_HANDSET_MIC_AEC,
-    SND_DEVICE_IN_HANDSET_MIC_NS,
-    SND_DEVICE_IN_HANDSET_MIC_AEC_NS,
-    SND_DEVICE_IN_HANDSET_DMIC,
-    SND_DEVICE_IN_HANDSET_DMIC_AEC,
-    SND_DEVICE_IN_HANDSET_DMIC_NS,
-    SND_DEVICE_IN_HANDSET_DMIC_AEC_NS,
-    SND_DEVICE_IN_SPEAKER_MIC,
-    SND_DEVICE_IN_SPEAKER_MIC_AEC,
-    SND_DEVICE_IN_SPEAKER_MIC_NS,
-    SND_DEVICE_IN_SPEAKER_MIC_AEC_NS,
-    SND_DEVICE_IN_SPEAKER_DMIC,
-    SND_DEVICE_IN_SPEAKER_DMIC_AEC,
-    SND_DEVICE_IN_SPEAKER_DMIC_NS,
-    SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS,
-    SND_DEVICE_IN_HEADSET_MIC,
-    SND_DEVICE_IN_HEADSET_MIC_FLUENCE,
-    SND_DEVICE_IN_VOICE_SPEAKER_MIC,
-    SND_DEVICE_IN_VOICE_HEADSET_MIC,
-    SND_DEVICE_IN_HDMI_MIC,
-    SND_DEVICE_IN_BT_SCO_MIC,
-    SND_DEVICE_IN_BT_SCO_MIC_WB,
-    SND_DEVICE_IN_CAMCORDER_MIC,
-    SND_DEVICE_IN_VOICE_DMIC,
-    SND_DEVICE_IN_VOICE_SPEAKER_DMIC,
-    SND_DEVICE_IN_VOICE_SPEAKER_QMIC,
-    SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC,
-    SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC,
-    SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC,
-    SND_DEVICE_IN_VOICE_REC_MIC,
-    SND_DEVICE_IN_VOICE_REC_MIC_NS,
-    SND_DEVICE_IN_VOICE_REC_DMIC_STEREO,
-    SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE,
-    SND_DEVICE_IN_USB_HEADSET_MIC,
-    SND_DEVICE_IN_CAPTURE_FM,
-    SND_DEVICE_IN_AANC_HANDSET_MIC,
-    SND_DEVICE_IN_QUAD_MIC,
-    SND_DEVICE_IN_HANDSET_STEREO_DMIC,
-    SND_DEVICE_IN_SPEAKER_STEREO_DMIC,
-    SND_DEVICE_IN_CAPTURE_VI_FEEDBACK,
-    SND_DEVICE_IN_END,
-
-    SND_DEVICE_MAX = SND_DEVICE_IN_END,
-
-};
-
-#define MIXER_CARD 0
-#define SOUND_CARD 0
-
-#define DEFAULT_OUTPUT_SAMPLING_RATE 48000
-
-#define ALL_SESSION_VSID                0xFFFFFFFF
-#define DEFAULT_MUTE_RAMP_DURATION      500
-#define DEFAULT_VOLUME_RAMP_DURATION_MS 20
-#define MIXER_PATH_MAX_LENGTH 100
-
-#define MAX_VOL_INDEX 5
-#define MIN_VOL_INDEX 0
-#define percent_to_index(val, min, max) \
-            ((val) * ((max) - (min)) * 0.01 + (min) + .5)
-
-/*
- * tinyAlsa library interprets period size as number of frames
- * one frame = channel_count * sizeof (pcm sample)
- * so if format = 16-bit PCM and channels = Stereo, frame size = 2 ch * 2 = 4 bytes
- * DEEP_BUFFER_OUTPUT_PERIOD_SIZE = 1024 means 1024 * 4 = 4096 bytes
- * We should take care of returning proper size when AudioFlinger queries for
- * the buffer size of an input/output stream
- */
-#define DEEP_BUFFER_OUTPUT_PERIOD_SIZE 960
-#define DEEP_BUFFER_OUTPUT_PERIOD_COUNT 8
-#define LOW_LATENCY_OUTPUT_PERIOD_SIZE 240
-#define LOW_LATENCY_OUTPUT_PERIOD_COUNT 2
-
-/*******************************************************************************
-ADTS HEADER PARSING
-*******************************************************************************/
-//Required for ADTS Header Parsing
-#define ADTS_HEADER_SYNC_RESULT 0xfff0
-#define ADTS_HEADER_SYNC_MASK 0xfff6
-/*******************************************************************************
-HDMI and SPDIF Device Output format control
-*******************************************************************************/
-
-#define HDMI_MULTI_PERIOD_SIZE  336
-#define HDMI_MULTI_PERIOD_COUNT 8
-#define HDMI_MULTI_DEFAULT_CHANNEL_COUNT 6
-#define HDMI_MULTI_PERIOD_BYTES (HDMI_MULTI_PERIOD_SIZE * HDMI_MULTI_DEFAULT_CHANNEL_COUNT * 2)
-
-#define AUDIO_CAPTURE_PERIOD_DURATION_MSEC 20
-#define AUDIO_CAPTURE_PERIOD_COUNT 2
-
-#define DEVICE_NAME_MAX_SIZE 128
-#define HW_INFO_ARRAY_MAX_SIZE 32
-
-#define DEEP_BUFFER_PCM_DEVICE 0
-#define AUDIO_RECORD_PCM_DEVICE 0
-#define MULTIMEDIA2_PCM_DEVICE 1
-#define FM_PLAYBACK_PCM_DEVICE 5
-#define FM_CAPTURE_PCM_DEVICE  6
-#define INCALL_MUSIC_UPLINK_PCM_DEVICE 1
-#define INCALL_MUSIC_UPLINK2_PCM_DEVICE 16
-#define SPKR_PROT_CALIB_RX_PCM_DEVICE 5
-#define SPKR_PROT_CALIB_TX_PCM_DEVICE 22
-#define COMPRESS_VOIP_CALL_PCM_DEVICE 3
-#define MULTI_CHANNEL_PCM_DEVICE 1
-#define VOICE_CALL_PCM_DEVICE 2
-//TODO: update the device number as per the dai links
-#define PLAYBACK_OFFLOAD_DEVICE1 2
-#define PLAYBACK_OFFLOAD_DEVICE2 3
-#define PLAYBACK_OFFLOAD_DEVICE3 4
-#define PLAYBACK_OFFLOAD_DEVICE4 19
-
-#define LOWLATENCY_PCM_DEVICE 15
-#define COMPRESS_CAPTURE_DEVICE 19
-
-#ifdef PLATFORM_MSM8x26
-#define VOICE_CALL_PCM_DEVICE 2
-#define VOICE2_CALL_PCM_DEVICE 14
-#define VOLTE_CALL_PCM_DEVICE 17
-#define QCHAT_CALL_PCM_DEVICE 18
-#elif PLATFORM_APQ8084
-#define VOICE_CALL_PCM_DEVICE 20
-#define VOICE2_CALL_PCM_DEVICE 13
-#define VOLTE_CALL_PCM_DEVICE 21
-#define QCHAT_CALL_PCM_DEVICE 06
-#else
-#define VOICE_CALL_PCM_DEVICE 2
-#define VOICE2_CALL_PCM_DEVICE 13
-#define VOLTE_CALL_PCM_DEVICE 14
-#define QCHAT_CALL_PCM_DEVICE 20
-#endif
-
-#define LIB_CSD_CLIENT "libcsd-client.so"
-/* CSD-CLIENT related functions */
-typedef int (*init_t)();
-typedef int (*deinit_t)();
-typedef int (*disable_device_t)();
-typedef int (*enable_device_t)(int, int, uint32_t);
-typedef int (*volume_t)(uint32_t, int);
-typedef int (*mic_mute_t)(uint32_t, int);
-typedef int (*slow_talk_t)(uint32_t, uint8_t);
-typedef int (*start_voice_t)(uint32_t);
-typedef int (*stop_voice_t)(uint32_t);
-typedef int (*start_playback_t)(uint32_t);
-typedef int (*stop_playback_t)(uint32_t);
-typedef int (*start_record_t)(uint32_t, int);
-typedef int (*stop_record_t)(uint32_t, int);
-/* CSD Client structure */
-struct csd_data {
-    void *csd_client;
-    init_t init;
-    deinit_t deinit;
-    disable_device_t disable_device;
-    enable_device_t enable_device;
-    volume_t volume;
-    mic_mute_t mic_mute;
-    slow_talk_t slow_talk;
-    start_voice_t start_voice;
-    stop_voice_t stop_voice;
-    start_playback_t start_playback;
-    stop_playback_t stop_playback;
-    start_record_t start_record;
-    stop_record_t stop_record;
-};
-
-void *hw_info_init(const char *snd_card_name);
-void hw_info_deinit(void *hw_info);
-void hw_info_append_hw_type(void *hw_info, snd_device_t snd_device,
-                             char *device_name);
-
-/*******************************************************************************
-USECASES AND THE CORRESPONDING DEVICE FORMATS THAT WE SUPPORT IN HAL
-*******************************************************************************/
-/*
-In general max of 2 for pass through. Additional 1 for handling transcode
-as the existence of transcode is with a PCM handle followed by transcode handle
-So, a (AC3/EAC3) pass through + trancode require - 1 for pas through, 1 - pcm and
-1 - transcode
-*/
-#define NUM_DEVICES_SUPPORT_COMPR_DATA 2+1
-#define NUM_SUPPORTED_CODECS           16
-#define NUM_COLUMN_FOR_INDEXING        2
-#define NUM_STATES_FOR_EACH_DEVICE_FMT 3
-#define DECODER_TYPE_IDX               0
-#define ROUTE_FORMAT_IDX               1
-
-#define MIN_SIZE_FOR_METADATA    64
-#define NUM_OF_PERIODS           8
-/*Period size to be a multiple of chanels * bitwidth,
-So min period size = LCM (1,2...8) * 4*/
-#define PERIOD_SIZE_COMPR        3360
-#define MS11_INPUT_BUFFER_SIZE   1536
-/*Max Period size which is exposed by the compr driver
-The value needs to be modified when the period size is modified*/
-#define PLAYBACK_MAX_PERIOD_SIZE (160 * 1024)
-
-#define COMPR_INPUT_BUFFER_SIZE  (PERIOD_SIZE_COMPR - MIN_SIZE_FOR_METADATA)
-#define PCM_16_BITS_PER_SAMPLE   2
-#define PCM_24_BITS_PER_SAMPLE   3
-#define AC3_PERIOD_SIZE          1536 * PCM_16_BITS_PER_SAMPLE
-#define TIME_PER_BUFFER          40 //Time duration in ms
-#define SAMPLES_PER_CHANNEL             32*1024 //1536*2 /*TODO:correct it
-#define MAX_INPUT_CHANNELS_SUPPORTED    8
-#define FACTOR_FOR_BUFFERING            2
-#define STEREO_CHANNELS                 2
-#define MAX_OUTPUT_CHANNELS_SUPPORTED   8
-#define PCM_BLOCK_PER_CHANNEL_MS11      1536*2
-#define AAC_BLOCK_PER_CHANNEL_MS11      768
-#define NUMBER_BITS_IN_A_BYTE           8
-#define AC3_BUFFER_SIZE                 1920*2
-
-#define MAX_OUTPUT_CHANNELS_SUPPORTED   8
-
-#define PCM_2CH_OUT                 0
-#define PCM_MCH_OUT                 1
-#define SPDIF_OUT                   2
-#define COMPRESSED_OUT              2 // should be same as SPDIF_OUT
-#define TRANSCODE_OUT               3
-#define FACTOR_FOR_BUFFERING        2
-
-#define NUM_DEVICES_SUPPORT_COMPR_DATA 2+1
-#define NUM_SUPPORTED_CODECS           16
-#define NUM_COLUMN_FOR_INDEXING        2
-#define NUM_STATES_FOR_EACH_DEVICE_FMT 3
-#define DECODER_TYPE_IDX               0
-#define ROUTE_FORMAT_IDX               1
-#define NUM_OF_PERIODS                 8
-
-enum {
-    LPCM,
-    MULTI_CH_PCM,
-    COMPR,
-    TRANSCODE
-};
-
-
-/*
-List of indexes of the supported formats
-Redundant formats such as (AAC-LC, HEAAC) are removed from the indexes as they
-are treated with the AAC format
-*/
-enum {
-    PCM_IDX = 0,
-    AAC_IDX,
-    AC3_IDX,
-    EAC3_IDX,
-    DTS_IDX,
-    DTS_LBR_IDX,
-    MP3_IDX,
-    WMA_IDX,
-    WMA_PRO_IDX,
-    MP2_IDX,
-    ALL_FORMATS_IDX
-};
-/*
-List of pass through's supported in the current usecases
-*/
-enum {
-    NO_PASSTHROUGH = 0,
-    AC3_PASSTHR,
-    EAC3_PASSTHR,
-    DTS_PASSTHR
-};
-/*
-List of transcoder's supported in the current usecases
-*/
-enum {
-    NO_TRANSCODER = 0,
-    AC3_TRANSCODER,
-    DTS_TRANSCODER
-};
-/*
-Requested end device format by user/app through set parameters
-*/
-enum {
-    UNCOMPRESSED = 0,
-    COMPRESSED,
-    COMPRESSED_CONVERT_EAC3_AC3,
-    COMPRESSED_CONVERT_ANY_AC3,
-    COMPRESSED_CONVERT_ANY_DTS,
-    AUTO_DEVICE_FORMAT,
-    UNCOMPRESSED_MCH,  /* not to be exposed, internal use only */
-    COMPRESSED_CONVERT_AC3_ASSOC, /* not to be exposed, internal use only */
-    ALL_DEVICE_FORMATS
-};
-/*
-List of type of data routed on end device
-*/
-typedef enum {
-    ROUTE_NONE = 0x0,
-    ROUTE_UNCOMPRESSED = 0x1,
-    ROUTE_COMPRESSED = 0x2,
-    ROUTE_SW_TRANSCODED = 0x10,   //route sub-format, not to be used directly
-    ROUTE_DSP_TRANSCODED = 0x20,  //route sub-format, not to be used directly
-    ROUTE_MCH = 0x40,             //route sub-format, not to be used directly
-    ROUTE_UNCOMPRESSED_MCH = (ROUTE_UNCOMPRESSED | ROUTE_MCH),
-    ROUTE_SW_TRANSCODED_COMPRESSED = (ROUTE_COMPRESSED | ROUTE_SW_TRANSCODED),
-    ROUTE_DSP_TRANSCODED_COMPRESSED = (ROUTE_COMPRESSED | ROUTE_DSP_TRANSCODED)
-}route_format_t;
-/*
-List of end device formats
-*/
-enum {
-    FORMAT_INVALID = -1,
-    FORMAT_PCM,
-    FORMAT_COMPR
-};
-/*
-Below are the only different types of decode that we perform
-*/
-enum {
-    DSP_DECODE = 1,      // render uncompressed
-    DSP_PASSTHROUGH = 2, // render compressed
-    DSP_TRANSCODE = 4,   // render as compressed
-    SW_DECODE = 8,       // render as uncompressed
-    SW_DECODE_MCH = 16,   // render as uncompressed
-    SW_PASSTHROUGH = 32, // render compressed
-    SW_TRANSCODE = 64,    // render compressed
-    NUM_DECODE_PATH = 7
-};
-/*
-Modes of buffering that we can support
-As of now, we only support input buffering to an extent specified by usecase
-*/
-enum {
-    NO_BUFFERING_MODE = 0,
-    INPUT_BUFFERING_MODE,
-    OUTPUT_BUFFEING_MODE
-};
-/*
-playback controls
-*/
-enum {
-    PLAY = 1,
-    PAUSE = (1<<1),
-    RESUME = (1<<2),
-    SEEK = (1<<3),
-    EOS = (1<<4),
-    STOP = (1<<5),
-    STANDBY = (1<<6),
-    INIT = (1<<7),
-};
-/*
-Multiple instance of use case
-*/
-enum {
-    STEREO_DRIVER = 0,
-    MULTI_CHANNEL_DRIVER,
-    COMRPESSED_DRIVER,
-};
-/*
-Instance bits
-*/
-enum {
-    MULTI_CHANNEL_1_BIT = 1<<4,
-    MULTI_CHANNEL_2_BIT = 1<<5,
-    MULTI_CHANNEL_3_BIT = 1<<6,
-    COMPRESSED_1_BIT    = 1<<12,
-    COMPRESSED_2_BIT    = 1<<13,
-    COMPRESSED_3_BIT    = 1<<14,
-    COMPRESSED_4_BIT    = 1<<15,
-    COMPRESSED_5_BIT    = 1<<16,
-    COMPRESSED_6_BIT    = 1<<17
-};
-
-/*
-List of support formats configured from frameworks
-*/
-static const int supportedFormats[NUM_SUPPORTED_CODECS] = {
-    AUDIO_FORMAT_PCM_16_BIT,
-    AUDIO_FORMAT_PCM_24_BIT,
-    AUDIO_FORMAT_AAC,
-    AUDIO_FORMAT_HE_AAC_V1,
-    AUDIO_FORMAT_HE_AAC_V2,
-    AUDIO_FORMAT_AAC_ADIF,
-    AUDIO_FORMAT_AC3,
-    AUDIO_FORMAT_AC3_DM,
-    AUDIO_FORMAT_EAC3,
-    AUDIO_FORMAT_EAC3_DM,
-    AUDIO_FORMAT_DTS,
-    AUDIO_FORMAT_DTS_LBR,
-    AUDIO_FORMAT_MP3,
-    AUDIO_FORMAT_WMA,
-    AUDIO_FORMAT_WMA_PRO,
-    AUDIO_FORMAT_MP2
-};
-/*
-we can only have 6 types of decoder type stored with bit masks.
-*/
-static const int route_to_driver[NUM_DECODE_PATH][NUM_COLUMN_FOR_INDEXING] = {
-    {DSP_DECODE,      ROUTE_UNCOMPRESSED_MCH},
-    {DSP_PASSTHROUGH, ROUTE_COMPRESSED},
-    {DSP_TRANSCODE,   ROUTE_DSP_TRANSCODED_COMPRESSED},
-    {SW_DECODE,       ROUTE_UNCOMPRESSED},
-    {SW_DECODE_MCH,   ROUTE_UNCOMPRESSED_MCH},
-    {SW_PASSTHROUGH,  ROUTE_COMPRESSED},
-    {SW_TRANSCODE,    ROUTE_SW_TRANSCODED_COMPRESSED}
-};
-/*
-table to query index based on the format
-*/
-static const int format_index[NUM_SUPPORTED_CODECS][NUM_COLUMN_FOR_INDEXING] = {
-/*---------------------------------------------
-|    FORMAT                  | INDEX           |
-----------------------------------------------*/
-    {AUDIO_FORMAT_PCM_16_BIT,  PCM_IDX},
-    {AUDIO_FORMAT_PCM_24_BIT,  PCM_IDX},
-    {AUDIO_FORMAT_AAC,         AAC_IDX},
-    {AUDIO_FORMAT_HE_AAC_V1,   AAC_IDX},
-    {AUDIO_FORMAT_HE_AAC_V2,   AAC_IDX},
-    {AUDIO_FORMAT_AAC_ADIF,    AAC_IDX},
-    {AUDIO_FORMAT_AC3,         AC3_IDX},
-    {AUDIO_FORMAT_AC3_DM,      AC3_IDX},
-    {AUDIO_FORMAT_EAC3,        EAC3_IDX},
-    {AUDIO_FORMAT_EAC3_DM,     EAC3_IDX},
-    {AUDIO_FORMAT_DTS,         DTS_IDX},
-    {AUDIO_FORMAT_DTS_LBR,     DTS_LBR_IDX},
-    {AUDIO_FORMAT_MP3,         MP3_IDX},
-    {AUDIO_FORMAT_WMA,         WMA_IDX},
-    {AUDIO_FORMAT_WMA_PRO,     WMA_PRO_IDX},
-    {AUDIO_FORMAT_MP2,         MP2_IDX}
-};
-
-/*
-Table to query non HDMI and SPDIF devices and their states such as type of
-decode, type of data routed to end device and type of transcoding needed
-*/
-static const int usecase_decode_format[ALL_FORMATS_IDX*NUM_STATES_FOR_EACH_DEVICE_FMT] = {
-/*-----------------
-|    UNCOMPR      |
------------------*/
-/*      PCM    */
-    DSP_DECODE,   //PCM_IDX
-    FORMAT_PCM,   //ROUTE_FORMAT
-    NO_TRANSCODER,//TRANSCODE_FORMAT
-/*      PCM    */
-    SW_DECODE,    // AAC_IDX
-    FORMAT_PCM,   //ROUTE_FORMAT
-    NO_TRANSCODER,//TRANSCODE_FORMAT
-/*      PCM    */
-    SW_DECODE,    //AC3_IDX
-    FORMAT_PCM,   //ROUTE_FORMAT
-    NO_TRANSCODER,//TRANSCODE_FORMAT
-/*      PCM    */
-    SW_DECODE,    //EAC3_IDX
-    FORMAT_PCM,   //ROUTE_FORMAT
-    NO_TRANSCODER,//TRANSCODE_FORMAT
-/*      PCM    */
-    DSP_DECODE,   //DTS_IDX
-    FORMAT_PCM,   //ROUTE_FORMAT
-    NO_TRANSCODER,//TRANSCODE_FORMAT
-/*      PCM    */
-    DSP_DECODE,   //DTS_LBR_IDX
-    FORMAT_PCM,   //ROUTE_FORMAT
-    NO_TRANSCODER,//TRANSCODE_FORMAT
-/*      PCM    */
-    DSP_DECODE,   //MP3_IDX
-    FORMAT_PCM,   //ROUTE_FORMAT
-    NO_TRANSCODER,//TRANSCODE_FORMAT
-/*      PCM    */
-    DSP_DECODE,   //WMA_IDX
-    FORMAT_PCM,   //ROUTE_FORMAT
-    NO_TRANSCODER,//TRANSCODE_FORMAT
-/*      PCM    */
-    DSP_DECODE,   //WMA_PRO_IDX
-    FORMAT_PCM,   //ROUTE_FORMAT
-    NO_TRANSCODER,//TRANSCODE_FORMAT
-/*      PCM    */
-    DSP_DECODE,  //MP2_IDX
-    FORMAT_PCM,  //ROUTE_FORMAT
-    NO_TRANSCODER//TRANSCODE_FORMAT
-};
-/*
-Table to query HDMI and SPDIF devices and their states such as type of
-decode, type of data routed to end device and type of transcoding needed
-*/
-static const int usecase_docode_hdmi_spdif[ALL_FORMATS_IDX*NUM_STATES_FOR_EACH_DEVICE_FMT]
-                                [ALL_DEVICE_FORMATS] = {
-/*-------------------------------------------------------------------------------------------------------------------------------------------------------
-|   UNCOMPRESSED   |     COMPR      |  COMPR_CONV  | COMPR_CONV    |   COMPR_CONV              |      AUTO         | UNCOMPR_MCH    |      AC3_AC3      |
-|                  |                |   EAC3_AC3   |   ANY_AC3     |     ANY_DTS               |                   |                |                   |
---------------------------------------------------------------------------------------------------------------------------------------------------------*/
-/*   PCM            PCM              PCM             PCM             PCM                         PCM               PCM                 PCM   */
-    {DSP_DECODE,    DSP_DECODE,      DSP_DECODE,     DSP_DECODE,     DSP_DECODE|DSP_TRANSCODE,   DSP_DECODE,       DSP_DECODE,         DSP_DECODE},     //PCM_IDX
-    {FORMAT_PCM,    FORMAT_PCM,      FORMAT_PCM,     FORMAT_PCM,     FORMAT_COMPR,               FORMAT_PCM,       FORMAT_PCM,         FORMAT_PCM},   //ROUTE_FORMAT
-    {NO_TRANSCODER, NO_TRANSCODER,   NO_TRANSCODER,  NO_TRANSCODER,  DTS_TRANSCODER,             NO_TRANSCODER,    NO_TRANSCODER,      NO_TRANSCODER}, //TRANSCODE_FMT
-/*   PCM            PCM              PCM             AC3             PCM                         PCM               PCM                 PCM   */
-    {SW_DECODE,     SW_DECODE,       SW_DECODE,      SW_TRANSCODE,   DSP_DECODE,                 SW_DECODE,        SW_DECODE_MCH,      SW_DECODE},     //AAC_IDX
-    {FORMAT_PCM,    FORMAT_PCM,      FORMAT_PCM,     FORMAT_COMPR,   FORMAT_PCM,                 FORMAT_PCM,       FORMAT_PCM,         FORMAT_PCM},     //ROUTE_FORMAT
-    {NO_TRANSCODER, NO_TRANSCODER,   NO_TRANSCODER,  AC3_TRANSCODER, NO_TRANSCODER,              NO_TRANSCODER,    NO_TRANSCODER,      NO_TRANSCODER}, //TRANSCODE_FMT
-/*   PCM            AC3              AC3             AC3             PCM                         AC3               PCM                 AC3   */
-    {SW_DECODE,     SW_PASSTHROUGH,  SW_PASSTHROUGH, SW_PASSTHROUGH, DSP_DECODE,                 SW_PASSTHROUGH,   SW_DECODE_MCH,      SW_TRANSCODE},     //AC3_IDX
-    {FORMAT_PCM,    FORMAT_COMPR,    FORMAT_COMPR,   FORMAT_COMPR,   FORMAT_PCM,                 FORMAT_COMPR,     FORMAT_PCM,         FORMAT_COMPR},     //ROUTE_FORMAT
-    {NO_TRANSCODER, AC3_PASSTHR,     AC3_PASSTHR,    AC3_PASSTHR,    NO_TRANSCODER,              AC3_PASSTHR,      NO_TRANSCODER,      AC3_TRANSCODER},  //TRANSCODE_FMT
-/*   PCM            EAC3             AC3             AC3             PCM                         EAC3              PCM                 PCM   */
-    {SW_DECODE,     SW_PASSTHROUGH,  SW_TRANSCODE,   SW_TRANSCODE,   DSP_DECODE,                 SW_PASSTHROUGH,   SW_DECODE_MCH,      SW_TRANSCODE},     //EAC3_IDX
-    {FORMAT_PCM,    FORMAT_COMPR,    FORMAT_COMPR,   FORMAT_COMPR,   FORMAT_PCM,                 FORMAT_COMPR,     FORMAT_PCM,         FORMAT_COMPR},     //ROUTE_FORMAT
-    {NO_TRANSCODER, EAC3_PASSTHR,    AC3_TRANSCODER, AC3_TRANSCODER, NO_TRANSCODER,              EAC3_PASSTHR,     NO_TRANSCODER,      AC3_TRANSCODER},  //TRANSCODE_FMT
-/*   PCM            DTS              PCM             PCM             DTS                         DTS               PCM                 PCM    */
-    {DSP_DECODE,    DSP_PASSTHROUGH, DSP_DECODE,     DSP_DECODE,     DSP_PASSTHROUGH,            DSP_PASSTHROUGH,  DSP_DECODE,         DSP_DECODE},//DTS_IDX
-    {FORMAT_PCM,    FORMAT_COMPR,    FORMAT_PCM,     FORMAT_PCM,     FORMAT_COMPR,               FORMAT_COMPR,     FORMAT_PCM,         FORMAT_PCM},   //ROUTE_FORMAT
-    {NO_TRANSCODER, DTS_PASSTHR,     NO_TRANSCODER,  NO_TRANSCODER,  DTS_PASSTHR,                DTS_PASSTHR,      NO_TRANSCODER,      NO_TRANSCODER},    //TRANSCODE_FMT
-/*   PCM            DTS_LBR          PCM             PCM             DTS                         DTS               PCM                 PCM    */
-    {DSP_DECODE,    DSP_PASSTHROUGH, DSP_DECODE,     DSP_DECODE,     DSP_PASSTHROUGH,            DSP_PASSTHROUGH,  DSP_DECODE,         DSP_DECODE},//DTS_LBR_IDX
-    {FORMAT_PCM,    FORMAT_COMPR,    FORMAT_PCM,     FORMAT_PCM,     FORMAT_COMPR,               FORMAT_COMPR,     FORMAT_PCM,         FORMAT_PCM},   //ROUTE_FORMAT
-    {NO_TRANSCODER, DTS_PASSTHR,     NO_TRANSCODER,  NO_TRANSCODER,  DTS_PASSTHR,                DTS_PASSTHR,      NO_TRANSCODER,      NO_TRANSCODER},    //TRANSCODE_FMT
-/*   PCM            PCM              PCM             PCM             DTS                         PCM               PCM                 PCM    */
-    {DSP_DECODE,    DSP_DECODE,      DSP_DECODE,     DSP_DECODE,     DSP_DECODE|DSP_TRANSCODE,   DSP_DECODE,       DSP_DECODE,         DSP_DECODE},  //MP3_IDX
-    {FORMAT_PCM,    FORMAT_PCM,      FORMAT_PCM,     FORMAT_PCM,     FORMAT_COMPR,               FORMAT_PCM,       FORMAT_PCM,         FORMAT_PCM},   //ROUTE_FORMAT
-    {NO_TRANSCODER, NO_TRANSCODER,   NO_TRANSCODER,  NO_TRANSCODER,  DTS_TRANSCODER,             NO_TRANSCODER,    NO_TRANSCODER,      NO_TRANSCODER}, //TRANSCODE_FMT
-/*   PCM            PCM              PCM             PCM             DTS                         PCM               PCM                 PCM    */
-    {DSP_DECODE,    DSP_DECODE,      DSP_DECODE,     DSP_DECODE,     DSP_DECODE|DSP_TRANSCODE,   DSP_DECODE,       DSP_DECODE,         DSP_DECODE},  //WMA_IDX
-    {FORMAT_PCM,    FORMAT_PCM,      FORMAT_PCM,     FORMAT_PCM,     FORMAT_COMPR,               FORMAT_PCM,       FORMAT_PCM,         FORMAT_PCM},   //ROUTE_FORMAT
-    {NO_TRANSCODER, NO_TRANSCODER,   NO_TRANSCODER,  NO_TRANSCODER,  DTS_TRANSCODER,             NO_TRANSCODER,    NO_TRANSCODER,      NO_TRANSCODER}, //TRANSCODE_FMT
-/*   PCM            PCM              PCM             PCM             DTS                         PCM               PCM                 PCM    */
-    {DSP_DECODE,    DSP_DECODE,      DSP_DECODE,     DSP_DECODE,     DSP_DECODE|DSP_TRANSCODE,   DSP_DECODE,       DSP_DECODE,         DSP_DECODE},  //WMA_PRO_IDX
-    {FORMAT_PCM,    FORMAT_PCM,      FORMAT_PCM,     FORMAT_PCM,     FORMAT_COMPR,               FORMAT_PCM,       FORMAT_PCM,         FORMAT_PCM},   //ROUTE_FORMAT
-    {NO_TRANSCODER, NO_TRANSCODER,   NO_TRANSCODER,  NO_TRANSCODER,  DTS_TRANSCODER,             NO_TRANSCODER,    NO_TRANSCODER,      NO_TRANSCODER}, //TRANSCODE_FMT
-/*   PCM            PCM              PCM             PCM             DTS                         PCM               PCM                 PCM    */
-    {DSP_DECODE,    DSP_DECODE,      DSP_DECODE,     DSP_DECODE,     DSP_DECODE|DSP_TRANSCODE,   DSP_DECODE,       DSP_DECODE,         DSP_DECODE},  //MP2_IDX
-    {FORMAT_PCM,    FORMAT_PCM,      FORMAT_PCM,     FORMAT_PCM,     FORMAT_COMPR,               FORMAT_PCM,       FORMAT_PCM,         FORMAT_PCM},   //ROUTE_FORMAT
-    {NO_TRANSCODER, NO_TRANSCODER,   NO_TRANSCODER,  NO_TRANSCODER,  DTS_TRANSCODER,             NO_TRANSCODER,    NO_TRANSCODER,      NO_TRANSCODER}  //TRANSCODE_FMT
-};
-/*
-List of decoders which require config as part of first buffer
-*/
-static const int decodersRequireConfig[] = {
-    AUDIO_FORMAT_AAC,
-    AUDIO_FORMAT_HE_AAC_V1,
-    AUDIO_FORMAT_HE_AAC_V2,
-    AUDIO_FORMAT_AAC_ADIF,
-    AUDIO_FORMAT_WMA,
-    AUDIO_FORMAT_WMA_PRO
-};
-/*
-List of enum that are used in Broadcast.
-NOTE: Need to be removed once broadcast is moved with updated states as above
-*/
-enum {
-    INVALID_FORMAT               = -1,
-    PCM_FORMAT                   = 0,
-    COMPRESSED_FORMAT            = 1,
-    COMPRESSED_FORCED_PCM_FORMAT = 2,
-    COMPRESSED_PASSTHROUGH_FORMAT = 3
-};
-
-
-struct audio_bitstream_sm {
-    int                buffering_factor;
-    int                buffering_factor_cnt;
-    // Buffer pointers for input and output
-    char               *inp_buf;
-    char               *inp_buf_curr_ptr;
-    char               *inp_buf_write_ptr;
-    uint32_t           inp_buf_size;
-
-    char               *enc_out_buf;
-    char               *enc_out_buf_write_ptr;
-    uint32_t           enc_out_buf_size;
-
-    char               *pcm_2_out_buf;
-    char               *pcm_2_out_buf_write_ptr;
-    uint32_t           pcm_2_out_buf_size;
-
-    char               *pcm_mch_out_buf;
-    char               *pcm_mch_out_buf_write_ptr;
-    uint32_t           pcm_mch_out_buf_size;
-
-    char               *passt_out_buf;
-    char               *passt_out_buf_write_ptr;
-    uint32_t           passt_out_buf_size;
-};
-
-/*
-Meta data structure for handling compressed output
-*/
-struct output_metadata {
-    uint32_t            metadataLength;
-    uint32_t            bufferLength;
-    uint64_t            timestamp;
-    uint32_t            reserved[12];
-};
-
-#endif // QCOM_AUDIO_PLATFORM_H
diff --git a/hal_mpq/platform_api.h b/hal_mpq/platform_api.h
deleted file mode 100644
index 955aa3b..0000000
--- a/hal_mpq/platform_api.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (c) 2013, The Linux Foundation. All rights reserved.
- * Not a contribution.
- *
- * Copyright (C) 2013 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.
- */
-
-#ifndef QCOM_AUDIO_PLATFORM_API_H
-#define QCOM_AUDIO_PLATFORM_API_H
-
-void *platform_init(struct audio_device *adev);
-void platform_deinit(void *platform);
-const char *platform_get_snd_device_name(snd_device_t snd_device);
-int platform_get_snd_device_name_extn(void *platform, snd_device_t snd_device,
-                                      char *device_name);
-void platform_add_backend_name(char *mixer_path, snd_device_t snd_device);
-int platform_get_pcm_device_id(audio_usecase_t usecase, int device_type);
-int platform_send_audio_calibration(void *platform, snd_device_t snd_device);
-int platform_switch_voice_call_device_pre(void *platform);
-int platform_switch_voice_call_device_post(void *platform,
-                                           snd_device_t out_snd_device,
-                                           snd_device_t in_snd_device);
-int platform_switch_voice_call_usecase_route_post(void *platform,
-                                                  snd_device_t out_snd_device,
-                                                  snd_device_t in_snd_device);
-int platform_start_voice_call(void *platform, uint32_t vsid);
-int platform_stop_voice_call(void *platform, uint32_t vsid);
-int platform_set_voice_volume(void *platform, int volume);
-int platform_set_mic_mute(void *platform, bool state);
-snd_device_t platform_get_output_snd_device(void *platform, audio_devices_t devices);
-snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_device);
-int platform_set_hdmi_channels(void *platform, int channel_count);
-int platform_edid_get_max_channels(void *platform);
-void platform_get_parameters(void *platform, struct str_parms *query,
-                             struct str_parms *reply);
-int platform_set_parameters(void *platform, struct str_parms *parms);
-int platform_set_incall_recoding_session_id(void *platform, uint32_t session_id);
-
-/* returns the latency for a usecase in Us */
-int64_t platform_render_latency(audio_usecase_t usecase);
-int platform_update_usecase_from_source(int source, audio_usecase_t usecase);
-audio_usecase_t platform_get_usecase(audio_usecase_stream_type_t uc_type);
-int platform_free_usecase(audio_usecase_t uc_id);
-
-#endif // QCOM_AUDIO_PLATFORM_API_H
diff --git a/legacy/Android.mk b/legacy/Android.mk
deleted file mode 100644
index 95d9ada..0000000
--- a/legacy/Android.mk
+++ /dev/null
@@ -1,5 +0,0 @@
-ifneq ($(filter msm8960,$(TARGET_BOARD_PLATFORM)),)
-
-include $(call all-subdir-makefiles)
-
-endif
diff --git a/legacy/alsa_sound/ALSAControl.cpp b/legacy/alsa_sound/ALSAControl.cpp
deleted file mode 100644
index 5b2cf31..0000000
--- a/legacy/alsa_sound/ALSAControl.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-/* ALSAControl.cpp
- **
- ** Copyright 2008-2009 Wind River Systems
- ** Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
- **
- ** 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.
- */
-
-#include <errno.h>
-#include <stdarg.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <dlfcn.h>
-
-#define LOG_TAG "ALSAControl"
-//#define LOG_NDEBUG 0
-#define LOG_NDDEBUG 0
-#include <utils/Log.h>
-#include <utils/String8.h>
-
-#include <cutils/properties.h>
-#include <media/AudioRecord.h>
-#include <hardware_legacy/power.h>
-
-#include "AudioHardwareALSA.h"
-
-namespace android_audio_legacy
-{
-
-ALSAControl::ALSAControl(const char *device)
-{
-    ALOGD("ALSAControl: ctor device %s", device);
-    mHandle = mixer_open(device);
-    ALOGV("ALSAControl: ctor mixer %p", mHandle);
-}
-
-ALSAControl::~ALSAControl()
-{
-    if (mHandle) mixer_close(mHandle);
-}
-
-status_t ALSAControl::get(const char *name, unsigned int &value, int index)
-{
-    struct mixer_ctl *ctl;
-
-    if (!mHandle) {
-        ALOGE("Control not initialized");
-        return NO_INIT;
-    }
-
-    ctl =  mixer_get_control(mHandle, name, index);
-    if (!ctl)
-        return BAD_VALUE;
-
-    mixer_ctl_get(ctl, &value);
-    return NO_ERROR;
-}
-
-status_t ALSAControl::set(const char *name, unsigned int value, int index)
-{
-    struct mixer_ctl *ctl;
-    int ret = 0;
-    ALOGD("set:: name %s value %d index %d", name, value, index);
-    if (!mHandle) {
-        ALOGE("Control not initialized");
-        return NO_INIT;
-    }
-
-    // ToDo: Do we need to send index here? Right now it works with 0
-    ctl = mixer_get_control(mHandle, name, 0);
-    if(ctl == NULL) {
-        ALOGE("Could not get the mixer control");
-        return BAD_VALUE;
-    }
-    ret = mixer_ctl_set(ctl, value);
-    return (ret < 0) ? BAD_VALUE : NO_ERROR;
-}
-
-status_t ALSAControl::set(const char *name, const char *value)
-{
-    struct mixer_ctl *ctl;
-    int ret = 0;
-    ALOGD("set:: name %s value %s", name, value);
-
-    if (!mHandle) {
-        ALOGE("Control not initialized");
-        return NO_INIT;
-    }
-
-    ctl = mixer_get_control(mHandle, name, 0);
-    if(ctl == NULL) {
-        ALOGE("Could not get the mixer control");
-        return BAD_VALUE;
-    }
-    ret = mixer_ctl_select(ctl, value);
-    return (ret < 0) ? BAD_VALUE : NO_ERROR;
-}
-
-status_t ALSAControl::setext(const char *name, int count, char **setValues)
-{
-    struct mixer_ctl *ctl;
-    int ret = 0;
-    ALOGD("setext:: name %s count %d", name, count);
-    if (!mHandle) {
-        ALOGE("Control not initialized");
-        return NO_INIT;
-    }
-
-    // ToDo: Do we need to send index here? Right now it works with 0
-    ctl = mixer_get_control(mHandle, name, 0);
-    if(ctl == NULL) {
-        ALOGE("Could not get the mixer control");
-        return BAD_VALUE;
-    }
-    ret = mixer_ctl_set_value(ctl, count, setValues);
-    return (ret < 0) ? BAD_VALUE : NO_ERROR;
-}
-
-};        // namespace android
diff --git a/legacy/alsa_sound/ALSAMixer.cpp b/legacy/alsa_sound/ALSAMixer.cpp
deleted file mode 100644
index d1383cf..0000000
--- a/legacy/alsa_sound/ALSAMixer.cpp
+++ /dev/null
@@ -1,433 +0,0 @@
-/* ALSAMixer.cpp
- **
- ** Copyright 2008-2010 Wind River Systems
- **
- ** 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.
- */
-
-#include <errno.h>
-#include <stdarg.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <dlfcn.h>
-
-#define LOG_TAG "AudioHardwareALSA"
-#include <utils/Log.h>
-#include <utils/String8.h>
-
-#include <cutils/properties.h>
-#include <media/AudioRecord.h>
-#include <hardware_legacy/power.h>
-
-#include "AudioHardwareALSA.h"
-
-#define SND_MIXER_VOL_RANGE_MIN  (0)
-#define SND_MIXER_VOL_RANGE_MAX  (100)
-
-#define ALSA_NAME_MAX 128
-
-#define ALSA_STRCAT(x,y) \
-    if (strlen(x) + strlen(y) < ALSA_NAME_MAX) \
-        strcat(x, y);
-
-namespace android
-{
-
-// ----------------------------------------------------------------------------
-
-struct mixer_info_t;
-
-struct alsa_properties_t
-{
-    const AudioSystem::audio_devices device;
-    const char         *propName;
-    const char         *propDefault;
-    mixer_info_t       *mInfo;
-};
-
-#define ALSA_PROP(dev, name, out, in) \
-    {\
-        {dev, "alsa.mixer.playback." name, out, NULL},\
-        {dev, "alsa.mixer.capture." name, in, NULL}\
-    }
-
-static alsa_properties_t
-mixerMasterProp[SND_PCM_STREAM_LAST+1] =
-        ALSA_PROP(AudioSystem::DEVICE_OUT_ALL, "master", "PCM", "Capture");
-
-static alsa_properties_t
-mixerProp[][SND_PCM_STREAM_LAST+1] = {
-    ALSA_PROP(AudioSystem::DEVICE_OUT_EARPIECE, "earpiece", "Earpiece", "Capture"),
-    ALSA_PROP(AudioSystem::DEVICE_OUT_SPEAKER, "speaker", "Speaker",  ""),
-    ALSA_PROP(AudioSystem::DEVICE_OUT_WIRED_HEADSET, "headset", "Headphone", "Capture"),
-    ALSA_PROP(AudioSystem::DEVICE_OUT_BLUETOOTH_SCO, "bluetooth.sco", "Bluetooth", "Bluetooth Capture"),
-    ALSA_PROP(AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP, "bluetooth.a2dp", "Bluetooth A2DP", "Bluetooth A2DP Capture"),
-    ALSA_PROP(static_cast<AudioSystem::audio_devices>(0), "", NULL, NULL)
-};
-
-struct mixer_info_t
-{
-    mixer_info_t() :
-        elem(0),
-        min(SND_MIXER_VOL_RANGE_MIN),
-        max(SND_MIXER_VOL_RANGE_MAX),
-        mute(false)
-    {
-    }
-
-    snd_mixer_elem_t *elem;
-    long              min;
-    long              max;
-    long              volume;
-    bool              mute;
-    char              name[ALSA_NAME_MAX];
-};
-
-static int initMixer (snd_mixer_t **mixer, const char *name)
-{
-    int err;
-
-    if ((err = snd_mixer_open(mixer, 0)) < 0) {
-        ALOGE("Unable to open mixer: %s", snd_strerror(err));
-        return err;
-    }
-
-    if ((err = snd_mixer_attach(*mixer, name)) < 0) {
-        ALOGW("Unable to attach mixer to device %s: %s",
-            name, snd_strerror(err));
-
-        if ((err = snd_mixer_attach(*mixer, "hw:00")) < 0) {
-            ALOGE("Unable to attach mixer to device default: %s",
-                snd_strerror(err));
-
-            snd_mixer_close (*mixer);
-            *mixer = NULL;
-            return err;
-        }
-    }
-
-    if ((err = snd_mixer_selem_register(*mixer, NULL, NULL)) < 0) {
-        ALOGE("Unable to register mixer elements: %s", snd_strerror(err));
-        snd_mixer_close (*mixer);
-        *mixer = NULL;
-        return err;
-    }
-
-    // Get the mixer controls from the kernel
-    if ((err = snd_mixer_load(*mixer)) < 0) {
-        ALOGE("Unable to load mixer elements: %s", snd_strerror(err));
-        snd_mixer_close (*mixer);
-        *mixer = NULL;
-        return err;
-    }
-
-    return 0;
-}
-
-typedef int (*hasVolume_t)(snd_mixer_elem_t*);
-
-static const hasVolume_t hasVolume[] = {
-    snd_mixer_selem_has_playback_volume,
-    snd_mixer_selem_has_capture_volume
-};
-
-typedef int (*getVolumeRange_t)(snd_mixer_elem_t*, long int*, long int*);
-
-static const getVolumeRange_t getVolumeRange[] = {
-    snd_mixer_selem_get_playback_volume_range,
-    snd_mixer_selem_get_capture_volume_range
-};
-
-typedef int (*setVolume_t)(snd_mixer_elem_t*, long int);
-
-static const setVolume_t setVol[] = {
-    snd_mixer_selem_set_playback_volume_all,
-    snd_mixer_selem_set_capture_volume_all
-};
-
-ALSAMixer::ALSAMixer()
-{
-    int err;
-
-    initMixer (&mMixer[SND_PCM_STREAM_PLAYBACK], "AndroidOut");
-    initMixer (&mMixer[SND_PCM_STREAM_CAPTURE], "AndroidIn");
-
-    snd_mixer_selem_id_t *sid;
-    snd_mixer_selem_id_alloca(&sid);
-
-    for (int i = 0; i <= SND_PCM_STREAM_LAST; i++) {
-
-        if (!mMixer[i]) continue;
-
-        mixer_info_t *info = mixerMasterProp[i].mInfo = new mixer_info_t;
-
-        property_get (mixerMasterProp[i].propName,
-                      info->name,
-                      mixerMasterProp[i].propDefault);
-
-        for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]);
-             elem;
-             elem = snd_mixer_elem_next(elem)) {
-
-            if (!snd_mixer_selem_is_active(elem))
-                continue;
-
-            snd_mixer_selem_get_id(elem, sid);
-
-            // Find PCM playback volume control element.
-            const char *elementName = snd_mixer_selem_id_get_name(sid);
-
-            if (info->elem == NULL &&
-                strcmp(elementName, info->name) == 0 &&
-                hasVolume[i] (elem)) {
-
-                info->elem = elem;
-                getVolumeRange[i] (elem, &info->min, &info->max);
-                info->volume = info->max;
-                setVol[i] (elem, info->volume);
-                if (i == SND_PCM_STREAM_PLAYBACK &&
-                    snd_mixer_selem_has_playback_switch (elem))
-                    snd_mixer_selem_set_playback_switch_all (elem, 1);
-                break;
-            }
-        }
-
-        ALOGV("Mixer: master '%s' %s.", info->name, info->elem ? "found" : "not found");
-
-        for (int j = 0; mixerProp[j][i].device; j++) {
-
-            mixer_info_t *info = mixerProp[j][i].mInfo = new mixer_info_t;
-
-            property_get (mixerProp[j][i].propName,
-                          info->name,
-                          mixerProp[j][i].propDefault);
-
-            for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]);
-                 elem;
-                 elem = snd_mixer_elem_next(elem)) {
-
-                if (!snd_mixer_selem_is_active(elem))
-                    continue;
-
-                snd_mixer_selem_get_id(elem, sid);
-
-                // Find PCM playback volume control element.
-                const char *elementName = snd_mixer_selem_id_get_name(sid);
-
-               if (info->elem == NULL &&
-                    strcmp(elementName, info->name) == 0 &&
-                    hasVolume[i] (elem)) {
-
-                    info->elem = elem;
-                    getVolumeRange[i] (elem, &info->min, &info->max);
-                    info->volume = info->max;
-                    setVol[i] (elem, info->volume);
-                    if (i == SND_PCM_STREAM_PLAYBACK &&
-                        snd_mixer_selem_has_playback_switch (elem))
-                        snd_mixer_selem_set_playback_switch_all (elem, 1);
-                    break;
-                }
-            }
-            ALOGV("Mixer: route '%s' %s.", info->name, info->elem ? "found" : "not found");
-        }
-    }
-    ALOGV("mixer initialized.");
-}
-
-ALSAMixer::~ALSAMixer()
-{
-    for (int i = 0; i <= SND_PCM_STREAM_LAST; i++) {
-        if (mMixer[i]) snd_mixer_close (mMixer[i]);
-        if (mixerMasterProp[i].mInfo) {
-            delete mixerMasterProp[i].mInfo;
-            mixerMasterProp[i].mInfo = NULL;
-        }
-        for (int j = 0; mixerProp[j][i].device; j++) {
-            if (mixerProp[j][i].mInfo) {
-                delete mixerProp[j][i].mInfo;
-                mixerProp[j][i].mInfo = NULL;
-            }
-        }
-    }
-    ALOGV("mixer destroyed.");
-}
-
-status_t ALSAMixer::setMasterVolume(float volume)
-{
-    mixer_info_t *info = mixerMasterProp[SND_PCM_STREAM_PLAYBACK].mInfo;
-    if (!info || !info->elem) return INVALID_OPERATION;
-
-    long minVol = info->min;
-    long maxVol = info->max;
-
-    // Make sure volume is between bounds.
-    long vol = minVol + volume * (maxVol - minVol);
-    if (vol > maxVol) vol = maxVol;
-    if (vol < minVol) vol = minVol;
-
-    info->volume = vol;
-    snd_mixer_selem_set_playback_volume_all (info->elem, vol);
-
-    return NO_ERROR;
-}
-
-status_t ALSAMixer::setMasterGain(float gain)
-{
-    mixer_info_t *info = mixerMasterProp[SND_PCM_STREAM_CAPTURE].mInfo;
-    if (!info || !info->elem) return INVALID_OPERATION;
-
-    long minVol = info->min;
-    long maxVol = info->max;
-
-    // Make sure volume is between bounds.
-    long vol = minVol + gain * (maxVol - minVol);
-    if (vol > maxVol) vol = maxVol;
-    if (vol < minVol) vol = minVol;
-
-    info->volume = vol;
-    snd_mixer_selem_set_capture_volume_all (info->elem, vol);
-
-    return NO_ERROR;
-}
-
-status_t ALSAMixer::setVolume(uint32_t device, float left, float right)
-{
-    for (int j = 0; mixerProp[j][SND_PCM_STREAM_PLAYBACK].device; j++)
-        if (mixerProp[j][SND_PCM_STREAM_PLAYBACK].device & device) {
-
-            mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_PLAYBACK].mInfo;
-            if (!info || !info->elem) return INVALID_OPERATION;
-
-            long minVol = info->min;
-            long maxVol = info->max;
-
-            // Make sure volume is between bounds.
-            long vol = minVol + left * (maxVol - minVol);
-            if (vol > maxVol) vol = maxVol;
-            if (vol < minVol) vol = minVol;
-
-            info->volume = vol;
-            snd_mixer_selem_set_playback_volume_all (info->elem, vol);
-        }
-
-    return NO_ERROR;
-}
-
-status_t ALSAMixer::setGain(uint32_t device, float gain)
-{
-    for (int j = 0; mixerProp[j][SND_PCM_STREAM_CAPTURE].device; j++)
-        if (mixerProp[j][SND_PCM_STREAM_CAPTURE].device & device) {
-
-            mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_CAPTURE].mInfo;
-            if (!info || !info->elem) return INVALID_OPERATION;
-
-            long minVol = info->min;
-            long maxVol = info->max;
-
-            // Make sure volume is between bounds.
-            long vol = minVol + gain * (maxVol - minVol);
-            if (vol > maxVol) vol = maxVol;
-            if (vol < minVol) vol = minVol;
-
-            info->volume = vol;
-            snd_mixer_selem_set_capture_volume_all (info->elem, vol);
-        }
-
-    return NO_ERROR;
-}
-
-status_t ALSAMixer::setCaptureMuteState(uint32_t device, bool state)
-{
-    for (int j = 0; mixerProp[j][SND_PCM_STREAM_CAPTURE].device; j++)
-        if (mixerProp[j][SND_PCM_STREAM_CAPTURE].device & device) {
-
-            mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_CAPTURE].mInfo;
-            if (!info || !info->elem) return INVALID_OPERATION;
-
-            if (snd_mixer_selem_has_capture_switch (info->elem)) {
-
-                int err = snd_mixer_selem_set_capture_switch_all (info->elem, static_cast<int>(!state));
-                if (err < 0) {
-                    ALOGE("Unable to %s capture mixer switch %s",
-                        state ? "enable" : "disable", info->name);
-                    return INVALID_OPERATION;
-                }
-            }
-
-            info->mute = state;
-        }
-
-    return NO_ERROR;
-}
-
-status_t ALSAMixer::getCaptureMuteState(uint32_t device, bool *state)
-{
-    if (!state) return BAD_VALUE;
-
-    for (int j = 0; mixerProp[j][SND_PCM_STREAM_CAPTURE].device; j++)
-        if (mixerProp[j][SND_PCM_STREAM_CAPTURE].device & device) {
-
-            mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_CAPTURE].mInfo;
-            if (!info || !info->elem) return INVALID_OPERATION;
-
-            *state = info->mute;
-            return NO_ERROR;
-        }
-
-    return BAD_VALUE;
-}
-
-status_t ALSAMixer::setPlaybackMuteState(uint32_t device, bool state)
-{
-    for (int j = 0; mixerProp[j][SND_PCM_STREAM_PLAYBACK].device; j++)
-        if (mixerProp[j][SND_PCM_STREAM_PLAYBACK].device & device) {
-
-            mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_PLAYBACK].mInfo;
-            if (!info || !info->elem) return INVALID_OPERATION;
-
-            if (snd_mixer_selem_has_playback_switch (info->elem)) {
-
-                int err = snd_mixer_selem_set_playback_switch_all (info->elem, static_cast<int>(!state));
-                if (err < 0) {
-                    ALOGE("Unable to %s playback mixer switch %s",
-                        state ? "enable" : "disable", info->name);
-                    return INVALID_OPERATION;
-                }
-            }
-
-            info->mute = state;
-        }
-
-    return NO_ERROR;
-}
-
-status_t ALSAMixer::getPlaybackMuteState(uint32_t device, bool *state)
-{
-    if (!state) return BAD_VALUE;
-
-    for (int j = 0; mixerProp[j][SND_PCM_STREAM_PLAYBACK].device; j++)
-        if (mixerProp[j][SND_PCM_STREAM_PLAYBACK].device & device) {
-
-            mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_PLAYBACK].mInfo;
-            if (!info || !info->elem) return INVALID_OPERATION;
-
-            *state = info->mute;
-            return NO_ERROR;
-        }
-
-    return BAD_VALUE;
-}
-
-};        // namespace android
diff --git a/legacy/alsa_sound/ALSAStreamOps.cpp b/legacy/alsa_sound/ALSAStreamOps.cpp
deleted file mode 100644
index ad9a117..0000000
--- a/legacy/alsa_sound/ALSAStreamOps.cpp
+++ /dev/null
@@ -1,375 +0,0 @@
-/* ALSAStreamOps.cpp
- **
- ** Copyright 2008-2009 Wind River Systems
- ** Copyright (c) 2011, The Linux Foundation. All rights reserved.
- **
- ** 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.
- */
-
-#include <errno.h>
-#include <stdarg.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <dlfcn.h>
-
-#define LOG_TAG "ALSAStreamOps"
-//#define LOG_NDEBUG 0
-#define LOG_NDDEBUG 0
-#include <utils/Log.h>
-#include <utils/String8.h>
-
-#include <cutils/properties.h>
-#include <media/AudioRecord.h>
-#include <hardware_legacy/power.h>
-#include "AudioUtil.h"
-#include "AudioHardwareALSA.h"
-
-namespace android_audio_legacy
-{
-
-// unused 'enumVal;' is to catch error at compile time if enumVal ever changes
-// or applied on a non-existent enum
-#define ENUM_TO_STRING(var, enumVal) {var = #enumVal; enumVal;}
-
-// ----------------------------------------------------------------------------
-
-ALSAStreamOps::ALSAStreamOps(AudioHardwareALSA *parent, alsa_handle_t *handle) :
-    mParent(parent),
-    mHandle(handle)
-{
-}
-
-ALSAStreamOps::~ALSAStreamOps()
-{
-    Mutex::Autolock autoLock(mParent->mLock);
-
-    if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
-       (!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
-        if((mParent->mVoipStreamCount)) {
-            mParent->mVoipStreamCount--;
-            if(mParent->mVoipStreamCount > 0) {
-                ALOGD("ALSAStreamOps::close() Ignore");
-                return ;
-            }
-       }
-       mParent->mVoipStreamCount = 0;
-       mParent->mVoipBitRate = 0;
-    }
-    close();
-
-    for(ALSAHandleList::iterator it = mParent->mDeviceList.begin();
-            it != mParent->mDeviceList.end(); ++it) {
-            if (mHandle == &(*it)) {
-                it->useCase[0] = 0;
-                mParent->mDeviceList.erase(it);
-                break;
-            }
-    }
-}
-
-// use emulated popcount optimization
-// http://www.df.lth.se/~john_e/gems/gem002d.html
-static inline uint32_t popCount(uint32_t u)
-{
-    u = ((u&0x55555555) + ((u>>1)&0x55555555));
-    u = ((u&0x33333333) + ((u>>2)&0x33333333));
-    u = ((u&0x0f0f0f0f) + ((u>>4)&0x0f0f0f0f));
-    u = ((u&0x00ff00ff) + ((u>>8)&0x00ff00ff));
-    u = ( u&0x0000ffff) + (u>>16);
-    return u;
-}
-
-status_t ALSAStreamOps::set(int      *format,
-                            uint32_t *channels,
-                            uint32_t *rate,
-                            uint32_t device)
-{
-    mDevices = device;
-    if (channels && *channels != 0) {
-        if (mHandle->channels != popCount(*channels))
-            return BAD_VALUE;
-    } else if (channels) {
-        if (mHandle->devices & AudioSystem::DEVICE_OUT_ALL) {
-            switch(*channels) {
-                case AUDIO_CHANNEL_OUT_5POINT1: // 5.0
-                case (AUDIO_CHANNEL_OUT_QUAD | AUDIO_CHANNEL_OUT_FRONT_CENTER): // 5.1
-                case AUDIO_CHANNEL_OUT_QUAD:
-                case AUDIO_CHANNEL_OUT_STEREO:
-                case AUDIO_CHANNEL_OUT_MONO:
-                    break;
-                default:
-                    *channels = AUDIO_CHANNEL_OUT_STEREO;
-                    return BAD_VALUE;
-            }
-        } else {
-            switch(*channels) {
-#ifdef QCOM_SSR_ENABLED
-                // For 5.1 recording
-                case AudioSystem::CHANNEL_IN_5POINT1:
-#endif
-                    // Do not fall through...
-                case AUDIO_CHANNEL_IN_MONO:
-                case AUDIO_CHANNEL_IN_STEREO:
-                case AUDIO_CHANNEL_IN_FRONT_BACK:
-                    break;
-                default:
-                    *channels = AUDIO_CHANNEL_IN_MONO;
-                    return BAD_VALUE;
-            }
-        }
-    }
-
-    if (rate && *rate > 0) {
-        if (mHandle->sampleRate != *rate)
-            return BAD_VALUE;
-    } else if (rate) {
-        *rate = mHandle->sampleRate;
-    }
-
-    snd_pcm_format_t iformat = mHandle->format;
-
-    if (format) {
-        switch(*format) {
-            case AudioSystem::FORMAT_DEFAULT:
-                break;
-
-            case AudioSystem::PCM_16_BIT:
-                iformat = SNDRV_PCM_FORMAT_S16_LE;
-                break;
-            case AudioSystem::AMR_NB:
-            case AudioSystem::AMR_WB:
-#ifdef QCOM_QCHAT_ENABLED
-            case AudioSystem::EVRC:
-            case AudioSystem::EVRCB:
-            case AudioSystem::EVRCWB:
-#endif
-                iformat = *format;
-                break;
-
-            case AudioSystem::PCM_8_BIT:
-                iformat = SNDRV_PCM_FORMAT_S8;
-                break;
-
-            default:
-                ALOGE("Unknown PCM format %i. Forcing default", *format);
-                break;
-        }
-
-        if (mHandle->format != iformat)
-            return BAD_VALUE;
-
-        switch(iformat) {
-            case SNDRV_PCM_FORMAT_S16_LE:
-                *format = AudioSystem::PCM_16_BIT;
-                break;
-            case SNDRV_PCM_FORMAT_S8:
-                *format = AudioSystem::PCM_8_BIT;
-                break;
-            default:
-                break;
-        }
-    }
-
-    return NO_ERROR;
-}
-
-status_t ALSAStreamOps::setParameters(const String8& keyValuePairs)
-{
-    AudioParameter param = AudioParameter(keyValuePairs);
-    String8 key = String8(AudioParameter::keyRouting);
-    int device;
-
-#ifdef SEPERATED_AUDIO_INPUT
-    String8 key_input = String8(AudioParameter::keyInputSource);
-    int source;
-
-    if (param.getInt(key_input, source) == NO_ERROR) {
-        ALOGD("setParameters(), input_source = %d", source);
-        mParent->mALSADevice->setInput(source);
-        param.remove(key_input);
-    }
-#endif
-
-    if (param.getInt(key, device) == NO_ERROR) {
-        // Ignore routing if device is 0.
-        ALOGD("setParameters(): keyRouting with device 0x%x", device);
-        // reset to speaker when disconnecting HDMI to avoid timeout due to write errors
-        if ((device == 0) && (mDevices == AudioSystem::DEVICE_OUT_AUX_DIGITAL)) {
-            device = AudioSystem::DEVICE_OUT_SPEAKER;
-        }
-        if (device)
-            mDevices = device;
-        else
-            ALOGV("must not change mDevices to 0");
-
-        if(device) {
-            mParent->doRouting(device);
-        }
-        param.remove(key);
-    }
-#ifdef QCOM_FM_ENABLED
-    else {
-        key = String8(AudioParameter::keyHandleFm);
-        if (param.getInt(key, device) == NO_ERROR) {
-        ALOGD("setParameters(): handleFm with device %d", device);
-        mDevices = device;
-            if(device) {
-                mParent->handleFm(device);
-            }
-            param.remove(key);
-        }
-    }
-#endif
-
-    return NO_ERROR;
-}
-
-String8 ALSAStreamOps::getParameters(const String8& keys)
-{
-    AudioParameter param = AudioParameter(keys);
-    String8 value;
-    String8 key = String8(AudioParameter::keyRouting);
-
-    if (param.get(key, value) == NO_ERROR) {
-        param.addInt(key, (int)mDevices);
-    }
-    else {
-#ifdef QCOM_VOIP_ENABLED
-        key = String8(AudioParameter::keyVoipCheck);
-        if (param.get(key, value) == NO_ERROR) {
-            if((!strncmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL, strlen(SND_USE_CASE_VERB_IP_VOICECALL))) ||
-               (!strncmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP, strlen(SND_USE_CASE_MOD_PLAY_VOIP))))
-                param.addInt(key, true);
-            else
-                param.addInt(key, false);
-        }
-#endif
-    }
-    key = String8(AUDIO_PARAMETER_STREAM_SUP_CHANNELS);
-    if (param.get(key, value) == NO_ERROR) {
-        EDID_AUDIO_INFO info = { 0 };
-        bool first = true;
-        value = String8();
-        if (AudioUtil::getHDMIAudioSinkCaps(&info)) {
-            for (int i = 0; i < info.nAudioBlocks && i < MAX_EDID_BLOCKS; i++) {
-                String8 append;
-                switch (info.AudioBlocksArray[i].nChannels) {
-                //Do not handle stereo output in Multi-channel cases
-                //Stereo case is handled in normal playback path
-                case 6:
-                    ENUM_TO_STRING(append, AUDIO_CHANNEL_OUT_5POINT1);
-                    break;
-                case 8:
-                    ENUM_TO_STRING(append, AUDIO_CHANNEL_OUT_7POINT1);
-                    break;
-                default:
-                    ALOGD("Unsupported number of channels %d", info.AudioBlocksArray[i].nChannels);
-                    break;
-                }
-                if (!append.isEmpty()) {
-                    value += (first ? append : String8("|") + append);
-                    first = false;
-                }
-            }
-        } else {
-            ALOGE("Failed to get HDMI sink capabilities");
-        }
-        param.add(key, value);
-    }
-    ALOGV("getParameters() %s", param.toString().string());
-    return param.toString();
-}
-
-uint32_t ALSAStreamOps::sampleRate() const
-{
-    return mHandle->sampleRate;
-}
-
-//
-// Return the number of bytes (not frames)
-//
-size_t ALSAStreamOps::bufferSize() const
-{
-    ALOGV("bufferSize() returns %d", mHandle->bufferSize);
-    return mHandle->bufferSize;
-}
-
-int ALSAStreamOps::format() const
-{
-    int audioSystemFormat;
-
-    snd_pcm_format_t ALSAFormat = mHandle->format;
-
-    switch(ALSAFormat) {
-        case SNDRV_PCM_FORMAT_S8:
-             audioSystemFormat = AudioSystem::PCM_8_BIT;
-             break;
-
-        case AudioSystem::AMR_NB:
-        case AudioSystem::AMR_WB:
-#ifdef QCOM_QCHAT_ENABLED
-        case AudioSystem::EVRC:
-        case AudioSystem::EVRCB:
-        case AudioSystem::EVRCWB:
-#endif
-            audioSystemFormat = mHandle->format;
-            break;
-        case SNDRV_PCM_FORMAT_S16_LE:
-            audioSystemFormat = AudioSystem::PCM_16_BIT;
-            break;
-
-        default:
-            LOG_FATAL("Unknown AudioSystem bit width %d!", audioSystemFormat);
-            audioSystemFormat = AudioSystem::PCM_16_BIT;
-            break;
-    }
-
-    ALOGV("ALSAFormat:0x%x,audioSystemFormat:0x%x",ALSAFormat,audioSystemFormat);
-    return audioSystemFormat;
-}
-
-uint32_t ALSAStreamOps::channels() const
-{
-    return mHandle->channelMask;
-}
-
-void ALSAStreamOps::close()
-{
-    ALOGD("close");
-    if((!strncmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL, strlen(SND_USE_CASE_VERB_IP_VOICECALL))) ||
-       (!strncmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP, strlen(SND_USE_CASE_MOD_PLAY_VOIP)))) {
-       mParent->mVoipBitRate = 0;
-       mParent->mVoipStreamCount = 0;
-    }
-    mParent->mALSADevice->close(mHandle);
-}
-
-//
-// Set playback or capture PCM device.  It's possible to support audio output
-// or input from multiple devices by using the ALSA plugins, but this is
-// not supported for simplicity.
-//
-// The AudioHardwareALSA API does not allow one to set the input routing.
-//
-// If the "routes" value does not map to a valid device, the default playback
-// device is used.
-//
-status_t ALSAStreamOps::open(int mode)
-{
-    ALOGD("open");
-    return mParent->mALSADevice->open(mHandle);
-}
-
-}       // namespace androidi_audio_legacy
diff --git a/legacy/alsa_sound/Android.mk b/legacy/alsa_sound/Android.mk
deleted file mode 100644
index 534dd6a..0000000
--- a/legacy/alsa_sound/Android.mk
+++ /dev/null
@@ -1,141 +0,0 @@
-# hardware/libaudio-alsa/Android.mk
-#
-# Copyright 2008 Wind River Systems
-#
-
-ifeq ($(strip $(BOARD_USES_ALSA_AUDIO)),true)
-
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_ARM_MODE := arm
-LOCAL_CFLAGS := -D_POSIX_SOURCE
-LOCAL_CFLAGS += -DQCOM_CSDCLIENT_ENABLED
-LOCAL_CFLAGS += -DQCOM_ACDB_ENABLED
-
-ifeq ($(strip $(BOARD_USES_FLUENCE_INCALL)),true)
-LOCAL_CFLAGS += -DUSES_FLUENCE_INCALL
-endif
-
-ifeq ($(strip $(BOARD_USES_SEPERATED_AUDIO_INPUT)),true)
-LOCAL_CFLAGS += -DSEPERATED_AUDIO_INPUT
-endif
-
-LOCAL_SRC_FILES := \
-  AudioHardwareALSA.cpp 	\
-  AudioStreamOutALSA.cpp 	\
-  AudioStreamInALSA.cpp 	\
-  ALSAStreamOps.cpp		\
-  audio_hw_hal.cpp \
-  AudioUsbALSA.cpp \
-  AudioUtil.cpp
-
-LOCAL_STATIC_LIBRARIES := \
-    libmedia_helper \
-    libaudiohw_legacy \
-    libaudiopolicy_legacy \
-
-LOCAL_SHARED_LIBRARIES := \
-    libcutils \
-    libutils \
-    libmedia \
-    libhardware \
-    libc        \
-    libpower    \
-    libalsa-intf
-
-ifeq ($(TARGET_SIMULATOR),true)
- LOCAL_LDLIBS += -ldl
-else
- LOCAL_SHARED_LIBRARIES += libdl
-endif
-
-LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/audio-alsa
-LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/libalsa-intf
-LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/surround_sound/
-LOCAL_C_INCLUDES += hardware/libhardware/include
-LOCAL_C_INCLUDES += hardware/libhardware_legacy/include
-LOCAL_C_INCLUDES += frameworks/base/include
-LOCAL_C_INCLUDES += system/core/include
-
-
-LOCAL_MODULE := audio.primary.msm8960
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
-LOCAL_MODULE_TAGS := optional
-
-include $(BUILD_SHARED_LIBRARY)
-
-# This is the ALSA audio policy manager
-
-include $(CLEAR_VARS)
-
-LOCAL_CFLAGS := -D_POSIX_SOURCE
-LOCAL_CFLAGS += -DQCOM_ACDB_ENABLED
-
-LOCAL_SRC_FILES := \
-    audio_policy_hal.cpp \
-    AudioPolicyManagerALSA.cpp
-
-LOCAL_MODULE := audio_policy.msm8960
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_STATIC_LIBRARIES := \
-    libmedia_helper \
-    libaudiopolicy_legacy
-
-LOCAL_SHARED_LIBRARIES := \
-    libcutils \
-    libutils
-
-LOCAL_C_INCLUDES += hardware/libhardware_legacy/audio
-
-include $(BUILD_SHARED_LIBRARY)
-
-# This is the ALSA module which behaves closely like the original
-
-include $(CLEAR_VARS)
-
-LOCAL_PRELINK_MODULE := false
-
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
-
-LOCAL_CFLAGS := -D_POSIX_SOURCE -Wno-multichar
-LOCAL_CFLAGS += -DQCOM_ACDB_ENABLED
-
-ifeq ($(strip $(BOARD_USES_FLUENCE_INCALL)),true)
-LOCAL_CFLAGS += -DUSES_FLUENCE_INCALL
-endif
-
-ifeq ($(strip $(BOARD_USES_SEPERATED_AUDIO_INPUT)),true)
-LOCAL_CFLAGS += -DSEPERATED_AUDIO_INPUT
-endif
-
-ifneq ($(ALSA_DEFAULT_SAMPLE_RATE),)
-    LOCAL_CFLAGS += -DALSA_DEFAULT_SAMPLE_RATE=$(ALSA_DEFAULT_SAMPLE_RATE)
-endif
-
-LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/libalsa-intf
-
-LOCAL_SRC_FILES:= \
-    alsa_default.cpp \
-    ALSAControl.cpp \
-    AudioUtil.cpp
-
-LOCAL_SHARED_LIBRARIES := \
-    libcutils \
-    liblog    \
-    libalsa-intf
-
-ifeq ($(TARGET_SIMULATOR),true)
- LOCAL_LDLIBS += -ldl
-else
- LOCAL_SHARED_LIBRARIES += libdl
-endif
-
-LOCAL_MODULE:= alsa.msm8960
-LOCAL_MODULE_TAGS := optional
-
-  include $(BUILD_SHARED_LIBRARY)
-endif
diff --git a/legacy/alsa_sound/AudioHardwareALSA.cpp b/legacy/alsa_sound/AudioHardwareALSA.cpp
deleted file mode 100644
index c61a3e8..0000000
--- a/legacy/alsa_sound/AudioHardwareALSA.cpp
+++ /dev/null
@@ -1,1707 +0,0 @@
-/* AudioHardwareALSA.cpp
- **
- ** Copyright 2008-2010 Wind River Systems
- ** Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
- **
- ** 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.
- */
-
-#include <errno.h>
-#include <stdarg.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <dlfcn.h>
-#include <math.h>
-
-#define LOG_TAG "AudioHardwareALSA"
-//#define LOG_NDEBUG 0
-#define LOG_NDDEBUG 0
-#include <utils/Log.h>
-#include <utils/String8.h>
-#include <sys/prctl.h>
-#include <sys/resource.h>
-#include <sys/poll.h>
-#include <sys/ioctl.h>
-#include <cutils/properties.h>
-#include <media/AudioRecord.h>
-#include <hardware_legacy/power.h>
-
-#include "AudioHardwareALSA.h"
-#ifdef QCOM_USBAUDIO_ENABLED
-#include "AudioUsbALSA.h"
-#endif
-#include "AudioUtil.h"
-
-extern "C"
-{
-    //
-    // Function for dlsym() to look up for creating a new AudioHardwareInterface.
-    //
-    android_audio_legacy::AudioHardwareInterface *createAudioHardware(void) {
-        return android_audio_legacy::AudioHardwareALSA::create();
-    }
-#ifdef QCOM_ACDB_ENABLED
-    static int (*acdb_init)();
-    static void (*acdb_deallocate)();
-#endif
-#ifdef QCOM_CSDCLIENT_ENABLED
-    static int (*csd_client_init)();
-    static int (*csd_client_deinit)();
-    static int (*csd_start_playback)();
-    static int (*csd_stop_playback)();
-#endif
-}         // extern "C"
-
-namespace android_audio_legacy
-{
-
-// ----------------------------------------------------------------------------
-
-AudioHardwareInterface *AudioHardwareALSA::create() {
-    return new AudioHardwareALSA();
-}
-
-AudioHardwareALSA::AudioHardwareALSA() :
-    mALSADevice(0),mVoipStreamCount(0),mVoipBitRate(0)
-    ,mCallState(0),mAcdbHandle(NULL),mCsdHandle(NULL),mMicMute(0)
-{
-    FILE *fp;
-    char soundCardInfo[200];
-    hw_module_t *module;
-    char platform[128], baseband[128];
-    int err = hw_get_module(ALSA_HARDWARE_MODULE_ID,
-            (hw_module_t const**)&module);
-    int codec_rev = 2;
-    ALOGD("hw_get_module(ALSA_HARDWARE_MODULE_ID) returned err %d", err);
-    if (err == 0) {
-        hw_device_t* device;
-        err = module->methods->open(module, ALSA_HARDWARE_NAME, &device);
-        if (err == 0) {
-            mALSADevice = (alsa_device_t *)device;
-            mALSADevice->init(mALSADevice, mDeviceList);
-            mCSCallActive = 0;
-            mVolteCallActive = 0;
-            mIsFmActive = 0;
-            mDevSettingsFlag = 0;
-#ifdef QCOM_USBAUDIO_ENABLED
-            mAudioUsbALSA = new AudioUsbALSA();
-            musbPlaybackState = 0;
-            musbRecordingState = 0;
-#endif
-#ifdef USES_FLUENCE_INCALL
-            mDevSettingsFlag |= TTY_OFF | DMIC_FLAG;
-#else
-            mDevSettingsFlag |= TTY_OFF;
-#endif
-            mBluetoothVGS = false;
-            mFusion3Platform = false;
-
-#ifdef QCOM_ACDB_ENABLED
-            mAcdbHandle = ::dlopen("/system/lib/libacdbloader.so", RTLD_NOW);
-            if (mAcdbHandle == NULL) {
-                ALOGE("AudioHardware: DLOPEN not successful for ACDBLOADER");
-            } else {
-                ALOGD("AudioHardware: DLOPEN successful for ACDBLOADER");
-                acdb_init = (int (*)())::dlsym(mAcdbHandle,"acdb_loader_init_ACDB");
-                if (acdb_init == NULL) {
-                    ALOGE("dlsym:Error:%s Loading acdb_loader_init_ACDB", dlerror());
-                }else {
-                   acdb_init();
-                   acdb_deallocate = (void (*)())::dlsym(mAcdbHandle,"acdb_loader_deallocate_ACDB");
-                }
-            }
-#endif
-
-#ifdef QCOM_CSDCLIENT_ENABLED
-             mCsdHandle = ::dlopen("/system/lib/libcsd-client.so", RTLD_NOW);
-             if (mCsdHandle == NULL) {
-                 ALOGE("AudioHardware: DLOPEN not successful for CSD CLIENT");
-             } else {
-                 ALOGD("AudioHardware: DLOPEN successful for CSD CLIENT");
-                 csd_client_init = (int (*)())::dlsym(mCsdHandle,"csd_client_init");
-                 csd_client_deinit = (int (*)())::dlsym(mCsdHandle,"csd_client_deinit");
-                 csd_start_playback = (int (*)())::dlsym(mCsdHandle,"csd_client_start_playback");
-                 csd_stop_playback = (int (*)())::dlsym(mCsdHandle,"csd_client_stop_playback");
-
-                 if (csd_client_init == NULL) {
-                    ALOGE("dlsym: Error:%s Loading csd_client_init", dlerror());
-                 } else {
-                    csd_client_init();
-                 }
-             }
-             mALSADevice->setCsdHandle(mCsdHandle);
-#endif
-            if((fp = fopen("/proc/asound/cards","r")) == NULL) {
-                ALOGE("Cannot open /proc/asound/cards file to get sound card info");
-            } else {
-                while((fgets(soundCardInfo, sizeof(soundCardInfo), fp) != NULL)) {
-                    ALOGV("SoundCardInfo %s", soundCardInfo);
-                    if (strstr(soundCardInfo, "msm8960-tabla1x-snd-card")) {
-                        codec_rev = 1;
-                        break;
-                    } else if (strstr(soundCardInfo, "msm-snd-card")) {
-                        codec_rev = 2;
-                        break;
-                    } else if (strstr(soundCardInfo, "msm8930-sitar-snd-card")) {
-                        codec_rev = 3;
-                        break;
-                    }
-                }
-                fclose(fp);
-            }
-
-            if (codec_rev == 1) {
-                    ALOGV("Detected tabla 1.x sound card");
-                    snd_use_case_mgr_open(&mUcMgr, "snd_soc_msm");
-            } else if (codec_rev == 3) {
-                    ALOGV("Detected sitar 1.x sound card");
-                    snd_use_case_mgr_open(&mUcMgr, "snd_soc_msm_Sitar");
-            } else {
-                    property_get("ro.board.platform", platform, "");
-                    property_get("ro.baseband", baseband, "");
-                    if (!strcmp("msm8960", platform) && !strcmp("mdm", baseband)) {
-                        ALOGV("Detected Fusion tabla 2.x");
-                        mFusion3Platform = true;
-                        snd_use_case_mgr_open(&mUcMgr, "snd_soc_msm_2x_Fusion3");
-                    } else {
-                        ALOGV("Detected tabla 2.x sound card");
-                        snd_use_case_mgr_open(&mUcMgr, "snd_soc_msm_2x");
-                    }
-            }
-
-            if (mUcMgr < 0) {
-                ALOGE("Failed to open ucm instance: %d", errno);
-            } else {
-                ALOGI("ucm instance opened: %u", (unsigned)mUcMgr);
-                mUcMgr->acdb_handle = NULL;
-#ifdef QCOM_ACDB_ENABLED
-                if (mAcdbHandle) {
-                    mUcMgr->acdb_handle = static_cast<void*> (mAcdbHandle);
-                    if (mFusion3Platform)
-                        mUcMgr->isFusion3Platform = true;
-                    else
-                        mUcMgr->isFusion3Platform = false;
-                }
-#endif
-            }
-        } else {
-            ALOGE("ALSA Module could not be opened!!!");
-        }
-    } else {
-        ALOGE("ALSA Module not found!!!");
-    }
-}
-
-AudioHardwareALSA::~AudioHardwareALSA()
-{
-    if (mUcMgr != NULL) {
-        ALOGV("closing ucm instance: %u", (unsigned)mUcMgr);
-        snd_use_case_mgr_close(mUcMgr);
-    }
-    if (mALSADevice) {
-        mALSADevice->common.close(&mALSADevice->common);
-    }
-    for(ALSAHandleList::iterator it = mDeviceList.begin();
-            it != mDeviceList.end(); ++it) {
-        it->useCase[0] = 0;
-        mDeviceList.erase(it);
-    }
-#ifdef QCOM_ACDB_ENABLED
-     if (acdb_deallocate == NULL) {
-        ALOGE("dlsym: Error:%s Loading acdb_deallocate_ACDB", dlerror());
-     } else {
-        acdb_deallocate();
-     }
-     if (mAcdbHandle) {
-        ::dlclose(mAcdbHandle);
-        mAcdbHandle = NULL;
-     }
-#endif
-#ifdef QCOM_USBAUDIO_ENABLED
-    delete mAudioUsbALSA;
-#endif
-
-#ifdef QCOM_CSDCLEINT_ENABLED
-     if (mCsdHandle) {
-         if (csd_client_deinit == NULL) {
-             ALOGE("dlsym: Error:%s Loading csd_client_deinit", dlerror());
-         } else {
-             csd_client_deinit();
-         }
-         ::dlclose(mCsdHandle);
-         mCsdHandle = NULL;
-     }
-#endif
-}
-
-status_t AudioHardwareALSA::initCheck()
-{
-    if (!mALSADevice)
-        return NO_INIT;
-
-    return NO_ERROR;
-}
-
-status_t AudioHardwareALSA::setVoiceVolume(float v)
-{
-    ALOGV("setVoiceVolume(%f)\n", v);
-    if (v < 0.0) {
-        ALOGW("setVoiceVolume(%f) under 0.0, assuming 0.0\n", v);
-        v = 0.0;
-    } else if (v > 1.0) {
-        ALOGW("setVoiceVolume(%f) over 1.0, assuming 1.0\n", v);
-        v = 1.0;
-    }
-
-    int newMode = mode();
-    ALOGV("setVoiceVolume  newMode %d",newMode);
-    int vol = lrint(v * 100.0);
-
-    // Voice volume levels from android are mapped to driver volume levels as follows.
-    // 0 -> 5, 20 -> 4, 40 ->3, 60 -> 2, 80 -> 1, 100 -> 0
-    // So adjust the volume to get the correct volume index in driver
-    vol = 100 - vol;
-
-    if (mALSADevice) {
-        if(newMode == AudioSystem::MODE_IN_COMMUNICATION) {
-            mALSADevice->setVoipVolume(vol);
-        } else if (newMode == AudioSystem::MODE_IN_CALL){
-               if (mCSCallActive == CS_ACTIVE)
-                   mALSADevice->setVoiceVolume(vol);
-               if (mVolteCallActive == IMS_ACTIVE)
-                   mALSADevice->setVoLTEVolume(vol);
-        }
-    }
-
-    return NO_ERROR;
-}
-
-#ifdef QCOM_FM_ENABLED
-status_t  AudioHardwareALSA::setFmVolume(float value)
-{
-    status_t status = NO_ERROR;
-
-    int vol;
-
-    if (value < 0.0) {
-        ALOGW("setFmVolume(%f) under 0.0, assuming 0.0\n", value);
-        value = 0.0;
-    } else if (value > 1.0) {
-        ALOGW("setFmVolume(%f) over 1.0, assuming 1.0\n", value);
-        value = 1.0;
-    }
-    vol  = lrint((value * 0x2000) + 0.5);
-
-    ALOGV("setFmVolume(%f)\n", value);
-    ALOGV("Setting FM volume to %d (available range is 0 to 0x2000)\n", vol);
-
-    mALSADevice->setFmVolume(vol);
-
-    return status;
-}
-#endif
-
-status_t AudioHardwareALSA::setMasterVolume(float volume)
-{
-    return NO_ERROR;
-}
-
-status_t AudioHardwareALSA::setMode(int mode)
-{
-    status_t status = NO_ERROR;
-
-    if (mode != mMode) {
-        status = AudioHardwareBase::setMode(mode);
-    }
-
-    if (mode == AudioSystem::MODE_IN_CALL) {
-        mCallState = CS_ACTIVE;
-    }else if (mode == AudioSystem::MODE_NORMAL) {
-        mCallState = 0;
-    }
-
-    return status;
-}
-
-status_t AudioHardwareALSA::setParameters(const String8& keyValuePairs)
-{
-    AudioParameter param = AudioParameter(keyValuePairs);
-    String8 key;
-    String8 value;
-    status_t status = NO_ERROR;
-    int device;
-    int btRate;
-    int state;
-    ALOGV("setParameters() %s", keyValuePairs.string());
-
-    key = String8(TTY_MODE_KEY);
-    if (param.get(key, value) == NO_ERROR) {
-        mDevSettingsFlag &= TTY_CLEAR;
-        if (value == "tty_full") {
-            mDevSettingsFlag |= TTY_FULL;
-        } else if (value == "tty_hco") {
-            mDevSettingsFlag |= TTY_HCO;
-        } else if (value == "tty_vco") {
-            mDevSettingsFlag |= TTY_VCO;
-        } else {
-            mDevSettingsFlag |= TTY_OFF;
-        }
-        ALOGI("Changed TTY Mode=%s", value.string());
-        mALSADevice->setFlags(mDevSettingsFlag);
-        if(mMode != AudioSystem::MODE_IN_CALL){
-           return NO_ERROR;
-        }
-        doRouting(0);
-    }
-
-    key = String8(FLUENCE_KEY);
-    if (param.get(key, value) == NO_ERROR) {
-        if (value == "quadmic") {
-            mDevSettingsFlag |= QMIC_FLAG;
-            mDevSettingsFlag &= (~DMIC_FLAG);
-            ALOGV("Fluence quadMic feature Enabled");
-        } else if (value == "dualmic") {
-            mDevSettingsFlag |= DMIC_FLAG;
-            mDevSettingsFlag &= (~QMIC_FLAG);
-            ALOGV("Fluence dualmic feature Enabled");
-        } else if (value == "none") {
-            mDevSettingsFlag &= (~DMIC_FLAG);
-            mDevSettingsFlag &= (~QMIC_FLAG);
-            ALOGV("Fluence feature Disabled");
-        }
-        mALSADevice->setFlags(mDevSettingsFlag);
-        doRouting(0);
-    }
-
-#ifdef QCOM_CSDCLIENT_ENABLED
-    if (mFusion3Platform) {
-        key = String8(INCALLMUSIC_KEY);
-        if (param.get(key, value) == NO_ERROR) {
-            if (value == "true") {
-                ALOGV("Enabling Incall Music setting in the setparameter\n");
-                if (csd_start_playback == NULL) {
-                    ALOGE("dlsym: Error:%s Loading csd_client_start_playback", dlerror());
-                } else {
-                    csd_start_playback();
-                }
-            } else {
-                ALOGV("Disabling Incall Music setting in the setparameter\n");
-                if (csd_stop_playback == NULL) {
-                    ALOGE("dlsym: Error:%s Loading csd_client_stop_playback", dlerror());
-                } else {
-                    csd_stop_playback();
-                }
-            }
-        }
-    }
-#endif
-
-    key = String8(ANC_KEY);
-    if (param.get(key, value) == NO_ERROR) {
-        if (value == "true") {
-            ALOGV("Enabling ANC setting in the setparameter\n");
-            mDevSettingsFlag |= ANC_FLAG;
-        } else {
-            ALOGV("Disabling ANC setting in the setparameter\n");
-            mDevSettingsFlag &= (~ANC_FLAG);
-        }
-        mALSADevice->setFlags(mDevSettingsFlag);
-        doRouting(0);
-    }
-
-    key = String8(AudioParameter::keyRouting);
-    if (param.getInt(key, device) == NO_ERROR) {
-        // Ignore routing if device is 0.
-        if(device) {
-            doRouting(device);
-        }
-        param.remove(key);
-    }
-
-    key = String8(BT_SAMPLERATE_KEY);
-    if (param.getInt(key, btRate) == NO_ERROR) {
-        mALSADevice->setBtscoRate(btRate);
-        param.remove(key);
-    }
-
-    key = String8(BTHEADSET_VGS);
-    if (param.get(key, value) == NO_ERROR) {
-        if (value == "on") {
-            mBluetoothVGS = true;
-        } else {
-            mBluetoothVGS = false;
-        }
-    }
-
-    key = String8(WIDEVOICE_KEY);
-    if (param.get(key, value) == NO_ERROR) {
-        bool flag = false;
-        if (value == "true") {
-            flag = true;
-        }
-        if(mALSADevice) {
-            mALSADevice->enableWideVoice(flag);
-        }
-        param.remove(key);
-    }
-
-    key = String8(VOIPRATE_KEY);
-    if (param.get(key, value) == NO_ERROR) {
-            mVoipBitRate = atoi(value);
-        param.remove(key);
-    }
-
-    key = String8(FENS_KEY);
-    if (param.get(key, value) == NO_ERROR) {
-        bool flag = false;
-        if (value == "true") {
-            flag = true;
-        }
-        if(mALSADevice) {
-            mALSADevice->enableFENS(flag);
-        }
-        param.remove(key);
-    }
-
-#ifdef QCOM_FM_ENABLED
-    key = String8(AudioParameter::keyHandleFm);
-    if (param.getInt(key, device) == NO_ERROR) {
-        // Ignore if device is 0
-        if(device) {
-            handleFm(device);
-        }
-        param.remove(key);
-    }
-#endif
-
-    key = String8(ST_KEY);
-    if (param.get(key, value) == NO_ERROR) {
-        bool flag = false;
-        if (value == "true") {
-            flag = true;
-        }
-        if(mALSADevice) {
-            mALSADevice->enableSlowTalk(flag);
-        }
-        param.remove(key);
-    }
-    key = String8(MODE_CALL_KEY);
-    if (param.getInt(key,state) == NO_ERROR) {
-        if (mCallState != state) {
-            mCallState = state;
-            doRouting(0);
-        }
-        mCallState = state;
-    }
-    if (param.size()) {
-        status = BAD_VALUE;
-    }
-    return status;
-}
-
-String8 AudioHardwareALSA::getParameters(const String8& keys)
-{
-    AudioParameter param = AudioParameter(keys);
-    String8 value;
-
-    String8 key = String8(DUALMIC_KEY);
-    if (param.get(key, value) == NO_ERROR) {
-        value = String8("false");
-        param.add(key, value);
-    }
-
-    key = String8(FLUENCE_KEY);
-    if (param.get(key, value) == NO_ERROR) {
-    if ((mDevSettingsFlag & QMIC_FLAG) &&
-                               (mDevSettingsFlag & ~DMIC_FLAG))
-            value = String8("quadmic");
-    else if ((mDevSettingsFlag & DMIC_FLAG) &&
-                                (mDevSettingsFlag & ~QMIC_FLAG))
-            value = String8("dualmic");
-    else if ((mDevSettingsFlag & ~DMIC_FLAG) &&
-                                (mDevSettingsFlag & ~QMIC_FLAG))
-            value = String8("none");
-        param.add(key, value);
-    }
-
-#ifdef QCOM_FM_ENABLED
-    key = String8("Fm-radio");
-    if ( param.get(key,value) == NO_ERROR ) {
-        if ( mIsFmActive ) {
-            param.addInt(String8("isFMON"), true );
-        }
-    }
-#endif
-
-    key = String8(BTHEADSET_VGS);
-    if (param.get(key, value) == NO_ERROR) {
-        if(mBluetoothVGS)
-           param.addInt(String8("isVGS"), true);
-    }
-
-    ALOGV("AudioHardwareALSA::getParameters() %s", param.toString().string());
-    return param.toString();
-}
-
-#ifdef QCOM_USBAUDIO_ENABLED
-void AudioHardwareALSA::closeUSBPlayback()
-{
-    ALOGV("closeUSBPlayback, musbPlaybackState: %d", musbPlaybackState);
-    musbPlaybackState = 0;
-    mAudioUsbALSA->exitPlaybackThread(SIGNAL_EVENT_KILLTHREAD);
-}
-
-void AudioHardwareALSA::closeUSBRecording()
-{
-    ALOGV("closeUSBRecording");
-    musbRecordingState = 0;
-    mAudioUsbALSA->exitRecordingThread(SIGNAL_EVENT_KILLTHREAD);
-}
-
-void AudioHardwareALSA::closeUsbPlaybackIfNothingActive(){
-    ALOGV("closeUsbPlaybackIfNothingActive, musbPlaybackState: %d", musbPlaybackState);
-    if(!musbPlaybackState && mAudioUsbALSA != NULL) {
-        mAudioUsbALSA->exitPlaybackThread(SIGNAL_EVENT_TIMEOUT);
-    }
-}
-
-void AudioHardwareALSA::closeUsbRecordingIfNothingActive(){
-    ALOGV("closeUsbRecordingIfNothingActive, musbRecordingState: %d", musbRecordingState);
-    if(!musbRecordingState && mAudioUsbALSA != NULL) {
-        ALOGD("Closing USB Recording Session as no stream is active");
-        mAudioUsbALSA->setkillUsbRecordingThread(true);
-    }
-}
-
-void AudioHardwareALSA::startUsbPlaybackIfNotStarted(){
-    ALOGV("Starting the USB playback %d kill %d", musbPlaybackState,
-             mAudioUsbALSA->getkillUsbPlaybackThread());
-    if((!musbPlaybackState) || (mAudioUsbALSA->getkillUsbPlaybackThread() == true)) {
-        mAudioUsbALSA->startPlayback();
-    }
-}
-
-void AudioHardwareALSA::startUsbRecordingIfNotStarted(){
-    ALOGV("Starting the recording musbRecordingState: %d killUsbRecordingThread %d",
-          musbRecordingState, mAudioUsbALSA->getkillUsbRecordingThread());
-    if((!musbRecordingState) || (mAudioUsbALSA->getkillUsbRecordingThread() == true)) {
-        mAudioUsbALSA->startRecording();
-    }
-}
-#endif
-
-void AudioHardwareALSA::doRouting(int device)
-{
-    Mutex::Autolock autoLock(mLock);
-    int newMode = mode();
-    bool isRouted = false;
-
-    if ((device == AudioSystem::DEVICE_IN_VOICE_CALL)
-#ifdef QCOM_FM_ENABLED
-        || (device == AudioSystem::DEVICE_IN_FM_RX)
-        || (device == AudioSystem::DEVICE_OUT_DIRECTOUTPUT)
-        || (device == AudioSystem::DEVICE_IN_FM_RX_A2DP)
-#endif
-        || (device == AudioSystem::DEVICE_IN_COMMUNICATION)
-        ) {
-        ALOGV("Ignoring routing for FM/INCALL/VOIP recording");
-        return;
-    }
-    if (device == 0)
-        device = mCurDevice;
-    ALOGV("doRouting: device %d newMode %d mCSCallActive %d mVolteCallActive %d"
-         "mIsFmActive %d", device, newMode, mCSCallActive, mVolteCallActive,
-         mIsFmActive);
-
-    isRouted = routeVoLTECall(device, newMode);
-    isRouted |= routeVoiceCall(device, newMode);
-
-    if(!isRouted) {
-#ifdef QCOM_USBAUDIO_ENABLED
-        if(!(device & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET) &&
-            !(device & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET) &&
-            !(device & AudioSystem::DEVICE_IN_ANLG_DOCK_HEADSET) &&
-             (musbPlaybackState)){
-                //USB unplugged
-                device &= ~ AudioSystem::DEVICE_OUT_PROXY;
-                device &= ~ AudioSystem::DEVICE_IN_PROXY;
-                ALSAHandleList::iterator it = mDeviceList.end();
-                it--;
-                mALSADevice->route(&(*it), (uint32_t)device, newMode);
-                ALOGD("USB UNPLUGGED, setting musbPlaybackState to 0");
-                musbPlaybackState = 0;
-                musbRecordingState = 0;
-                closeUSBRecording();
-                closeUSBPlayback();
-        } else if((device & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)||
-                  (device & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){
-                    ALOGD("Routing everything to prox now");
-                    ALSAHandleList::iterator it = mDeviceList.end();
-                    it--;
-                    mALSADevice->route(&(*it), AudioSystem::DEVICE_OUT_PROXY,
-                                       newMode);
-                    for(it = mDeviceList.begin(); it != mDeviceList.end(); ++it) {
-                         if((!strcmp(it->useCase, SND_USE_CASE_VERB_HIFI_LOW_POWER)) ||
-                            (!strcmp(it->useCase, SND_USE_CASE_MOD_PLAY_LPA))) {
-                                 ALOGV("doRouting: LPA device switch to proxy");
-                                 startUsbPlaybackIfNotStarted();
-                                 musbPlaybackState |= USBPLAYBACKBIT_LPA;
-                                 break;
-                         } else if((!strcmp(it->useCase, SND_USE_CASE_VERB_VOICECALL)) ||
-                                   (!strcmp(it->useCase, SND_USE_CASE_MOD_PLAY_VOICE))) {
-                                    ALOGV("doRouting: VOICE device switch to proxy");
-                                    startUsbRecordingIfNotStarted();
-                                    startUsbPlaybackIfNotStarted();
-                                    musbPlaybackState |= USBPLAYBACKBIT_VOICECALL;
-                                    musbRecordingState |= USBPLAYBACKBIT_VOICECALL;
-                                    break;
-                        }else if((!strcmp(it->useCase, SND_USE_CASE_VERB_DIGITAL_RADIO)) ||
-                                 (!strcmp(it->useCase, SND_USE_CASE_MOD_PLAY_FM))) {
-                                    ALOGV("doRouting: FM device switch to proxy");
-                                    startUsbPlaybackIfNotStarted();
-                                    musbPlaybackState |= USBPLAYBACKBIT_FM;
-                                    break;
-                         }
-                    }
-        } else
-#endif
-        {
-             ALSAHandleList::iterator it = mDeviceList.end();
-             it--;
-             mALSADevice->route(&(*it), (uint32_t)device, newMode);
-        }
-    }
-    mCurDevice = device;
-}
-
-uint32_t AudioHardwareALSA::getVoipMode(int format)
-{
-    switch(format) {
-    case AudioSystem::PCM_16_BIT:
-               return MODE_PCM;
-         break;
-    case AudioSystem::AMR_NB:
-               return MODE_AMR;
-         break;
-    case AudioSystem::AMR_WB:
-               return MODE_AMR_WB;
-         break;
-
-#ifdef QCOM_QCHAT_ENABLED
-    case AudioSystem::EVRC:
-               return MODE_IS127;
-         break;
-
-    case AudioSystem::EVRCB:
-               return MODE_4GV_NB;
-         break;
-    case AudioSystem::EVRCWB:
-               return MODE_4GV_WB;
-         break;
-#endif
-
-    default:
-               return MODE_PCM;
-    }
-}
-
-AudioStreamOut *
-AudioHardwareALSA::openOutputStream(uint32_t devices,
-                                    int *format,
-                                    uint32_t *channels,
-                                    uint32_t *sampleRate,
-                                    status_t *status)
-{
-    Mutex::Autolock autoLock(mLock);
-    ALOGV("openOutputStream: devices 0x%x channels %d sampleRate %d",
-         devices, *channels, *sampleRate);
-
-    audio_output_flags_t flag = static_cast<audio_output_flags_t> (*status);
-
-    status_t err = BAD_VALUE;
-    *status = NO_ERROR;
-    AudioStreamOutALSA *out = 0;
-    ALSAHandleList::iterator it;
-
-    if (devices & (devices - 1)) {
-        if (status) *status = err;
-        ALOGE("openOutputStream called with bad devices");
-        return out;
-    }
-
-
-# if 0
-    if((devices == AudioSystem::DEVICE_OUT_DIRECTOUTPUT) &&
-       ((*sampleRate == VOIP_SAMPLING_RATE_8K) || (*sampleRate == VOIP_SAMPLING_RATE_16K))) {
-        bool voipstream_active = false;
-        for(it = mDeviceList.begin();
-            it != mDeviceList.end(); ++it) {
-                if((!strcmp(it->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
-                   (!strcmp(it->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
-                    ALOGD("openOutput:  it->rxHandle %d it->handle %d",it->rxHandle,it->handle);
-                    voipstream_active = true;
-                    break;
-                }
-        }
-      if(voipstream_active == false) {
-         mVoipStreamCount = 0;
-         alsa_handle_t alsa_handle;
-         unsigned long bufferSize;
-         if(*sampleRate == VOIP_SAMPLING_RATE_8K) {
-             bufferSize = VOIP_BUFFER_SIZE_8K;
-         }
-         else if(*sampleRate == VOIP_SAMPLING_RATE_16K) {
-             bufferSize = VOIP_BUFFER_SIZE_16K;
-         }
-         else {
-             ALOGE("unsupported samplerate %d for voip",*sampleRate);
-             if (status) *status = err;
-                 return out;
-          }
-          alsa_handle.module = mALSADevice;
-          alsa_handle.bufferSize = bufferSize;
-          alsa_handle.devices = devices;
-          alsa_handle.handle = 0;
-          if(*format == AudioSystem::PCM_16_BIT)
-              alsa_handle.format = SNDRV_PCM_FORMAT_S16_LE;
-          else
-              alsa_handle.format = *format;
-          alsa_handle.channels = VOIP_DEFAULT_CHANNEL_MODE;
-          alsa_handle.channelMask = AUDIO_CHANNEL_IN_MONO;
-          alsa_handle.sampleRate = *sampleRate;
-          alsa_handle.latency = VOIP_PLAYBACK_LATENCY;
-          alsa_handle.rxHandle = 0;
-          alsa_handle.ucMgr = mUcMgr;
-          mALSADevice->setVoipConfig(getVoipMode(*format), mVoipBitRate);
-          char *use_case;
-          snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case);
-          if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) {
-              strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_IP_VOICECALL, sizeof(alsa_handle.useCase));
-          } else {
-              strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_PLAY_VOIP, sizeof(alsa_handle.useCase));
-          }
-          free(use_case);
-          mDeviceList.push_back(alsa_handle);
-          it = mDeviceList.end();
-          it--;
-          ALOGV("openoutput: mALSADevice->route useCase %s mCurDevice %d mVoipStreamCount %d mode %d", it->useCase,mCurDevice,mVoipStreamCount, mode());
-          if((mCurDevice & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)||
-             (mCurDevice & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)||
-             (mCurDevice & AudioSystem::DEVICE_OUT_PROXY)){
-              ALOGD("Routing to proxy for normal voip call in openOutputStream");
-              mCurDevice |= AudioSystem::DEVICE_OUT_PROXY;
-              alsa_handle.devices = AudioSystem::DEVICE_OUT_PROXY;
-              mALSADevice->route(&(*it), mCurDevice, AudioSystem::MODE_IN_COMMUNICATION);
-              ALOGD("enabling VOIP in openoutputstream, musbPlaybackState: %d", musbPlaybackState);
-              startUsbPlaybackIfNotStarted();
-              musbPlaybackState |= USBPLAYBACKBIT_VOIPCALL;
-              ALOGD("Starting recording in openoutputstream, musbRecordingState: %d", musbRecordingState);
-              startUsbRecordingIfNotStarted();
-              musbRecordingState |= USBRECBIT_VOIPCALL;
-          } else{
-              mALSADevice->route(&(*it), mCurDevice, AudioSystem::MODE_IN_COMMUNICATION);
-          }
-          if(!strcmp(it->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) {
-              snd_use_case_set(mUcMgr, "_verb", SND_USE_CASE_VERB_IP_VOICECALL);
-          } else {
-              snd_use_case_set(mUcMgr, "_enamod", SND_USE_CASE_MOD_PLAY_VOIP);
-          }
-          err = mALSADevice->startVoipCall(&(*it));
-          if (err) {
-              ALOGE("Device open failed");
-              return NULL;
-          }
-      }
-      out = new AudioStreamOutALSA(this, &(*it));
-      err = out->set(format, channels, sampleRate, devices);
-      if(err == NO_ERROR) {
-          mVoipStreamCount++;   //increment VoipstreamCount only if success
-          ALOGD("openoutput mVoipStreamCount %d",mVoipStreamCount);
-      }
-      if (status) *status = err;
-      return out;
-    } else
-#endif
-    if ((flag & AUDIO_OUTPUT_FLAG_DIRECT) &&
-        (devices == AudioSystem::DEVICE_OUT_AUX_DIGITAL)) {
-        ALOGD("Multi channel PCM");
-        alsa_handle_t alsa_handle;
-        EDID_AUDIO_INFO info = { 0 };
-
-        alsa_handle.module = mALSADevice;
-        alsa_handle.devices = devices;
-        alsa_handle.handle = 0;
-        alsa_handle.format = SNDRV_PCM_FORMAT_S16_LE;
-
-        if (!AudioUtil::getHDMIAudioSinkCaps(&info)) {
-            ALOGE("openOutputStream: Failed to get HDMI sink capabilities");
-            return NULL;
-        }
-        if (0 == *channels) {
-            alsa_handle.channels = info.AudioBlocksArray[info.nAudioBlocks-1].nChannels;
-            if (alsa_handle.channels > 6) {
-                alsa_handle.channels = 6;
-            }
-            *channels = audio_channel_out_mask_from_count(alsa_handle.channels);
-        } else {
-            alsa_handle.channels = AudioSystem::popCount(*channels);
-        }
-        alsa_handle.channelMask = *channels;
-
-        if (6 == alsa_handle.channels) {
-            alsa_handle.bufferSize = DEFAULT_MULTI_CHANNEL_BUF_SIZE;
-        } else {
-            alsa_handle.bufferSize = DEFAULT_BUFFER_SIZE;
-        }
-        if (0 == *sampleRate) {
-            alsa_handle.sampleRate = info.AudioBlocksArray[info.nAudioBlocks-1].nSamplingFreq;
-            *sampleRate = alsa_handle.sampleRate;
-        } else {
-            alsa_handle.sampleRate = *sampleRate;
-        }
-        alsa_handle.latency = PLAYBACK_LATENCY;
-        alsa_handle.rxHandle = 0;
-        alsa_handle.ucMgr = mUcMgr;
-        ALOGD("alsa_handle.channels %d alsa_handle.sampleRate %d",alsa_handle.channels,alsa_handle.sampleRate);
-
-        char *use_case;
-        snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case);
-        if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) {
-            strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_HIFI2 , sizeof(alsa_handle.useCase));
-        } else {
-            strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_PLAY_MUSIC2, sizeof(alsa_handle.useCase));
-        }
-        free(use_case);
-        mDeviceList.push_back(alsa_handle);
-        ALSAHandleList::iterator it = mDeviceList.end();
-        it--;
-        ALOGD("it->useCase %s", it->useCase);
-        mALSADevice->route(&(*it), devices, mode());
-        if(!strcmp(it->useCase, SND_USE_CASE_VERB_HIFI2)) {
-            snd_use_case_set(mUcMgr, "_verb", SND_USE_CASE_VERB_HIFI2 );
-        } else {
-            snd_use_case_set(mUcMgr, "_enamod", SND_USE_CASE_MOD_PLAY_MUSIC2);
-        }
-        ALOGD("channels: %d", AudioSystem::popCount(*channels));
-        err = mALSADevice->open(&(*it));
-
-        if (err) {
-            ALOGE("Device open failed err:%d",err);
-        } else {
-            out = new AudioStreamOutALSA(this, &(*it));
-            err = out->set(format, channels, sampleRate, devices);
-        }
-        if (status) *status = err;
-        return out;
-    } else {
-
-      alsa_handle_t alsa_handle;
-      unsigned long bufferSize = DEFAULT_BUFFER_SIZE;
-
-      for (size_t b = 1; (bufferSize & ~b) != 0; b <<= 1)
-          bufferSize &= ~b;
-
-      alsa_handle.module = mALSADevice;
-      alsa_handle.bufferSize = bufferSize;
-      alsa_handle.devices = devices;
-      alsa_handle.handle = 0;
-      alsa_handle.format = SNDRV_PCM_FORMAT_S16_LE;
-      alsa_handle.channels = DEFAULT_CHANNEL_MODE;
-      alsa_handle.channelMask = AUDIO_CHANNEL_OUT_STEREO;
-      alsa_handle.sampleRate = DEFAULT_SAMPLING_RATE;
-      alsa_handle.latency = PLAYBACK_LATENCY;
-      alsa_handle.rxHandle = 0;
-      alsa_handle.ucMgr = mUcMgr;
-      alsa_handle.isDeepbufferOutput = false;
-
-      char *use_case;
-      snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case);
-
-      if (flag & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) {
-      ALOGD("openOutputStream: DeepBuffer Output");
-          alsa_handle.isDeepbufferOutput = true;
-          if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) {
-               strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_HIFI, sizeof(alsa_handle.useCase));
-          } else {
-               strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_PLAY_MUSIC, sizeof(alsa_handle.useCase));
-          }
-      } else {
-      ALOGD("openOutputStream: Lowlatency Output");
-          alsa_handle.bufferSize = PLAYBACK_LOW_LATENCY_BUFFER_SIZE;
-          alsa_handle.latency = PLAYBACK_LOW_LATENCY_MEASURED;
-          if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) {
-               strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC, sizeof(alsa_handle.useCase));
-          } else {
-               strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_PLAY_LOWLATENCY_MUSIC, sizeof(alsa_handle.useCase));
-          }
-      }
-      free(use_case);
-      mDeviceList.push_back(alsa_handle);
-      ALSAHandleList::iterator it = mDeviceList.end();
-      it--;
-      ALOGV("useCase %s", it->useCase);
-#ifdef QCOM_USBAUDIO_ENABLED
-      if((devices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)||
-         (devices & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){
-          ALOGD("Routing to proxy for normal playback in openOutputStream");
-          devices |= AudioSystem::DEVICE_OUT_PROXY;
-      }
-#endif
-      mALSADevice->route(&(*it), devices, mode());
-      if (flag & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) {
-          if(!strcmp(it->useCase, SND_USE_CASE_VERB_HIFI)) {
-             snd_use_case_set(mUcMgr, "_verb", SND_USE_CASE_VERB_HIFI);
-          } else {
-             snd_use_case_set(mUcMgr, "_enamod", SND_USE_CASE_MOD_PLAY_MUSIC);
-          }
-      } else {
-          if(!strcmp(it->useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC)) {
-             snd_use_case_set(mUcMgr, "_verb", SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC);
-          } else {
-             snd_use_case_set(mUcMgr, "_enamod", SND_USE_CASE_MOD_PLAY_LOWLATENCY_MUSIC);
-          }
-      }
-      err = mALSADevice->open(&(*it));
-      if (err) {
-          ALOGE("Device open failed");
-      } else {
-          out = new AudioStreamOutALSA(this, &(*it));
-          err = out->set(format, channels, sampleRate, devices);
-      }
-
-      if (status) *status = err;
-      return out;
-    }
-}
-
-void
-AudioHardwareALSA::closeOutputStream(AudioStreamOut* out)
-{
-    delete out;
-}
-
-#ifdef QCOM_TUNNEL_LPA_ENABLED
-AudioStreamOut *
-AudioHardwareALSA::openOutputSession(uint32_t devices,
-                                     int *format,
-                                     status_t *status,
-                                     int sessionId,
-                                     uint32_t samplingRate,
-                                     uint32_t channels)
-{
-    Mutex::Autolock autoLock(mLock);
-    ALOGD("openOutputSession = %d" ,sessionId);
-    AudioStreamOutALSA *out = 0;
-    status_t err = BAD_VALUE;
-
-    alsa_handle_t alsa_handle;
-    unsigned long bufferSize = DEFAULT_BUFFER_SIZE;
-
-    for (size_t b = 1; (bufferSize & ~b) != 0; b <<= 1)
-        bufferSize &= ~b;
-
-    alsa_handle.module = mALSADevice;
-    alsa_handle.bufferSize = bufferSize;
-    alsa_handle.devices = devices;
-    alsa_handle.handle = 0;
-    alsa_handle.format = SNDRV_PCM_FORMAT_S16_LE;
-    alsa_handle.channels = DEFAULT_CHANNEL_MODE;
-    alsa_handle.channelMask = AUDIO_CHANNEL_OUT_STEREO;
-    alsa_handle.sampleRate = DEFAULT_SAMPLING_RATE;
-    alsa_handle.latency = VOICE_LATENCY;
-    alsa_handle.rxHandle = 0;
-    alsa_handle.ucMgr = mUcMgr;
-
-    char *use_case;
-    if(sessionId == TUNNEL_SESSION_ID) {
-        snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case);
-        if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) {
-            strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_HIFI_TUNNEL, sizeof(alsa_handle.useCase));
-        } else {
-            strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_PLAY_TUNNEL, sizeof(alsa_handle.useCase));
-        }
-    } else {
-        snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case);
-        if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) {
-            strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_HIFI_LOW_POWER, sizeof(alsa_handle.useCase));
-        } else {
-            strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_PLAY_LPA, sizeof(alsa_handle.useCase));
-        }
-    }
-    free(use_case);
-    mDeviceList.push_back(alsa_handle);
-    ALSAHandleList::iterator it = mDeviceList.end();
-    it--;
-    ALOGD("useCase %s", it->useCase);
-#ifdef QCOM_USBAUDIO_ENABLED
-    if((devices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)||
-       (devices & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){
-        ALOGD("Routing to proxy for LPA in openOutputSession");
-        devices |= AudioSystem::DEVICE_OUT_PROXY;
-        mALSADevice->route(&(*it), devices, mode());
-        devices = AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET;
-        ALOGD("Starting USBPlayback for LPA");
-        startUsbPlaybackIfNotStarted();
-        musbPlaybackState |= USBPLAYBACKBIT_LPA;
-    } else
-#endif
-    {
-        mALSADevice->route(&(*it), devices, mode());
-    }
-    if(sessionId == TUNNEL_SESSION_ID) {
-        if(!strcmp(it->useCase, SND_USE_CASE_VERB_HIFI_TUNNEL)) {
-            snd_use_case_set(mUcMgr, "_verb", SND_USE_CASE_VERB_HIFI_TUNNEL);
-        } else {
-            snd_use_case_set(mUcMgr, "_enamod", SND_USE_CASE_MOD_PLAY_TUNNEL);
-        }
-    }
-    else {
-        if(!strcmp(it->useCase, SND_USE_CASE_VERB_HIFI_LOW_POWER)) {
-            snd_use_case_set(mUcMgr, "_verb", SND_USE_CASE_VERB_HIFI_LOW_POWER);
-        } else {
-            snd_use_case_set(mUcMgr, "_enamod", SND_USE_CASE_MOD_PLAY_LPA);
-        }
-    }
-    err = mALSADevice->open(&(*it));
-    out = new AudioStreamOutALSA(this, &(*it));
-
-    if (status) *status = err;
-       return out;
-}
-
-void
-AudioHardwareALSA::closeOutputSession(AudioStreamOut* out)
-{
-    delete out;
-}
-#endif
-
-AudioStreamIn *
-AudioHardwareALSA::openInputStream(uint32_t devices,
-                                   int *format,
-                                   uint32_t *channels,
-                                   uint32_t *sampleRate,
-                                   status_t *status,
-                                   AudioSystem::audio_in_acoustics acoustics)
-{
-    Mutex::Autolock autoLock(mLock);
-    char *use_case;
-    int newMode = mode();
-    uint32_t route_devices;
-
-    status_t err = BAD_VALUE;
-    AudioStreamInALSA *in = 0;
-    ALSAHandleList::iterator it;
-
-    ALOGD("openInputStream: devices 0x%x channels %d sampleRate %d", devices, *channels, *sampleRate);
-    if (devices & (devices - 1)) {
-        if (status) *status = err;
-        return in;
-    }
-
-    if((devices == AudioSystem::DEVICE_IN_COMMUNICATION) &&
-       ((*sampleRate == VOIP_SAMPLING_RATE_8K) || (*sampleRate == VOIP_SAMPLING_RATE_16K))) {
-        bool voipstream_active = false;
-        for(it = mDeviceList.begin();
-            it != mDeviceList.end(); ++it) {
-                if((!strcmp(it->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
-                   (!strcmp(it->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
-                    ALOGD("openInput:  it->rxHandle %p it->handle %p",it->rxHandle,it->handle);
-                    voipstream_active = true;
-                    break;
-                }
-        }
-        if(voipstream_active == false) {
-           mVoipStreamCount = 0;
-           alsa_handle_t alsa_handle;
-           unsigned long bufferSize;
-           if(*sampleRate == VOIP_SAMPLING_RATE_8K) {
-               bufferSize = VOIP_BUFFER_SIZE_8K;
-           }
-           else if(*sampleRate == VOIP_SAMPLING_RATE_16K) {
-               bufferSize = VOIP_BUFFER_SIZE_16K;
-           }
-           else {
-               ALOGE("unsupported samplerate %d for voip",*sampleRate);
-               if (status) *status = err;
-               return in;
-           }
-           alsa_handle.module = mALSADevice;
-           alsa_handle.bufferSize = bufferSize;
-           alsa_handle.devices = devices;
-           alsa_handle.handle = 0;
-          if(*format == AudioSystem::PCM_16_BIT)
-              alsa_handle.format = SNDRV_PCM_FORMAT_S16_LE;
-          else
-              alsa_handle.format = *format;
-           alsa_handle.channels = VOIP_DEFAULT_CHANNEL_MODE;
-           alsa_handle.channelMask = AUDIO_CHANNEL_IN_MONO;
-           alsa_handle.sampleRate = *sampleRate;
-           alsa_handle.latency = VOIP_RECORD_LATENCY;
-           alsa_handle.rxHandle = 0;
-           alsa_handle.ucMgr = mUcMgr;
-          mALSADevice->setVoipConfig(getVoipMode(*format), mVoipBitRate);
-           snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case);
-           if ((use_case != NULL) && (strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) {
-                strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_PLAY_VOIP, sizeof(alsa_handle.useCase));
-           } else {
-                strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_IP_VOICECALL, sizeof(alsa_handle.useCase));
-           }
-           free(use_case);
-           mDeviceList.push_back(alsa_handle);
-           it = mDeviceList.end();
-           it--;
-           ALOGD("mCurrDevice: %d", mCurDevice);
-#ifdef QCOM_USBAUDIO_ENABLED
-           if((mCurDevice == AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)||
-              (mCurDevice == AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){
-              ALOGD("Routing everything from proxy for voipcall");
-              mALSADevice->route(&(*it), AudioSystem::DEVICE_IN_PROXY, AudioSystem::MODE_IN_COMMUNICATION);
-              ALOGD("enabling VOIP in openInputstream, musbPlaybackState: %d", musbPlaybackState);
-              startUsbPlaybackIfNotStarted();
-              musbPlaybackState |= USBPLAYBACKBIT_VOIPCALL;
-              ALOGD("Starting recording in openoutputstream, musbRecordingState: %d", musbRecordingState);
-              startUsbRecordingIfNotStarted();
-              musbRecordingState |= USBRECBIT_VOIPCALL;
-           } else
-#endif
-           {
-               mALSADevice->route(&(*it),mCurDevice, AudioSystem::MODE_IN_COMMUNICATION);
-           }
-           if(!strcmp(it->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) {
-               snd_use_case_set(mUcMgr, "_verb", SND_USE_CASE_VERB_IP_VOICECALL);
-           } else {
-               snd_use_case_set(mUcMgr, "_enamod", SND_USE_CASE_MOD_PLAY_VOIP);
-           }
-           if(sampleRate) {
-               it->sampleRate = *sampleRate;
-           }
-           if(channels)
-               it->channels = AudioSystem::popCount(*channels);
-           err = mALSADevice->startVoipCall(&(*it));
-           if (err) {
-               ALOGE("Error opening pcm input device");
-               return NULL;
-           }
-        }
-        in = new AudioStreamInALSA(this, &(*it), acoustics);
-        err = in->set(format, channels, sampleRate, devices);
-        if(err == NO_ERROR) {
-            mVoipStreamCount++;   //increment VoipstreamCount only if success
-            ALOGD("OpenInput mVoipStreamCount %d",mVoipStreamCount);
-        }
-        ALOGD("openInput: After Get alsahandle");
-        if (status) *status = err;
-        return in;
-      } else {
-        alsa_handle_t alsa_handle;
-        unsigned long bufferSize = MIN_CAPTURE_BUFFER_SIZE_PER_CH;
-
-        alsa_handle.module = mALSADevice;
-        alsa_handle.bufferSize = bufferSize;
-        alsa_handle.devices = devices;
-        alsa_handle.handle = 0;
-        alsa_handle.format = SNDRV_PCM_FORMAT_S16_LE;
-        alsa_handle.channels = VOICE_CHANNEL_MODE;
-        alsa_handle.channelMask = AUDIO_CHANNEL_IN_MONO;
-        alsa_handle.sampleRate = android::AudioRecord::DEFAULT_SAMPLE_RATE;
-        alsa_handle.latency = RECORD_LATENCY;
-        alsa_handle.rxHandle = 0;
-        alsa_handle.ucMgr = mUcMgr;
-        snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case);
-        if ((use_case != NULL) && (strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) {
-            if ((devices == AudioSystem::DEVICE_IN_VOICE_CALL) &&
-                (newMode == AudioSystem::MODE_IN_CALL)) {
-                ALOGD("openInputStream: into incall recording, channels %d", *channels);
-                mIncallMode = *channels;
-                if ((*channels & AudioSystem::CHANNEL_IN_VOICE_UPLINK) &&
-                    (*channels & AudioSystem::CHANNEL_IN_VOICE_DNLINK)) {
-                    if (mFusion3Platform) {
-                        mALSADevice->setVocRecMode(INCALL_REC_STEREO);
-                        strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_CAPTURE_VOICE,
-                                sizeof(alsa_handle.useCase));
-                    } else {
-                        strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_CAPTURE_VOICE_UL_DL,
-                                sizeof(alsa_handle.useCase));
-                    }
-                } else if (*channels & AudioSystem::CHANNEL_IN_VOICE_DNLINK) {
-                    if (mFusion3Platform) {
-                        mALSADevice->setVocRecMode(INCALL_REC_MONO);
-                        strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_CAPTURE_VOICE,
-                                sizeof(alsa_handle.useCase));
-                    } else {
-                        strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_CAPTURE_VOICE_DL,
-                                sizeof(alsa_handle.useCase));
-                    }
-                }
-#ifdef QCOM_FM_ENABLED
-            } else if((devices == AudioSystem::DEVICE_IN_FM_RX)) {
-                strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_CAPTURE_FM, sizeof(alsa_handle.useCase));
-            } else if(devices == AudioSystem::DEVICE_IN_FM_RX_A2DP) {
-                strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_CAPTURE_A2DP_FM, sizeof(alsa_handle.useCase));
-#endif
-            } else {
-        char value[128];
-        property_get("persist.audio.lowlatency.rec",value,"0");
-                if (!strcmp("true", value)) {
-                    strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_CAPTURE_LOWLATENCY_MUSIC, sizeof(alsa_handle.useCase));
-                } else {
-                    strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_CAPTURE_MUSIC, sizeof(alsa_handle.useCase));
-                }
-            }
-        } else {
-            if ((devices == AudioSystem::DEVICE_IN_VOICE_CALL) &&
-                (newMode == AudioSystem::MODE_IN_CALL)) {
-                ALOGD("openInputStream: incall recording, channels %d", *channels);
-                mIncallMode = *channels;
-                if ((*channels & AudioSystem::CHANNEL_IN_VOICE_UPLINK) &&
-                    (*channels & AudioSystem::CHANNEL_IN_VOICE_DNLINK)) {
-                    if (mFusion3Platform) {
-                        mALSADevice->setVocRecMode(INCALL_REC_STEREO);
-                        strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_INCALL_REC,
-                                sizeof(alsa_handle.useCase));
-                    } else {
-                        strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_UL_DL_REC,
-                                sizeof(alsa_handle.useCase));
-                    }
-                } else if (*channels & AudioSystem::CHANNEL_IN_VOICE_DNLINK) {
-                    if (mFusion3Platform) {
-                        mALSADevice->setVocRecMode(INCALL_REC_MONO);
-                        strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_INCALL_REC,
-                                sizeof(alsa_handle.useCase));
-                    } else {
-                       strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_DL_REC,
-                               sizeof(alsa_handle.useCase));
-                    }
-                }
-#ifdef QCOM_FM_ENABLED
-            } else if(devices == AudioSystem::DEVICE_IN_FM_RX) {
-                strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_FM_REC, sizeof(alsa_handle.useCase));
-            } else if (devices == AudioSystem::DEVICE_IN_FM_RX_A2DP) {
-                strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_FM_A2DP_REC, sizeof(alsa_handle.useCase));
-#endif
-            } else {
-                char value[128];
-                property_get("persist.audio.lowlatency.rec",value,"0");
-                if (!strcmp("true", value)) {
-                    strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_REC, sizeof(alsa_handle.useCase));
-                } else {
-                    strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_HIFI_REC, sizeof(alsa_handle.useCase));
-                }
-            }
-        }
-        free(use_case);
-        mDeviceList.push_back(alsa_handle);
-        ALSAHandleList::iterator it = mDeviceList.end();
-        it--;
-        //update channel info before do routing
-        if(channels) {
-            it->channels = AudioSystem::popCount((*channels) &
-                      (AudioSystem::CHANNEL_IN_STEREO
-                       | AudioSystem::CHANNEL_IN_MONO
-#ifdef QCOM_SSR_ENABLED
-                       | AudioSystem::CHANNEL_IN_5POINT1
-#endif
-                       | AUDIO_CHANNEL_IN_FRONT_BACK));
-            it->channelMask = *channels;
-            ALOGV("updated channel info: channels=%d channelMask %08x",
-                  it->channels, it->channelMask);
-        }
-        if (devices == AudioSystem::DEVICE_IN_VOICE_CALL){
-           /* Add current devices info to devices to do route */
-#ifdef QCOM_USBAUDIO_ENABLED
-            if(mCurDevice == AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET ||
-               mCurDevice == AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET){
-                ALOGD("Routing everything from proxy for VOIP call");
-                route_devices = devices | AudioSystem::DEVICE_IN_PROXY;
-            } else
-#endif
-            {
-            route_devices = devices | mCurDevice;
-            }
-            mALSADevice->route(&(*it), route_devices, mode());
-        } else {
-#ifdef QCOM_USBAUDIO_ENABLED
-            if(devices & AudioSystem::DEVICE_IN_ANLG_DOCK_HEADSET ||
-               devices & AudioSystem::DEVICE_IN_PROXY) {
-                devices |= AudioSystem::DEVICE_IN_PROXY;
-                ALOGD("routing everything from proxy");
-            mALSADevice->route(&(*it), devices, mode());
-            } else
-#endif
-            {
-                mALSADevice->route(&(*it), devices, mode());
-            }
-        }
-        if(!strcmp(it->useCase, SND_USE_CASE_VERB_HIFI_REC) ||
-           !strcmp(it->useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_REC) ||
-#ifdef QCOM_FM_ENABLED
-           !strcmp(it->useCase, SND_USE_CASE_VERB_FM_REC) ||
-           !strcmp(it->useCase, SND_USE_CASE_VERB_FM_A2DP_REC) ||
-#endif
-           !strcmp(it->useCase, SND_USE_CASE_VERB_DL_REC) ||
-           !strcmp(it->useCase, SND_USE_CASE_VERB_UL_DL_REC) ||
-           !strcmp(it->useCase, SND_USE_CASE_VERB_INCALL_REC)) {
-            snd_use_case_set(mUcMgr, "_verb", it->useCase);
-        } else {
-            snd_use_case_set(mUcMgr, "_enamod", it->useCase);
-        }
-        if(sampleRate) {
-            it->sampleRate = *sampleRate;
-        }
-        if (!strncmp(it->useCase, SND_USE_CASE_VERB_HIFI_REC, strlen(SND_USE_CASE_VERB_HIFI_REC))
-            || !strncmp(it->useCase, SND_USE_CASE_MOD_CAPTURE_MUSIC, strlen(SND_USE_CASE_MOD_CAPTURE_MUSIC))) {
-            ALOGV("OpenInoutStream: Use larger buffer size for 5.1(%s) recording ", it->useCase);
-            it->bufferSize = getInputBufferSize(it->sampleRate,*format,it->channels);
-        }
-        err = mALSADevice->open(&(*it));
-        if (err) {
-           ALOGE("Error opening pcm input device");
-        } else {
-           in = new AudioStreamInALSA(this, &(*it), acoustics);
-           err = in->set(format, channels, sampleRate, devices);
-        }
-        if (status) *status = err;
-        return in;
-      }
-}
-
-void
-AudioHardwareALSA::closeInputStream(AudioStreamIn* in)
-{
-    delete in;
-}
-
-status_t AudioHardwareALSA::setMicMute(bool state)
-{
-    if (mMicMute != state) {
-        mMicMute = state;
-        ALOGD("setMicMute: mMicMute %d", mMicMute);
-        if(mALSADevice) {
-            mALSADevice->setMicMute(state);
-        }
-    }
-    return NO_ERROR;
-}
-
-status_t AudioHardwareALSA::getMicMute(bool *state)
-{
-    *state = mMicMute;
-    return NO_ERROR;
-}
-
-status_t AudioHardwareALSA::dump(int fd, const Vector<String16>& args)
-{
-    return NO_ERROR;
-}
-
-size_t AudioHardwareALSA::getInputBufferSize(uint32_t sampleRate, int format, int channelCount)
-{
-    size_t bufferSize = 0;
-    if (format == AudioSystem::PCM_16_BIT) {
-        if(sampleRate == 8000 || sampleRate == 16000 || sampleRate == 32000) {
-            bufferSize = (sampleRate * channelCount * 20 * sizeof(int16_t)) / 1000;
-        } else if (sampleRate == 11025 || sampleRate == 12000) {
-            bufferSize = 256 * sizeof(int16_t)  * channelCount;
-        } else if (sampleRate == 22050 || sampleRate == 24000) {
-            bufferSize = 512 * sizeof(int16_t)  * channelCount;
-        } else if (sampleRate == 44100 || sampleRate == 48000) {
-            bufferSize = 1024 * sizeof(int16_t) * channelCount;
-        }
-    } else {
-        ALOGE("getInputBufferSize bad format: %d", format);
-    }
-    return bufferSize;
-}
-
-#ifdef QCOM_FM_ENABLED
-void AudioHardwareALSA::handleFm(int device)
-{
-int newMode = mode();
-    if(device & AudioSystem::DEVICE_OUT_FM && mIsFmActive == 0) {
-        // Start FM Radio on current active device
-        unsigned long bufferSize = FM_BUFFER_SIZE;
-        alsa_handle_t alsa_handle;
-        char *use_case;
-        ALOGV("Start FM");
-        snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case);
-        if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) {
-            strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_DIGITAL_RADIO, sizeof(alsa_handle.useCase));
-        } else {
-            strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_PLAY_FM, sizeof(alsa_handle.useCase));
-        }
-        free(use_case);
-
-        for (size_t b = 1; (bufferSize & ~b) != 0; b <<= 1)
-        bufferSize &= ~b;
-        alsa_handle.module = mALSADevice;
-        alsa_handle.bufferSize = bufferSize;
-        alsa_handle.devices = device;
-        alsa_handle.handle = 0;
-        alsa_handle.format = SNDRV_PCM_FORMAT_S16_LE;
-        alsa_handle.channels = DEFAULT_CHANNEL_MODE;
-        alsa_handle.channelMask = AUDIO_CHANNEL_OUT_STEREO;
-        alsa_handle.sampleRate = DEFAULT_SAMPLING_RATE;
-        alsa_handle.latency = VOICE_LATENCY;
-        alsa_handle.rxHandle = 0;
-        alsa_handle.ucMgr = mUcMgr;
-        mIsFmActive = 1;
-        mDeviceList.push_back(alsa_handle);
-        ALSAHandleList::iterator it = mDeviceList.end();
-        it--;
-        if((device & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)||
-           (device & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){
-            device |= AudioSystem::DEVICE_OUT_PROXY;
-            alsa_handle.devices = AudioSystem::DEVICE_OUT_PROXY;
-            ALOGD("Routing to proxy for FM case");
-        }
-        mALSADevice->route(&(*it), (uint32_t)device, newMode);
-        if(!strcmp(it->useCase, SND_USE_CASE_VERB_DIGITAL_RADIO)) {
-            snd_use_case_set(mUcMgr, "_verb", SND_USE_CASE_VERB_DIGITAL_RADIO);
-        } else {
-            snd_use_case_set(mUcMgr, "_enamod", SND_USE_CASE_MOD_PLAY_FM);
-        }
-        mALSADevice->startFm(&(*it));
-        if((device & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)||
-           (device & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){
-            ALOGD("Starting FM, musbPlaybackState %d", musbPlaybackState);
-            startUsbPlaybackIfNotStarted();
-            musbPlaybackState |= USBPLAYBACKBIT_FM;
-        }
-    } else if (!(device & AudioSystem::DEVICE_OUT_FM) && mIsFmActive == 1) {
-        //i Stop FM Radio
-        ALOGV("Stop FM");
-        for(ALSAHandleList::iterator it = mDeviceList.begin();
-            it != mDeviceList.end(); ++it) {
-            if((!strcmp(it->useCase, SND_USE_CASE_VERB_DIGITAL_RADIO)) ||
-              (!strcmp(it->useCase, SND_USE_CASE_MOD_PLAY_FM))) {
-                mALSADevice->close(&(*it));
-                //mALSADevice->route(&(*it), (uint32_t)device, newMode);
-                mDeviceList.erase(it);
-                break;
-            }
-        }
-        mIsFmActive = 0;
-        musbPlaybackState &= ~USBPLAYBACKBIT_FM;
-        if((device & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)||
-           (device & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){
-            closeUsbPlaybackIfNothingActive();
-        }
-    }
-}
-#endif
-
-void AudioHardwareALSA::disableVoiceCall(char* verb, char* modifier, int mode, int device)
-{
-    for(ALSAHandleList::iterator it = mDeviceList.begin();
-         it != mDeviceList.end(); ++it) {
-        if((!strcmp(it->useCase, verb)) ||
-           (!strcmp(it->useCase, modifier))) {
-            ALOGV("Disabling voice call");
-            mALSADevice->close(&(*it));
-            mALSADevice->route(&(*it), (uint32_t)device, mode);
-            mDeviceList.erase(it);
-            break;
-        }
-    }
-#ifdef QCOM_USBAUDIO_ENABLED
-   if(musbPlaybackState & USBPLAYBACKBIT_VOICECALL) {
-          ALOGD("Voice call ended on USB");
-          musbPlaybackState &= ~USBPLAYBACKBIT_VOICECALL;
-          musbRecordingState &= ~USBRECBIT_VOICECALL;
-          closeUsbRecordingIfNothingActive();
-          closeUsbPlaybackIfNothingActive();
-   }
-#endif
-}
-void AudioHardwareALSA::enableVoiceCall(char* verb, char* modifier, int mode, int device)
-{
-// Start voice call
-unsigned long bufferSize = DEFAULT_VOICE_BUFFER_SIZE;
-alsa_handle_t alsa_handle;
-char *use_case;
-    snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case);
-    if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) {
-        strlcpy(alsa_handle.useCase, verb, sizeof(alsa_handle.useCase));
-    } else {
-        strlcpy(alsa_handle.useCase, modifier, sizeof(alsa_handle.useCase));
-    }
-    free(use_case);
-
-    for (size_t b = 1; (bufferSize & ~b) != 0; b <<= 1)
-    bufferSize &= ~b;
-    alsa_handle.module = mALSADevice;
-    alsa_handle.bufferSize = bufferSize;
-    alsa_handle.devices = device;
-    alsa_handle.handle = 0;
-    alsa_handle.format = SNDRV_PCM_FORMAT_S16_LE;
-    alsa_handle.channels = VOICE_CHANNEL_MODE;
-    alsa_handle.channelMask = AUDIO_CHANNEL_IN_MONO;
-    alsa_handle.sampleRate = VOICE_SAMPLING_RATE;
-    alsa_handle.latency = VOICE_LATENCY;
-    alsa_handle.rxHandle = 0;
-    alsa_handle.ucMgr = mUcMgr;
-    mDeviceList.push_back(alsa_handle);
-    ALSAHandleList::iterator it = mDeviceList.end();
-    it--;
-#ifdef QCOM_USBAUDIO_ENABLED
-    if((device & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)||
-       (device & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){
-        device |= AudioSystem::DEVICE_OUT_PROXY;
-        alsa_handle.devices = device;
-    }
-#endif
-    mALSADevice->route(&(*it), (uint32_t)device, mode);
-    if (!strcmp(it->useCase, verb)) {
-        snd_use_case_set(mUcMgr, "_verb", verb);
-    } else {
-        snd_use_case_set(mUcMgr, "_enamod", modifier);
-    }
-    mALSADevice->startVoiceCall(&(*it));
-#ifdef QCOM_USBAUDIO_ENABLED
-    if((device & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)||
-       (device & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){
-       startUsbRecordingIfNotStarted();
-       startUsbPlaybackIfNotStarted();
-       musbPlaybackState |= USBPLAYBACKBIT_VOICECALL;
-       musbRecordingState |= USBRECBIT_VOICECALL;
-    }
-#endif
-}
-
-bool AudioHardwareALSA::routeVoiceCall(int device, int newMode)
-{
-int csCallState = mCallState&0xF;
- bool isRouted = false;
- switch (csCallState) {
-    case CS_INACTIVE:
-        if (mCSCallActive != CS_INACTIVE) {
-            ALOGD("doRouting: Disabling voice call");
-            disableVoiceCall((char *)SND_USE_CASE_VERB_VOICECALL,
-                (char *)SND_USE_CASE_MOD_PLAY_VOICE, newMode, device);
-            isRouted = true;
-            mCSCallActive = CS_INACTIVE;
-        }
-    break;
-    case CS_ACTIVE:
-        if (mCSCallActive == CS_INACTIVE) {
-            ALOGD("doRouting: Enabling CS voice call ");
-            enableVoiceCall((char *)SND_USE_CASE_VERB_VOICECALL,
-                (char *)SND_USE_CASE_MOD_PLAY_VOICE, newMode, device);
-            isRouted = true;
-            mCSCallActive = CS_ACTIVE;
-        } else if (mCSCallActive == CS_HOLD) {
-             ALOGD("doRouting: Resume voice call from hold state");
-             ALSAHandleList::iterator vt_it;
-             for(vt_it = mDeviceList.begin();
-                 vt_it != mDeviceList.end(); ++vt_it) {
-                 if((!strncmp(vt_it->useCase, SND_USE_CASE_VERB_VOICECALL,
-                     strlen(SND_USE_CASE_VERB_VOICECALL))) ||
-                     (!strncmp(vt_it->useCase, SND_USE_CASE_MOD_PLAY_VOICE,
-                     strlen(SND_USE_CASE_MOD_PLAY_VOICE)))) {
-                     alsa_handle_t *handle = (alsa_handle_t *)(&(*vt_it));
-                     mCSCallActive = CS_ACTIVE;
-                     if(ioctl((int)handle->handle->fd,SNDRV_PCM_IOCTL_PAUSE,0)<0)
-                                   ALOGE("VoLTE resume failed");
-                     break;
-                 }
-             }
-        }
-    break;
-    case CS_HOLD:
-        if (mCSCallActive == CS_ACTIVE) {
-            ALOGD("doRouting: Voice call going to Hold");
-             ALSAHandleList::iterator vt_it;
-             for(vt_it = mDeviceList.begin();
-                 vt_it != mDeviceList.end(); ++vt_it) {
-                 if((!strncmp(vt_it->useCase, SND_USE_CASE_VERB_VOICECALL,
-                     strlen(SND_USE_CASE_VERB_VOICECALL))) ||
-                     (!strncmp(vt_it->useCase, SND_USE_CASE_MOD_PLAY_VOICE,
-                         strlen(SND_USE_CASE_MOD_PLAY_VOICE)))) {
-                         mCSCallActive = CS_HOLD;
-                         alsa_handle_t *handle = (alsa_handle_t *)(&(*vt_it));
-                         if(ioctl((int)handle->handle->fd,SNDRV_PCM_IOCTL_PAUSE,1)<0)
-                                   ALOGE("Voice pause failed");
-                         break;
-                }
-            }
-        }
-    break;
-    }
-    return isRouted;
-}
-bool AudioHardwareALSA::routeVoLTECall(int device, int newMode)
-{
-int volteCallState = mCallState&0xF0;
-bool isRouted = false;
-switch (volteCallState) {
-    case IMS_INACTIVE:
-        if (mVolteCallActive != IMS_INACTIVE) {
-            ALOGD("doRouting: Disabling IMS call");
-            disableVoiceCall((char *)SND_USE_CASE_VERB_VOLTE,
-                (char *)SND_USE_CASE_MOD_PLAY_VOLTE, newMode, device);
-            isRouted = true;
-            mVolteCallActive = IMS_INACTIVE;
-        }
-    break;
-    case IMS_ACTIVE:
-        if (mVolteCallActive == IMS_INACTIVE) {
-            ALOGD("doRouting: Enabling IMS voice call ");
-            enableVoiceCall((char *)SND_USE_CASE_VERB_VOLTE,
-                (char *)SND_USE_CASE_MOD_PLAY_VOLTE, newMode, device);
-            isRouted = true;
-            mVolteCallActive = IMS_ACTIVE;
-        } else if (mVolteCallActive == IMS_HOLD) {
-             ALOGD("doRouting: Resume IMS call from hold state");
-             ALSAHandleList::iterator vt_it;
-             for(vt_it = mDeviceList.begin();
-                 vt_it != mDeviceList.end(); ++vt_it) {
-                 if((!strncmp(vt_it->useCase, SND_USE_CASE_VERB_VOLTE,
-                     strlen(SND_USE_CASE_VERB_VOLTE))) ||
-                     (!strncmp(vt_it->useCase, SND_USE_CASE_MOD_PLAY_VOLTE,
-                     strlen(SND_USE_CASE_MOD_PLAY_VOLTE)))) {
-                     alsa_handle_t *handle = (alsa_handle_t *)(&(*vt_it));
-                     mVolteCallActive = IMS_ACTIVE;
-                     if(ioctl((int)handle->handle->fd,SNDRV_PCM_IOCTL_PAUSE,0)<0)
-                                   ALOGE("VoLTE resume failed");
-                     break;
-                 }
-             }
-        }
-    break;
-    case IMS_HOLD:
-        if (mVolteCallActive == IMS_ACTIVE) {
-             ALOGD("doRouting: IMS ACTIVE going to HOLD");
-             ALSAHandleList::iterator vt_it;
-             for(vt_it = mDeviceList.begin();
-                 vt_it != mDeviceList.end(); ++vt_it) {
-                 if((!strncmp(vt_it->useCase, SND_USE_CASE_VERB_VOLTE,
-                     strlen(SND_USE_CASE_VERB_VOLTE))) ||
-                     (!strncmp(vt_it->useCase, SND_USE_CASE_MOD_PLAY_VOLTE,
-                         strlen(SND_USE_CASE_MOD_PLAY_VOLTE)))) {
-                          mVolteCallActive = IMS_HOLD;
-                         alsa_handle_t *handle = (alsa_handle_t *)(&(*vt_it));
-                         if(ioctl((int)handle->handle->fd,SNDRV_PCM_IOCTL_PAUSE,1)<0)
-                                   ALOGE("VoLTE Pause failed");
-                    break;
-                }
-            }
-        }
-    break;
-    }
-    return isRouted;
-}
-
-}       // namespace android_audio_legacy
diff --git a/legacy/alsa_sound/AudioHardwareALSA.h b/legacy/alsa_sound/AudioHardwareALSA.h
deleted file mode 100644
index b65773a..0000000
--- a/legacy/alsa_sound/AudioHardwareALSA.h
+++ /dev/null
@@ -1,593 +0,0 @@
-/* AudioHardwareALSA.h
- **
- ** Copyright 2008-2010, Wind River Systems
- ** Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
- **
- ** 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.
- */
-
-#ifndef ANDROID_AUDIO_HARDWARE_ALSA_H
-#define ANDROID_AUDIO_HARDWARE_ALSA_H
-
-#define QCOM_CSDCLIENT_ENABLED 1
-
-#include <utils/List.h>
-#include <hardware_legacy/AudioHardwareBase.h>
-
-#include <hardware_legacy/AudioHardwareInterface.h>
-#include <hardware_legacy/AudioSystemLegacy.h>
-#include <system/audio.h>
-#include <hardware/audio.h>
-#include <utils/threads.h>
-#include <dlfcn.h>
-
-#ifdef QCOM_USBAUDIO_ENABLED
-#include <AudioUsbALSA.h>
-#endif
-
-extern "C" {
-   #include <sound/asound.h>
-   #include "alsa_audio.h"
-   #include "msm8960_use_cases.h"
-}
-
-#include <hardware/hardware.h>
-
-namespace android_audio_legacy
-{
-using android::List;
-using android::Mutex;
-class AudioHardwareALSA;
-
-/**
- * The id of ALSA module
- */
-#define ALSA_HARDWARE_MODULE_ID "alsa"
-#define ALSA_HARDWARE_NAME      "alsa"
-
-#define DEFAULT_SAMPLING_RATE 48000
-#define DEFAULT_CHANNEL_MODE  2
-#define VOICE_SAMPLING_RATE   8000
-#define VOICE_CHANNEL_MODE    1
-#define PLAYBACK_LATENCY      170000
-#define RECORD_LATENCY        96000
-#define VOICE_LATENCY         85333
-#define DEFAULT_BUFFER_SIZE   4096
-//4032 = 336(kernel buffer size) * 2(bytes pcm_16) * 6(number of channels)
-#define DEFAULT_MULTI_CHANNEL_BUF_SIZE    4032
-#define DEFAULT_VOICE_BUFFER_SIZE   2048
-#define PLAYBACK_LOW_LATENCY_BUFFER_SIZE   1024
-#define PLAYBACK_LOW_LATENCY  22000
-#define PLAYBACK_LOW_LATENCY_MEASURED  42000
-#define DEFAULT_IN_BUFFER_SIZE 320
-#define MIN_CAPTURE_BUFFER_SIZE_PER_CH   320
-#define MAX_CAPTURE_BUFFER_SIZE_PER_CH   2048
-#define FM_BUFFER_SIZE        1024
-
-#define VOIP_SAMPLING_RATE_8K 8000
-#define VOIP_SAMPLING_RATE_16K 16000
-#define VOIP_DEFAULT_CHANNEL_MODE  1
-#define VOIP_BUFFER_SIZE_8K    320
-#define VOIP_BUFFER_SIZE_16K   640
-#define VOIP_BUFFER_MAX_SIZE   VOIP_BUFFER_SIZE_16K
-#define VOIP_PLAYBACK_LATENCY      6400
-#define VOIP_RECORD_LATENCY        6400
-
-#define MODE_IS127              0x2
-#define MODE_4GV_NB             0x3
-#define MODE_4GV_WB             0x4
-#define MODE_AMR                0x5
-#define MODE_AMR_WB             0xD
-#define MODE_PCM                0xC
-
-#define DUALMIC_KEY         "dualmic_enabled"
-#define FLUENCE_KEY         "fluence"
-#define ANC_KEY             "anc_enabled"
-#define TTY_MODE_KEY        "tty_mode"
-#define BT_SAMPLERATE_KEY   "bt_samplerate"
-#define BTHEADSET_VGS       "bt_headset_vgs"
-#define WIDEVOICE_KEY       "wide_voice_enable"
-#define VOIPRATE_KEY        "voip_rate"
-#define FENS_KEY            "fens_enable"
-#define ST_KEY              "st_enable"
-#define INCALLMUSIC_KEY     "incall_music_enabled"
-
-#define ANC_FLAG        0x00000001
-#define DMIC_FLAG       0x00000002
-#define QMIC_FLAG       0x00000004
-#ifdef QCOM_SSR_ENABLED
-#define SSRQMIC_FLAG    0x00000008
-#endif
-
-#define TTY_OFF         0x00000010
-#define TTY_FULL        0x00000020
-#define TTY_VCO         0x00000040
-#define TTY_HCO         0x00000080
-#define TTY_CLEAR       0xFFFFFF0F
-
-#define LPA_SESSION_ID 1
-#define TUNNEL_SESSION_ID 2
-#ifdef QCOM_USBAUDIO_ENABLED
-static int USBPLAYBACKBIT_MUSIC = (1 << 0);
-static int USBPLAYBACKBIT_VOICECALL = (1 << 1);
-static int USBPLAYBACKBIT_VOIPCALL = (1 << 2);
-static int USBPLAYBACKBIT_FM = (1 << 3);
-static int USBPLAYBACKBIT_LPA = (1 << 4);
-
-static int USBRECBIT_REC = (1 << 0);
-static int USBRECBIT_VOICECALL = (1 << 1);
-static int USBRECBIT_VOIPCALL = (1 << 2);
-static int USBRECBIT_FM = (1 << 3);
-#endif
-
-#define DEVICE_SPEAKER_HEADSET "Speaker Headset"
-#define DEVICE_HEADSET "Headset"
-#define DEVICE_HEADPHONES "Headphones"
-
-#ifdef QCOM_SSR_ENABLED
-#define COEFF_ARRAY_SIZE          4
-#define FILT_SIZE                 ((512+1)* 6)    /* # ((FFT bins)/2+1)*numOutputs */
-#define SSR_FRAME_SIZE            512
-#define SSR_INPUT_FRAME_SIZE      (SSR_FRAME_SIZE * 4)
-#define SSR_OUTPUT_FRAME_SIZE     (SSR_FRAME_SIZE * 6)
-#endif
-
-#define MODE_CALL_KEY  "CALL_KEY"
-
-struct alsa_device_t;
-static uint32_t FLUENCE_MODE_ENDFIRE   = 0;
-static uint32_t FLUENCE_MODE_BROADSIDE = 1;
-
-enum {
-    INCALL_REC_MONO,
-    INCALL_REC_STEREO,
-};
-
-enum audio_call_mode {
-    CS_INACTIVE   = 0x0,
-    CS_ACTIVE     = 0x1,
-    CS_HOLD       = 0x2,
-    IMS_INACTIVE  = 0x0,
-    IMS_ACTIVE    = 0x10,
-    IMS_HOLD      = 0x20
-};
-
-
-struct alsa_handle_t {
-    alsa_device_t *     module;
-    uint32_t            devices;
-    char                useCase[MAX_STR_LEN];
-    struct pcm *        handle;
-    snd_pcm_format_t    format;
-    uint32_t            channels;
-    audio_channel_mask_t channelMask;
-    uint32_t            sampleRate;
-    unsigned int        latency;         // Delay in usec
-    unsigned int        bufferSize;      // Size of sample buffer
-    unsigned int        periodSize;
-    bool                isDeepbufferOutput;
-    struct pcm *        rxHandle;
-    snd_use_case_mgr_t  *ucMgr;
-};
-
-typedef List < alsa_handle_t > ALSAHandleList;
-
-struct use_case_t {
-    char                useCase[MAX_STR_LEN];
-};
-
-typedef List < use_case_t > ALSAUseCaseList;
-
-struct alsa_device_t {
-    hw_device_t common;
-
-    status_t (*init)(alsa_device_t *, ALSAHandleList &);
-    status_t (*open)(alsa_handle_t *);
-    status_t (*close)(alsa_handle_t *);
-    status_t (*standby)(alsa_handle_t *);
-    status_t (*route)(alsa_handle_t *, uint32_t, int);
-    status_t (*startVoiceCall)(alsa_handle_t *);
-    status_t (*startVoipCall)(alsa_handle_t *);
-    status_t (*startFm)(alsa_handle_t *);
-    void     (*setVoiceVolume)(int);
-    void     (*setVoipVolume)(int);
-    void     (*setMicMute)(int);
-    void     (*setVoipMicMute)(int);
-    void     (*setVoipConfig)(int, int);
-    status_t (*setFmVolume)(int);
-    void     (*setBtscoRate)(int);
-    status_t (*setLpaVolume)(int);
-    void     (*enableWideVoice)(bool);
-    void     (*enableFENS)(bool);
-    void     (*setFlags)(uint32_t);
-    status_t (*setCompressedVolume)(int);
-    void     (*enableSlowTalk)(bool);
-    void     (*setVocRecMode)(uint8_t);
-    void     (*setVoLTEMicMute)(int);
-    void     (*setVoLTEVolume)(int);
-#ifdef SEPERATED_AUDIO_INPUT
-    void     (*setInput)(int);
-#endif
-#ifdef QCOM_CSDCLIENT_ENABLED
-    void     (*setCsdHandle)(void*);
-#endif
-};
-
-// ----------------------------------------------------------------------------
-
-class ALSAMixer
-{
-public:
-    ALSAMixer();
-    virtual                ~ALSAMixer();
-
-    bool                    isValid() { return 1;}
-    status_t                setMasterVolume(float volume);
-    status_t                setMasterGain(float gain);
-
-    status_t                setVolume(uint32_t device, float left, float right);
-    status_t                setGain(uint32_t device, float gain);
-
-    status_t                setCaptureMuteState(uint32_t device, bool state);
-    status_t                getCaptureMuteState(uint32_t device, bool *state);
-    status_t                setPlaybackMuteState(uint32_t device, bool state);
-    status_t                getPlaybackMuteState(uint32_t device, bool *state);
-
-};
-
-class ALSAControl
-{
-public:
-    ALSAControl(const char *device = "/dev/snd/controlC0");
-    virtual                ~ALSAControl();
-
-    status_t                get(const char *name, unsigned int &value, int index = 0);
-    status_t                set(const char *name, unsigned int value, int index = -1);
-    status_t                set(const char *name, const char *);
-    status_t                setext(const char *name, int count, char **setValues);
-
-private:
-    struct mixer*             mHandle;
-};
-
-class ALSAStreamOps
-{
-public:
-    ALSAStreamOps(AudioHardwareALSA *parent, alsa_handle_t *handle);
-    virtual            ~ALSAStreamOps();
-
-    status_t            set(int *format, uint32_t *channels, uint32_t *rate, uint32_t device);
-
-    status_t            setParameters(const String8& keyValuePairs);
-    String8             getParameters(const String8& keys);
-
-    uint32_t            sampleRate() const;
-    size_t              bufferSize() const;
-    int                 format() const;
-    uint32_t            channels() const;
-
-    status_t            open(int mode);
-    void                close();
-
-protected:
-    friend class AudioHardwareALSA;
-
-    AudioHardwareALSA *     mParent;
-    alsa_handle_t *         mHandle;
-    uint32_t                mDevices;
-};
-
-// ----------------------------------------------------------------------------
-
-class AudioStreamOutALSA : public AudioStreamOut, public ALSAStreamOps
-{
-public:
-    AudioStreamOutALSA(AudioHardwareALSA *parent, alsa_handle_t *handle);
-    virtual            ~AudioStreamOutALSA();
-
-    virtual uint32_t    sampleRate() const
-    {
-        return ALSAStreamOps::sampleRate();
-    }
-
-    virtual size_t      bufferSize() const
-    {
-        return ALSAStreamOps::bufferSize();
-    }
-
-    virtual uint32_t    channels() const;
-
-    virtual int         format() const
-    {
-        return ALSAStreamOps::format();
-    }
-
-    virtual uint32_t    latency() const;
-
-    virtual ssize_t     write(const void *buffer, size_t bytes);
-    virtual status_t    dump(int fd, const Vector<String16>& args);
-
-    status_t            setVolume(float left, float right);
-
-    virtual status_t    standby();
-
-    virtual status_t    setParameters(const String8& keyValuePairs) {
-        return ALSAStreamOps::setParameters(keyValuePairs);
-    }
-
-    virtual String8     getParameters(const String8& keys) {
-        return ALSAStreamOps::getParameters(keys);
-    }
-
-    // return the number of audio frames written by the audio dsp to DAC since
-    // the output has exited standby
-    virtual status_t    getRenderPosition(uint32_t *dspFrames);
-
-    status_t            open(int mode);
-    status_t            close();
-
-private:
-    uint32_t            mFrameCount;
-
-protected:
-    AudioHardwareALSA *     mParent;
-};
-
-class AudioStreamInALSA : public AudioStreamIn, public ALSAStreamOps
-{
-public:
-    AudioStreamInALSA(AudioHardwareALSA *parent,
-            alsa_handle_t *handle,
-            AudioSystem::audio_in_acoustics audio_acoustics);
-    virtual            ~AudioStreamInALSA();
-
-    virtual uint32_t    sampleRate() const
-    {
-        return ALSAStreamOps::sampleRate();
-    }
-
-    virtual size_t      bufferSize() const
-    {
-        return ALSAStreamOps::bufferSize();
-    }
-
-    virtual uint32_t    channels() const
-    {
-        return ALSAStreamOps::channels();
-    }
-
-    virtual int         format() const
-    {
-        return ALSAStreamOps::format();
-    }
-
-    virtual ssize_t     read(void* buffer, ssize_t bytes);
-    virtual status_t    dump(int fd, const Vector<String16>& args);
-
-    virtual status_t    setGain(float gain);
-
-    virtual status_t    standby();
-
-    virtual status_t    setParameters(const String8& keyValuePairs)
-    {
-        return ALSAStreamOps::setParameters(keyValuePairs);
-    }
-
-    virtual String8     getParameters(const String8& keys)
-    {
-        return ALSAStreamOps::getParameters(keys);
-    }
-
-    // Return the amount of input frames lost in the audio driver since the last call of this function.
-    // Audio driver is expected to reset the value to 0 and restart counting upon returning the current value by this function call.
-    // Such loss typically occurs when the user space process is blocked longer than the capacity of audio driver buffers.
-    // Unit: the number of input audio frames
-    virtual unsigned int  getInputFramesLost() const;
-
-    virtual status_t addAudioEffect(effect_handle_t effect)
-    {
-        return BAD_VALUE;
-    }
-   
-    virtual status_t removeAudioEffect(effect_handle_t effect)
-    {
-        return BAD_VALUE;
-    }
-    status_t            setAcousticParams(void* params);
-
-    status_t            open(int mode);
-    status_t            close();
-#ifdef QCOM_SSR_ENABLED
-    // Helper function to initialize the Surround Sound library.
-    status_t initSurroundSoundLibrary(unsigned long buffersize);
-#endif
-
-private:
-    void                resetFramesLost();
-
-#ifdef QCOM_CSDCLIENT_ENABLED
-    int                 start_csd_record(int);
-    int                 stop_csd_record(void);
-#endif
-
-    unsigned int        mFramesLost;
-    AudioSystem::audio_in_acoustics mAcoustics;
-
-#ifdef QCOM_SSR_ENABLED
-    // Function to read coefficients from files.
-    status_t            readCoeffsFromFile();
-
-    FILE                *mFp_4ch;
-    FILE                *mFp_6ch;
-    int16_t             **mRealCoeffs;
-    int16_t             **mImagCoeffs;
-    void                *mSurroundObj;
-
-    int16_t             *mSurroundInputBuffer;
-    int16_t             *mSurroundOutputBuffer;
-    int                 mSurroundInputBufferIdx;
-    int                 mSurroundOutputBufferIdx;
-#endif
-
-protected:
-    AudioHardwareALSA *     mParent;
-};
-
-class AudioHardwareALSA : public AudioHardwareBase
-{
-public:
-    AudioHardwareALSA();
-    virtual            ~AudioHardwareALSA();
-
-    /**
-     * check to see if the audio hardware interface has been initialized.
-     * return status based on values defined in include/utils/Errors.h
-     */
-    virtual status_t    initCheck();
-
-    /** set the audio volume of a voice call. Range is between 0.0 and 1.0 */
-    virtual status_t    setVoiceVolume(float volume);
-
-    /**
-     * set the audio volume for all audio activities other than voice call.
-     * Range between 0.0 and 1.0. If any value other than NO_ERROR is returned,
-     * the software mixer will emulate this capability.
-     */
-    virtual status_t    setMasterVolume(float volume);
-#ifdef QCOM_FM_ENABLED
-    virtual status_t    setFmVolume(float volume);
-#endif
-    /**
-     * setMode is called when the audio mode changes. NORMAL mode is for
-     * standard audio playback, RINGTONE when a ringtone is playing, and IN_CALL
-     * when a call is in progress.
-     */
-    virtual status_t    setMode(int mode);
-
-    // mic mute
-    virtual status_t    setMicMute(bool state);
-    virtual status_t    getMicMute(bool* state);
-
-    // set/get global audio parameters
-    virtual status_t    setParameters(const String8& keyValuePairs);
-    virtual String8     getParameters(const String8& keys);
-
-    // Returns audio input buffer size according to parameters passed or 0 if one of the
-    // parameters is not supported
-    virtual size_t    getInputBufferSize(uint32_t sampleRate, int format, int channels);
-
-#ifdef QCOM_TUNNEL_LPA_ENABLED
-    /** This method creates and opens the audio hardware output
-      *  session for LPA */
-    virtual AudioStreamOut* openOutputSession(
-            uint32_t devices,
-            int *format,
-            status_t *status,
-            int sessionId,
-            uint32_t samplingRate=0,
-            uint32_t channels=0);
-    virtual void closeOutputSession(AudioStreamOut* out);
-#endif
-
-    /** This method creates and opens the audio hardware output stream */
-    virtual AudioStreamOut* openOutputStream(
-            uint32_t devices,
-            int *format=0,
-            uint32_t *channels=0,
-            uint32_t *sampleRate=0,
-            status_t *status=0);
-    virtual    void        closeOutputStream(AudioStreamOut* out);
-
-    /** This method creates and opens the audio hardware input stream */
-    virtual AudioStreamIn* openInputStream(
-            uint32_t devices,
-            int *format,
-            uint32_t *channels,
-            uint32_t *sampleRate,
-            status_t *status,
-            AudioSystem::audio_in_acoustics acoustics);
-    virtual    void        closeInputStream(AudioStreamIn* in);
-
-    /**This method dumps the state of the audio hardware */
-    //virtual status_t dumpState(int fd, const Vector<String16>& args);
-
-    static AudioHardwareInterface* create();
-
-    int                 mode()
-    {
-        return mMode;
-    }
-
-protected:
-    virtual status_t    dump(int fd, const Vector<String16>& args);
-    virtual uint32_t    getVoipMode(int format);
-    void                doRouting(int device);
-#ifdef QCOM_FM_ENABLED
-    void                handleFm(int device);
-#endif
-#ifdef QCOM_USBAUDIO_ENABLED
-    void                closeUSBPlayback();
-    void                closeUSBRecording();
-    void                closeUsbRecordingIfNothingActive();
-    void                closeUsbPlaybackIfNothingActive();
-    void                startUsbPlaybackIfNotStarted();
-    void                startUsbRecordingIfNotStarted();
-#endif
-
-    void                disableVoiceCall(char* verb, char* modifier, int mode, int device);
-    void                enableVoiceCall(char* verb, char* modifier, int mode, int device);
-    bool                routeVoiceCall(int device, int	newMode);
-    bool                routeVoLTECall(int device, int newMode);
-    friend class AudioStreamOutALSA;
-    friend class AudioStreamInALSA;
-    friend class ALSAStreamOps;
-
-    alsa_device_t *     mALSADevice;
-
-    ALSAHandleList      mDeviceList;
-
-#ifdef QCOM_USBAUDIO_ENABLED
-    AudioUsbALSA        *mAudioUsbALSA;
-#endif
-
-    Mutex                   mLock;
-
-    snd_use_case_mgr_t *mUcMgr;
-
-    uint32_t            mCurDevice;
-    /* The flag holds all the audio related device settings from
-     * Settings and Qualcomm Settings applications */
-    uint32_t            mDevSettingsFlag;
-    uint32_t            mVoipStreamCount;
-    uint32_t            mVoipBitRate;
-    uint32_t            mIncallMode;
-
-    bool                mMicMute;
-    int mCSCallActive;
-    int mVolteCallActive;
-    int mCallState;
-    int mIsFmActive;
-    bool mBluetoothVGS;
-    bool mFusion3Platform;
-#ifdef QCOM_USBAUDIO_ENABLED
-    int musbPlaybackState;
-    int musbRecordingState;
-#endif
-    void *mAcdbHandle;
-    void *mCsdHandle;
-};
-
-// ----------------------------------------------------------------------------
-
-};        // namespace android_audio_legacy
-#endif    // ANDROID_AUDIO_HARDWARE_ALSA_H
diff --git a/legacy/alsa_sound/AudioPolicyManagerALSA.cpp b/legacy/alsa_sound/AudioPolicyManagerALSA.cpp
deleted file mode 100644
index 36ae4d3..0000000
--- a/legacy/alsa_sound/AudioPolicyManagerALSA.cpp
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- * Copyright (C) 2009 The Android Open Source Project
- * Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
- *
- * 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 "AudioPolicyManagerALSA"
-//#define LOG_NDEBUG 0
-#define LOG_NDDEBUG 0
-#include <utils/Log.h>
-
-#include "AudioPolicyManagerALSA.h"
-#include <media/mediarecorder.h>
-
-namespace android_audio_legacy {
-
-// ----------------------------------------------------------------------------
-// AudioPolicyManagerALSA
-// ----------------------------------------------------------------------------
-
-//Compiling error seen if AudioParamer doesn't exist in this file
-
-AudioParameter param;
-
-// ---  class factory
-
-
-extern "C" AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
-{
-    return new AudioPolicyManager(clientInterface);
-}
-
-extern "C" void destroyAudioPolicyManager(AudioPolicyInterface *interface)
-{
-    delete interface;
-}
-
-void AudioPolicyManager::setPhoneState(int state) {
-    ALOGV("setPhoneState() state %d", state);
-    audio_devices_t newDevice = AUDIO_DEVICE_NONE;
-    if (state < 0 || state >= AudioSystem::NUM_MODES) {
-        ALOGW("setPhoneState() invalid state %d", state);
-        return;
-    }
-
-    if (state == mPhoneState) {
-        ALOGW("setPhoneState() setting same state %d", state);
-        return;
-    }
-
-    // if leaving call state, handle special case of active streams
-    // pertaining to sonification strategy see handleIncallSonification()
-    if (isInCall()) {
-        ALOGV("setPhoneState() in call state management: new state is %d", state);
-        for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) {
-            handleIncallSonification(stream, false, true);
-        }
-    }
-
-    // store previous phone state for management of sonification strategy below
-    int oldState = mPhoneState;
-    mPhoneState = state;
-    bool force = false;
-
-    // are we entering or starting a call
-    if (!isStateInCall(oldState) && isStateInCall(state)) {
-        ALOGV("  Entering call in setPhoneState()");
-        // force routing command to audio hardware when starting a call
-        // even if no device change is needed
-        force = true;
-    } else if (isStateInCall(oldState) && !isStateInCall(state)) {
-        ALOGV("  Exiting call in setPhoneState()");
-        // force routing command to audio hardware when exiting a call
-        // even if no device change is needed
-        force = true;
-    } else if (isStateInCall(state) && (state != oldState)) {
-        ALOGV("  Switching between telephony and VoIP in setPhoneState()");
-        // force routing command to audio hardware when switching between telephony and VoIP
-        // even if no device change is needed
-        force = true;
-    }
-
-    // check for device and output changes triggered by new phone state
-    newDevice = getNewDevice(mPrimaryOutput, false /*fromCache*/);
-    checkA2dpSuspend();
-    checkOutputForAllStrategies();
-    updateDevicesAndOutputs();
-
-    AudioOutputDescriptor *hwOutputDesc = mOutputs.valueFor(mPrimaryOutput);
-
-    // force routing command to audio hardware when ending call
-    // even if no device change is needed
-    if (isStateInCall(oldState) && newDevice == AUDIO_DEVICE_NONE) {
-        newDevice = hwOutputDesc->device();
-    }
-
-    // when changing from ring tone to in call mode, mute the ringing tone
-    // immediately and delay the route change to avoid sending the ring tone
-    // tail into the earpiece or headset.
-    int delayMs = 0;
-    if (isStateInCall(state) && oldState == AudioSystem::MODE_RINGTONE) {
-        // delay the device change command by twice the output latency to have some margin
-        // and be sure that audio buffers not yet affected by the mute are out when
-        // we actually apply the route change
-        delayMs = hwOutputDesc->mLatency*2;
-        setStreamMute(AudioSystem::RING, true, mPrimaryOutput);
-    }
-
-    if (isStateInCall(state)) {
-        for (size_t i = 0; i < mOutputs.size(); i++) {
-            AudioOutputDescriptor *desc = mOutputs.valueAt(i);
-            //take the biggest latency for all outputs
-            if (delayMs < desc->mLatency*2) {
-                delayMs = desc->mLatency*2;
-            }
-            //mute STRATEGY_MEDIA on all outputs
-            if (desc->strategyRefCount(STRATEGY_MEDIA) != 0) {
-                setStrategyMute(STRATEGY_MEDIA, true, mOutputs.keyAt(i));
-                setStrategyMute(STRATEGY_MEDIA, false, mOutputs.keyAt(i), MUTE_TIME_MS,
-                    getDeviceForStrategy(STRATEGY_MEDIA, true /*fromCache*/));
-            }
-        }
-    }
-
-    // Ignore the delay to enable voice call on this target as the enabling the
-    // voice call has enough delay to make sure the ringtone audio completely
-    // played out
-    if (state == AudioSystem::MODE_IN_CALL && oldState == AudioSystem::MODE_RINGTONE) {
-        delayMs = 40;
-    }
-
-    // change routing is necessary
-    setOutputDevice(mPrimaryOutput, newDevice, force, delayMs);
-
-    // if entering in call state, handle special case of active streams
-    // pertaining to sonification strategy see handleIncallSonification()
-    if (isStateInCall(state)) {
-        ALOGV("setPhoneState() in call state management: new state is %d", state);
-        // unmute the ringing tone after a sufficient delay if it was muted before
-        // setting output device above
-        if (oldState == AudioSystem::MODE_RINGTONE) {
-            setStreamMute(AudioSystem::RING, false, mPrimaryOutput, MUTE_TIME_MS);
-        }
-        for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) {
-            handleIncallSonification(stream, true, true);
-        }
-    }
-
-    // Flag that ringtone volume must be limited to music volume until we exit MODE_RINGTONE
-    if (state == AudioSystem::MODE_RINGTONE &&
-        isStreamActive(AudioSystem::MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY)) {
-        mLimitRingtoneVolume = true;
-    } else {
-        mLimitRingtoneVolume = false;
-    }
-}
-
-}; // namespace androidi_audio_legacy
diff --git a/legacy/alsa_sound/AudioPolicyManagerALSA.h b/legacy/alsa_sound/AudioPolicyManagerALSA.h
deleted file mode 100644
index a343cff..0000000
--- a/legacy/alsa_sound/AudioPolicyManagerALSA.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (C) 2009 The Android Open Source Project
- * Copyright (C) 2011-2012, The Linux Foundation. All rights reserved.
- *
- * 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.
- */
-
-
-#include <stdint.h>
-#include <sys/types.h>
-#include <utils/Timers.h>
-#include <utils/Errors.h>
-#include <utils/KeyedVector.h>
-#include <hardware_legacy/AudioPolicyManagerBase.h>
-
-
-namespace android_audio_legacy {
-
-// ----------------------------------------------------------------------------
-
-class AudioPolicyManager: public AudioPolicyManagerBase
-{
-
-public:
-                AudioPolicyManager(AudioPolicyClientInterface *clientInterface)
-                : AudioPolicyManagerBase(clientInterface) {}
-
-        virtual void setPhoneState(int state);
-
-        virtual ~AudioPolicyManager() {}
-
-};
-};
diff --git a/legacy/alsa_sound/AudioStreamInALSA.cpp b/legacy/alsa_sound/AudioStreamInALSA.cpp
deleted file mode 100644
index 7887f55..0000000
--- a/legacy/alsa_sound/AudioStreamInALSA.cpp
+++ /dev/null
@@ -1,896 +0,0 @@
-/* AudioStreamInALSA.cpp
- **
- ** Copyright 2008-2009 Wind River Systems
- ** Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
- **
- ** 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.
- */
-
-#include <errno.h>
-#include <stdarg.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <dlfcn.h>
-
-#define LOG_TAG "AudioStreamInALSA"
-//#define LOG_NDEBUG 0
-#define LOG_NDDEBUG 0
-#include <utils/Log.h>
-#include <utils/String8.h>
-
-#include <cutils/properties.h>
-#include <media/AudioRecord.h>
-#include <hardware_legacy/power.h>
-
-#include "AudioHardwareALSA.h"
-
-extern "C" {
-#ifdef QCOM_CSDCLIENT_ENABLED
-static int (*csd_start_record)(int);
-static int (*csd_stop_record)(void);
-#endif
-
-#ifdef QCOM_SSR_ENABLED
-#include "surround_filters_interface.h"
-#endif
-}
-
-namespace android_audio_legacy
-{
-#ifdef QCOM_SSR_ENABLED
-#define SURROUND_FILE_1R "/system/etc/surround_sound/filter1r.pcm"
-#define SURROUND_FILE_2R "/system/etc/surround_sound/filter2r.pcm"
-#define SURROUND_FILE_3R "/system/etc/surround_sound/filter3r.pcm"
-#define SURROUND_FILE_4R "/system/etc/surround_sound/filter4r.pcm"
-
-#define SURROUND_FILE_1I "/system/etc/surround_sound/filter1i.pcm"
-#define SURROUND_FILE_2I "/system/etc/surround_sound/filter2i.pcm"
-#define SURROUND_FILE_3I "/system/etc/surround_sound/filter3i.pcm"
-#define SURROUND_FILE_4I "/system/etc/surround_sound/filter4i.pcm"
-
-// Use AAC/DTS channel mapping as default channel mapping: C,FL,FR,Ls,Rs,LFE
-const int chanMap[] = { 1, 2, 4, 3, 0, 5 };
-#endif
-
-AudioStreamInALSA::AudioStreamInALSA(AudioHardwareALSA *parent,
-        alsa_handle_t *handle,
-        AudioSystem::audio_in_acoustics audio_acoustics) :
-    ALSAStreamOps(parent, handle),
-    mFramesLost(0),
-    mAcoustics(audio_acoustics),
-    mParent(parent)
-#ifdef QCOM_SSR_ENABLED
-    , mFp_4ch(NULL),
-    mFp_6ch(NULL),
-    mRealCoeffs(NULL),
-    mImagCoeffs(NULL),
-    mSurroundObj(NULL),
-    mSurroundOutputBuffer(NULL),
-    mSurroundInputBuffer(NULL),
-    mSurroundOutputBufferIdx(0),
-    mSurroundInputBufferIdx(0)
-#endif
-{
-#ifdef QCOM_SSR_ENABLED
-    char c_multi_ch_dump[128] = {0};
-    status_t err = NO_ERROR;
-
-    // Call surround sound library init if device is Surround Sound
-    if ( handle->channels == 6) {
-        if (!strncmp(handle->useCase, SND_USE_CASE_VERB_HIFI_REC, strlen(SND_USE_CASE_VERB_HIFI_REC))
-            || !strncmp(handle->useCase, SND_USE_CASE_MOD_CAPTURE_MUSIC, strlen(SND_USE_CASE_MOD_CAPTURE_MUSIC))) {
-
-            err = initSurroundSoundLibrary(handle->bufferSize);
-            if ( NO_ERROR != err) {
-                ALOGE("initSurroundSoundLibrary failed: %d  handle->bufferSize:%d", err,handle->bufferSize);
-            }
-
-            property_get("ssr.pcmdump",c_multi_ch_dump,"0");
-            if (0 == strncmp("true",c_multi_ch_dump, sizeof("ssr.dump-pcm"))) {
-                //Remember to change file system permission of data(e.g. chmod 777 data/),
-                //otherwise, fopen may fail.
-                if ( !mFp_4ch)
-                    mFp_4ch = fopen("/data/4ch_ssr.pcm", "wb");
-                if ( !mFp_6ch)
-                    mFp_6ch = fopen("/data/6ch_ssr.pcm", "wb");
-                if ((!mFp_4ch) || (!mFp_6ch))
-                    ALOGE("mfp_4ch or mfp_6ch open failed: mfp_4ch:%p mfp_6ch:%p",mFp_4ch,mFp_6ch);
-            }
-        }
-    }
-#endif
-}
-
-AudioStreamInALSA::~AudioStreamInALSA()
-{
-    close();
-}
-
-status_t AudioStreamInALSA::setGain(float gain)
-{
-    return 0; //mixer() ? mixer()->setMasterGain(gain) : (status_t)NO_INIT;
-}
-
-ssize_t AudioStreamInALSA::read(void *buffer, ssize_t bytes)
-{
-    int period_size;
-
-    ALOGV("read:: buffer %p, bytes %d", buffer, bytes);
-
-    int n;
-    status_t          err;
-    ssize_t            read = 0;
-    char *use_case;
-    int newMode = mParent->mode();
-
-    if((mHandle->handle == NULL) && (mHandle->rxHandle == NULL) &&
-         (strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) &&
-         (strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
-        mParent->mLock.lock();
-        snd_use_case_get(mHandle->ucMgr, "_verb", (const char **)&use_case);
-        if ((use_case != NULL) && (strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) {
-            if ((mHandle->devices == AudioSystem::DEVICE_IN_VOICE_CALL) &&
-                (newMode == AudioSystem::MODE_IN_CALL)) {
-                ALOGD("read:: mParent->mIncallMode=%d", mParent->mIncallMode);
-                if ((mParent->mIncallMode & AudioSystem::CHANNEL_IN_VOICE_UPLINK) &&
-                    (mParent->mIncallMode & AudioSystem::CHANNEL_IN_VOICE_DNLINK)) {
-#ifdef QCOM_CSDCLIENT_ENABLED
-                    if (mParent->mFusion3Platform) {
-                        mParent->mALSADevice->setVocRecMode(INCALL_REC_STEREO);
-                        strlcpy(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_VOICE,
-                                sizeof(mHandle->useCase));
-                        start_csd_record(INCALL_REC_STEREO);
-                    } else
-#endif
-                    {
-                        strlcpy(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_VOICE_UL_DL,
-                                sizeof(mHandle->useCase));
-                    }
-                } else if (mParent->mIncallMode & AudioSystem::CHANNEL_IN_VOICE_DNLINK) {
-#ifdef QCOM_CSDCLIENT_ENABLED
-                    if (mParent->mFusion3Platform) {
-                        mParent->mALSADevice->setVocRecMode(INCALL_REC_MONO);
-                        strlcpy(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_VOICE,
-                                sizeof(mHandle->useCase));
-                        start_csd_record(INCALL_REC_MONO);
-                    } else
-#endif
-                    {
-                        strlcpy(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_VOICE_DL,
-                                sizeof(mHandle->useCase));
-                    }
-                }
-#ifdef QCOM_FM_ENABLED
-            } else if(mHandle->devices == AudioSystem::DEVICE_IN_FM_RX) {
-                strlcpy(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_FM, sizeof(mHandle->useCase));
-            } else if (mHandle->devices == AudioSystem::DEVICE_IN_FM_RX_A2DP) {
-                strlcpy(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_A2DP_FM, sizeof(mHandle->useCase));
-#endif
-            } else if(!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP)) {
-                strlcpy(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP, sizeof(mHandle->useCase));
-            } else {
-                    char value[128];
-                    property_get("persist.audio.lowlatency.rec",value,"0");
-                    if (!strcmp("true", value)) {
-                        strlcpy(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_LOWLATENCY_MUSIC, sizeof(mHandle->useCase));
-                    } else {
-                        strlcpy(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_MUSIC, sizeof(mHandle->useCase));
-                    }
-            }
-        } else {
-            if ((mHandle->devices == AudioSystem::DEVICE_IN_VOICE_CALL) &&
-                (newMode == AudioSystem::MODE_IN_CALL)) {
-                ALOGD("read:: ---- mParent->mIncallMode=%d", mParent->mIncallMode);
-                if ((mParent->mIncallMode & AudioSystem::CHANNEL_IN_VOICE_UPLINK) &&
-                    (mParent->mIncallMode & AudioSystem::CHANNEL_IN_VOICE_DNLINK)) {
-#ifdef QCOM_CSDCLIENT_ENABLED
-                    if (mParent->mFusion3Platform) {
-                        mParent->mALSADevice->setVocRecMode(INCALL_REC_STEREO);
-                        strlcpy(mHandle->useCase, SND_USE_CASE_VERB_INCALL_REC,
-                                sizeof(mHandle->useCase));
-                        start_csd_record(INCALL_REC_STEREO);
-                    } else
-#endif
-                    {
-                        strlcpy(mHandle->useCase, SND_USE_CASE_VERB_UL_DL_REC,
-                                sizeof(mHandle->useCase));
-                    }
-                } else if (mParent->mIncallMode & AudioSystem::CHANNEL_IN_VOICE_DNLINK) {
-#ifdef QCOM_CSDCLIENT_ENABLED
-                   if (mParent->mFusion3Platform) {
-                       mParent->mALSADevice->setVocRecMode(INCALL_REC_MONO);
-                       strlcpy(mHandle->useCase, SND_USE_CASE_VERB_INCALL_REC,
-                               sizeof(mHandle->useCase));
-                       start_csd_record(INCALL_REC_MONO);
-                   } else
-#endif
-                   {
-                       strlcpy(mHandle->useCase, SND_USE_CASE_VERB_DL_REC,
-                               sizeof(mHandle->useCase));
-                   }
-                }
-#ifdef QCOM_FM_ENABLED
-            } else if(mHandle->devices == AudioSystem::DEVICE_IN_FM_RX) {
-                strlcpy(mHandle->useCase, SND_USE_CASE_VERB_FM_REC, sizeof(mHandle->useCase));
-        } else if (mHandle->devices == AudioSystem::DEVICE_IN_FM_RX_A2DP) {
-                strlcpy(mHandle->useCase, SND_USE_CASE_VERB_FM_A2DP_REC, sizeof(mHandle->useCase));
-#endif
-            } else if(!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)){
-                    strlcpy(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL, sizeof(mHandle->useCase));
-            } else {
-                    char value[128];
-                    property_get("persist.audio.lowlatency.rec",value,"0");
-                    if (!strcmp("true", value)) {
-                        strlcpy(mHandle->useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_REC, sizeof(mHandle->useCase));
-                    } else {
-                        strlcpy(mHandle->useCase, SND_USE_CASE_VERB_HIFI_REC, sizeof(mHandle->useCase));
-                    }
-            }
-        }
-        if (mHandle->channelMask == AUDIO_CHANNEL_IN_FRONT_BACK) {
-            mHandle->module->setFlags(mParent->mDevSettingsFlag | DMIC_FLAG);
-        }
-        free(use_case);
-        if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
-            (!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
-#ifdef QCOM_USBAUDIO_ENABLED
-            if((mDevices & AudioSystem::DEVICE_IN_ANLG_DOCK_HEADSET) ||
-               (mDevices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)) {
-                mHandle->module->route(mHandle, (mDevices | AudioSystem::DEVICE_IN_PROXY) , AudioSystem::MODE_IN_COMMUNICATION);
-            }else
-#endif
-            {
-                mHandle->module->route(mHandle, mDevices , AudioSystem::MODE_IN_COMMUNICATION);
-            }
-        } else {
-#ifdef QCOM_USBAUDIO_ENABLED
-            if((mHandle->devices == AudioSystem::DEVICE_IN_ANLG_DOCK_HEADSET)||
-               (mHandle->devices == AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)){
-                mHandle->module->route(mHandle, AudioSystem::DEVICE_IN_PROXY , mParent->mode());
-            } else
-#endif
-            {
-
-                mHandle->module->route(mHandle, mDevices , mParent->mode());
-            }
-        }
-        if (!strcmp(mHandle->useCase, SND_USE_CASE_VERB_HIFI_REC) ||
-            !strcmp(mHandle->useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_REC) ||
-            !strcmp(mHandle->useCase, SND_USE_CASE_VERB_FM_REC) ||
-            !strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL) ||
-            !strcmp(mHandle->useCase, SND_USE_CASE_VERB_FM_A2DP_REC) ||
-            !strcmp(mHandle->useCase, SND_USE_CASE_VERB_UL_DL_REC) ||
-            !strcmp(mHandle->useCase, SND_USE_CASE_VERB_DL_REC) ||
-            !strcmp(mHandle->useCase, SND_USE_CASE_VERB_INCALL_REC)) {
-            snd_use_case_set(mHandle->ucMgr, "_verb", mHandle->useCase);
-        } else {
-            snd_use_case_set(mHandle->ucMgr, "_enamod", mHandle->useCase);
-        }
-       if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
-           (!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
-            err = mHandle->module->startVoipCall(mHandle);
-        }
-        else
-            mHandle->module->open(mHandle);
-        if(mHandle->handle == NULL) {
-            ALOGE("read:: PCM device open failed");
-            mParent->mLock.unlock();
-
-            return 0;
-        }
-#ifdef QCOM_USBAUDIO_ENABLED
-        if((mHandle->devices == AudioSystem::DEVICE_IN_ANLG_DOCK_HEADSET)||
-           (mHandle->devices == AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)){
-            if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
-               (!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
-                mParent->musbRecordingState |= USBRECBIT_VOIPCALL;
-            } else {
-                mParent->startUsbRecordingIfNotStarted();
-                mParent->musbRecordingState |= USBRECBIT_REC;
-            }
-        }
-#endif
-        mParent->mLock.unlock();
-    }
-#ifdef QCOM_USBAUDIO_ENABLED
-    if(((mDevices & AudioSystem::DEVICE_IN_ANLG_DOCK_HEADSET) ||
-       (mDevices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)) &&
-       (!mParent->musbRecordingState)) {
-        mParent->mLock.lock();
-        ALOGD("Starting UsbRecording thread");
-        mParent->startUsbRecordingIfNotStarted();
-        if(!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL) ||
-           !strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP)) {
-            ALOGD("Enabling voip recording bit");
-            mParent->musbRecordingState |= USBRECBIT_VOIPCALL;
-        }else{
-            ALOGD("Enabling HiFi Recording bit");
-            mParent->musbRecordingState |= USBRECBIT_REC;
-        }
-        mParent->mLock.unlock();
-    }
-#endif
-    period_size = mHandle->periodSize;
-    int read_pending = bytes;
-
-#ifdef QCOM_SSR_ENABLED
-    if (mSurroundObj) {
-        int processed = 0;
-        int processed_pending;
-        int samples = bytes >> 1;
-        void *buffer_start = buffer;
-        int period_bytes = mHandle->handle->period_size;
-        int period_samples = period_bytes >> 1;
-
-        do {
-            if (mSurroundOutputBufferIdx > 0) {
-                ALOGV("AudioStreamInALSA::read() - copy processed output "
-                     "to buffer, mSurroundOutputBufferIdx = %d",
-                     mSurroundOutputBufferIdx);
-                // Copy processed output to buffer
-                processed_pending = mSurroundOutputBufferIdx;
-                if (processed_pending > (samples - processed)) {
-                    processed_pending = (samples - processed);
-                }
-                memcpy(buffer, mSurroundOutputBuffer, processed_pending * sizeof(Word16));
-                buffer += processed_pending * sizeof(Word16);
-                processed += processed_pending;
-                if (mSurroundOutputBufferIdx > processed_pending) {
-                    // Shift leftover samples to beginning of the buffer
-                    memcpy(&mSurroundOutputBuffer[0],
-                           &mSurroundOutputBuffer[processed_pending],
-                           (mSurroundOutputBufferIdx - processed_pending) * sizeof(Word16));
-                }
-                mSurroundOutputBufferIdx -= processed_pending;
-            }
-
-            if (processed >= samples) {
-                ALOGV("AudioStreamInALSA::read() - done processing buffer, "
-                     "processed = %d", processed);
-                // Done processing this buffer
-                break;
-            }
-
-            // Fill input buffer until there is enough to process
-            read_pending = SSR_INPUT_FRAME_SIZE - mSurroundInputBufferIdx;
-            read = mSurroundInputBufferIdx;
-            while (mHandle->handle && read_pending > 0) {
-                n = pcm_read(mHandle->handle, &mSurroundInputBuffer[read],
-                             period_bytes);
-                ALOGV("pcm_read() returned n = %d buffer:%p size:%d", n, &mSurroundInputBuffer[read], period_bytes);
-                if (n && n != -EAGAIN) {
-                    //Recovery part of pcm_read. TODO:split recovery.
-                    return static_cast<ssize_t>(n);
-                }
-                else if (n < 0) {
-                    // Recovery is part of pcm_write. TODO split is later.
-                    return static_cast<ssize_t>(n);
-                }
-                else {
-                    read_pending -= period_samples;
-                    read += period_samples;
-                }
-            }
-
-
-            if (mFp_4ch) {
-                fwrite( mSurroundInputBuffer, 1,
-                        SSR_INPUT_FRAME_SIZE * sizeof(Word16), mFp_4ch);
-            }
-
-            //apply ssr libs to conver 4ch to 6ch
-            surround_filters_intl_process(mSurroundObj,
-                &mSurroundOutputBuffer[mSurroundOutputBufferIdx],
-                (Word16 *)mSurroundInputBuffer);
-
-            // Shift leftover samples to beginning of input buffer
-            if (read_pending < 0) {
-                memcpy(&mSurroundInputBuffer[0],
-                       &mSurroundInputBuffer[SSR_INPUT_FRAME_SIZE],
-                       (-read_pending) * sizeof(Word16));
-            }
-            mSurroundInputBufferIdx = -read_pending;
-
-            if (mFp_6ch) {
-                fwrite( &mSurroundOutputBuffer[mSurroundOutputBufferIdx],
-                        1, SSR_OUTPUT_FRAME_SIZE * sizeof(Word16), mFp_6ch);
-            }
-
-            mSurroundOutputBufferIdx += SSR_OUTPUT_FRAME_SIZE;
-            ALOGV("do_while loop: processed=%d, samples=%d\n", processed, samples);
-        } while (mHandle->handle && processed < samples);
-        read = processed * sizeof(Word16);
-        buffer = buffer_start;
-    } else
-#endif
-    {
-
-        do {
-            if (read_pending < period_size) {
-                read_pending = period_size;
-            }
-
-            n = pcm_read(mHandle->handle, buffer,
-                period_size);
-            ALOGV("pcm_read() returned n = %d", n);
-            if (n && (n == -EIO || n == -EAGAIN || n == -EPIPE || n == -EBADFD)) {
-                mParent->mLock.lock();
-                ALOGW("pcm_read() returned error n %d, Recovering from error\n", n);
-                pcm_close(mHandle->handle);
-                mHandle->handle = NULL;
-                if((!strncmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL, strlen(SND_USE_CASE_VERB_IP_VOICECALL))) ||
-                (!strncmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP, strlen(SND_USE_CASE_MOD_PLAY_VOIP)))) {
-                    pcm_close(mHandle->rxHandle);
-                    mHandle->rxHandle = NULL;
-                    mHandle->module->startVoipCall(mHandle);
-                }
-                else
-                    mHandle->module->open(mHandle);
-
-                if(mHandle->handle == NULL) {
-                   ALOGE("read:: PCM device re-open failed");
-                   mParent->mLock.unlock();
-                   return 0;
-                }
-
-                mParent->mLock.unlock();
-                continue;
-            }
-            else if (n < 0) {
-                ALOGD("pcm_read() returned n < 0");
-                return static_cast<ssize_t>(n);
-            }
-            else {
-                read += static_cast<ssize_t>((period_size));
-                read_pending -= period_size;
-                //Set mute by cleanning buffers read
-                if (mParent->mMicMute) {
-                    memset(buffer, 0, period_size);
-                }
-                buffer = ((uint8_t *)buffer) + period_size;
-            }
-
-        } while (mHandle->handle && read < bytes);
-    }
-
-    return read;
-}
-
-status_t AudioStreamInALSA::dump(int fd, const Vector<String16>& args)
-{
-    return NO_ERROR;
-}
-
-status_t AudioStreamInALSA::open(int mode)
-{
-    Mutex::Autolock autoLock(mParent->mLock);
-
-    status_t status = ALSAStreamOps::open(mode);
-
-    return status;
-}
-
-status_t AudioStreamInALSA::close()
-{
-    Mutex::Autolock autoLock(mParent->mLock);
-
-    ALOGD("close");
-    if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
-        (!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
-        if((mParent->mVoipStreamCount)) {
-#ifdef QCOM_USBAUDIO_ENABLED
-            ALOGD("musbRecordingState: %d, mVoipStreamCount:%d",mParent->musbRecordingState,
-                  mParent->mVoipStreamCount );
-            if(mParent->mVoipStreamCount == 1) {
-                ALOGD("Deregistering VOIP Call bit, musbPlaybackState:%d,"
-                       "musbRecordingState:%d", mParent->musbPlaybackState, mParent->musbRecordingState);
-                mParent->musbPlaybackState &= ~USBPLAYBACKBIT_VOIPCALL;
-                mParent->musbRecordingState &= ~USBRECBIT_VOIPCALL;
-                mParent->closeUsbRecordingIfNothingActive();
-                mParent->closeUsbPlaybackIfNothingActive();
-            }
-#endif
-               return NO_ERROR;
-        }
-        mParent->mVoipStreamCount = 0;
-#ifdef QCOM_USBAUDIO_ENABLED
-    } else {
-        ALOGD("Deregistering REC bit, musbRecordingState:%d", mParent->musbRecordingState);
-        mParent->musbRecordingState &= ~USBRECBIT_REC;
-#endif
-     }
-#ifdef QCOM_CSDCLIENT_ENABLED
-    if (mParent->mFusion3Platform) {
-       if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_INCALL_REC)) ||
-           (!strcmp(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_VOICE))) {
-           stop_csd_record();
-       }
-    }
-#endif
-    ALOGD("close");
-#ifdef QCOM_USBAUDIO_ENABLED
-    mParent->closeUsbRecordingIfNothingActive();
-#endif
-
-    ALSAStreamOps::close();
-
-#ifdef QCOM_SSR_ENABLED
-    if (mSurroundObj) {
-        surround_filters_release(mSurroundObj);
-        if (mSurroundObj)
-            free(mSurroundObj);
-        mSurroundObj = NULL;
-        if (mRealCoeffs){
-            for (int i =0; i<COEFF_ARRAY_SIZE; i++ ) {
-                if (mRealCoeffs[i]) {
-                    free(mRealCoeffs[i]);
-                    mRealCoeffs[i] = NULL;
-                }
-            }
-            free(mRealCoeffs);
-            mRealCoeffs = NULL;
-        }
-        if (mImagCoeffs){
-            for (int i =0; i<COEFF_ARRAY_SIZE; i++ ) {
-                if (mImagCoeffs[i]) {
-                    free(mImagCoeffs[i]);
-                    mImagCoeffs[i] = NULL;
-                }
-            }
-            free(mImagCoeffs);
-            mImagCoeffs = NULL;
-        }
-        if (mSurroundOutputBuffer){
-            free(mSurroundOutputBuffer);
-            mSurroundOutputBuffer = NULL;
-        }
-        if (mSurroundInputBuffer) {
-            free(mSurroundInputBuffer);
-            mSurroundInputBuffer = NULL;
-        }
-
-        if ( mFp_4ch ) fclose(mFp_4ch);
-        if ( mFp_6ch ) fclose(mFp_6ch);
-
-    }
-#endif
-
-    return NO_ERROR;
-}
-
-status_t AudioStreamInALSA::standby()
-{
-    Mutex::Autolock autoLock(mParent->mLock);
-
-    ALOGD("standby");
-
-    if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
-        (!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
-         return NO_ERROR;
-    }
-
-#ifdef QCOM_CSDCLIENT_ENABLED
-    ALOGD("standby");
-    if (mParent->mFusion3Platform) {
-       if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_INCALL_REC)) ||
-           (!strcmp(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_VOICE))) {
-           ALOGD(" into standby, stop record");
-           stop_csd_record();
-       }
-    }
-#endif
-    mHandle->module->standby(mHandle);
-
-#ifdef QCOM_USBAUDIO_ENABLED
-    ALOGD("Checking for musbRecordingState %d", mParent->musbRecordingState);
-    mParent->musbRecordingState &= ~USBRECBIT_REC;
-    mParent->closeUsbRecordingIfNothingActive();
-#endif
-
-    if (mHandle->channelMask == AUDIO_CHANNEL_IN_FRONT_BACK) {
-        mHandle->module->setFlags(mParent->mDevSettingsFlag);
-    }
-
-    return NO_ERROR;
-}
-
-void AudioStreamInALSA::resetFramesLost()
-{
-    mFramesLost = 0;
-}
-
-unsigned int AudioStreamInALSA::getInputFramesLost() const
-{
-    unsigned int count = mFramesLost;
-    // Stupid interface wants us to have a side effect of clearing the count
-    // but is defined as a const to prevent such a thing.
-    ((AudioStreamInALSA *)this)->resetFramesLost();
-    return count;
-}
-
-status_t AudioStreamInALSA::setAcousticParams(void *params)
-{
-    Mutex::Autolock autoLock(mParent->mLock);
-
-    return (status_t)NO_ERROR;
-}
-
-#ifdef QCOM_SSR_ENABLED
-status_t AudioStreamInALSA::initSurroundSoundLibrary(unsigned long buffersize)
-{
-    int subwoofer = 0;  // subwoofer channel assignment: default as first microphone input channel
-    int low_freq = 4;   // frequency upper bound for subwoofer: frequency=(low_freq-1)/FFT_SIZE*samplingRate, default as 4
-    int high_freq = 100;    // frequency upper bound for spatial processing: frequency=(high_freq-1)/FFT_SIZE*samplingRate, default as 100
-    int ret = 0;
-
-    mSurroundInputBufferIdx = 0;
-    mSurroundOutputBufferIdx = 0;
-
-    if ( mSurroundObj ) {
-        ALOGE("ola filter library is already initialized");
-        return ALREADY_EXISTS;
-    }
-
-    // Allocate memory for input buffer
-    mSurroundInputBuffer = (Word16 *) calloc(2 * SSR_INPUT_FRAME_SIZE,
-                                              sizeof(Word16));
-    if ( !mSurroundInputBuffer ) {
-       ALOGE("Memory allocation failure. Not able to allocate memory for surroundInputBuffer");
-       goto init_fail;
-    }
-
-    // Allocate memory for output buffer
-    mSurroundOutputBuffer = (Word16 *) calloc(2 * SSR_OUTPUT_FRAME_SIZE,
-                                               sizeof(Word16));
-    if ( !mSurroundOutputBuffer ) {
-       ALOGE("Memory allocation failure. Not able to allocate memory for surroundOutputBuffer");
-       goto init_fail;
-    }
-
-    // Allocate memory for real and imag coeffs array
-    mRealCoeffs = (Word16 **) calloc(COEFF_ARRAY_SIZE, sizeof(Word16 *));
-    if ( !mRealCoeffs ) {
-        ALOGE("Memory allocation failure during real Coefficient array");
-        goto init_fail;
-    }
-
-    mImagCoeffs = (Word16 **) calloc(COEFF_ARRAY_SIZE, sizeof(Word16 *));
-    if ( !mImagCoeffs ) {
-        ALOGE("Memory allocation failure during imaginary Coefficient array");
-        goto init_fail;
-    }
-
-    if( readCoeffsFromFile() != NO_ERROR) {
-        ALOGE("Error while loading coeffs from file");
-        goto init_fail;
-    }
-
-    //calculate the size of data to allocate for mSurroundObj
-    ret = surround_filters_init(NULL,
-                  6, // Num output channel
-                  4,     // Num input channel
-                  mRealCoeffs,       // Coeffs hardcoded in header
-                  mImagCoeffs,       // Coeffs hardcoded in header
-                  subwoofer,
-                  low_freq,
-                  high_freq,
-                  NULL);
-
-    if ( ret > 0 ) {
-        ALOGV("Allocating surroundObj size is %d", ret);
-        mSurroundObj = (void *)malloc(ret);
-        memset(mSurroundObj,0,ret);
-        if (NULL != mSurroundObj) {
-            //initialize after allocating the memory for mSurroundObj
-            ret = surround_filters_init(mSurroundObj,
-                        6,
-                        4,
-                        mRealCoeffs,
-                        mImagCoeffs,
-                        subwoofer,
-                        low_freq,
-                        high_freq,
-                        NULL);
-            if (0 != ret) {
-               ALOGE("surround_filters_init failed with ret:%d",ret);
-               surround_filters_release(mSurroundObj);
-               goto init_fail;
-            }
-        } else {
-            ALOGE("Allocationg mSurroundObj failed");
-            goto init_fail;
-        }
-    } else {
-        ALOGE("surround_filters_init(mSurroundObj=Null) failed with ret: %d",ret);
-        goto init_fail;
-    }
-
-    (void) surround_filters_set_channel_map(mSurroundObj, chanMap);
-
-    return NO_ERROR;
-
-init_fail:
-    if (mSurroundObj) {
-        free(mSurroundObj);
-        mSurroundObj = NULL;
-    }
-    if (mSurroundOutputBuffer) {
-        free(mSurroundOutputBuffer);
-        mSurroundOutputBuffer = NULL;
-    }
-    if (mSurroundInputBuffer) {
-        free(mSurroundInputBuffer);
-        mSurroundInputBuffer = NULL;
-    }
-    if (mRealCoeffs){
-        for (int i =0; i<COEFF_ARRAY_SIZE; i++ ) {
-            if (mRealCoeffs[i]) {
-                free(mRealCoeffs[i]);
-                mRealCoeffs[i] = NULL;
-            }
-        }
-        free(mRealCoeffs);
-        mRealCoeffs = NULL;
-    }
-    if (mImagCoeffs){
-        for (int i =0; i<COEFF_ARRAY_SIZE; i++ ) {
-            if (mImagCoeffs[i]) {
-                free(mImagCoeffs[i]);
-                mImagCoeffs[i] = NULL;
-            }
-        }
-        free(mImagCoeffs);
-        mImagCoeffs = NULL;
-    }
-
-    return NO_MEMORY;
-
-}
-
-
-// Helper function to read coeffs from File and updates real and imaginary
-// coeff array member variable
-status_t AudioStreamInALSA::readCoeffsFromFile()
-{
-    FILE    *flt1r;
-    FILE    *flt2r;
-    FILE    *flt3r;
-    FILE    *flt4r;
-    FILE    *flt1i;
-    FILE    *flt2i;
-    FILE    *flt3i;
-    FILE    *flt4i;
-
-    if ( (flt1r = fopen(SURROUND_FILE_1R, "rb")) == NULL ) {
-        ALOGE("Cannot open filter co-efficient file %s", SURROUND_FILE_1R);
-        return NAME_NOT_FOUND;
-    }
-
-    if ( (flt2r = fopen(SURROUND_FILE_2R, "rb")) == NULL ) {
-        ALOGE("Cannot open filter co-efficient file %s", SURROUND_FILE_2R);
-        return NAME_NOT_FOUND;
-    }
-
-    if ( (flt3r = fopen(SURROUND_FILE_3R, "rb")) == NULL ) {
-        ALOGE("Cannot open filter co-efficient file %s", SURROUND_FILE_3R);
-        return  NAME_NOT_FOUND;
-    }
-
-    if ( (flt4r = fopen(SURROUND_FILE_4R, "rb")) == NULL ) {
-        ALOGE("Cannot open filter co-efficient file %s", SURROUND_FILE_4R);
-        return  NAME_NOT_FOUND;
-    }
-
-    if ( (flt1i = fopen(SURROUND_FILE_1I, "rb")) == NULL ) {
-        ALOGE("Cannot open filter co-efficient file %s", SURROUND_FILE_1I);
-        return NAME_NOT_FOUND;
-    }
-
-    if ( (flt2i = fopen(SURROUND_FILE_2I, "rb")) == NULL ) {
-        ALOGE("Cannot open filter co-efficient file %s", SURROUND_FILE_2I);
-        return NAME_NOT_FOUND;
-    }
-
-    if ( (flt3i = fopen(SURROUND_FILE_3I, "rb")) == NULL ) {
-        ALOGE("Cannot open filter co-efficient file %s", SURROUND_FILE_3I);
-        return NAME_NOT_FOUND;
-    }
-
-    if ( (flt4i = fopen(SURROUND_FILE_4I, "rb")) == NULL ) {
-        ALOGE("Cannot open filter co-efficient file %s", SURROUND_FILE_4I);
-        return NAME_NOT_FOUND;
-    }
-    ALOGV("readCoeffsFromFile all filter files opened");
-
-    for (int i=0; i<COEFF_ARRAY_SIZE; i++) {
-        mRealCoeffs[i] = (Word16 *)calloc(FILT_SIZE, sizeof(Word16));
-    }
-    for (int i=0; i<COEFF_ARRAY_SIZE; i++) {
-        mImagCoeffs[i] = (Word16 *)calloc(FILT_SIZE, sizeof(Word16));
-    }
-
-    // Read real co-efficients
-    if (NULL != mRealCoeffs[0]) {
-        fread(mRealCoeffs[0], sizeof(int16), FILT_SIZE, flt1r);
-    }
-    if (NULL != mRealCoeffs[0]) {
-        fread(mRealCoeffs[1], sizeof(int16), FILT_SIZE, flt2r);
-    }
-    if (NULL != mRealCoeffs[0]) {
-        fread(mRealCoeffs[2], sizeof(int16), FILT_SIZE, flt3r);
-    }
-    if (NULL != mRealCoeffs[0]) {
-        fread(mRealCoeffs[3], sizeof(int16), FILT_SIZE, flt4r);
-    }
-
-    // read imaginary co-efficients
-    if (NULL != mImagCoeffs[0]) {
-        fread(mImagCoeffs[0], sizeof(int16), FILT_SIZE, flt1i);
-    }
-    if (NULL != mImagCoeffs[0]) {
-        fread(mImagCoeffs[1], sizeof(int16), FILT_SIZE, flt2i);
-    }
-    if (NULL != mImagCoeffs[0]) {
-        fread(mImagCoeffs[2], sizeof(int16), FILT_SIZE, flt3i);
-    }
-    if (NULL != mImagCoeffs[0]) {
-        fread(mImagCoeffs[3], sizeof(int16), FILT_SIZE, flt4i);
-    }
-
-    fclose(flt1r);
-    fclose(flt2r);
-    fclose(flt3r);
-    fclose(flt4r);
-    fclose(flt1i);
-    fclose(flt2i);
-    fclose(flt3i);
-    fclose(flt4i);
-
-    return NO_ERROR;
-}
-#endif
-
-#ifdef QCOM_CSDCLIENT_ENABLED
-int AudioStreamInALSA::start_csd_record(int param)
-{
-    int err = NO_ERROR;
-
-    if (mParent->mCsdHandle != NULL) {
-        csd_start_record = (int (*)(int))::dlsym(mParent->mCsdHandle,"csd_client_start_record");
-        if (csd_start_record == NULL) {
-            ALOGE("dlsym:Error:%s Loading csd_client_start_record", dlerror());
-        } else {
-            err = csd_start_record(param);
-        }
-    }
-    return err;
-}
-
-int AudioStreamInALSA::stop_csd_record()
-{
-    int err = NO_ERROR;
-    if (mParent->mCsdHandle != NULL) {
-        csd_stop_record = (int (*)())::dlsym(mParent->mCsdHandle,"csd_client_stop_record");
-        if (csd_start_record == NULL) {
-            ALOGE("dlsym:Error:%s Loading csd_client_start_record", dlerror());
-        } else {
-            csd_stop_record();
-        }
-    }
-    return err;
-}
-#endif
-
-}       // namespace android_audio_legacy
diff --git a/legacy/alsa_sound/AudioStreamOutALSA.cpp b/legacy/alsa_sound/AudioStreamOutALSA.cpp
deleted file mode 100644
index bbb8d3d..0000000
--- a/legacy/alsa_sound/AudioStreamOutALSA.cpp
+++ /dev/null
@@ -1,384 +0,0 @@
-/* AudioStreamOutALSA.cpp
- **
- ** Copyright 2008-2009 Wind River Systems
- ** Copyright (c) 2011, The Linux Foundation. All rights reserved.
- **
- ** 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.
- */
-
-#include <errno.h>
-#include <stdarg.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <dlfcn.h>
-#include <math.h>
-
-#define LOG_TAG "AudioStreamOutALSA"
-//#define LOG_NDEBUG 0
-#define LOG_NDDEBUG 0
-#include <utils/Log.h>
-#include <utils/String8.h>
-
-#include <cutils/properties.h>
-#include <media/AudioRecord.h>
-#include <hardware_legacy/power.h>
-
-#include "AudioHardwareALSA.h"
-
-#ifndef ALSA_DEFAULT_SAMPLE_RATE
-#define ALSA_DEFAULT_SAMPLE_RATE 44100 // in Hz
-#endif
-
-namespace android_audio_legacy
-{
-
-// ----------------------------------------------------------------------------
-
-static const int DEFAULT_SAMPLE_RATE = ALSA_DEFAULT_SAMPLE_RATE;
-
-// ----------------------------------------------------------------------------
-
-AudioStreamOutALSA::AudioStreamOutALSA(AudioHardwareALSA *parent, alsa_handle_t *handle) :
-    ALSAStreamOps(parent, handle),
-    mParent(parent),
-    mFrameCount(0)
-{
-}
-
-AudioStreamOutALSA::~AudioStreamOutALSA()
-{
-    close();
-}
-
-uint32_t AudioStreamOutALSA::channels() const
-{
-    int c = ALSAStreamOps::channels();
-    return c;
-}
-
-status_t AudioStreamOutALSA::setVolume(float left, float right)
-{
-    int vol;
-    float volume;
-    status_t status = NO_ERROR;
-
-    volume = (left + right) / 2;
-    if (volume < 0.0) {
-        ALOGW("AudioSessionOutALSA::setVolume(%f) under 0.0, assuming 0.0\n", volume);
-        volume = 0.0;
-    } else if (volume > 1.0) {
-        ALOGW("AudioSessionOutALSA::setVolume(%f) over 1.0, assuming 1.0\n", volume);
-        volume = 1.0;
-    }
-    vol = lrint((volume * 0x2000)+0.5);
-
-    if(!strcmp(mHandle->useCase, SND_USE_CASE_VERB_HIFI_LOW_POWER) ||
-       !strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_LPA)) {
-        ALOGV("setLpaVolume(%f)\n", volume);
-        ALOGV("Setting LPA volume to %d (available range is 0 to 100)\n", vol);
-        mHandle->module->setLpaVolume(vol);
-        return status;
-    }
-    else if(!strcmp(mHandle->useCase, SND_USE_CASE_VERB_HIFI_TUNNEL) ||
-            !strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_TUNNEL)) {
-        ALOGV("setCompressedVolume(%f)\n", volume);
-        ALOGV("Setting Compressed volume to %d (available range is 0 to 100)\n", vol);
-        mHandle->module->setCompressedVolume(vol);
-        return status;
-    }
-    else if(!strncmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL,
-            sizeof(mHandle->useCase)) || !strncmp(mHandle->useCase,
-            SND_USE_CASE_MOD_PLAY_VOIP, sizeof(mHandle->useCase))) {
-        ALOGV("Avoid Software volume by returning success\n");
-        return status;
-    }
-    return INVALID_OPERATION;
-}
-
-ssize_t AudioStreamOutALSA::write(const void *buffer, size_t bytes)
-{
-    int period_size;
-    char *use_case;
-
-    ALOGV("write:: buffer %p, bytes %d", buffer, bytes);
-
-    snd_pcm_sframes_t n = 0;
-    size_t            sent = 0;
-    status_t          err;
-
-    int write_pending = bytes;
-
-    if((mHandle->handle == NULL) && (mHandle->rxHandle == NULL) &&
-         (strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) &&
-         (strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
-        mParent->mLock.lock();
-
-        ALOGD("mHandle->useCase: %s", mHandle->useCase);
-        snd_use_case_get(mHandle->ucMgr, "_verb", (const char **)&use_case);
-        if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) {
-            if(!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP)){
-                strlcpy(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL,
-                        sizeof(SND_USE_CASE_VERB_IP_VOICECALL));
-            } else if(!strcmp(mHandle->useCase,SND_USE_CASE_MOD_PLAY_MUSIC2)) {
-                strlcpy(mHandle->useCase, SND_USE_CASE_VERB_HIFI2,
-                        sizeof(SND_USE_CASE_MOD_PLAY_MUSIC2));
-            } else if (!strcmp(mHandle->useCase,SND_USE_CASE_MOD_PLAY_MUSIC)){
-                strlcpy(mHandle->useCase, SND_USE_CASE_VERB_HIFI,
-                        sizeof(SND_USE_CASE_MOD_PLAY_MUSIC));
-            } else if(!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_LOWLATENCY_MUSIC)) {
-                strlcpy(mHandle->useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC,
-                        sizeof(SND_USE_CASE_MOD_PLAY_LOWLATENCY_MUSIC));
-            }
-        } else {
-            if(!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)){
-                strlcpy(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP,
-                        sizeof(SND_USE_CASE_MOD_PLAY_VOIP));
-            } else if(!strcmp(mHandle->useCase,SND_USE_CASE_VERB_HIFI2)) {
-                strlcpy(mHandle->useCase, SND_USE_CASE_MOD_PLAY_MUSIC2,
-                        sizeof(SND_USE_CASE_MOD_PLAY_MUSIC2));
-            } else if (!strcmp(mHandle->useCase,SND_USE_CASE_VERB_HIFI)){
-                strlcpy(mHandle->useCase, SND_USE_CASE_MOD_PLAY_MUSIC,
-                        sizeof(SND_USE_CASE_MOD_PLAY_MUSIC));
-            } else if(!strcmp(mHandle->useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC)) {
-                strlcpy(mHandle->useCase, SND_USE_CASE_MOD_PLAY_LOWLATENCY_MUSIC,
-                        sizeof(SND_USE_CASE_MOD_PLAY_LOWLATENCY_MUSIC));
-            }
-        }
-        free(use_case);
-        if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
-           (!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
-#ifdef QCOM_USBAUDIO_ENABLED
-            if((mDevices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)||
-                  (mDevices & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)||
-                  (mDevices & AudioSystem::DEVICE_OUT_PROXY)) {
-                mDevices |= AudioSystem::DEVICE_OUT_PROXY;
-                mHandle->module->route(mHandle, mDevices , mParent->mode());
-            }else
-#endif
-            {
-              mHandle->module->route(mHandle, mDevices , AudioSystem::MODE_IN_COMMUNICATION);
-            }
-#ifdef QCOM_USBAUDIO_ENABLED
-        } else if((mDevices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)||
-                  (mDevices & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)||
-                  (mDevices & AudioSystem::DEVICE_OUT_PROXY)) {
-            mDevices |= AudioSystem::DEVICE_OUT_PROXY;
-            mHandle->module->route(mHandle, mDevices , mParent->mode());
-#endif
-        } else {
-            mHandle->module->route(mHandle, mDevices , mParent->mode());
-        }
-        if (!strcmp(mHandle->useCase, SND_USE_CASE_VERB_HIFI) ||
-            !strcmp(mHandle->useCase, SND_USE_CASE_VERB_HIFI2) ||
-            !strcmp(mHandle->useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC) ||
-            !strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) {
-            snd_use_case_set(mHandle->ucMgr, "_verb", mHandle->useCase);
-        } else {
-            snd_use_case_set(mHandle->ucMgr, "_enamod", mHandle->useCase);
-        }
-        if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
-          (!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
-             err = mHandle->module->startVoipCall(mHandle);
-        }
-        else
-             mHandle->module->open(mHandle);
-        if(mHandle->handle == NULL) {
-            ALOGE("write:: device open failed");
-            mParent->mLock.unlock();
-            return bytes;
-        }
-#ifdef QCOM_USBAUDIO_ENABLED
-        if((mHandle->devices == AudioSystem::DEVICE_IN_ANLG_DOCK_HEADSET)||
-               (mHandle->devices == AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)){
-            if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
-               (!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
-                mParent->musbPlaybackState |= USBPLAYBACKBIT_VOIPCALL;
-            } else {
-                mParent->startUsbPlaybackIfNotStarted();
-                mParent->musbPlaybackState |= USBPLAYBACKBIT_MUSIC;
-            }
-        }
-#endif
-
-        mParent->mLock.unlock();
-    }
-
-#ifdef QCOM_USBAUDIO_ENABLED
-    if(((mDevices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET) ||
-        (mDevices & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)) &&
-        (!mParent->musbPlaybackState)) {
-        mParent->mLock.lock();
-        mParent->startUsbPlaybackIfNotStarted();
-        ALOGV("Starting playback on USB");
-        if(!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL) ||
-           !strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP)) {
-            ALOGD("Setting VOIPCALL bit here, musbPlaybackState %d", mParent->musbPlaybackState);
-            mParent->musbPlaybackState |= USBPLAYBACKBIT_VOIPCALL;
-        }else{
-            ALOGV("enabling music, musbPlaybackState: %d ", mParent->musbPlaybackState);
-            mParent->musbPlaybackState |= USBPLAYBACKBIT_MUSIC;
-        }
-        mParent->mLock.unlock();
-    }
-#endif
-
-    period_size = mHandle->periodSize;
-    do {
-        if (write_pending < period_size) {
-            write_pending = period_size;
-        }
-        if((mParent->mVoipStreamCount) && (mHandle->rxHandle != 0)) {
-            n = pcm_write(mHandle->rxHandle,
-                     (char *)buffer + sent,
-                      period_size);
-        } else if (mHandle->handle != 0){
-            n = pcm_write(mHandle->handle,
-                     (char *)buffer + sent,
-                      period_size);
-        }
-        if (n < 0) {
-            mParent->mLock.lock();
-            if (mHandle->handle != NULL) {
-                ALOGE("pcm_write returned error %d, trying to recover\n", n);
-                pcm_close(mHandle->handle);
-                mHandle->handle = NULL;
-                if((!strncmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL, strlen(SND_USE_CASE_VERB_IP_VOICECALL))) ||
-                  (!strncmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP, strlen(SND_USE_CASE_MOD_PLAY_VOIP)))) {
-                     pcm_close(mHandle->rxHandle);
-                     mHandle->rxHandle = NULL;
-                     mHandle->module->startVoipCall(mHandle);
-                }
-                else
-                    mHandle->module->open(mHandle);
-                if(mHandle->handle == NULL) {
-                   ALOGE("write:: device re-open failed");
-                   mParent->mLock.unlock();
-                   return bytes;
-                }
-            }
-            mParent->mLock.unlock();
-            continue;
-        }
-        else {
-            mFrameCount += n;
-            sent += static_cast<ssize_t>((period_size));
-            write_pending -= period_size;
-        }
-
-    } while ((mHandle->handle||(mHandle->rxHandle && mParent->mVoipStreamCount)) && sent < bytes);
-
-    return sent;
-}
-
-status_t AudioStreamOutALSA::dump(int fd, const Vector<String16>& args)
-{
-    return NO_ERROR;
-}
-
-status_t AudioStreamOutALSA::open(int mode)
-{
-    Mutex::Autolock autoLock(mParent->mLock);
-
-    return ALSAStreamOps::open(mode);
-}
-
-status_t AudioStreamOutALSA::close()
-{
-    Mutex::Autolock autoLock(mParent->mLock);
-
-    ALOGV("close");
-    if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
-        (!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
-         if((mParent->mVoipStreamCount)) {
-#ifdef QCOM_USBAUDIO_ENABLED
-             if(mParent->mVoipStreamCount == 1) {
-                 ALOGV("Deregistering VOIP Call bit, musbPlaybackState:%d, musbRecordingState: %d",
-                       mParent->musbPlaybackState, mParent->musbRecordingState);
-                 mParent->musbPlaybackState &= ~USBPLAYBACKBIT_VOIPCALL;
-                 mParent->musbRecordingState &= ~USBRECBIT_VOIPCALL;
-                 mParent->closeUsbPlaybackIfNothingActive();
-                 mParent->closeUsbRecordingIfNothingActive();
-             }
-#endif
-                return NO_ERROR;
-         }
-         mParent->mVoipStreamCount = 0;
-    }
-#ifdef QCOM_USBAUDIO_ENABLED
-      else if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_HIFI_LOW_POWER)) ||
-              (!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_LPA))) {
-        mParent->musbPlaybackState &= ~USBPLAYBACKBIT_LPA;
-    } else {
-        mParent->musbPlaybackState &= ~USBPLAYBACKBIT_MUSIC;
-    }
-
-    mParent->closeUsbPlaybackIfNothingActive();
-#endif
-
-    ALSAStreamOps::close();
-
-    return NO_ERROR;
-}
-
-status_t AudioStreamOutALSA::standby()
-{
-    Mutex::Autolock autoLock(mParent->mLock);
-
-    ALOGV("standby");
-
-    if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
-      (!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
-        return NO_ERROR;
-    }
-
-#ifdef QCOM_USBAUDIO_ENABLED
-    if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_HIFI_LOW_POWER)) ||
-        (!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_LPA))) {
-        ALOGV("Deregistering LPA bit");
-        mParent->musbPlaybackState &= ~USBPLAYBACKBIT_LPA;
-    } else {
-        ALOGV("Deregistering MUSIC bit, musbPlaybackState: %d", mParent->musbPlaybackState);
-        mParent->musbPlaybackState &= ~USBPLAYBACKBIT_MUSIC;
-    }
-#endif
-
-    mHandle->module->standby(mHandle);
-
-#ifdef QCOM_USBAUDIO_ENABLED
-    mParent->closeUsbPlaybackIfNothingActive();
-#endif
-
-    mFrameCount = 0;
-
-    return NO_ERROR;
-}
-
-#define USEC_TO_MSEC(x) ((x + 999) / 1000)
-
-uint32_t AudioStreamOutALSA::latency() const
-{
-    // Android wants latency in milliseconds.
-    return USEC_TO_MSEC (mHandle->latency);
-}
-
-// return the number of audio frames written by the audio dsp to DAC since
-// the output has exited standby
-status_t AudioStreamOutALSA::getRenderPosition(uint32_t *dspFrames)
-{
-    *dspFrames = mFrameCount;
-    return NO_ERROR;
-}
-
-}       // namespace android_audio_legacy
diff --git a/legacy/alsa_sound/AudioUsbALSA.cpp b/legacy/alsa_sound/AudioUsbALSA.cpp
deleted file mode 100644
index 93e0754..0000000
--- a/legacy/alsa_sound/AudioUsbALSA.cpp
+++ /dev/null
@@ -1,1063 +0,0 @@
-/* AudioUsbALSA.cpp
-Copyright (c) 2012, 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 "AudioUsbALSA"
-#define LOG_NDEBUG 0
-#define LOG_NDDEBUG 0
-#include <utils/Log.h>
-#include <utils/String8.h>
-
-#include <cutils/properties.h>
-#include <media/AudioRecord.h>
-#include <hardware_legacy/power.h>
-#include <sys/poll.h>
-#include <sys/ioctl.h>
-#include <fcntl.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <errno.h>
-#include <jni.h>
-#include <stdio.h>
-#include <sys/eventfd.h>
-
-
-#include "AudioUsbALSA.h"
-struct pollfd pfdProxyPlayback[2];
-struct pollfd pfdUsbPlayback[2];
-struct pollfd pfdProxyRecording[1];
-struct pollfd pfdUsbRecording[1];
-
-#define USB_PERIOD_SIZE 2048
-#define PROXY_PERIOD_SIZE 3072
-
-namespace android_audio_legacy
-{
-AudioUsbALSA::AudioUsbALSA()
-{
-    mproxypfdPlayback = -1;
-    musbpfdPlayback = -1;
-    mkillPlayBackThread = false;
-    mkillRecordingThread = false;
-}
-
-AudioUsbALSA::~AudioUsbALSA()
-{
-    mkillPlayBackThread = true;
-    mkillRecordingThread = true;
-}
-
-
-int AudioUsbALSA::getnumOfRates(char *ratesStr){
-    int i, size = 0;
-    char *nextSRString, *temp_ptr;
-    nextSRString = strtok_r(ratesStr, " ,", &temp_ptr);
-    if (nextSRString == NULL) {
-        ALOGE("ERROR: getnumOfRates: could not find rates string");
-        return NULL;
-    }
-    for (i = 1; nextSRString != NULL; i++) {
-        size ++;
-        nextSRString = strtok_r(NULL, " ,.-", &temp_ptr);
-    }
-    return size;
-}
-
-
-status_t AudioUsbALSA::getCap(char * type, int &channels, int &sampleRate)
-{
-    ALOGD("getCap for %s",type);
-    long unsigned fileSize;
-    FILE *fp;
-    char *buffer;
-    int err = 1;
-    int size = 0;
-    int fd, i, lchannelsPlayback;
-    char *read_buf, *str_start, *channel_start, *ratesStr, *ratesStrForVal,
-    *ratesStrStart, *chString, *nextSRStr, *test, *nextSRString, *temp_ptr;
-    struct stat st;
-    memset(&st, 0x0, sizeof(struct stat));
-    sampleRate = 0;
-    fd = open(PATH, O_RDONLY);
-    if (fd <0) {
-        ALOGE("ERROR: failed to open config file %s error: %d\n", PATH, errno);
-        close(fd);
-        return UNKNOWN_ERROR;
-    }
-
-    if (fstat(fd, &st) < 0) {
-        ALOGE("ERROR: failed to stat %s error %d\n", PATH, errno);
-        close(fd);
-        return UNKNOWN_ERROR;
-    }
-
-    fileSize = st.st_size;
-
-    read_buf = (char *)malloc(BUFFSIZE);
-    memset(read_buf, 0x0, BUFFSIZE);
-    err = read(fd, read_buf, BUFFSIZE);
-    str_start = strstr(read_buf, type);
-    if (str_start == NULL) {
-        ALOGE("ERROR:%s section not found in usb config file", type);
-        close(fd);
-        free(read_buf);
-        return UNKNOWN_ERROR;
-    }
-
-    channel_start = strstr(str_start, "Channels:");
-    if (channel_start == NULL) {
-        ALOGE("ERROR: Could not find Channels information");
-        close(fd);
-        free(read_buf);
-        return UNKNOWN_ERROR;
-    }
-    channel_start = strstr(channel_start, " ");
-    if (channel_start == NULL) {
-        ALOGE("ERROR: Channel section not found in usb config file");
-        close(fd);
-        free(read_buf);
-        return UNKNOWN_ERROR;
-    }
-
-    lchannelsPlayback = atoi(channel_start);
-    if (lchannelsPlayback == 1) {
-        channels = 1;
-    } else {
-        channels = 2;
-    }
-    ALOGD("channels supported by device: %d", lchannelsPlayback);
-    ratesStrStart = strstr(str_start, "Rates:");
-    if (ratesStrStart == NULL) {
-        ALOGE("ERROR: Cant find rates information");
-        close(fd);
-        free(read_buf);
-        return UNKNOWN_ERROR;
-    }
-
-    ratesStrStart = strstr(ratesStrStart, " ");
-    if (ratesStrStart == NULL) {
-        ALOGE("ERROR: Channel section not found in usb config file");
-        close(fd);
-        free(read_buf);
-        return UNKNOWN_ERROR;
-    }
-
-    //copy to ratesStr, current line.
-    char *target = strchr(ratesStrStart, '\n');
-    if (target == NULL) {
-        ALOGE("ERROR: end of line not found");
-        close(fd);
-        free(read_buf);
-        return UNKNOWN_ERROR;
-    }
-    size = target - ratesStrStart;
-    ratesStr = (char *)malloc(size + 1) ;
-    ratesStrForVal = (char *)malloc(size + 1) ;
-    memcpy(ratesStr, ratesStrStart, size);
-    memcpy(ratesStrForVal, ratesStrStart, size);
-    ratesStr[size] = '\0';
-    ratesStrForVal[size] = '\0';
-
-    size = getnumOfRates(ratesStr);
-    if (!size) {
-        ALOGE("ERROR: Could not get rate size, returning");
-        close(fd);
-        free(ratesStrForVal);
-        free(ratesStr);
-        free(read_buf);
-        return UNKNOWN_ERROR;
-    }
-
-    //populate playback rates array
-    int ratesSupported[size];
-    nextSRString = strtok_r(ratesStrForVal, " ,", &temp_ptr);
-    if (nextSRString == NULL) {
-        ALOGE("ERROR: Could not get first rate val");
-        close(fd);
-        free(ratesStrForVal);
-        free(ratesStr);
-        free(read_buf);
-        return UNKNOWN_ERROR;
-    }
-
-    ratesSupported[0] = atoi(nextSRString);
-    for (i = 1; i<size; i++) {
-        nextSRString = strtok_r(NULL, " ,.-", &temp_ptr);
-        ratesSupported[i] = atoi(nextSRString);
-        ALOGV("ratesSupported[%d] for playback: %d",i, ratesSupported[i]);
-    }
-
-    for (i = 0; i<=size; i++) {
-        if (ratesSupported[i] <= 48000) {
-            sampleRate = ratesSupported[i];
-            break;
-        }
-    }
-    ALOGD("sampleRate: %d", sampleRate);
-
-    close(fd);
-    free(ratesStrForVal);
-    free(ratesStr);
-    free(read_buf);
-    ratesStrForVal = NULL;
-    ratesStr = NULL;
-    read_buf = NULL;
-    return NO_ERROR;
-}
-
-void AudioUsbALSA::exitPlaybackThread(uint64_t writeVal)
-{
-    ALOGD("exitPlaybackThread, mproxypfdPlayback: %d", mproxypfdPlayback);
-    if (writeVal == SIGNAL_EVENT_KILLTHREAD) {
-        int err;
-
-        err = closeDevice(mproxyPlaybackHandle);
-        if (err) {
-            ALOGE("Info: Could not close proxy %p", mproxyPlaybackHandle);
-        }
-        err = closeDevice(musbPlaybackHandle);
-        if (err) {
-            ALOGE("Info: Could not close USB device %p", musbPlaybackHandle);
-        }
-    }
-    if ((mproxypfdPlayback != -1) && (musbpfdPlayback != -1)) {
-        write(mproxypfdPlayback, &writeVal, sizeof(uint64_t));
-        write(musbpfdPlayback, &writeVal, sizeof(uint64_t));
-        mkillPlayBackThread = true;
-        pthread_join(mPlaybackUsb,NULL);
-    }
-}
-
-void AudioUsbALSA::exitRecordingThread(uint64_t writeVal)
-{
-    ALOGD("exitRecordingThread");
-    if (writeVal == SIGNAL_EVENT_KILLTHREAD) {
-        int err;
-
-        err = closeDevice(mproxyRecordingHandle);
-        if (err) {
-            ALOGE("Info: Could not close proxy for recording %p", mproxyRecordingHandle);
-        }
-        err = closeDevice(musbRecordingHandle);
-        if (err) {
-            ALOGE("Info: Could not close USB recording device %p", musbRecordingHandle);
-        }
-    }
-    mkillRecordingThread = true;
-}
-
-void AudioUsbALSA::setkillUsbRecordingThread(bool val){
-    ALOGD("setkillUsbRecordingThread");
-    mkillRecordingThread = val;
-}
-
-status_t AudioUsbALSA::setHardwareParams(pcm *txHandle, uint32_t sampleRate, uint32_t channels, int periodBytes)
-{
-    ALOGD("setHardwareParams");
-    struct snd_pcm_hw_params *params;
-    unsigned long bufferSize, reqBuffSize;
-    unsigned int periodTime, bufferTime;
-    unsigned int requestedRate = sampleRate;
-    int status = 0;
-
-    params = (snd_pcm_hw_params*) calloc(1, sizeof(struct snd_pcm_hw_params));
-    if (!params) {
-        return NO_INIT;
-    }
-
-    param_init(params);
-    param_set_mask(params, SNDRV_PCM_HW_PARAM_ACCESS,
-                   SNDRV_PCM_ACCESS_MMAP_INTERLEAVED);
-    param_set_mask(params, SNDRV_PCM_HW_PARAM_FORMAT,
-                   SNDRV_PCM_FORMAT_S16_LE);
-    param_set_mask(params, SNDRV_PCM_HW_PARAM_SUBFORMAT,
-                   SNDRV_PCM_SUBFORMAT_STD);
-    ALOGV("Setting period size:%d samplerate:%d, channels: %d",periodBytes,sampleRate, channels);
-    param_set_min(params, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, periodBytes);
-    param_set_int(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 16);
-    param_set_int(params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
-                  channels - 1 ? 32 : 16);
-    param_set_int(params, SNDRV_PCM_HW_PARAM_CHANNELS,
-                  channels);
-    param_set_int(params, SNDRV_PCM_HW_PARAM_RATE, sampleRate);
-    param_set_hw_refine(txHandle, params);
-
-    if (param_set_hw_params(txHandle, params)) {
-        ALOGE("ERROR: cannot set hw params");
-        return NO_INIT;
-    }
-
-    param_dump(params);
-
-    txHandle->period_size = pcm_period_size(params);
-    txHandle->buffer_size = pcm_buffer_size(params);
-    txHandle->period_cnt = txHandle->buffer_size/txHandle->period_size;
-
-    ALOGD("setHardwareParams: buffer_size %d, period_size %d, period_cnt %d",
-         txHandle->buffer_size, txHandle->period_size,
-         txHandle->period_cnt);
-
-    return NO_ERROR;
-}
-
-status_t AudioUsbALSA::setSoftwareParams(pcm *pcm, bool playback)
-{
-    ALOGD("setSoftwareParams");
-    struct snd_pcm_sw_params* params;
-
-    params = (snd_pcm_sw_params*) calloc(1, sizeof(struct snd_pcm_sw_params));
-    if (!params) {
-        LOG_ALWAYS_FATAL("Failed to allocate ALSA software parameters!");
-        return NO_INIT;
-    }
-
-    params->tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
-    params->period_step = 1;
-
-    params->avail_min = (pcm->flags & PCM_MONO) ? pcm->period_size/2 : pcm->period_size/4;
-
-    if (playback) {
-        params->start_threshold = (pcm->flags & PCM_MONO) ? pcm->period_size*8 : pcm->period_size*4;
-        params->xfer_align = (pcm->flags & PCM_MONO) ? pcm->period_size*8 : pcm->period_size*4;
-    } else {
-        params->start_threshold = (pcm->flags & PCM_MONO) ? pcm->period_size/2 : pcm->period_size/4;
-        params->xfer_align = (pcm->flags & PCM_MONO) ? pcm->period_size/2 : pcm->period_size/4;
-    }
-    params->stop_threshold = pcm->buffer_size;
-
-    params->xfer_align = (pcm->flags & PCM_MONO) ? pcm->period_size/2 : pcm->period_size/4;
-    params->silence_size = 0;
-    params->silence_threshold = 0;
-
-    if (param_set_sw_params(pcm, params)) {
-        ALOGE("ERROR: cannot set sw params");
-        return NO_INIT;
-    }
-
-    return NO_ERROR;
-}
-
-status_t AudioUsbALSA::closeDevice(pcm *handle)
-{
-    ALOGD("closeDevice handle %p", handle);
-    status_t err = NO_ERROR;
-    if (handle) {
-        err = pcm_close(handle);
-        if (err != NO_ERROR) {
-            ALOGE("INFO: closeDevice: pcm_close failed with err %d", err);
-        }
-    }
-    handle = NULL;
-    return err;
-}
-
-void AudioUsbALSA::RecordingThreadEntry() {
-    ALOGD("Inside RecordingThreadEntry");
-    int nfds = 1;
-    mtimeOutRecording = TIMEOUT_INFINITE;
-    int fd;
-    long frames;
-    static int start = 0;
-    struct snd_xferi x;
-    int filed;
-    unsigned avail, bufsize;
-    int bytes_written;
-    uint32_t sampleRate;
-    uint32_t channels;
-    u_int8_t *srcUsb_addr = NULL;
-    u_int8_t *dstProxy_addr = NULL;
-    int err;
-    const char *fn = "/data/RecordPcm.pcm";
-    filed = open(fn, O_WRONLY | O_CREAT | O_TRUNC | O_APPEND, 0664);
-
-    err = getCap((char *)"Capture:", mchannelsCapture, msampleRateCapture);
-    if (err) {
-        ALOGE("ERROR: Could not get capture capabilities from usb device");
-        return;
-    }
-    int channelFlag = PCM_MONO;
-    if (mchannelsCapture >= 2) {
-        channelFlag = PCM_STEREO;
-    }
-
-    musbRecordingHandle = configureDevice(PCM_IN|channelFlag|PCM_MMAP, (char *)"hw:1,0",
-                                         msampleRateCapture, mchannelsCapture,768,false);
-    if (!musbRecordingHandle) {
-        ALOGE("ERROR: Could not configure USB device for recording");
-        return;
-    } else {
-        ALOGD("USB device Configured for recording");
-    }
-
-    pfdUsbRecording[0].fd = musbRecordingHandle->fd;                           //DEBUG
-    pfdUsbRecording[0].events = POLLIN;
-
-    mproxyRecordingHandle = configureDevice(PCM_OUT|channelFlag|PCM_MMAP, (char *)"hw:0,7",
-                                            msampleRateCapture, mchannelsCapture,768,false);
-    if (!mproxyRecordingHandle) {
-        ALOGE("ERROR: Could not configure Proxy for recording");
-        closeDevice(musbRecordingHandle);
-        return;
-    } else {
-        ALOGD("Proxy Configured for recording");
-    }
-
-    bufsize = musbRecordingHandle->period_size;
-    pfdProxyRecording[0].fd = mproxyRecordingHandle->fd;
-    pfdProxyRecording[0].events = POLLOUT;
-    frames = (musbRecordingHandle->flags & PCM_MONO) ? (bufsize / 2) : (bufsize / 4);
-    x.frames = (musbRecordingHandle->flags & PCM_MONO) ? (bufsize / 2) : (bufsize / 4);
-
-    /***********************keep reading from usb and writing to proxy******************************************/
-    while (mkillRecordingThread != true) {
-        if (!musbRecordingHandle->running) {
-            if (pcm_prepare(musbRecordingHandle)) {
-                ALOGE("ERROR: pcm_prepare failed for usb device for recording");
-                mkillRecordingThread = true;
-                break;;
-            }
-        }
-        if (!mproxyRecordingHandle->running) {
-            if (pcm_prepare(mproxyRecordingHandle)) {
-                ALOGE("ERROR: pcm_prepare failed for proxy device for recording");
-                mkillRecordingThread = true;
-                break;;
-            }
-        }
-
-        /********** USB syncing before write **************/
-        if (!musbRecordingHandle->start && !mkillRecordingThread) {
-            err = startDevice(musbRecordingHandle, &mkillRecordingThread);
-            if (err == EPIPE) {
-                continue;
-            } else if (err != NO_ERROR) {
-                mkillRecordingThread = true;
-                break;
-            }
-        }
-        for (;;) {
-            if (!musbRecordingHandle->running) {
-                if (pcm_prepare(musbRecordingHandle)) {
-                    ALOGE("ERROR: pcm_prepare failed for proxy device for recording");
-                    mkillRecordingThread = true;
-                    break;
-                }
-            }
-            /* Sync the current Application pointer from the kernel */
-            musbRecordingHandle->sync_ptr->flags = SNDRV_PCM_SYNC_PTR_APPL |
-                                                   SNDRV_PCM_SYNC_PTR_AVAIL_MIN;
-
-            err = syncPtr(musbRecordingHandle, &mkillRecordingThread);
-            if (err == EPIPE) {
-                continue;
-            } else if (err != NO_ERROR) {
-                break;
-            }
-
-            avail = pcm_avail(musbRecordingHandle);
-            if (avail < musbRecordingHandle->sw_p->avail_min) {
-                poll(pfdUsbRecording, nfds, TIMEOUT_INFINITE);
-                continue;
-            } else {
-                break;
-            }
-        }
-        if (mkillRecordingThread) {
-            break;
-        }
-        if (x.frames > avail)
-            frames = avail;
-
-        srcUsb_addr = dst_address(musbRecordingHandle);
-        /**********End USB syncing before write**************/
-
-        /*************Proxy syncing before write ******************/
-
-        for (;;) {
-            if (!mproxyRecordingHandle->running) {
-                if (pcm_prepare(mproxyRecordingHandle)) {
-                    ALOGE("ERROR: pcm_prepare failed for proxy device for recording");
-                    mkillRecordingThread = true;
-                    break;
-                }
-            }
-            mproxyRecordingHandle->sync_ptr->flags = SNDRV_PCM_SYNC_PTR_APPL |
-                                                     SNDRV_PCM_SYNC_PTR_AVAIL_MIN;
-
-            err = syncPtr(mproxyRecordingHandle, &mkillRecordingThread);
-            if (err == EPIPE) {
-                continue;
-            } else if (err != NO_ERROR) {
-                break;
-            }
-            avail = pcm_avail(mproxyRecordingHandle);
-            if (avail < mproxyRecordingHandle->sw_p->avail_min) {
-                poll(pfdProxyRecording, nfds, TIMEOUT_INFINITE);
-                continue;
-            } else {
-                break;
-            }
-        }
-        if (mkillRecordingThread) {
-            break;
-        }
-
-        dstProxy_addr = dst_address(mproxyRecordingHandle);
-        memset(dstProxy_addr, 0x0, bufsize);
-
-        /**************End Proxy syncing before write *************/
-
-        memcpy(dstProxy_addr, srcUsb_addr, bufsize );
-
-        /************* sync up after write -- USB  *********************/
-        musbRecordingHandle->sync_ptr->c.control.appl_ptr += frames;
-        musbRecordingHandle->sync_ptr->flags = 0;
-        err = syncPtr(musbRecordingHandle, &mkillRecordingThread);
-        if (err == EPIPE) {
-            continue;
-        } else if (err != NO_ERROR) {
-            break;
-        }
-
-        /************* end sync up after write -- USB *********************/
-
-        /**************** sync up after write -- Proxy  ************************/
-        mproxyRecordingHandle->sync_ptr->c.control.appl_ptr += frames;
-        mproxyRecordingHandle->sync_ptr->flags = 0;
-
-        err = syncPtr(mproxyRecordingHandle, &mkillRecordingThread);
-        if (err == EPIPE) {
-            continue;
-        } else if (err != NO_ERROR) {
-            break;
-        }
-
-        bytes_written = mproxyRecordingHandle->sync_ptr->c.control.appl_ptr - mproxyRecordingHandle->sync_ptr->s.status.hw_ptr;
-        if ((bytes_written >= mproxyRecordingHandle->sw_p->start_threshold) && (!mproxyRecordingHandle->start)) {
-            if (!mkillPlayBackThread) {
-                err = startDevice(mproxyRecordingHandle, &mkillRecordingThread);
-                if (err == EPIPE) {
-                    continue;
-                } else if (err != NO_ERROR) {
-                    mkillRecordingThread = true;
-                    break;
-                }
-            }
-        }
-    }
-    /***************  End sync up after write -- Proxy *********************/
-    if (mkillRecordingThread) {
-        closeDevice(mproxyRecordingHandle);
-        closeDevice(musbRecordingHandle);
-    }
-    ALOGD("Exiting USB Recording thread");
-}
-
-void *AudioUsbALSA::PlaybackThreadWrapper(void *me) {
-    static_cast<AudioUsbALSA *>(me)->PlaybackThreadEntry();
-    return NULL;
-}
-
-void *AudioUsbALSA::RecordingThreadWrapper(void *me) {
-    static_cast<AudioUsbALSA *>(me)->RecordingThreadEntry();
-    return NULL;
-}
-
-struct pcm * AudioUsbALSA::configureDevice(unsigned flags, char* hw, int sampleRate, int channelCount, int periodSize, bool playback){
-    int err = NO_ERROR;
-    struct pcm * handle = NULL;
-    handle = pcm_open(flags, hw);
-    if (!handle || handle->fd < 0) {
-        ALOGE("ERROR: pcm_open failed");
-        return NULL;
-    }
-
-    if (!pcm_ready(handle)) {
-        ALOGE("ERROR: pcm_ready failed");
-        closeDevice(handle);
-        return NULL;
-    }
-
-    ALOGD("Setting hardware params: sampleRate:%d, channels: %d",sampleRate, channelCount);
-    err = setHardwareParams(handle, sampleRate, channelCount,periodSize);
-    if (err != NO_ERROR) {
-        ALOGE("ERROR: setHardwareParams failed");
-        closeDevice(handle);
-        return NULL;
-    }
-
-    err = setSoftwareParams(handle, playback);
-    if (err != NO_ERROR) {
-        ALOGE("ERROR: setSoftwareParams failed");
-        closeDevice(handle);
-        return NULL;
-    }
-
-    err = mmap_buffer(handle);
-    if (err) {
-        ALOGE("ERROR: mmap_buffer failed");
-        closeDevice(handle);
-        return NULL;
-    }
-
-    err = pcm_prepare(handle);
-    if (err) {
-        ALOGE("ERROR: pcm_prepare failed");
-        closeDevice(handle);
-        return NULL;
-    }
-
-    return handle;
-}
-
-status_t AudioUsbALSA::startDevice(pcm *handle, bool *killThread) {
-    int err = NO_ERROR;;
-    if (ioctl(handle->fd, SNDRV_PCM_IOCTL_START)) {
-        err = -errno;
-        if (errno == EPIPE) {
-            ALOGE("ERROR: SNDRV_PCM_IOCTL_START returned EPIPE for usb recording case");
-            handle->underruns++;
-            handle->running = 0;
-            handle->start = 0;
-            return errno;
-        } else {
-            ALOGE("ERROR: SNDRV_PCM_IOCTL_START failed for usb recording case errno:%d", errno);
-            *killThread = true;
-            return errno;
-        }
-    }
-    handle->start = 1;
-    if (handle == musbRecordingHandle) {
-        ALOGD("Usb Driver started for recording");
-    } else if (handle == mproxyRecordingHandle) {
-        ALOGD("Proxy Driver started for recording");
-    } else if (handle == musbPlaybackHandle) {
-        ALOGD("Usb Driver started for playback");
-    } else if (handle == mproxyPlaybackHandle) {
-        ALOGD("proxy Driver started for playback");
-    }
-    return NO_ERROR;
-}
-
-status_t AudioUsbALSA::syncPtr(struct pcm *handle, bool *killThread) {
-    int err;
-    err = sync_ptr(handle);
-    if (err == EPIPE) {
-        ALOGE("ERROR: Failed in sync_ptr \n");
-        handle->running = 0;
-        handle->underruns++;
-        handle->start = 0;
-    } else if (err == ENODEV) {
-        ALOGE("Info: Device not available");
-    } else if (err != NO_ERROR) {
-        ALOGE("ERROR: Sync ptr returned %d", err);
-        *killThread = true;
-    }
-    return err;
-}
-
-void AudioUsbALSA::pollForProxyData(){
-    int err_poll = poll(pfdProxyPlayback, mnfdsPlayback, mtimeOut);
-    if (err_poll == 0 ) {
-        ALOGD("POLL timedout");
-        mkillPlayBackThread = true;
-        pfdProxyPlayback[0].revents = 0;
-        pfdProxyPlayback[1].revents = 0;
-        return;
-    }
-
-    if (pfdProxyPlayback[1].revents & POLLIN) {
-        ALOGD("Signalled from HAL about timeout");
-        uint64_t u;
-        read(mproxypfdPlayback, &u, sizeof(uint64_t));
-        pfdProxyPlayback[1].revents = 0;
-        if (u == SIGNAL_EVENT_KILLTHREAD) {
-            ALOGD("kill thread event");
-            mkillPlayBackThread = true;
-            pfdProxyPlayback[0].revents = 0;
-            pfdProxyPlayback[1].revents = 0;
-            return;
-        } else if (u == SIGNAL_EVENT_TIMEOUT) {
-            ALOGD("Setting timeout for 3 sec");
-            mtimeOut = POLL_TIMEOUT;
-        }
-    } else if (pfdProxyPlayback[1].revents & POLLERR || pfdProxyPlayback[1].revents & POLLHUP ||
-               pfdProxyPlayback[1].revents & POLLNVAL) {
-        ALOGE("Info: proxy throwing error from location 1");
-        mkillPlayBackThread = true;
-        pfdProxyPlayback[0].revents = 0;
-        pfdProxyPlayback[1].revents = 0;
-        return;
-    }
-
-    if (pfdProxyPlayback[0].revents & POLLERR || pfdProxyPlayback[0].revents & POLLHUP ||
-        pfdProxyPlayback[0].revents & POLLNVAL) {
-        ALOGE("Info: proxy throwing error");
-        mkillPlayBackThread = true;
-        pfdProxyPlayback[0].revents = 0;
-        pfdProxyPlayback[1].revents = 0;
-    }
-}
-
-void AudioUsbALSA::pollForUsbData(){
-    int err_poll = poll(pfdUsbPlayback, mnfdsPlayback, mtimeOut);
-    if (err_poll == 0 ) {
-        ALOGD("POLL timedout");
-        mkillPlayBackThread = true;
-        pfdUsbPlayback[0].revents = 0;
-        pfdUsbPlayback[1].revents = 0;
-        return;
-    }
-
-    if (pfdUsbPlayback[1].revents & POLLIN) {
-        ALOGD("Info: Signalled from HAL about an event");
-        uint64_t u;
-        read(musbpfdPlayback, &u, sizeof(uint64_t));
-        pfdUsbPlayback[0].revents = 0;
-        pfdUsbPlayback[1].revents = 0;
-        if (u == SIGNAL_EVENT_KILLTHREAD) {
-            ALOGD("kill thread");
-            mkillPlayBackThread = true;
-            return;
-        } else if (u == SIGNAL_EVENT_TIMEOUT) {
-            ALOGD("Setting timeout for 3 sec");
-            mtimeOut = POLL_TIMEOUT;
-        }
-    } else if (pfdUsbPlayback[1].revents & POLLERR || pfdUsbPlayback[1].revents & POLLHUP ||
-               pfdUsbPlayback[1].revents & POLLNVAL) {
-        ALOGE("Info: usb throwing error from location 1");
-        mkillPlayBackThread = true;
-        pfdUsbPlayback[0].revents = 0;
-        pfdUsbPlayback[1].revents = 0;
-        return;
-    }
-
-    if (pfdUsbPlayback[0].revents & POLLERR || pfdProxyPlayback[0].revents & POLLHUP ||
-        pfdUsbPlayback[0].revents & POLLNVAL) {
-        ALOGE("Info: usb throwing error");
-        mkillPlayBackThread = true;
-        pfdUsbPlayback[0].revents = 0;
-        return;
-    }
-}
-
-void AudioUsbALSA::PlaybackThreadEntry() {
-    ALOGD("PlaybackThreadEntry");
-    mnfdsPlayback = 2;
-    mtimeOut = TIMEOUT_INFINITE;
-    long frames;
-    static int fd;
-    struct snd_xferi x;
-    int bytes_written;
-    unsigned avail, xfer, bufsize;
-    unsigned proxyPeriod, usbPeriod;
-    uint32_t sampleRate;
-    uint32_t channels;
-    unsigned int tmp;
-    int numOfBytesWritten;
-    int err;
-    int filed;
-    const char *fn = "/data/test.pcm";
-    mdstUsb_addr = NULL;
-    msrcProxy_addr = NULL;
-
-    int proxySizeRemaining = 0;
-    int usbSizeFilled = 0;
-
-    pid_t tid  = gettid();
-    androidSetThreadPriority(tid, ANDROID_PRIORITY_URGENT_AUDIO);
-
-    err = getCap((char *)"Playback:", mchannelsPlayback, msampleRatePlayback);
-    if (err) {
-        ALOGE("ERROR: Could not get playback capabilities from usb device");
-        return;
-    }
-
-    musbPlaybackHandle = configureDevice(PCM_OUT|PCM_STEREO|PCM_MMAP, (char *)"hw:1,0",
-                                         msampleRatePlayback, mchannelsPlayback, USB_PERIOD_SIZE, true);
-    if (!musbPlaybackHandle) {
-        ALOGE("ERROR: configureUsbDevice failed, returning");
-        closeDevice(musbPlaybackHandle);
-        return;
-    } else {
-        ALOGD("USB Configured for playback");
-    }
-
-    if (!mkillPlayBackThread) {
-        pfdUsbPlayback[0].fd = musbPlaybackHandle->timer_fd;
-        pfdUsbPlayback[0].events = POLLIN;
-        musbpfdPlayback = eventfd(0,0);
-        pfdUsbPlayback[1].fd = musbpfdPlayback;
-        pfdUsbPlayback[1].events = (POLLIN | POLLOUT | POLLERR | POLLNVAL | POLLHUP);
-    }
-
-    mproxyPlaybackHandle = configureDevice(PCM_IN|PCM_STEREO|PCM_MMAP, (char *)"hw:0,8",
-                               msampleRatePlayback, mchannelsPlayback, PROXY_PERIOD_SIZE, false);
-    if (!mproxyPlaybackHandle) {
-        ALOGE("ERROR: Could not configure Proxy, returning");
-        closeDevice(musbPlaybackHandle);
-        return;
-    } else {
-        ALOGD("Proxy Configured for playback");
-    }
-
-    proxyPeriod = mproxyPlaybackHandle->period_size;
-    usbPeriod = musbPlaybackHandle->period_size;
-
-    if (!mkillPlayBackThread) {
-        pfdProxyPlayback[0].fd = mproxyPlaybackHandle->fd;
-        pfdProxyPlayback[0].events = (POLLIN);                                 // | POLLERR | POLLNVAL);
-        mproxypfdPlayback = eventfd(0,0);
-        pfdProxyPlayback[1].fd = mproxypfdPlayback;
-        pfdProxyPlayback[1].events = (POLLIN | POLLOUT| POLLERR | POLLNVAL);
-    }
-
-    frames = (mproxyPlaybackHandle->flags & PCM_MONO) ? (proxyPeriod / 2) : (proxyPeriod / 4);
-    x.frames = (mproxyPlaybackHandle->flags & PCM_MONO) ? (proxyPeriod / 2) : (proxyPeriod / 4);
-    int usbframes = (musbPlaybackHandle->flags & PCM_MONO) ? (usbPeriod / 2) : (usbPeriod / 4);
-
-    u_int8_t *proxybuf = ( u_int8_t *) malloc(PROXY_PERIOD_SIZE);
-    u_int8_t *usbbuf = ( u_int8_t *) malloc(USB_PERIOD_SIZE);
-    memset(proxybuf, 0x0, PROXY_PERIOD_SIZE);
-    memset(usbbuf, 0x0, USB_PERIOD_SIZE);
-
-
-    /***********************keep reading from proxy and writing to USB******************************************/
-    while (mkillPlayBackThread != true) {
-        if (!mproxyPlaybackHandle->running) {
-            if (pcm_prepare(mproxyPlaybackHandle)) {
-                ALOGE("ERROR: pcm_prepare failed for proxy");
-                mkillPlayBackThread = true;
-                break;
-            }
-        }
-        if (!musbPlaybackHandle->running) {
-            if (pcm_prepare(musbPlaybackHandle)) {
-                ALOGE("ERROR: pcm_prepare failed for usb");
-                mkillPlayBackThread = true;
-                break;
-            }
-        }
-
-        /********** Proxy syncing before write **************/
-        if (!mkillPlayBackThread && (!mproxyPlaybackHandle->start)) {
-            err = startDevice(mproxyPlaybackHandle, &mkillPlayBackThread);
-            if (err == EPIPE) {
-                continue;
-            } else if (err != NO_ERROR) {
-                mkillPlayBackThread = true;
-                break;
-            }
-        }
-        if (proxySizeRemaining == 0) {
-            for (;;) {
-                if (!mproxyPlaybackHandle->running) {
-                    if (pcm_prepare(mproxyPlaybackHandle)) {
-                        ALOGE("ERROR: pcm_prepare failed for proxy");
-                        mkillPlayBackThread = true;
-                        break;
-                    }
-                }
-                /* Sync the current Application pointer from the kernel */
-                mproxyPlaybackHandle->sync_ptr->flags = SNDRV_PCM_SYNC_PTR_APPL |
-                                                        SNDRV_PCM_SYNC_PTR_AVAIL_MIN;
-
-                if (mtimeOut == TIMEOUT_INFINITE && !mkillPlayBackThread) {
-                    err = syncPtr(mproxyPlaybackHandle, &mkillPlayBackThread);
-                    if (err == EPIPE) {
-                        continue;
-                    } else if (err != NO_ERROR) {
-                        break;
-                    }
-                    avail = pcm_avail(mproxyPlaybackHandle);
-                }
-                if (avail < mproxyPlaybackHandle->sw_p->avail_min && !mkillPlayBackThread) {
-                    pollForProxyData();
-                    //if polling returned some error
-                    if (!mkillPlayBackThread) {
-                        continue;
-                    } else {
-                        break;
-                    }
-                } else {                                                           //Got some data or mkillPlayBackThread is true
-                    break;
-                }
-            }
-            if (mkillPlayBackThread) {
-                break;
-            }
-
-            if (x.frames > avail)
-                frames = avail;
-
-            if (!mkillPlayBackThread) {
-                msrcProxy_addr = dst_address(mproxyPlaybackHandle);
-                memcpy(proxybuf, msrcProxy_addr, proxyPeriod );
-
-                x.frames -= frames;
-                mproxyPlaybackHandle->sync_ptr->c.control.appl_ptr += frames;
-                mproxyPlaybackHandle->sync_ptr->flags = 0;
-                proxySizeRemaining = proxyPeriod;
-            }
-
-            if (!mkillPlayBackThread) {
-                err = syncPtr(mproxyPlaybackHandle, &mkillPlayBackThread);
-                if (err == EPIPE) {
-                    continue;
-                } else if (err != NO_ERROR) {
-                    break;
-                }
-            }
-        }
-        //ALOGE("usbSizeFilled %d, proxySizeRemaining %d ",usbSizeFilled,proxySizeRemaining);
-        if (usbPeriod - usbSizeFilled <= proxySizeRemaining) {
-            memcpy(usbbuf + usbSizeFilled, proxybuf + proxyPeriod - proxySizeRemaining, usbPeriod - usbSizeFilled);
-            proxySizeRemaining -= (usbPeriod - usbSizeFilled);
-            usbSizeFilled = usbPeriod;
-        }
-        else {
-            memcpy(usbbuf + usbSizeFilled, proxybuf + proxyPeriod - proxySizeRemaining,proxySizeRemaining);
-            usbSizeFilled += proxySizeRemaining;
-            proxySizeRemaining = 0;
-        }
-
-        if (usbSizeFilled == usbPeriod) {
-            for (;;) {
-                if (!musbPlaybackHandle->running) {
-                    if (pcm_prepare(musbPlaybackHandle)) {
-                        ALOGE("ERROR: pcm_prepare failed for usb");
-                        mkillPlayBackThread = true;
-                        break;
-                    }
-                }
-                /*************USB syncing before write ******************/
-                musbPlaybackHandle->sync_ptr->flags = SNDRV_PCM_SYNC_PTR_APPL |
-                                                      SNDRV_PCM_SYNC_PTR_AVAIL_MIN;
-                if (mtimeOut == TIMEOUT_INFINITE && !mkillPlayBackThread) {
-                    err = syncPtr(musbPlaybackHandle, &mkillPlayBackThread);
-                    if (err == EPIPE) {
-                        continue;
-                    } else if (err != NO_ERROR) {
-                        break;
-                    }
-                    avail = pcm_avail(musbPlaybackHandle);
-                    //ALOGV("Avail USB is: %d", avail);
-                }
-
-                if (avail < musbPlaybackHandle->sw_p->avail_min && !mkillPlayBackThread) {
-                    pollForUsbData();
-                    if (!mkillPlayBackThread) {
-                        continue;
-                    } else {
-                        break;
-                    }
-                } else {
-                    break;
-                }
-            }
-            if (mkillPlayBackThread) {
-                break;
-            }
-
-            if (!mkillPlayBackThread) {
-                mdstUsb_addr = dst_address(musbPlaybackHandle);
-
-                /**************End USB syncing before write *************/
-
-                memcpy(mdstUsb_addr, usbbuf, usbPeriod );
-                usbSizeFilled = 0;
-                memset(usbbuf, 0x0, usbPeriod);
-            }
-
-            /**************** sync up after write -- USB  ************************/
-            musbPlaybackHandle->sync_ptr->c.control.appl_ptr += usbframes;
-            musbPlaybackHandle->sync_ptr->flags = 0;
-            if (!mkillPlayBackThread) {
-                err = syncPtr(musbPlaybackHandle, &mkillPlayBackThread);
-                if (err == EPIPE) {
-                    continue;
-                } else if (err != NO_ERROR) {
-                    break;
-                }
-            }
-
-            bytes_written = musbPlaybackHandle->sync_ptr->c.control.appl_ptr - musbPlaybackHandle->sync_ptr->s.status.hw_ptr;
-            ALOGE("Appl ptr %d , hw_ptr %d, difference %d",musbPlaybackHandle->sync_ptr->c.control.appl_ptr, musbPlaybackHandle->sync_ptr->s.status.hw_ptr, bytes_written);
-
-            /*
-                Following is the check to prevent USB from going to bad state.
-                This happens in case of an underrun where there is not enough
-                data from the proxy
-            */
-	    if (bytes_written <= usbPeriod && musbPlaybackHandle->start) {
-                ioctl(musbPlaybackHandle->fd, SNDRV_PCM_IOCTL_PAUSE,1);
-                pcm_prepare(musbPlaybackHandle);
-                musbPlaybackHandle->start = false;
-                continue;
-            }
-            if ((bytes_written >= musbPlaybackHandle->sw_p->start_threshold) && (!musbPlaybackHandle->start)) {
-                if (!mkillPlayBackThread) {
-                    err = startDevice(musbPlaybackHandle, &mkillPlayBackThread);
-                    if (err == EPIPE) {
-                        continue;
-                    } else if (err != NO_ERROR) {
-                        mkillPlayBackThread = true;
-                        break;
-                    }
-                }
-            }
-            /***************  End sync up after write -- USB *********************/
-        }
-    }
-    if (mkillPlayBackThread) {
-        if (proxybuf)
-            free(proxybuf);
-        if (usbbuf)
-            free(usbbuf);
-        mproxypfdPlayback = -1;
-        musbpfdPlayback = -1;
-        closeDevice(mproxyPlaybackHandle);
-        closeDevice(musbPlaybackHandle);
-    }
-    ALOGD("Exiting USB Playback Thread");
-}
-
-void AudioUsbALSA::startPlayback()
-{
-    mkillPlayBackThread = false;
-    ALOGD("Creating USB Playback Thread");
-    pthread_create(&mPlaybackUsb, NULL, PlaybackThreadWrapper, this);
-}
-
-void AudioUsbALSA::startRecording()
-{
-    //create Thread
-    mkillRecordingThread = false;
-    ALOGV("Creating USB recording Thread");
-    pthread_create(&mRecordingUsb, NULL, RecordingThreadWrapper, this);
-}
-}
diff --git a/legacy/alsa_sound/AudioUsbALSA.h b/legacy/alsa_sound/AudioUsbALSA.h
deleted file mode 100644
index d06bbb7..0000000
--- a/legacy/alsa_sound/AudioUsbALSA.h
+++ /dev/null
@@ -1,143 +0,0 @@
-/* AudioUsbALSA.h
-
-Copyright (c) 2012, 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.*/
-
-#ifndef ANDROID_AUDIO_USB_ALSA_H
-#define ANDROID_AUDIO_USB_ALSA_H
-
-#include <utils/List.h>
-#include <hardware_legacy/AudioHardwareBase.h>
-
-#include <hardware_legacy/AudioHardwareInterface.h>
-#include <hardware_legacy/AudioSystemLegacy.h>
-#include <system/audio.h>
-#include <hardware/audio.h>
-#include <utils/threads.h>
-
-#define DEFAULT_BUFFER_SIZE   2048
-#define POLL_TIMEOUT   3000
-#define DEFAULT_CHANNEL_MODE  2
-#define CHANNEL_MODE_ONE  1
-#define PROXY_DEFAULT_SAMPLING_RATE 48000
-#define SIGNAL_EVENT_TIMEOUT 1
-#define SIGNAL_EVENT_KILLTHREAD 2
-
-#define BUFFSIZE 1000000
-
-#define PATH "/proc/asound/card1/stream0"
-
-extern "C" {
-   #include <sound/asound.h>
-   #include "alsa_audio.h"
-   #include "msm8960_use_cases.h"
-}
-
-#include <hardware/hardware.h>
-
-namespace android_audio_legacy
-{
-using android::List;
-using android::Mutex;
-class AudioUsbALSA;
-
-class AudioUsbALSA
-{
-private:
-    int mproxypfdPlayback;
-    int musbpfdPlayback;
-    int mnfdsPlayback;
-    int mnfdsRecording;
-    int mtimeOut;
-    int mtimeOutRecording;
-    struct pcm *mproxyRecordingHandle;
-    struct pcm *musbRecordingHandle;
-    struct pcm *mproxyPlaybackHandle;
-    struct pcm *musbPlaybackHandle;
-    u_int8_t *mdstUsb_addr;
-    u_int8_t *msrcProxy_addr;
-    bool mkillPlayBackThread;
-    bool mkillRecordingThread;
-    pthread_t mPlaybackUsb;
-    pthread_t mRecordingUsb;
-    snd_use_case_mgr_t *mUcMgr;
-
-    //Helper functions
-    struct pcm * configureDevice(unsigned flags, char* hw, int sampleRate, int channelCount, int periodSize, bool playback);
-    status_t syncPtr(struct pcm *handle, bool *killThread);
-
-    //playback
-    void pollForProxyData();
-    void pollForUsbData();
-
-    //recording
-    void pollForUsbDataForRecording();
-    void pollForProxyDataForRecording();
-
-    status_t startDevice(pcm *handle, bool *killThread);
-
-    void PlaybackThreadEntry();
-    static void *PlaybackThreadWrapper(void *me);
-
-    void RecordingThreadEntry();
-    static void *RecordingThreadWrapper(void *me);
-
-    status_t setHardwareParams(pcm *local_handle, uint32_t sampleRate, uint32_t channels, int periodSize);
-
-    status_t setSoftwareParams(pcm *pcm, bool playback);
-
-    status_t closeDevice(pcm *handle);
-
-    status_t getCap(char * type, int &channels, int &sampleRate);
-    int         getnumOfRates(char *rateStr);
-    int         mchannelsPlayback;
-    int         msampleRatePlayback;
-    int         mchannelsCapture;
-    int         msampleRateCapture;
-
-public:
-    AudioUsbALSA();
-    virtual            ~AudioUsbALSA();
-
-    void exitPlaybackThread(uint64_t writeVal);
-    void exitRecordingThread(uint64_t writeVal);
-    void setkillUsbRecordingThread(bool val);
-    bool getkillUsbPlaybackThread() {
-        return mkillPlayBackThread;
-    }
-    bool getkillUsbRecordingThread() {
-        return mkillRecordingThread;
-    }
-    //Playback
-    void startPlayback();
-
-    //Capture
-    void startRecording();
-};
-
-};        // namespace android_audio_legacy
-#endif    // ANDROID_AUDIO_USB_ALSA_H
diff --git a/legacy/alsa_sound/AudioUtil.cpp b/legacy/alsa_sound/AudioUtil.cpp
deleted file mode 100644
index 3549f24..0000000
--- a/legacy/alsa_sound/AudioUtil.cpp
+++ /dev/null
@@ -1,279 +0,0 @@
-/* AudioUtil.cpp
- *
- * Copyright (C) 2012 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 "AudioUtil"
-//#define LOG_NDEBUG 0
-#include <utils/Log.h>
-
-#include "AudioUtil.h"
-
-int AudioUtil::printFormatFromEDID(unsigned char format) {
-    switch (format) {
-    case LPCM:
-        ALOGV("Format:LPCM");
-        break;
-    case AC3:
-        ALOGV("Format:AC-3");
-        break;
-    case MPEG1:
-        ALOGV("Format:MPEG1 (Layers 1 & 2)");
-        break;
-    case MP3:
-        ALOGV("Format:MP3 (MPEG1 Layer 3)");
-        break;
-    case MPEG2_MULTI_CHANNEL:
-        ALOGV("Format:MPEG2 (multichannel)");
-        break;
-    case AAC:
-        ALOGV("Format:AAC");
-        break;
-    case DTS:
-        ALOGV("Format:DTS");
-        break;
-    case ATRAC:
-        ALOGV("Format:ATRAC");
-        break;
-    case SACD:
-        ALOGV("Format:One-bit audio aka SACD");
-        break;
-    case DOLBY_DIGITAL_PLUS:
-        ALOGV("Format:Dolby Digital +");
-        break;
-    case DTS_HD:
-        ALOGV("Format:DTS-HD");
-        break;
-    case MAT:
-        ALOGV("Format:MAT (MLP)");
-        break;
-    case DST:
-        ALOGV("Format:DST");
-        break;
-    case WMA_PRO:
-        ALOGV("Format:WMA Pro");
-        break;
-    default:
-        ALOGV("Invalid format ID....");
-        break;
-    }
-    return format;
-}
-
-int AudioUtil::getSamplingFrequencyFromEDID(unsigned char byte) {
-    int nFreq = 0;
-
-    if (byte & BIT(6)) {
-        ALOGV("192kHz");
-        nFreq = 192000;
-    } else if (byte & BIT(5)) {
-        ALOGV("176kHz");
-        nFreq = 176000;
-    } else if (byte & BIT(4)) {
-        ALOGV("96kHz");
-        nFreq = 96000;
-    } else if (byte & BIT(3)) {
-        ALOGV("88.2kHz");
-        nFreq = 88200;
-    } else if (byte & BIT(2)) {
-        ALOGV("48kHz");
-        nFreq = 48000;
-    } else if (byte & BIT(1)) {
-        ALOGV("44.1kHz");
-        nFreq = 44100;
-    } else if (byte & BIT(0)) {
-        ALOGV("32kHz");
-        nFreq = 32000;
-    }
-    return nFreq;
-}
-
-int AudioUtil::getBitsPerSampleFromEDID(unsigned char byte,
-    unsigned char format) {
-    int nBitsPerSample = 0;
-    if (format == 1) {
-        if (byte & BIT(2)) {
-            ALOGV("24bit");
-            nBitsPerSample = 24;
-        } else if (byte & BIT(1)) {
-            ALOGV("20bit");
-            nBitsPerSample = 20;
-        } else if (byte & BIT(0)) {
-            ALOGV("16bit");
-            nBitsPerSample = 16;
-        }
-    } else {
-        ALOGV("not lpcm format, return 0");
-        return 0;
-    }
-    return nBitsPerSample;
-}
-
-bool AudioUtil::getHDMIAudioSinkCaps(EDID_AUDIO_INFO* pInfo) {
-    unsigned char channels[16];
-    unsigned char formats[16];
-    unsigned char frequency[16];
-    unsigned char bitrate[16];
-    unsigned char* data = NULL;
-    unsigned char* original_data_ptr = NULL;
-    int count = 0;
-    bool bRet = false;
-    const char* file = "/sys/class/graphics/fb1/audio_data_block";
-    FILE* fpaudiocaps = fopen(file, "rb");
-    if (fpaudiocaps) {
-        ALOGV("opened audio_caps successfully...");
-        fseek(fpaudiocaps, 0, SEEK_END);
-        long size = ftell(fpaudiocaps);
-        ALOGV("audiocaps size is %ld\n",size);
-        data = (unsigned char*) malloc(size);
-        if (data) {
-            fseek(fpaudiocaps, 0, SEEK_SET);
-            original_data_ptr = data;
-            fread(data, 1, size, fpaudiocaps);
-        }
-        fclose(fpaudiocaps);
-    } else {
-        ALOGE("failed to open audio_caps");
-    }
-
-    if (pInfo && data) {
-        int length = 0;
-        memcpy(&count,  data, sizeof(int));
-        data+= sizeof(int);
-        ALOGV("#Audio Block Count is %d",count);
-        memcpy(&length, data, sizeof(int));
-        data += sizeof(int);
-        ALOGV("Total length is %d",length);
-        unsigned int sad[MAX_SHORT_AUDIO_DESC_CNT];
-        int nblockindex = 0;
-        int nCountDesc = 0;
-        while (length >= MIN_AUDIO_DESC_LENGTH && count < MAX_SHORT_AUDIO_DESC_CNT) {
-            sad[nblockindex] = (unsigned int)data[0] + ((unsigned int)data[1] << 8)
-                               + ((unsigned int)data[2] << 16);
-            nblockindex+=1;
-            nCountDesc++;
-            length -= MIN_AUDIO_DESC_LENGTH;
-            data += MIN_AUDIO_DESC_LENGTH;
-        }
-        memset(pInfo, 0, sizeof(EDID_AUDIO_INFO));
-        pInfo->nAudioBlocks = nCountDesc;
-        ALOGV("Total # of audio descriptors %d",nCountDesc);
-        int nIndex = 0;
-        while (nCountDesc--) {
-              channels [nIndex]   = (sad[nIndex] & 0x7) + 1;
-              formats  [nIndex]   = (sad[nIndex] & 0xFF) >> 3;
-              frequency[nIndex]   = (sad[nIndex] >> 8) & 0xFF;
-              bitrate  [nIndex]   = (sad[nIndex] >> 16) & 0xFF;
-              nIndex++;
-        }
-        bRet = true;
-        for (int i = 0; i < pInfo->nAudioBlocks; i++) {
-            ALOGV("AUDIO DESC BLOCK # %d\n",i);
-
-            pInfo->AudioBlocksArray[i].nChannels = channels[i];
-            ALOGV("pInfo->AudioBlocksArray[i].nChannels %d\n", pInfo->AudioBlocksArray[i].nChannels);
-
-            ALOGV("Format Byte %d\n", formats[i]);
-            pInfo->AudioBlocksArray[i].nFormatId = (EDID_AUDIO_FORMAT_ID)printFormatFromEDID(formats[i]);
-            ALOGV("pInfo->AudioBlocksArray[i].nFormatId %d",pInfo->AudioBlocksArray[i].nFormatId);
-
-            ALOGV("Frequency Byte %d\n", frequency[i]);
-            pInfo->AudioBlocksArray[i].nSamplingFreq = getSamplingFrequencyFromEDID(frequency[i]);
-            ALOGV("pInfo->AudioBlocksArray[i].nSamplingFreq %d",pInfo->AudioBlocksArray[i].nSamplingFreq);
-
-            ALOGV("BitsPerSample Byte %d\n", bitrate[i]);
-            pInfo->AudioBlocksArray[i].nBitsPerSample = getBitsPerSampleFromEDID(bitrate[i],formats[i]);
-            ALOGV("pInfo->AudioBlocksArray[i].nBitsPerSample %d",pInfo->AudioBlocksArray[i].nBitsPerSample);
-        }
-            getSpeakerAllocation(pInfo);
-    }
-    if (original_data_ptr)
-        free(original_data_ptr);
-
-    return bRet;
-}
-
-bool AudioUtil::getSpeakerAllocation(EDID_AUDIO_INFO* pInfo) {
-    int count = 0;
-    bool bRet = false;
-    unsigned char* data = NULL;
-    unsigned char* original_data_ptr = NULL;
-    const char* spkrfile = "/sys/class/graphics/fb1/spkr_alloc_data_block";
-    FILE* fpspkrfile = fopen(spkrfile, "rb");
-    if(fpspkrfile) {
-        ALOGV("opened spkr_alloc_data_block successfully...");
-        fseek(fpspkrfile,0,SEEK_END);
-        long size = ftell(fpspkrfile);
-        ALOGV("fpspkrfile size is %ld\n",size);
-        data = (unsigned char*)malloc(size);
-        if(data) {
-            original_data_ptr = data;
-            fseek(fpspkrfile,0,SEEK_SET);
-            fread(data,1,size,fpspkrfile);
-        }
-        fclose(fpspkrfile);
-    } else {
-        ALOGE("failed to open fpspkrfile");
-    }
-
-    if(pInfo && data) {
-        int length = 0;
-        memcpy(&count,  data, sizeof(int));
-        ALOGV("Count is %d",count);
-        data += sizeof(int);
-        memcpy(&length, data, sizeof(int));
-        ALOGV("Total length is %d",length);
-        data+= sizeof(int);
-        ALOGV("Total speaker allocation Block count # %d\n",count);
-        bRet = true;
-        for (int i = 0; i < count; i++) {
-            ALOGV("Speaker Allocation BLOCK # %d\n",i);
-            pInfo->nSpeakerAllocation[0] = data[0];
-            pInfo->nSpeakerAllocation[1] = data[1];
-            pInfo->nSpeakerAllocation[2] = data[2];
-            ALOGV("pInfo->nSpeakerAllocation %x %x %x\n", data[0],data[1],data[2]);
-
-
-            if (pInfo->nSpeakerAllocation[0] & BIT(7)) {
-                 ALOGV("FLW/FRW");
-            } else if (pInfo->nSpeakerAllocation[0] & BIT(6)) {
-                 ALOGV("RLC/RRC");
-            } else if (pInfo->nSpeakerAllocation[0] & BIT(5)) {
-                 ALOGV("FLC/FRC");
-            } else if (pInfo->nSpeakerAllocation[0] & BIT(4)) {
-                ALOGV("RC");
-            } else if (pInfo->nSpeakerAllocation[0] & BIT(3)) {
-                ALOGV("RL/RR");
-            } else if (pInfo->nSpeakerAllocation[0] & BIT(2)) {
-                ALOGV("FC");
-            } else if (pInfo->nSpeakerAllocation[0] & BIT(1)) {
-                ALOGV("LFE");
-            } else if (pInfo->nSpeakerAllocation[0] & BIT(0)) {
-                ALOGV("FL/FR");
-            }
-
-            if (pInfo->nSpeakerAllocation[1] & BIT(2)) {
-                ALOGV("FCH");
-            } else if (pInfo->nSpeakerAllocation[1] & BIT(1)) {
-                ALOGV("TC");
-            } else if (pInfo->nSpeakerAllocation[1] & BIT(0)) {
-                ALOGV("FLH/FRH");
-            }
-        }
-    }
-    if (original_data_ptr)
-        free(original_data_ptr);
-    return bRet;
-}
diff --git a/legacy/alsa_sound/AudioUtil.h b/legacy/alsa_sound/AudioUtil.h
deleted file mode 100644
index 6575315..0000000
--- a/legacy/alsa_sound/AudioUtil.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/* AudioUtil.h
- *
- * Copyright (C) 2012 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.
- */
-
-#ifndef ALSA_SOUND_AUDIO_UTIL_H
-#define ALSA_SOUND_AUDIO_UTIL_H
-
-#define BIT(nr)     (1UL << (nr))
-#define MAX_EDID_BLOCKS 10
-#define MAX_SHORT_AUDIO_DESC_CNT        30
-#define MIN_AUDIO_DESC_LENGTH           3
-#define MIN_SPKR_ALLOCATION_DATA_LENGTH 3
-
-typedef enum EDID_AUDIO_FORMAT_ID {
-    LPCM = 1,
-    AC3,
-    MPEG1,
-    MP3,
-    MPEG2_MULTI_CHANNEL,
-    AAC,
-    DTS,
-    ATRAC,
-    SACD,
-    DOLBY_DIGITAL_PLUS,
-    DTS_HD,
-    MAT,
-    DST,
-    WMA_PRO
-} EDID_AUDIO_FORMAT_ID;
-
-typedef struct EDID_AUDIO_BLOCK_INFO {
-    EDID_AUDIO_FORMAT_ID nFormatId;
-    int nSamplingFreq;
-    int nBitsPerSample;
-    int nChannels;
-} EDID_AUDIO_BLOCK_INFO;
-
-typedef struct EDID_AUDIO_INFO {
-    int nAudioBlocks;
-    unsigned char nSpeakerAllocation[MIN_SPKR_ALLOCATION_DATA_LENGTH];
-    EDID_AUDIO_BLOCK_INFO AudioBlocksArray[MAX_EDID_BLOCKS];
-} EDID_AUDIO_INFO;
-
-class AudioUtil {
-public:
-
-    //Parses EDID audio block when if HDMI is connected to determine audio sink capabilities.
-    static bool getHDMIAudioSinkCaps(EDID_AUDIO_INFO*);
-
-private:
-    static int printFormatFromEDID(unsigned char format);
-    static int getSamplingFrequencyFromEDID(unsigned char byte);
-    static int getBitsPerSampleFromEDID(unsigned char byte,
-        unsigned char format);
-    static bool getSpeakerAllocation(EDID_AUDIO_INFO* pInfo);
-};
-
-#endif /* ALSA_SOUND_AUDIO_UTIL_H */
diff --git a/legacy/alsa_sound/CleanSpec.mk b/legacy/alsa_sound/CleanSpec.mk
deleted file mode 100755
index d2bc78b..0000000
--- a/legacy/alsa_sound/CleanSpec.mk
+++ /dev/null
@@ -1,51 +0,0 @@
-# Copyright (C) 2007 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.
-#
-
-# If you don't need to do a full clean build but would like to touch
-# a file or delete some intermediate files, add a clean step to the end
-# of the list.  These steps will only be run once, if they haven't been
-# run before.
-#
-# E.g.:
-#     $(call add-clean-step, touch -c external/sqlite/sqlite3.h)
-#     $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/STATIC_LIBRARIES/libz_intermediates)
-#
-# Always use "touch -c" and "rm -f" or "rm -rf" to gracefully deal with
-# files that are missing or have been moved.
-#
-# Use $(PRODUCT_OUT) to get to the "out/target/product/blah/" directory.
-# Use $(OUT_DIR) to refer to the "out" directory.
-#
-# If you need to re-do something that's already mentioned, just copy
-# the command and add it to the bottom of the list.  E.g., if a change
-# that you made last week required touching a file and a change you
-# made today requires touching the same file, just copy the old
-# touch step and add it to the end of the list.
-#
-# ************************************************
-# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
-# ************************************************
-
-# For example:
-#$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/APPS/AndroidTests_intermediates)
-#$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/core_intermediates)
-#$(call add-clean-step, find $(OUT_DIR) -type f -name "IGTalkSession*" -print0 | xargs -0 rm -f)
-#$(call add-clean-step, rm -rf $(PRODUCT_OUT)/data/*)
-
-$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/etc/audio_policy.conf)
-
-# ************************************************
-# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
-# ************************************************
diff --git a/legacy/alsa_sound/MODULE_LICENSE_APACHE2 b/legacy/alsa_sound/MODULE_LICENSE_APACHE2
deleted file mode 100644
index e69de29..0000000
--- a/legacy/alsa_sound/MODULE_LICENSE_APACHE2
+++ /dev/null
diff --git a/legacy/alsa_sound/NOTICE b/legacy/alsa_sound/NOTICE
deleted file mode 100644
index ada44e1..0000000
--- a/legacy/alsa_sound/NOTICE
+++ /dev/null
@@ -1,191 +0,0 @@
-
-   Copyright (c) 2005-2008, The Android Open Source Project
-   Copyright 2008 Wind River Systems
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-
-   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.
-
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
diff --git a/legacy/alsa_sound/acoustics_default.cpp b/legacy/alsa_sound/acoustics_default.cpp
deleted file mode 100644
index aa21190..0000000
--- a/legacy/alsa_sound/acoustics_default.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-/* acoustics_default.cpp
- **
- ** Copyright 2009 Wind River Systems
- **
- ** 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 "AcousticsModule"
-#include <utils/Log.h>
-
-#include "AudioHardwareALSA.h"
-
-namespace android
-{
-
-static int s_device_open(const hw_module_t*, const char*, hw_device_t**);
-static int s_device_close(hw_device_t*);
-
-static status_t s_use_handle(acoustic_device_t *, alsa_handle_t *);
-static status_t s_cleanup(acoustic_device_t *);
-static status_t s_set_params(acoustic_device_t *,
-        AudioSystem::audio_in_acoustics, void *params);
-
-static hw_module_methods_t s_module_methods = {
-    open            : s_device_open
-};
-
-extern "C" hw_module_t HAL_MODULE_INFO_SYM = {
-    tag             : HARDWARE_MODULE_TAG,
-    version_major   : 1,
-    version_minor   : 0,
-    id              : ACOUSTICS_HARDWARE_MODULE_ID,
-    name            : "ALSA acoustics module",
-    author          : "Wind River",
-    methods         : &s_module_methods,
-    dso             : 0,
-    reserved        : { 0, },
-};
-
-static int s_device_open(const hw_module_t* module, const char* name,
-        hw_device_t** device)
-{
-    acoustic_device_t *dev;
-    dev = (acoustic_device_t *) malloc(sizeof(*dev));
-    if (!dev) return -ENOMEM;
-
-    memset(dev, 0, sizeof(*dev));
-
-    /* initialize the procs */
-    dev->common.tag = HARDWARE_DEVICE_TAG;
-    dev->common.version = 0;
-    dev->common.module = (hw_module_t *) module;
-    dev->common.close = s_device_close;
-
-    // Required methods...
-    dev->use_handle = s_use_handle;
-    dev->cleanup = s_cleanup;
-    dev->set_params = s_set_params;
-
-    // read, write, and recover are optional methods...
-
-    *device = &dev->common;
-    return 0;
-}
-
-static int s_device_close(hw_device_t* device)
-{
-    free(device);
-    return 0;
-}
-
-static status_t s_use_handle(acoustic_device_t *dev, alsa_handle_t *h)
-{
-    return NO_ERROR;
-}
-
-static status_t s_cleanup(acoustic_device_t *dev)
-{
-    ALOGD("Acoustics close stub called.");
-    return NO_ERROR;
-}
-
-static status_t s_set_params(acoustic_device_t *dev,
-        AudioSystem::audio_in_acoustics acoustics, void *params)
-{
-    ALOGD("Acoustics set_params stub called with %d.", (int)acoustics);
-    return NO_ERROR;
-}
-}
diff --git a/legacy/alsa_sound/alsa_default.cpp b/legacy/alsa_sound/alsa_default.cpp
deleted file mode 100644
index 5be2958..0000000
--- a/legacy/alsa_sound/alsa_default.cpp
+++ /dev/null
@@ -1,1833 +0,0 @@
-/* alsa_default.cpp
- **
- ** Copyright 2009 Wind River Systems
- ** Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
- **
- ** 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 "ALSAModule"
-//#define LOG_NDEBUG 0
-#define LOG_NDDEBUG 0
-#include <utils/Log.h>
-#include <cutils/properties.h>
-#include <linux/ioctl.h>
-#include "AudioUtil.h"
-#include "AudioHardwareALSA.h"
-#include <media/AudioRecord.h>
-#include <dlfcn.h>
-#ifdef QCOM_CSDCLIENT_ENABLED
-extern "C" {
-static int (*csd_disable_device)();
-static int (*csd_enable_device)(int, int, uint32_t);
-static int (*csd_volume)(int);
-static int (*csd_mic_mute)(int);
-static int (*csd_wide_voice)(uint8_t);
-static int (*csd_slow_talk)(uint8_t);
-static int (*csd_fens)(uint8_t);
-static int (*csd_start_voice)();
-static int (*csd_stop_voice)();
-}
-#endif
-
-#ifndef ALSA_DEFAULT_SAMPLE_RATE
-#define ALSA_DEFAULT_SAMPLE_RATE 44100 // in Hz
-#endif
-
-#define BTSCO_RATE_16KHZ 16000
-#define USECASE_TYPE_RX 1
-#define USECASE_TYPE_TX 2
-#define MAX_HDMI_CHANNEL_CNT 6
-
-namespace android_audio_legacy
-{
-
-static int      s_device_open(const hw_module_t*, const char*, hw_device_t**);
-static int      s_device_close(hw_device_t*);
-static status_t s_init(alsa_device_t *, ALSAHandleList &);
-static status_t s_open(alsa_handle_t *);
-static status_t s_close(alsa_handle_t *);
-static status_t s_standby(alsa_handle_t *);
-static status_t s_route(alsa_handle_t *, uint32_t, int);
-static status_t s_start_voice_call(alsa_handle_t *);
-static status_t s_start_voip_call(alsa_handle_t *);
-static status_t s_start_fm(alsa_handle_t *);
-static void     s_set_voice_volume(int);
-static void     s_set_voip_volume(int);
-static void     s_set_mic_mute(int);
-static void     s_set_voip_mic_mute(int);
-static void     s_set_voip_config(int, int);
-static status_t s_set_fm_vol(int);
-static void     s_set_btsco_rate(int);
-static status_t s_set_lpa_vol(int);
-static void     s_enable_wide_voice(bool flag);
-static void     s_enable_fens(bool flag);
-static void     s_set_flags(uint32_t flags);
-static status_t s_set_compressed_vol(int);
-static void     s_enable_slow_talk(bool flag);
-static void     s_set_voc_rec_mode(uint8_t mode);
-static void     s_set_volte_mic_mute(int state);
-static void     s_set_volte_volume(int vol);
-static bool     s_is_tmus();
-#ifdef SEPERATED_AUDIO_INPUT
-static void     s_setInput(int);
-
-static int input_source;
-#endif
-static int mccmnc;
-#ifdef QCOM_CSDCLIENT_ENABLED
-static void     s_set_csd_handle(void*);
-#endif
-
-static char mic_type[25];
-static char curRxUCMDevice[50];
-static char curTxUCMDevice[50];
-static int fluence_mode;
-static int fmVolume;
-#ifdef USES_FLUENCE_INCALL
-static uint32_t mDevSettingsFlag = TTY_OFF | DMIC_FLAG;
-#else
-static uint32_t mDevSettingsFlag = TTY_OFF;
-#endif
-static int btsco_samplerate = 8000;
-static ALSAUseCaseList mUseCaseList;
-static void *csd_handle;
-
-static hw_module_methods_t s_module_methods = {
-    open            : s_device_open
-};
-
-extern "C" {
-hw_module_t HAL_MODULE_INFO_SYM = {
-    tag             : HARDWARE_MODULE_TAG,
-    version_major   : 1,
-    version_minor   : 0,
-    id              : ALSA_HARDWARE_MODULE_ID,
-    name            : "QCOM ALSA module",
-    author          : "QuIC Inc",
-    methods         : &s_module_methods,
-    dso             : 0,
-    reserved        : {0,},
-};
-}
-
-static int s_device_open(const hw_module_t* module, const char* name,
-        hw_device_t** device)
-{
-    char value[128];
-    alsa_device_t *dev;
-    dev = (alsa_device_t *) malloc(sizeof(*dev));
-    if (!dev) return -ENOMEM;
-
-    memset(dev, 0, sizeof(*dev));
-
-    /* initialize the procs */
-    dev->common.tag = HARDWARE_DEVICE_TAG;
-    dev->common.version = 0;
-    dev->common.module = (hw_module_t *) module;
-    dev->common.close = s_device_close;
-    dev->init = s_init;
-    dev->open = s_open;
-    dev->close = s_close;
-    dev->route = s_route;
-    dev->standby = s_standby;
-    dev->startVoiceCall = s_start_voice_call;
-    dev->startVoipCall = s_start_voip_call;
-    dev->startFm = s_start_fm;
-    dev->setVoiceVolume = s_set_voice_volume;
-    dev->setVoipVolume = s_set_voip_volume;
-    dev->setMicMute = s_set_mic_mute;
-    dev->setVoipMicMute = s_set_voip_mic_mute;
-    dev->setVoipConfig = s_set_voip_config;
-    dev->setFmVolume = s_set_fm_vol;
-    dev->setBtscoRate = s_set_btsco_rate;
-    dev->setLpaVolume = s_set_lpa_vol;
-    dev->enableWideVoice = s_enable_wide_voice;
-    dev->enableFENS = s_enable_fens;
-    dev->setFlags = s_set_flags;
-    dev->setCompressedVolume = s_set_compressed_vol;
-    dev->enableSlowTalk = s_enable_slow_talk;
-    dev->setVocRecMode = s_set_voc_rec_mode;
-    dev->setVoLTEMicMute = s_set_volte_mic_mute;
-    dev->setVoLTEVolume = s_set_volte_volume;
-#ifdef SEPERATED_AUDIO_INPUT
-    dev->setInput = s_setInput;
-#endif
-#ifdef QCOM_CSDCLIENT_ENABLED
-    dev->setCsdHandle = s_set_csd_handle;
-#endif
-    *device = &dev->common;
-
-    property_get("persist.audio.handset.mic",value,"0");
-    strlcpy(mic_type, value, sizeof(mic_type));
-    property_get("persist.audio.fluence.mode",value,"0");
-    if (!strcmp("broadside", value)) {
-        fluence_mode = FLUENCE_MODE_BROADSIDE;
-    } else {
-        fluence_mode = FLUENCE_MODE_ENDFIRE;
-    }
-    strlcpy(curRxUCMDevice, "None", sizeof(curRxUCMDevice));
-    strlcpy(curTxUCMDevice, "None", sizeof(curTxUCMDevice));
-    ALOGV("ALSA module opened");
-
-    return 0;
-}
-
-static int s_device_close(hw_device_t* device)
-{
-    free(device);
-    device = NULL;
-    return 0;
-}
-
-// ----------------------------------------------------------------------------
-
-static const int DEFAULT_SAMPLE_RATE = ALSA_DEFAULT_SAMPLE_RATE;
-
-static void switchDevice(alsa_handle_t *handle, uint32_t devices, uint32_t mode);
-static char *getUCMDevice(uint32_t devices, int input, char *rxDevice);
-static void disableDevice(alsa_handle_t *handle);
-int getUseCaseType(const char *useCase);
-
-static int callMode = AudioSystem::MODE_NORMAL;
-// ----------------------------------------------------------------------------
-
-bool platform_is_Fusion3()
-{
-    char platform[128], baseband[128];
-    property_get("ro.board.platform", platform, "");
-    property_get("ro.baseband", baseband, "");
-    if (!strcmp("msm8960", platform) && !strcmp("mdm", baseband))
-        return true;
-    else
-        return false;
-}
-
-int deviceName(alsa_handle_t *handle, unsigned flags, char **value)
-{
-    int ret = 0;
-    char ident[70];
-
-    if (flags & PCM_IN) {
-        strlcpy(ident, "CapturePCM/", sizeof(ident));
-    } else {
-        strlcpy(ident, "PlaybackPCM/", sizeof(ident));
-    }
-    strlcat(ident, handle->useCase, sizeof(ident));
-    ret = snd_use_case_get(handle->ucMgr, ident, (const char **)value);
-    ALOGD("Device value returned is %s", (*value));
-    return ret;
-}
-
-status_t setHDMIChannelCount()
-{
-    status_t err = NO_ERROR;
-    int channel_count = 0;
-    const char *channel_cnt_str = NULL;
-    EDID_AUDIO_INFO info = { 0 };
-
-    ALSAControl control("/dev/snd/controlC0");
-    if (AudioUtil::getHDMIAudioSinkCaps(&info)) {
-        for (int i = 0; i < info.nAudioBlocks && i < MAX_EDID_BLOCKS; i++) {
-            if (info.AudioBlocksArray[i].nChannels > channel_count &&
-                  info.AudioBlocksArray[i].nChannels <= MAX_HDMI_CHANNEL_CNT) {
-                channel_count = info.AudioBlocksArray[i].nChannels;
-            }
-        }
-    }
-
-    switch (channel_count) {
-    case 6: channel_cnt_str = "Six"; break;
-    case 5: channel_cnt_str = "Five"; break;
-    case 4: channel_cnt_str = "Four"; break;
-    case 3: channel_cnt_str = "Three"; break;
-    default: channel_cnt_str = "Two"; break;
-    }
-    ALOGD("HDMI channel count: %s", channel_cnt_str);
-    control.set("HDMI_RX Channels", channel_cnt_str);
-
-    return err;
-}
-
-status_t setHardwareParams(alsa_handle_t *handle)
-{
-    struct snd_pcm_hw_params *params;
-    unsigned long bufferSize, reqBuffSize;
-    unsigned int periodTime, bufferTime;
-    unsigned int requestedRate = handle->sampleRate;
-    int status = 0;
-    int channels = handle->channels;
-    snd_pcm_format_t format = SNDRV_PCM_FORMAT_S16_LE;
-
-    params = (snd_pcm_hw_params*) calloc(1, sizeof(struct snd_pcm_hw_params));
-    if (!params) {
-        ALOGE("Failed to allocate ALSA hardware parameters!");
-        return NO_INIT;
-    }
-
-    reqBuffSize = handle->bufferSize;
-    ALOGD("setHardwareParams: reqBuffSize %d channels %d sampleRate %d",
-         (int) reqBuffSize, handle->channels, handle->sampleRate);
-
-#ifdef QCOM_SSR_ENABLED
-    if (channels == 6) {
-        if (!strncmp(handle->useCase, SND_USE_CASE_VERB_HIFI_REC, strlen(SND_USE_CASE_VERB_HIFI_REC))
-            || !strncmp(handle->useCase, SND_USE_CASE_MOD_CAPTURE_MUSIC, strlen(SND_USE_CASE_MOD_CAPTURE_MUSIC))) {
-            ALOGV("HWParams: Use 4 channels in kernel for 5.1(%s) recording ", handle->useCase);
-            channels = 4;
-        }
-    }
-#endif
-
-    param_init(params);
-    param_set_mask(params, SNDRV_PCM_HW_PARAM_ACCESS,
-                   SNDRV_PCM_ACCESS_RW_INTERLEAVED);
-    if (handle->format != SNDRV_PCM_FORMAT_S16_LE) {
-        if (handle->format == AudioSystem::AMR_NB
-            || handle->format == AudioSystem::AMR_WB
-#ifdef QCOM_QCHAT_ENABLED
-            || handle->format == AudioSystem::EVRC
-            || handle->format == AudioSystem::EVRCB
-            || handle->format == AudioSystem::EVRCWB
-#endif
-            )
-              format = SNDRV_PCM_FORMAT_SPECIAL;
-    }
-    param_set_mask(params, SNDRV_PCM_HW_PARAM_FORMAT,
-                   format);
-    param_set_mask(params, SNDRV_PCM_HW_PARAM_SUBFORMAT,
-                   SNDRV_PCM_SUBFORMAT_STD);
-    param_set_int(params, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, reqBuffSize);
-    param_set_int(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 16);
-    param_set_int(params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
-                   channels * 16);
-    param_set_int(params, SNDRV_PCM_HW_PARAM_CHANNELS,
-                  channels);
-    param_set_int(params, SNDRV_PCM_HW_PARAM_RATE, handle->sampleRate);
-    param_set_hw_refine(handle->handle, params);
-
-    if (param_set_hw_params(handle->handle, params)) {
-        ALOGE("cannot set hw params");
-        return NO_INIT;
-    }
-    param_dump(params);
-
-    handle->handle->buffer_size = pcm_buffer_size(params);
-    handle->handle->period_size = pcm_period_size(params);
-    handle->handle->period_cnt = handle->handle->buffer_size/handle->handle->period_size;
-    ALOGD("setHardwareParams: buffer_size %d, period_size %d, period_cnt %d",
-        handle->handle->buffer_size, handle->handle->period_size,
-        handle->handle->period_cnt);
-    handle->handle->rate = handle->sampleRate;
-    handle->handle->channels = handle->channels;
-    handle->periodSize = handle->handle->period_size;
-    if (strcmp(handle->useCase, SND_USE_CASE_VERB_HIFI_REC) &&
-        strcmp(handle->useCase, SND_USE_CASE_MOD_CAPTURE_MUSIC) &&
-        (6 != handle->channels)) {
-        //Do not update buffersize for 5.1 recording
-        handle->bufferSize = handle->handle->period_size;
-    }
-
-    return NO_ERROR;
-}
-
-status_t setSoftwareParams(alsa_handle_t *handle)
-{
-    struct snd_pcm_sw_params* params;
-    struct pcm* pcm = handle->handle;
-
-    unsigned long periodSize = pcm->period_size;
-    int channels = handle->channels;
-
-    params = (snd_pcm_sw_params*) calloc(1, sizeof(struct snd_pcm_sw_params));
-    if (!params) {
-        LOG_ALWAYS_FATAL("Failed to allocate ALSA software parameters!");
-        return NO_INIT;
-    }
-
-#ifdef QCOM_SSR_ENABLED
-    if (channels == 6) {
-        if (!strncmp(handle->useCase, SND_USE_CASE_VERB_HIFI_REC, strlen(SND_USE_CASE_VERB_HIFI_REC))
-            || !strncmp(handle->useCase, SND_USE_CASE_MOD_CAPTURE_MUSIC, strlen(SND_USE_CASE_MOD_CAPTURE_MUSIC))) {
-            ALOGV("SWParams: Use 4 channels in kernel for 5.1(%s) recording ", handle->useCase);
-            channels = 4;
-        }
-    }
-#endif
-
-    // Get the current software parameters
-    params->tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
-    params->period_step = 1;
-    if(((!strcmp(handle->useCase,SND_USE_CASE_MOD_PLAY_VOIP)) ||
-        (!strcmp(handle->useCase,SND_USE_CASE_VERB_IP_VOICECALL)))){
-          ALOGV("setparam:  start & stop threshold for Voip ");
-          params->avail_min = handle->channels - 1 ? periodSize/4 : periodSize/2;
-          params->start_threshold = periodSize/2;
-          params->stop_threshold = INT_MAX;
-     } else {
-         params->avail_min = periodSize/(channels * 2);
-         params->start_threshold = periodSize/(channels * 2);
-         params->stop_threshold = INT_MAX;
-     }
-    params->silence_threshold = 0;
-    params->silence_size = 0;
-
-    if (param_set_sw_params(handle->handle, params)) {
-        ALOGE("cannot set sw params");
-        return NO_INIT;
-    }
-    return NO_ERROR;
-}
-
-void switchDevice(alsa_handle_t *handle, uint32_t devices, uint32_t mode)
-{
-    const char **mods_list;
-    use_case_t useCaseNode;
-    unsigned usecase_type = 0;
-    bool inCallDevSwitch = false;
-    char *rxDevice, *txDevice, ident[70], *use_case = NULL;
-    int err = 0, index, mods_size;
-    int rx_dev_id, tx_dev_id;
-    ALOGD("%s: device %d mode:%d", __FUNCTION__, devices, mode);
-
-    if ((mode == AudioSystem::MODE_IN_CALL)  || (mode == AudioSystem::MODE_IN_COMMUNICATION)) {
-        if ((devices & AudioSystem::DEVICE_OUT_WIRED_HEADSET) ||
-            (devices & AudioSystem::DEVICE_IN_WIRED_HEADSET)) {
-            devices = devices | (AudioSystem::DEVICE_OUT_WIRED_HEADSET |
-                      AudioSystem::DEVICE_IN_WIRED_HEADSET);
-        } else if (devices & AudioSystem::DEVICE_OUT_WIRED_HEADPHONE) {
-            devices = devices | (AudioSystem::DEVICE_OUT_WIRED_HEADPHONE |
-                      AudioSystem::DEVICE_IN_BUILTIN_MIC);
-        } else if (devices & AudioSystem::DEVICE_IN_BUILTIN_MIC) {
-            if (mode == AudioSystem::MODE_IN_CALL) {
-                devices |= AudioSystem::DEVICE_OUT_EARPIECE;
-            } else if (mode == AudioSystem::MODE_IN_COMMUNICATION) {
-                if (!strncmp(curRxUCMDevice, SND_USE_CASE_DEV_SPEAKER, MAX_LEN(curRxUCMDevice, SND_USE_CASE_DEV_SPEAKER))) {
-                    devices &= ~AudioSystem::DEVICE_IN_BUILTIN_MIC;
-                    devices |= AudioSystem::DEVICE_IN_BACK_MIC;
-                }
-            }
-        } else if (devices & AudioSystem::DEVICE_OUT_EARPIECE) {
-            devices = devices | AudioSystem::DEVICE_IN_BUILTIN_MIC;
-        } else if (devices & AudioSystem::DEVICE_OUT_SPEAKER) {
-            devices = devices | (AudioSystem::DEVICE_IN_BACK_MIC |
-                       AudioSystem::DEVICE_OUT_SPEAKER);
-        } else if ((devices & AudioSystem::DEVICE_OUT_BLUETOOTH_SCO) ||
-                   (devices & AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET) ||
-                   (devices & AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET)) {
-            devices = devices | (AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET |
-                      AudioSystem::DEVICE_OUT_BLUETOOTH_SCO);
-#ifdef QCOM_ANC_HEADSET_ENABLED
-        } else if ((devices & AudioSystem::DEVICE_OUT_ANC_HEADSET) ||
-                   (devices & AudioSystem::DEVICE_IN_ANC_HEADSET)) {
-            devices = devices | (AudioSystem::DEVICE_OUT_ANC_HEADSET |
-                      AudioSystem::DEVICE_IN_ANC_HEADSET);
-        } else if (devices & AudioSystem::DEVICE_OUT_ANC_HEADPHONE) {
-            devices = devices | (AudioSystem::DEVICE_OUT_ANC_HEADPHONE |
-                      AudioSystem::DEVICE_IN_BUILTIN_MIC);
-#endif
-        } else if (devices & AudioSystem::DEVICE_OUT_AUX_DIGITAL) {
-            if (mode == AudioSystem::MODE_IN_CALL)
-                devices = devices | (AudioSystem::DEVICE_IN_BACK_MIC |
-                           AudioSystem::DEVICE_OUT_SPEAKER);
-            else
-                devices = devices | (AudioSystem::DEVICE_OUT_AUX_DIGITAL |
-                          AudioSystem::DEVICE_IN_BACK_MIC);
-#ifdef QCOM_PROXY_DEVICE_ENABLED
-        } else if ((devices & AudioSystem::DEVICE_OUT_PROXY) ||
-                  (devices & AudioSystem::DEVICE_IN_PROXY)) {
-            devices = devices | (AudioSystem::DEVICE_OUT_PROXY |
-                      AudioSystem::DEVICE_IN_PROXY);
-#endif
-        }
-    }
-#ifdef QCOM_SSR_ENABLED
-    if ((devices & AudioSystem::DEVICE_IN_BUILTIN_MIC) && ( 6 == handle->channels)) {
-        if (!strncmp(handle->useCase, SND_USE_CASE_VERB_HIFI_REC, strlen(SND_USE_CASE_VERB_HIFI_REC))
-            || !strncmp(handle->useCase, SND_USE_CASE_MOD_CAPTURE_MUSIC, strlen(SND_USE_CASE_MOD_CAPTURE_MUSIC))) {
-            ALOGV(" switchDevice , use ssr devices for channels:%d usecase:%s",handle->channels,handle->useCase);
-            s_set_flags(SSRQMIC_FLAG);
-        }
-    }
-#endif
-
-    rxDevice = getUCMDevice(devices & AudioSystem::DEVICE_OUT_ALL, 0, NULL);
-    txDevice = getUCMDevice(devices & AudioSystem::DEVICE_IN_ALL, 1, rxDevice);
-
-    if ((rxDevice != NULL) && (txDevice != NULL)) {
-        if (((strncmp(rxDevice, curRxUCMDevice, MAX_STR_LEN)) ||
-            (strncmp(txDevice, curTxUCMDevice, MAX_STR_LEN))) &&
-            ((mode == AudioSystem::MODE_IN_CALL)  ||
-            (mode == AudioSystem::MODE_IN_COMMUNICATION)))
-            inCallDevSwitch = true;
-    }
-
-#ifdef QCOM_CSDCLIENT_ENABLED
-    if (platform_is_Fusion3() && (inCallDevSwitch == true)) {
-        if (csd_disable_device == NULL) {
-            ALOGE("dlsym:Error:%s Loading csd_client_disable_device", dlerror());
-        } else {
-            err = csd_disable_device();
-            if (err < 0)
-            {
-                ALOGE("csd_client_disable_device, failed, error %d", err);
-            }
-        }
-    }
-#endif
-
-    snd_use_case_get(handle->ucMgr, "_verb", (const char **)&use_case);
-    mods_size = snd_use_case_get_list(handle->ucMgr, "_enamods", &mods_list);
-    if (rxDevice != NULL) {
-        if ((strncmp(curRxUCMDevice, "None", 4)) &&
-            ((strncmp(rxDevice, curRxUCMDevice, MAX_STR_LEN)) || (inCallDevSwitch == true))) {
-            if ((use_case != NULL) && (strncmp(use_case, SND_USE_CASE_VERB_INACTIVE,
-                strlen(SND_USE_CASE_VERB_INACTIVE)))) {
-                usecase_type = getUseCaseType(use_case);
-                if (usecase_type & USECASE_TYPE_RX) {
-                    ALOGD("Deroute use case %s type is %d\n", use_case, usecase_type);
-                    strlcpy(useCaseNode.useCase, use_case, MAX_STR_LEN);
-                    snd_use_case_set(handle->ucMgr, "_verb", SND_USE_CASE_VERB_INACTIVE);
-                    mUseCaseList.push_front(useCaseNode);
-                }
-            }
-            if (mods_size) {
-                for(index = 0; index < mods_size; index++) {
-                    usecase_type = getUseCaseType(mods_list[index]);
-                    if (usecase_type & USECASE_TYPE_RX) {
-                        ALOGD("Deroute use case %s type is %d\n", mods_list[index], usecase_type);
-                        strlcpy(useCaseNode.useCase, mods_list[index], MAX_STR_LEN);
-                        snd_use_case_set(handle->ucMgr, "_dismod", mods_list[index]);
-                        mUseCaseList.push_back(useCaseNode);
-                    }
-                }
-            }
-            snd_use_case_set(handle->ucMgr, "_disdev", curRxUCMDevice);
-        }
-    }
-    if (txDevice != NULL) {
-        if ((strncmp(curTxUCMDevice, "None", 4)) &&
-            ((strncmp(txDevice, curTxUCMDevice, MAX_STR_LEN)) || (inCallDevSwitch == true))) {
-            if ((use_case != NULL) && (strncmp(use_case, SND_USE_CASE_VERB_INACTIVE,
-                strlen(SND_USE_CASE_VERB_INACTIVE)))) {
-                usecase_type = getUseCaseType(use_case);
-                if ((usecase_type & USECASE_TYPE_TX) && (!(usecase_type & USECASE_TYPE_RX))) {
-                    ALOGD("Deroute use case %s type is %d\n", use_case, usecase_type);
-                    strlcpy(useCaseNode.useCase, use_case, MAX_STR_LEN);
-                    snd_use_case_set(handle->ucMgr, "_verb", SND_USE_CASE_VERB_INACTIVE);
-                    mUseCaseList.push_front(useCaseNode);
-                }
-            }
-            if (mods_size) {
-                for(index = 0; index < mods_size; index++) {
-                    usecase_type = getUseCaseType(mods_list[index]);
-                    if ((usecase_type & USECASE_TYPE_TX) && (!(usecase_type & USECASE_TYPE_RX))) {
-                        ALOGD("Deroute use case %s type is %d\n", mods_list[index], usecase_type);
-                        strlcpy(useCaseNode.useCase, mods_list[index], MAX_STR_LEN);
-                        snd_use_case_set(handle->ucMgr, "_dismod", mods_list[index]);
-                        mUseCaseList.push_back(useCaseNode);
-                    }
-                }
-            }
-            snd_use_case_set(handle->ucMgr, "_disdev", curTxUCMDevice);
-       }
-    }
-    ALOGD("%s,rxDev:%s, txDev:%s, curRxDev:%s, curTxDev:%s\n", __FUNCTION__, rxDevice, txDevice, curRxUCMDevice, curTxUCMDevice);
-
-    if (rxDevice != NULL) {
-        snd_use_case_set(handle->ucMgr, "_enadev", rxDevice);
-        strlcpy(curRxUCMDevice, rxDevice, sizeof(curRxUCMDevice));
-#ifdef QCOM_FM_ENABLED
-        if (devices & AudioSystem::DEVICE_OUT_FM)
-            s_set_fm_vol(fmVolume);
-#endif
-    }
-    if (txDevice != NULL) {
-       snd_use_case_set(handle->ucMgr, "_enadev", txDevice);
-       strlcpy(curTxUCMDevice, txDevice, sizeof(curTxUCMDevice));
-    }
-    for(ALSAUseCaseList::iterator it = mUseCaseList.begin(); it != mUseCaseList.end(); ++it) {
-        ALOGD("Route use case %s\n", it->useCase);
-        if ((use_case != NULL) && (strncmp(use_case, SND_USE_CASE_VERB_INACTIVE,
-            strlen(SND_USE_CASE_VERB_INACTIVE))) && (!strncmp(use_case, it->useCase, MAX_UC_LEN))) {
-            snd_use_case_set(handle->ucMgr, "_verb", it->useCase);
-        } else {
-            snd_use_case_set(handle->ucMgr, "_enamod", it->useCase);
-        }
-    }
-    if (!mUseCaseList.empty())
-        mUseCaseList.clear();
-    if (use_case != NULL) {
-        free(use_case);
-        use_case = NULL;
-    }
-    ALOGD("switchDevice: curTxUCMDevivce %s curRxDevDevice %s", curTxUCMDevice, curRxUCMDevice);
-
-    if (platform_is_Fusion3() && (inCallDevSwitch == true)) {
-        /* get tx acdb id */
-        memset(&ident,0,sizeof(ident));
-        strlcpy(ident, "ACDBID/", sizeof(ident));
-        strlcat(ident, curTxUCMDevice, sizeof(ident));
-        tx_dev_id = snd_use_case_get(handle->ucMgr, ident, NULL);
-
-       /* get rx acdb id */
-        memset(&ident,0,sizeof(ident));
-        strlcpy(ident, "ACDBID/", sizeof(ident));
-        strlcat(ident, curRxUCMDevice, sizeof(ident));
-        rx_dev_id = snd_use_case_get(handle->ucMgr, ident, NULL);
-
-        if (((rx_dev_id == DEVICE_SPEAKER_MONO_RX_ACDB_ID ) || (rx_dev_id == DEVICE_SPEAKER_STEREO_RX_ACDB_ID ))
-         && tx_dev_id == DEVICE_HANDSET_TX_ACDB_ID) {
-            tx_dev_id = DEVICE_SPEAKER_TX_ACDB_ID;
-        }
-
-#ifdef QCOM_CSDCLIENT_ENABLED
-        ALOGV("rx_dev_id=%d, tx_dev_id=%d\n", rx_dev_id, tx_dev_id);
-        if (csd_enable_device == NULL) {
-            ALOGE("dlsym:Error:%s Loading csd_client_enable_device", dlerror());
-        } else {
-            err = csd_enable_device(rx_dev_id, tx_dev_id, mDevSettingsFlag);
-            if (err < 0)
-            {
-                ALOGE("csd_client_disable_device failed, error %d", err);
-            }
-        }
-#endif
-    }
-
-    if (rxDevice != NULL) {
-        free(rxDevice);
-        rxDevice = NULL;
-    }
-    if (txDevice != NULL) {
-        free(txDevice);
-        txDevice = NULL;
-    }
-}
-
-// ----------------------------------------------------------------------------
-
-static status_t s_init(alsa_device_t *module, ALSAHandleList &list)
-{
-    ALOGV("s_init: Initializing devices for ALSA module");
-
-    list.clear();
-
-    return NO_ERROR;
-}
-
-static status_t s_open(alsa_handle_t *handle)
-{
-    char *devName;
-    unsigned flags = 0;
-    int err = NO_ERROR;
-
-    if(handle->devices & AudioSystem::DEVICE_OUT_AUX_DIGITAL) {
-        err = setHDMIChannelCount();
-        if(err != OK) {
-            ALOGE("setHDMIChannelCount err = %d", err);
-            return err;
-        }
-    }
-    /* No need to call s_close for LPA as pcm device open and close is handled by LPAPlayer in stagefright */
-    if((!strcmp(handle->useCase, SND_USE_CASE_VERB_HIFI_LOW_POWER)) || (!strcmp(handle->useCase, SND_USE_CASE_MOD_PLAY_LPA))
-    ||(!strcmp(handle->useCase, SND_USE_CASE_VERB_HIFI_TUNNEL)) || (!strcmp(handle->useCase, SND_USE_CASE_MOD_PLAY_TUNNEL))) {
-        ALOGV("s_open: Opening LPA /Tunnel playback");
-        return NO_ERROR;
-    }
-
-    s_close(handle);
-
-    ALOGV("s_open: handle %p", handle);
-
-    // ASoC multicomponent requires a valid path (frontend/backend) for
-    // the device to be opened
-
-    // The PCM stream is opened in blocking mode, per ALSA defaults.  The
-    // AudioFlinger seems to assume blocking mode too, so asynchronous mode
-    // should not be used.
-    if ((!strcmp(handle->useCase, SND_USE_CASE_VERB_HIFI_LOW_POWER)) ||
-        (!strcmp(handle->useCase, SND_USE_CASE_MOD_PLAY_LPA)) ||
-        (!strcmp(handle->useCase, SND_USE_CASE_VERB_HIFI_TUNNEL)) ||
-        (!strcmp(handle->useCase, SND_USE_CASE_MOD_PLAY_TUNNEL))) {
-        ALOGV("LPA/tunnel use case");
-        flags |= PCM_MMAP;
-        flags |= DEBUG_ON;
-    } else if ((!strcmp(handle->useCase, SND_USE_CASE_VERB_HIFI)) ||
-        (!strcmp(handle->useCase, SND_USE_CASE_VERB_HIFI2)) ||
-        (!strcmp(handle->useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC)) ||
-        (!strcmp(handle->useCase, SND_USE_CASE_MOD_PLAY_LOWLATENCY_MUSIC)) ||
-        (!strcmp(handle->useCase, SND_USE_CASE_MOD_PLAY_MUSIC2)) ||
-        (!strcmp(handle->useCase, SND_USE_CASE_MOD_PLAY_MUSIC))) {
-        ALOGV("Music case");
-        flags = PCM_OUT;
-    } else {
-        flags = PCM_IN;
-    }
-    if (handle->channels == 1) {
-        flags |= PCM_MONO;
-    }
-    else if (handle->channels == 4 ) {
-        flags |= PCM_QUAD;
-    } else if (handle->channels == 6 ) {
-#ifdef QCOM_SSR_ENABLED
-        if (!strncmp(handle->useCase, SND_USE_CASE_VERB_HIFI_REC, strlen(SND_USE_CASE_VERB_HIFI_REC))
-            || !strncmp(handle->useCase, SND_USE_CASE_MOD_CAPTURE_MUSIC, strlen(SND_USE_CASE_MOD_CAPTURE_MUSIC))) {
-            flags |= PCM_QUAD;
-        } else {
-            flags |= PCM_5POINT1;
-        }
-#else
-        flags |= PCM_5POINT1;
-#endif
-    }
-    else {
-        flags |= PCM_STEREO;
-    }
-    if (deviceName(handle, flags, &devName) < 0) {
-        ALOGE("Failed to get pcm device node: %s", devName);
-        return NO_INIT;
-    }
-    if (devName != NULL) {
-        handle->handle = pcm_open(flags, (char*)devName);
-    } else {
-        ALOGE("Failed to get pcm device node");
-        return NO_INIT;
-    }
-
-    if (!handle->handle) {
-        ALOGE("s_open: Failed to initialize ALSA device '%s'", devName);
-        free(devName);
-        return NO_INIT;
-    }
-
-    handle->handle->flags = flags;
-    err = setHardwareParams(handle);
-
-    if (err == NO_ERROR) {
-        err = setSoftwareParams(handle);
-    }
-
-    if(err != NO_ERROR) {
-        ALOGE("Set HW/SW params failed: Closing the pcm stream");
-        s_standby(handle);
-    }
-
-    free(devName);
-    return NO_ERROR;
-}
-
-static status_t s_start_voip_call(alsa_handle_t *handle)
-{
-
-    char* devName;
-    char* devName1;
-    unsigned flags = 0;
-    int err = NO_ERROR;
-    uint8_t voc_pkt[VOIP_BUFFER_MAX_SIZE];
-
-    s_close(handle);
-    flags = PCM_OUT;
-    flags |= PCM_MONO;
-    ALOGV("s_open:s_start_voip_call  handle %p", handle);
-
-    if (deviceName(handle, flags, &devName) < 0) {
-         ALOGE("Failed to get pcm device node");
-         return NO_INIT;
-    }
-
-    if (devName != NULL) {
-        handle->handle = pcm_open(flags, (char*)devName);
-    } else {
-         ALOGE("Failed to get pcm device node");
-         return NO_INIT;
-    }
-
-     if (!handle->handle) {
-          free(devName);
-          ALOGE("s_open: Failed to initialize ALSA device '%s'", devName);
-          return NO_INIT;
-     }
-
-     if (!pcm_ready(handle->handle)) {
-         ALOGE(" pcm ready failed");
-     }
-
-     handle->handle->flags = flags;
-     err = setHardwareParams(handle);
-
-     if (err == NO_ERROR) {
-         err = setSoftwareParams(handle);
-     }
-
-     err = pcm_prepare(handle->handle);
-     if(err != NO_ERROR) {
-         ALOGE("DEVICE_OUT_DIRECTOUTPUT: pcm_prepare failed");
-     }
-
-     /* first write required start dsp */
-     memset(&voc_pkt,0,sizeof(voc_pkt));
-     pcm_write(handle->handle,&voc_pkt,handle->handle->period_size);
-     handle->rxHandle = handle->handle;
-     free(devName);
-     ALOGV("s_open: DEVICE_IN_COMMUNICATION ");
-     flags = PCM_IN;
-     flags |= PCM_MONO;
-     handle->handle = 0;
-
-     if (deviceName(handle, flags, &devName1) < 0) {
-        ALOGE("Failed to get pcm device node");
-        return NO_INIT;
-     }
-    if (devName != NULL) {
-        handle->handle = pcm_open(flags, (char*)devName1);
-    } else {
-         ALOGE("Failed to get pcm device node");
-         return NO_INIT;
-    }
-
-     if (!handle->handle) {
-         free(devName);
-         ALOGE("s_open: Failed to initialize ALSA device '%s'", devName);
-         return NO_INIT;
-     }
-
-     if (!pcm_ready(handle->handle)) {
-        ALOGE(" pcm ready in failed");
-     }
-
-     handle->handle->flags = flags;
-
-     err = setHardwareParams(handle);
-
-     if (err == NO_ERROR) {
-         err = setSoftwareParams(handle);
-     }
-
-
-     err = pcm_prepare(handle->handle);
-     if(err != NO_ERROR) {
-         ALOGE("DEVICE_IN_COMMUNICATION: pcm_prepare failed");
-     }
-
-     /* first read required start dsp */
-     memset(&voc_pkt,0,sizeof(voc_pkt));
-     pcm_read(handle->handle,&voc_pkt,handle->handle->period_size);
-     return NO_ERROR;
-}
-
-static status_t s_start_voice_call(alsa_handle_t *handle)
-{
-    char* devName;
-    unsigned flags = 0;
-    int err = NO_ERROR;
-
-    ALOGV("s_start_voice_call: handle %p", handle);
-
-    // ASoC multicomponent requires a valid path (frontend/backend) for
-    // the device to be opened
-
-    flags = PCM_OUT | PCM_MONO;
-    if (deviceName(handle, flags, &devName) < 0) {
-        ALOGE("Failed to get pcm device node");
-        return NO_INIT;
-    }
-    if (devName != NULL) {
-        handle->handle = pcm_open(flags, (char*)devName);
-    } else {
-         ALOGE("Failed to get pcm device node");
-         return NO_INIT;
-    }
-    if (!handle->handle) {
-        ALOGE("s_start_voicecall: could not open PCM device");
-        goto Error;
-    }
-
-    handle->handle->flags = flags;
-    err = setHardwareParams(handle);
-    if(err != NO_ERROR) {
-        ALOGE("s_start_voice_call: setHardwareParams failed");
-        goto Error;
-    }
-
-    err = setSoftwareParams(handle);
-    if(err != NO_ERROR) {
-        ALOGE("s_start_voice_call: setSoftwareParams failed");
-        goto Error;
-    }
-
-    err = pcm_prepare(handle->handle);
-    if(err != NO_ERROR) {
-        ALOGE("s_start_voice_call: pcm_prepare failed");
-        goto Error;
-    }
-
-    if (ioctl(handle->handle->fd, SNDRV_PCM_IOCTL_START)) {
-        ALOGE("s_start_voice_call:SNDRV_PCM_IOCTL_START failed\n");
-        goto Error;
-    }
-
-    // Store the PCM playback device pointer in rxHandle
-    handle->rxHandle = handle->handle;
-    free(devName);
-
-    // Open PCM capture device
-    flags = PCM_IN | PCM_MONO;
-    if (deviceName(handle, flags, &devName) < 0) {
-        ALOGE("Failed to get pcm device node");
-        goto Error;
-    }
-    if (devName != NULL) {
-        handle->handle = pcm_open(flags, (char*)devName);
-    } else {
-         ALOGE("Failed to get pcm device node");
-         return NO_INIT;
-    }
-    if (!handle->handle) {
-        free(devName);
-        goto Error;
-    }
-
-    handle->handle->flags = flags;
-    err = setHardwareParams(handle);
-    if(err != NO_ERROR) {
-        ALOGE("s_start_voice_call: setHardwareParams failed");
-        goto Error;
-    }
-
-    err = setSoftwareParams(handle);
-    if(err != NO_ERROR) {
-        ALOGE("s_start_voice_call: setSoftwareParams failed");
-        goto Error;
-    }
-
-    err = pcm_prepare(handle->handle);
-    if(err != NO_ERROR) {
-        ALOGE("s_start_voice_call: pcm_prepare failed");
-        goto Error;
-    }
-
-    if (ioctl(handle->handle->fd, SNDRV_PCM_IOCTL_START)) {
-        ALOGE("s_start_voice_call:SNDRV_PCM_IOCTL_START failed\n");
-        goto Error;
-    }
-
-    if (platform_is_Fusion3()) {
-#ifdef QCOM_CSDCLIENT_ENABLED
-        if (csd_start_voice == NULL) {
-            ALOGE("dlsym:Error:%s Loading csd_client_start_voice", dlerror());
-        } else {
-            err = csd_start_voice();
-            if (err < 0){
-                ALOGE("s_start_voice_call: csd_client error %d\n", err);
-                goto Error;
-            }
-        }
-#endif
-    }
-
-    free(devName);
-    return NO_ERROR;
-
-Error:
-    ALOGE("s_start_voice_call: Failed to initialize ALSA device '%s'", devName);
-    free(devName);
-    s_close(handle);
-    return NO_INIT;
-}
-
-static status_t s_start_fm(alsa_handle_t *handle)
-{
-    char *devName;
-    unsigned flags = 0;
-    int err = NO_ERROR;
-
-    ALOGV("s_start_fm: handle %p", handle);
-
-    // ASoC multicomponent requires a valid path (frontend/backend) for
-    // the device to be opened
-
-    flags = PCM_OUT | PCM_STEREO;
-    if (deviceName(handle, flags, &devName) < 0) {
-        ALOGE("Failed to get pcm device node");
-        goto Error;
-    }
-    if (devName != NULL) {
-        handle->handle = pcm_open(flags, (char*)devName);
-    } else {
-         ALOGE("Failed to get pcm device node");
-         return NO_INIT;
-    }
-    if (!handle->handle) {
-        ALOGE("s_start_fm: could not open PCM device");
-        goto Error;
-    }
-
-    handle->handle->flags = flags;
-    err = setHardwareParams(handle);
-    if(err != NO_ERROR) {
-        ALOGE("s_start_fm: setHardwareParams failed");
-        goto Error;
-    }
-
-    err = setSoftwareParams(handle);
-    if(err != NO_ERROR) {
-        ALOGE("s_start_fm: setSoftwareParams failed");
-        goto Error;
-    }
-
-    err = pcm_prepare(handle->handle);
-    if(err != NO_ERROR) {
-        ALOGE("s_start_fm: setSoftwareParams failed");
-        goto Error;
-    }
-
-    if (ioctl(handle->handle->fd, SNDRV_PCM_IOCTL_START)) {
-        ALOGE("s_start_fm: SNDRV_PCM_IOCTL_START failed\n");
-        goto Error;
-    }
-
-    // Store the PCM playback device pointer in rxHandle
-    handle->rxHandle = handle->handle;
-    free(devName);
-
-    // Open PCM capture device
-    flags = PCM_IN | PCM_STEREO;
-    if (deviceName(handle, flags, &devName) < 0) {
-        ALOGE("Failed to get pcm device node");
-        goto Error;
-    }
-    if (devName != NULL) {
-        handle->handle = pcm_open(flags, (char*)devName);
-    } else {
-         ALOGE("Failed to get pcm device node");
-         return NO_INIT;
-    }
-    if (!handle->handle) {
-        goto Error;
-    }
-
-    handle->handle->flags = flags;
-    err = setHardwareParams(handle);
-    if(err != NO_ERROR) {
-        ALOGE("s_start_fm: setHardwareParams failed");
-        goto Error;
-    }
-
-    err = setSoftwareParams(handle);
-    if(err != NO_ERROR) {
-        ALOGE("s_start_fm: setSoftwareParams failed");
-        goto Error;
-    }
-
-    err = pcm_prepare(handle->handle);
-    if(err != NO_ERROR) {
-        ALOGE("s_start_fm: pcm_prepare failed");
-        goto Error;
-    }
-
-    if (ioctl(handle->handle->fd, SNDRV_PCM_IOCTL_START)) {
-        ALOGE("s_start_fm: SNDRV_PCM_IOCTL_START failed\n");
-        goto Error;
-    }
-
-    s_set_fm_vol(fmVolume);
-    free(devName);
-    return NO_ERROR;
-
-Error:
-    free(devName);
-    s_close(handle);
-    return NO_INIT;
-}
-
-static status_t s_set_fm_vol(int value)
-{
-    status_t err = NO_ERROR;
-
-    ALSAControl control("/dev/snd/controlC0");
-    control.set("Internal FM RX Volume",value,0);
-    fmVolume = value;
-
-    return err;
-}
-
-static status_t s_set_lpa_vol(int value)
-{
-    status_t err = NO_ERROR;
-
-    ALSAControl control("/dev/snd/controlC0");
-    control.set("LPA RX Volume",value,0);
-
-    return err;
-}
-
-static status_t s_start(alsa_handle_t *handle)
-{
-    status_t err = NO_ERROR;
-
-    if(!handle->handle) {
-        ALOGE("No active PCM driver to start");
-        return err;
-    }
-
-    err = pcm_prepare(handle->handle);
-
-    return err;
-}
-
-static status_t s_close(alsa_handle_t *handle)
-{
-    int ret;
-    status_t err = NO_ERROR;
-     struct pcm *h = handle->rxHandle;
-
-    handle->rxHandle = 0;
-    ALOGV("s_close: handle %p h %p", handle, h);
-    if (h) {
-        if ((!strcmp(handle->useCase, SND_USE_CASE_VERB_VOICECALL) ||
-             !strcmp(handle->useCase, SND_USE_CASE_MOD_PLAY_VOICE)) &&
-            platform_is_Fusion3()) {
-#ifdef QCOM_CSDCLIENT_ENABLED
-            if (csd_stop_voice == NULL) {
-                ALOGE("dlsym:Error:%s Loading csd_client_disable_device", dlerror());
-            } else {
-                err = csd_stop_voice();
-                if (err < 0) {
-                    ALOGE("s_close: csd_client error %d\n", err);
-                }
-            }
-#endif
-        }
-
-        ALOGV("s_close rxHandle\n");
-        err = pcm_close(h);
-        if(err != NO_ERROR) {
-            ALOGE("s_close: pcm_close failed for rxHandle with err %d", err);
-        }
-    }
-
-    h = handle->handle;
-    handle->handle = 0;
-
-    if (h) {
-        ALOGV("s_close handle h %p\n", h);
-        err = pcm_close(h);
-        if(err != NO_ERROR) {
-            ALOGE("s_close: pcm_close failed for handle with err %d", err);
-        }
-
-        disableDevice(handle);
-    } else if((!strcmp(handle->useCase, SND_USE_CASE_VERB_HIFI_LOW_POWER)) ||
-              (!strcmp(handle->useCase, SND_USE_CASE_MOD_PLAY_LPA)) ||
-              (!strcmp(handle->useCase, SND_USE_CASE_VERB_HIFI_TUNNEL)) ||
-              (!strcmp(handle->useCase, SND_USE_CASE_MOD_PLAY_TUNNEL))){
-        disableDevice(handle);
-    }
-
-    return err;
-}
-
-/*
-    this is same as s_close, but don't discard
-    the device/mode info. This way we can still
-    close the device, hit idle and power-save, reopen the pcm
-    for the same device/mode after resuming
-*/
-static status_t s_standby(alsa_handle_t *handle)
-{
-    int ret;
-    status_t err = NO_ERROR;
-    struct pcm *h = handle->rxHandle;
-    handle->rxHandle = 0;
-    ALOGV("s_standby: handle %p h %p", handle, h);
-    if (h) {
-        ALOGD("s_standby  rxHandle\n");
-        err = pcm_close(h);
-        if(err != NO_ERROR) {
-            ALOGE("s_standby: pcm_close failed for rxHandle with err %d", err);
-        }
-    }
-
-    h = handle->handle;
-    handle->handle = 0;
-
-    if (h) {
-          ALOGV("s_standby handle h %p\n", h);
-        err = pcm_close(h);
-        if(err != NO_ERROR) {
-            ALOGE("s_standby: pcm_close failed for handle with err %d", err);
-        }
-        disableDevice(handle);
-    } else if((!strcmp(handle->useCase, SND_USE_CASE_VERB_HIFI_LOW_POWER)) ||
-              (!strcmp(handle->useCase, SND_USE_CASE_MOD_PLAY_LPA)) ||
-              (!strcmp(handle->useCase, SND_USE_CASE_VERB_HIFI_TUNNEL)) ||
-              (!strcmp(handle->useCase, SND_USE_CASE_MOD_PLAY_TUNNEL))) {
-        disableDevice(handle);
-    }
-
-    return err;
-}
-
-static status_t s_route(alsa_handle_t *handle, uint32_t devices, int mode)
-{
-    status_t status = NO_ERROR;
-
-    ALOGD("s_route: devices 0x%x in mode %d", devices, mode);
-    callMode = mode;
-    switchDevice(handle, devices, mode);
-    return status;
-}
-
-int getUseCaseType(const char *useCase)
-{
-    ALOGD("use case is %s\n", useCase);
-    if (!strncmp(useCase, SND_USE_CASE_VERB_HIFI,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_HIFI2,
-            MAX_LEN(useCase, SND_USE_CASE_VERB_HIFI2)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_HIFI_LOW_POWER,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_LOW_POWER)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_HIFI_TUNNEL,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_TUNNEL)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_HIFI2,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI2)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_DIGITAL_RADIO,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_DIGITAL_RADIO)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_MUSIC,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_MUSIC)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_MUSIC2,
-            MAX_LEN(useCase, SND_USE_CASE_MOD_PLAY_MUSIC2)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_LOWLATENCY_MUSIC,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_LOWLATENCY_MUSIC)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_MUSIC2,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_MUSIC2)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_LPA,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_LPA)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_TUNNEL,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_TUNNEL)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_FM,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_FM))) {
-        return USECASE_TYPE_RX;
-    } else if (!strncmp(useCase, SND_USE_CASE_VERB_HIFI_REC,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_REC)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_REC,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_LOWLATENCY_REC)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_FM_REC,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_FM_REC)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_FM_A2DP_REC,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_FM_A2DP_REC)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_MUSIC,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_MUSIC)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_LOWLATENCY_MUSIC,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_LOWLATENCY_MUSIC)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_FM,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_FM)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_A2DP_FM,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_A2DP_FM))) {
-        return USECASE_TYPE_TX;
-    } else if (!strncmp(useCase, SND_USE_CASE_VERB_VOICECALL,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_VOICECALL)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_IP_VOICECALL,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_IP_VOICECALL)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_DL_REC,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_DL_REC)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_UL_DL_REC,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_UL_DL_REC)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_INCALL_REC,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_INCALL_REC)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_VOICE,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_VOICE)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_VOIP,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_VOIP)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_VOICE_DL,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_VOICE_DL)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_VOICE_UL_DL,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_VOICE_UL_DL)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_VOICE,
-            MAX_LEN(useCase, SND_USE_CASE_MOD_CAPTURE_VOICE)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_VOLTE,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_VOLTE)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_VOLTE,
-            MAX_LEN(useCase, SND_USE_CASE_MOD_PLAY_VOLTE))) {
-        return (USECASE_TYPE_RX | USECASE_TYPE_TX);
-    } else {
-        ALOGE("unknown use case %s\n", useCase);
-        return 0;
-    }
-}
-
-static void disableDevice(alsa_handle_t *handle)
-{
-    unsigned usecase_type = 0;
-    int i, mods_size;
-    char *useCase;
-    const char **mods_list;
-
-    snd_use_case_get(handle->ucMgr, "_verb", (const char **)&useCase);
-    if (useCase != NULL) {
-        if (!strncmp(useCase, handle->useCase, MAX_UC_LEN)) {
-            snd_use_case_set(handle->ucMgr, "_verb", SND_USE_CASE_VERB_INACTIVE);
-        } else {
-            snd_use_case_set(handle->ucMgr, "_dismod", handle->useCase);
-        }
-        free(useCase);
-        snd_use_case_get(handle->ucMgr, "_verb", (const char **)&useCase);
-        if (strncmp(useCase, SND_USE_CASE_VERB_INACTIVE,
-               strlen(SND_USE_CASE_VERB_INACTIVE)))
-            usecase_type |= getUseCaseType(useCase);
-        mods_size = snd_use_case_get_list(handle->ucMgr, "_enamods", &mods_list);
-        ALOGV("Number of modifiers %d\n", mods_size);
-        if (mods_size) {
-            for(i = 0; i < mods_size; i++) {
-                ALOGV("index %d modifier %s\n", i, mods_list[i]);
-                usecase_type |= getUseCaseType(mods_list[i]);
-            }
-        }
-        ALOGV("usecase_type is %d\n", usecase_type);
-        if (!(usecase_type & USECASE_TYPE_TX) && (strncmp(curTxUCMDevice, "None", 4)))
-            snd_use_case_set(handle->ucMgr, "_disdev", curTxUCMDevice);
-        if (!(usecase_type & USECASE_TYPE_RX) && (strncmp(curRxUCMDevice, "None", 4)))
-            snd_use_case_set(handle->ucMgr, "_disdev", curRxUCMDevice);
-    } else {
-        ALOGE("Invalid state, no valid use case found to disable");
-    }
-    free(useCase);
-}
-
-char *getUCMDevice(uint32_t devices, int input, char *rxDevice)
-{
-    bool is_tmus = s_is_tmus();
-
-    if (!input) {
-        if (!(mDevSettingsFlag & TTY_OFF) &&
-            (callMode == AudioSystem::MODE_IN_CALL) &&
-            ((devices & AudioSystem::DEVICE_OUT_WIRED_HEADSET) ||
-             (devices & AudioSystem::DEVICE_OUT_WIRED_HEADPHONE))) {
-#ifdef QCOM_ANC_HEADSET_ENABLED
-             ||
-             (devices & AudioSystem::DEVICE_OUT_ANC_HEADSET) ||
-             (devices & AudioSystem::DEVICE_OUT_ANC_HEADPHONE))) {
-#endif
-             if (mDevSettingsFlag & TTY_VCO) {
-                 return strdup(SND_USE_CASE_DEV_TTY_HEADSET_RX);
-             } else if (mDevSettingsFlag & TTY_FULL) {
-                 return strdup(SND_USE_CASE_DEV_TTY_FULL_RX);
-             } else if (mDevSettingsFlag & TTY_HCO) {
-                 return strdup(SND_USE_CASE_DEV_TTY_HANDSET_RX); /* HANDSET RX */
-             }
-        }else if ((devices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET) ||
-                  (devices & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)) {
-             return strdup(SND_USE_CASE_DEV_PROXY_RX); /* PROXY RX */
-        } else if ((devices & AudioSystem::DEVICE_OUT_SPEAKER) &&
-            ((devices & AudioSystem::DEVICE_OUT_WIRED_HEADSET) ||
-            (devices & AudioSystem::DEVICE_OUT_WIRED_HEADPHONE))) {
-            if (mDevSettingsFlag & ANC_FLAG) {
-                return strdup(SND_USE_CASE_DEV_SPEAKER_ANC_HEADSET); /* COMBO SPEAKER+ANC HEADSET RX */
-            } else {
-                return strdup(SND_USE_CASE_DEV_SPEAKER_HEADSET); /* COMBO SPEAKER+HEADSET RX */
-            }
-        } else if ((devices & AudioSystem::DEVICE_OUT_SPEAKER) &&
-            ((devices & AudioSystem::DEVICE_OUT_AUX_DIGITAL))) {
-            return strdup(SND_USE_CASE_DEV_HDMI_SPEAKER);
-#ifdef QCOM_ANC_HEADSET_ENABLED
-        } else if ((devices & AudioSystem::DEVICE_OUT_SPEAKER) &&
-            ((devices & AudioSystem::DEVICE_OUT_ANC_HEADSET) ||
-            (devices & AudioSystem::DEVICE_OUT_ANC_HEADPHONE))) {
-            return strdup(SND_USE_CASE_DEV_SPEAKER_ANC_HEADSET); /* COMBO SPEAKER+ANC HEADSET RX */
-        } else if ((devices & AudioSystem::DEVICE_OUT_SPEAKER) &&
-                 (devices & AudioSystem::DEVICE_OUT_FM_TX)) {
-            return strdup(SND_USE_CASE_DEV_SPEAKER_FM_TX); /* COMBO SPEAKER+FM_TX RX */
-#endif
-        } else if (devices & AudioSystem::DEVICE_OUT_EARPIECE) {
-            if (callMode == AudioSystem::MODE_IN_CALL) {
-                if(is_tmus)
-                    return strdup(SND_USE_CASE_DEV_VOC_EARPIECE_TMUS); /* Voice HANDSET RX for TMUS */
-                else
-                    return strdup(SND_USE_CASE_DEV_VOC_EARPIECE); /* Voice HANDSET RX */
-            } else
-                return strdup(SND_USE_CASE_DEV_EARPIECE); /* HANDSET RX */
-        } else if (devices & AudioSystem::DEVICE_OUT_SPEAKER) {
-            if (callMode == AudioSystem::MODE_IN_CALL) {
-                return strdup(SND_USE_CASE_DEV_VOC_SPEAKER); /* Voice SPEAKER RX */
-            } else
-                return strdup(SND_USE_CASE_DEV_SPEAKER); /* SPEAKER RX */
-        } else if ((devices & AudioSystem::DEVICE_OUT_WIRED_HEADSET) ||
-                   (devices & AudioSystem::DEVICE_OUT_WIRED_HEADPHONE)) {
-            if (mDevSettingsFlag & ANC_FLAG) {
-                if (callMode == AudioSystem::MODE_IN_CALL) {
-                    return strdup(SND_USE_CASE_DEV_VOC_ANC_HEADSET); /* Voice ANC HEADSET RX */
-                } else
-                    return strdup(SND_USE_CASE_DEV_ANC_HEADSET); /* ANC HEADSET RX */
-            } else {
-                if (callMode == AudioSystem::MODE_IN_CALL) {
-                    return strdup(SND_USE_CASE_DEV_VOC_HEADPHONE); /* Voice HEADSET RX */
-                } else
-                    return strdup(SND_USE_CASE_DEV_HEADPHONES); /* HEADSET RX */
-            }
-#ifdef QCOM_ANC_HEADSET_ENABLED
-        } else if ((devices & AudioSystem::DEVICE_OUT_ANC_HEADSET) ||
-                   (devices & AudioSystem::DEVICE_OUT_ANC_HEADPHONE)) {
-            if (callMode == AudioSystem::MODE_IN_CALL) {
-                return strdup(SND_USE_CASE_DEV_VOC_ANC_HEADSET); /* Voice ANC HEADSET RX */
-            } else
-                return strdup(SND_USE_CASE_DEV_ANC_HEADSET); /* ANC HEADSET RX */
-#endif
-        } else if ((devices & AudioSystem::DEVICE_OUT_BLUETOOTH_SCO) ||
-                  (devices & AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET) ||
-                  (devices & AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT)) {
-            if (btsco_samplerate == BTSCO_RATE_16KHZ)
-                return strdup(SND_USE_CASE_DEV_BTSCO_WB_RX); /* BTSCO RX*/
-            else
-                return strdup(SND_USE_CASE_DEV_BTSCO_NB_RX); /* BTSCO RX*/
-        } else if ((devices & AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP) ||
-                   (devices & AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES) ||
-#ifdef QCOM_VOIP_ENABLED
-                   (devices & AudioSystem::DEVICE_OUT_DIRECTOUTPUT) ||
-#endif
-                   (devices & AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER)) {
-            /* Nothing to be done, use current active device */
-            if (strncmp(curRxUCMDevice, "None", 4)) {
-                return strdup(curRxUCMDevice);
-            }
-        } else if (devices & AudioSystem::DEVICE_OUT_AUX_DIGITAL) {
-            return strdup(SND_USE_CASE_DEV_HDMI); /* HDMI RX */
-#ifdef QCOM_PROXY_DEVICE_ENABLED
-        } else if (devices & AudioSystem::DEVICE_OUT_PROXY) {
-            return strdup(SND_USE_CASE_DEV_PROXY_RX); /* PROXY RX */
-#endif
-#ifdef QCOM_FM_TX_ENABLED
-        } else if (devices & AudioSystem::DEVICE_OUT_FM_TX) {
-            return strdup(SND_USE_CASE_DEV_FM_TX); /* FM Tx */
-#endif
-        } else if (devices & AudioSystem::DEVICE_OUT_DEFAULT) {
-            if (callMode == AudioSystem::MODE_IN_CALL) {
-                return strdup(SND_USE_CASE_DEV_VOC_SPEAKER); /* Voice SPEAKER RX */
-            } else
-                return strdup(SND_USE_CASE_DEV_SPEAKER); /* SPEAKER RX */
-        } else {
-            ALOGD("No valid output device: %u", devices);
-        }
-    } else {
-        if (!(mDevSettingsFlag & TTY_OFF) &&
-            (callMode == AudioSystem::MODE_IN_CALL) &&
-            ((devices & AudioSystem::DEVICE_IN_WIRED_HEADSET)
-#ifdef QCOM_ANC_HEADSET_ENABLED
-              || (devices & AudioSystem::DEVICE_IN_ANC_HEADSET)
-#endif
-            )) {
-             if (mDevSettingsFlag & TTY_HCO) {
-                 return strdup(SND_USE_CASE_DEV_TTY_HEADSET_TX);
-             } else if (mDevSettingsFlag & TTY_FULL) {
-                 return strdup(SND_USE_CASE_DEV_TTY_FULL_TX);
-             } else if (mDevSettingsFlag & TTY_VCO) {
-                 if (!strncmp(mic_type, "analog", 6)) {
-                     return strdup(SND_USE_CASE_DEV_TTY_HANDSET_ANALOG_TX);
-                 } else {
-                     return strdup(SND_USE_CASE_DEV_TTY_HANDSET_TX);
-                 }
-             }
-        } else if (devices & AudioSystem::DEVICE_IN_BUILTIN_MIC) {
-            if (!strncmp(mic_type, "analog", 6)) {
-                return strdup(SND_USE_CASE_DEV_HANDSET); /* HANDSET TX */
-            } else {
-                if (mDevSettingsFlag & DMIC_FLAG) {
-                    if(callMode == AudioSystem::MODE_IN_CALL) {
-#ifdef USES_FLUENCE_INCALL
-                        if (fluence_mode == FLUENCE_MODE_ENDFIRE) {
-                            if(is_tmus)
-                                return strdup(SND_USE_CASE_DEV_DUAL_MIC_ENDFIRE_TMUS); /* DUALMIC EF TX */
-                            else
-                                return strdup(SND_USE_CASE_DEV_DUAL_MIC_ENDFIRE); /* DUALMIC EF TX */
-                        } else if (fluence_mode == FLUENCE_MODE_BROADSIDE) {
-                            return strdup(SND_USE_CASE_DEV_DUAL_MIC_BROADSIDE); /* DUALMIC BS TX */
-                        } else {
-                            return strdup(SND_USE_CASE_DEV_HANDSET); /* BUILTIN-MIC TX */
-                        }
-#endif
-                    }
-                    if (((rxDevice != NULL) &&
-                        !strncmp(rxDevice, SND_USE_CASE_DEV_SPEAKER,
-                        (strlen(SND_USE_CASE_DEV_SPEAKER)+1))) ||
-                        !strncmp(curRxUCMDevice, SND_USE_CASE_DEV_SPEAKER,
-                        (strlen(SND_USE_CASE_DEV_SPEAKER)+1))) {
-                        if (fluence_mode == FLUENCE_MODE_ENDFIRE) {
-                            if (input_source == AUDIO_SOURCE_VOICE_RECOGNITION) {
-// TODO: check if different ACDB settings are needed when speaker is enabled
-                                return strdup(SND_USE_CASE_DEV_DUAL_MIC_ENDFIRE_VREC);
-                            } else {
-                                return strdup(SND_USE_CASE_DEV_SPEAKER_DUAL_MIC_ENDFIRE);
-                            }
-                        } else if (fluence_mode == FLUENCE_MODE_BROADSIDE) {
-                            if (input_source == AUDIO_SOURCE_VOICE_RECOGNITION) {
-                                return strdup(SND_USE_CASE_DEV_DUAL_MIC_BROADSIDE_VREC);
-                            } else {
-                                return strdup(SND_USE_CASE_DEV_SPEAKER_DUAL_MIC_BROADSIDE);
-                            }
-                        }
-                    } else {
-                        if (fluence_mode == FLUENCE_MODE_ENDFIRE) {
-                            if (input_source == AUDIO_SOURCE_VOICE_RECOGNITION) {
-                                return strdup(SND_USE_CASE_DEV_DUAL_MIC_ENDFIRE_VREC);
-                            } else {
-                                return strdup(SND_USE_CASE_DEV_DUAL_MIC_ENDFIRE);
-                            }
-                        } else if (fluence_mode == FLUENCE_MODE_BROADSIDE) {
-                            if (input_source == AUDIO_SOURCE_VOICE_RECOGNITION) {
-                                return strdup(SND_USE_CASE_DEV_DUAL_MIC_BROADSIDE_VREC);
-                            } else {
-                                return strdup(SND_USE_CASE_DEV_DUAL_MIC_BROADSIDE);
-                            }
-                        }
-                    }
-                } else if (mDevSettingsFlag & QMIC_FLAG){
-                    return strdup(SND_USE_CASE_DEV_QUAD_MIC);
-                }
-#ifdef QCOM_SSR_ENABLED
-                else if (mDevSettingsFlag & SSRQMIC_FLAG){
-                    ALOGV("return SSRQMIC_FLAG: 0x%x devices:0x%x",mDevSettingsFlag,devices);
-                    // Mapping for quad mic input device.
-                    return strdup(SND_USE_CASE_DEV_SSR_QUAD_MIC); /* SSR Quad MIC */
-                }
-#endif
-#ifdef SEPERATED_AUDIO_INPUT
-                if(input_source == AUDIO_SOURCE_VOICE_RECOGNITION) {
-                    return strdup(SND_USE_CASE_DEV_VOICE_RECOGNITION ); /* VOICE RECOGNITION TX */
-                }
-#endif
-                else {
-                    return strdup(SND_USE_CASE_DEV_HANDSET); /* BUILTIN-MIC TX */
-                }
-            }
-        } else if (devices & AudioSystem::DEVICE_IN_AUX_DIGITAL) {
-            return strdup(SND_USE_CASE_DEV_HDMI_TX); /* HDMI TX */
-#ifdef QCOM_ANC_HEADSET_ENABLED
-        } else if (devices & AudioSystem::DEVICE_IN_ANC_HEADSET) {
-            return strdup(SND_USE_CASE_DEV_HEADSET); /* HEADSET TX */
-#endif
-        } else if (devices & AudioSystem::DEVICE_IN_WIRED_HEADSET) {
-            if (callMode == AudioSystem::MODE_IN_CALL) {
-                return strdup(SND_USE_CASE_DEV_VOC_HEADSET); /* Voice HEADSET TX */
-            } else
-                return strdup(SND_USE_CASE_DEV_HEADSET); /* HEADSET TX */
-        } else if (devices & AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET) {
-             if (btsco_samplerate == BTSCO_RATE_16KHZ)
-                 return strdup(SND_USE_CASE_DEV_BTSCO_WB_TX); /* BTSCO TX*/
-             else
-                 return strdup(SND_USE_CASE_DEV_BTSCO_NB_TX); /* BTSCO TX*/
-#ifdef QCOM_USBAUDIO_ENABLED
-        } else if ((devices & AudioSystem::DEVICE_IN_ANLG_DOCK_HEADSET) ||
-                   (devices & AudioSystem::DEVICE_IN_PROXY)) {
-            return strdup(SND_USE_CASE_DEV_PROXY_TX); /* PROXY TX */
-#endif
-        } else if ((devices & AudioSystem::DEVICE_IN_COMMUNICATION) ||
-                   (devices & AudioSystem::DEVICE_IN_VOICE_CALL)) {
-            /* Nothing to be done, use current active device */
-            if (strncmp(curTxUCMDevice, "None", 4)) {
-                return strdup(curTxUCMDevice);
-            }
-#ifdef QCOM_FM_ENABLED
-        } else if ((devices & AudioSystem::DEVICE_IN_FM_RX) ||
-                   (devices & AudioSystem::DEVICE_IN_FM_RX_A2DP)) {
-            /* Nothing to be done, use current tx device or set dummy device */
-            if (strncmp(curTxUCMDevice, "None", 4)) {
-                return strdup(curTxUCMDevice);
-            } else {
-                return strdup(SND_USE_CASE_DEV_DUMMY_TX);
-            }
-#endif
-        } else if ((devices & AudioSystem::DEVICE_IN_AMBIENT) ||
-                   (devices & AudioSystem::DEVICE_IN_BACK_MIC)) {
-            ALOGI("No proper mapping found with UCM device list, setting default");
-            if (!strncmp(mic_type, "analog", 6)) {
-                return strdup(SND_USE_CASE_DEV_HANDSET); /* HANDSET TX */
-            } else {
-                if (callMode == AudioSystem::MODE_IN_CALL) {
-                    return strdup(SND_USE_CASE_DEV_VOC_LINE); /* Voice BUILTIN-MIC TX */
-#ifdef SEPERATED_AUDIO_INPUT
-                } else if(input_source == AUDIO_SOURCE_CAMCORDER) {
-                    return strdup(SND_USE_CASE_DEV_CAMCORDER_TX ); /* CAMCORDER TX */
-#endif
-                } else
-                    return strdup(SND_USE_CASE_DEV_LINE); /* BUILTIN-MIC TX */
-            }
-        } else {
-            ALOGD("No valid input device: %u", devices);
-        }
-    }
-    return NULL;
-}
-
-void s_set_voice_volume(int vol)
-{
-    int err = 0;
-    ALOGV("s_set_voice_volume: volume %d", vol);
-    ALSAControl control("/dev/snd/controlC0");
-    control.set("Voice Rx Volume", vol, 0);
-
-    if (platform_is_Fusion3()) {
-#ifdef QCOM_CSDCLIENT_ENABLED
-        if (csd_volume == NULL) {
-            ALOGE("dlsym:Error:%s Loading csd_client_volume", dlerror());
-        } else {
-            err = csd_volume(vol);
-            if (err < 0) {
-                ALOGE("s_set_voice_volume: csd_client error %d", err);
-            }
-        }
-#endif
-    }
-}
-
-void s_set_volte_volume(int vol)
-{
-    ALOGV("s_set_volte_volume: volume %d", vol);
-    ALSAControl control("/dev/snd/controlC0");
-    control.set("VoLTE Rx Volume", vol, 0);
-}
-
-
-void s_set_voip_volume(int vol)
-{
-    ALOGV("s_set_voip_volume: volume %d", vol);
-    ALSAControl control("/dev/snd/controlC0");
-    control.set("Voip Rx Volume", vol, 0);
-}
-void s_set_mic_mute(int state)
-{
-    int err = 0;
-    ALOGV("s_set_mic_mute: state %d", state);
-    ALSAControl control("/dev/snd/controlC0");
-    control.set("Voice Tx Mute", state, 0);
-
-    if (platform_is_Fusion3()) {
-#ifdef QCOM_CSDCLIENT_ENABLED
-        if (csd_mic_mute == NULL) {
-            ALOGE("dlsym:Error:%s Loading csd_mic_mute", dlerror());
-        } else {
-            err=csd_mic_mute(state);
-            if (err < 0) {
-                ALOGE("s_set_mic_mute: csd_client error %d", err);
-            }
-        }
-#endif
-    }
-}
-void s_set_volte_mic_mute(int state)
-{
-    ALOGV("s_set_volte_mic_mute: state %d", state);
-    ALSAControl control("/dev/snd/controlC0");
-    control.set("VoLTE Tx Mute", state, 0);
-}
-
-void s_set_voip_mic_mute(int state)
-{
-    ALOGV("s_set_voip_mic_mute: state %d", state);
-    ALSAControl control("/dev/snd/controlC0");
-    control.set("Voip Tx Mute", state, 0);
-}
-
-void s_set_voip_config(int mode, int rate)
-{
-    ALOGV("s_set_voip_config: mode %d,rate %d", mode, rate);
-    ALSAControl control("/dev/snd/controlC0");
-    char** setValues;
-    setValues = (char**)malloc(2*sizeof(char*));
-    if (setValues == NULL) {
-          return;
-    }
-    setValues[0] = (char*)malloc(4*sizeof(char));
-    if (setValues[0] == NULL) {
-          free(setValues);
-          return;
-    }
-
-    setValues[1] = (char*)malloc(8*sizeof(char));
-    if (setValues[1] == NULL) {
-          free(setValues);
-          free(setValues[0]);
-          return;
-    }
-
-    sprintf(setValues[0], "%d",mode);
-    sprintf(setValues[1], "%d",rate);
-
-    control.setext("Voip Mode Rate Config", 2, setValues);
-    free(setValues[1]);
-    free(setValues[0]);
-    free(setValues);
-    return;
-}
-
-void s_set_btsco_rate(int rate)
-{
-    btsco_samplerate = rate;
-}
-
-void s_enable_wide_voice(bool flag)
-{
-    int err = 0;
-
-    ALOGV("s_enable_wide_voice: flag %d", flag);
-    ALSAControl control("/dev/snd/controlC0");
-    if(flag == true) {
-        control.set("Widevoice Enable", 1, 0);
-    } else {
-        control.set("Widevoice Enable", 0, 0);
-    }
-
-    if (platform_is_Fusion3()) {
-#ifdef QCOM_CSDCLIENT_ENABLED
-        if (csd_wide_voice == NULL) {
-            ALOGE("dlsym:Error:%s Loading csd_wide_voice", dlerror());
-        } else {
-            err = csd_wide_voice(flag);
-            if (err < 0) {
-                ALOGE("enableWideVoice: csd_client_wide_voice error %d", err);
-            }
-        }
-#endif
-    }
-}
-
-void s_set_voc_rec_mode(uint8_t mode)
-{
-    ALOGV("s_set_voc_rec_mode: mode %d", mode);
-    ALSAControl control("/dev/snd/controlC0");
-    control.set("Incall Rec Mode", mode, 0);
-}
-
-void s_enable_fens(bool flag)
-{
-    int err = 0;
-
-    ALOGV("s_enable_fens: flag %d", flag);
-    ALSAControl control("/dev/snd/controlC0");
-    if(flag == true) {
-        control.set("FENS Enable", 1, 0);
-    } else {
-        control.set("FENS Enable", 0, 0);
-    }
-
-    if (platform_is_Fusion3()) {
-#ifdef QCOM_CSDCLIENT_ENABLED
-        if (csd_fens == NULL) {
-            ALOGE("dlsym:Error:%s Loading csd_fens", dlerror());
-        } else {
-            err = csd_fens(flag);
-            if (err < 0) {
-                ALOGE("s_enable_fens: csd_client error %d", err);
-            }
-        }
-#endif
-    }
-}
-
-void s_enable_slow_talk(bool flag)
-{
-    int err = 0;
-
-    ALOGV("s_enable_slow_talk: flag %d", flag);
-    ALSAControl control("/dev/snd/controlC0");
-    if(flag == true) {
-        control.set("Slowtalk Enable", 1, 0);
-    } else {
-        control.set("Slowtalk Enable", 0, 0);
-    }
-
-    if (platform_is_Fusion3()) {
-#ifdef QCOM_CSDCLIENT_ENABLED
-        if (csd_slow_talk == NULL) {
-            ALOGE("dlsym:Error:%s Loading csd_slow_talk", dlerror());
-        } else {
-            err = csd_slow_talk(flag);
-            if (err < 0) {
-                ALOGE("s_enable_slow_talk: csd_client error %d", err);
-            }
-        }
-#endif
-    }
-}
-
-void s_set_flags(uint32_t flags)
-{
-    ALOGV("s_set_flags: flags %d", flags);
-    mDevSettingsFlag = flags;
-}
-
-static status_t s_set_compressed_vol(int value)
-{
-    status_t err = NO_ERROR;
-
-    ALSAControl control("/dev/snd/controlC0");
-    control.set("COMPRESSED RX Volume",value,0);
-
-    return err;
-}
-
-#ifdef SEPERATED_AUDIO_INPUT
-void s_setInput(int input)
-{
-    input_source = input;
-    ALOGD("s_setInput() : input_source = %d",input_source);
-}
-#endif
-
-#ifdef QCOM_CSDCLIENT_ENABLED
-static void  s_set_csd_handle(void* handle)
-{
-    csd_handle = static_cast<void*>(handle);
-    ALOGI("%s csd_handle: %p", __func__, csd_handle);
-
-    csd_disable_device = (int (*)())::dlsym(csd_handle,"csd_client_disable_device");
-    csd_enable_device = (int (*)(int,int,uint32_t))::dlsym(csd_handle,"csd_client_enable_device");
-    csd_start_voice = (int (*)())::dlsym(csd_handle,"csd_client_start_voice");
-    csd_stop_voice = (int (*)())::dlsym(csd_handle,"csd_client_stop_voice");
-    csd_volume = (int (*)(int))::dlsym(csd_handle,"csd_client_volume");
-    csd_mic_mute = (int (*)(int))::dlsym(csd_handle,"csd_client_mic_mute");
-    csd_wide_voice = (int (*)(uint8_t))::dlsym(csd_handle,"csd_client_wide_voice");
-    csd_fens = (int (*)(uint8_t))::dlsym(csd_handle,"csd_client_fens");
-    csd_slow_talk = (int (*)(uint8_t))::dlsym(csd_handle,"csd_client_slow_talk");
-}
-#endif
-
-static bool s_is_tmus()
-{
-    char value[128];
-    bool ret = false;
-
-    if (mccmnc == 0) {
-        property_get("gsm.sim.operator.numeric",value,"0");
-        mccmnc = atoi(value);
-    }
-
-    ALOGD("%s: mnc_mcc :  %d", __FUNCTION__, mccmnc);
-    switch(mccmnc)
-    {
-    //TMUS MCC(310), MNC(490, 260, 026)
-    case 310490:
-    case 310260:
-    case 310026:
-        ret = true;
-        break;
-    default:
-        ret = false;
-        break;
-    }
-
-    return ret;
-}
-
-}
diff --git a/legacy/alsa_sound/audio_hw_hal.cpp b/legacy/alsa_sound/audio_hw_hal.cpp
deleted file mode 100644
index 24e50d3..0000000
--- a/legacy/alsa_sound/audio_hw_hal.cpp
+++ /dev/null
@@ -1,783 +0,0 @@
-/*
- * Copyright (C) 2011 The Android Open Source Project
- * Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
- *
- * 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 "qcom_audio_hw_hal"
-//#define LOG_NDEBUG 0
-
-#include <stdint.h>
-
-#include <hardware/hardware.h>
-#include <system/audio.h>
-#include <hardware/audio.h>
-
-#include <hardware_legacy/AudioHardwareInterface.h>
-#include <hardware_legacy/AudioSystemLegacy.h>
-
-namespace android_audio_legacy {
-
-extern "C" {
-
-struct qcom_audio_module {
-    struct audio_module module;
-};
-
-struct qcom_audio_device {
-    struct audio_hw_device device;
-
-    struct AudioHardwareInterface *hwif;
-};
-
-struct qcom_stream_out {
-    struct audio_stream_out stream;
-
-    AudioStreamOut *qcom_out;
-};
-
-struct qcom_stream_in {
-    struct audio_stream_in stream;
-
-    AudioStreamIn *qcom_in;
-};
-
-
-enum {
-    HAL_API_REV_1_0,
-    HAL_API_REV_2_0,
-    HAL_API_REV_NUM
-} hal_api_rev;
-
-static uint32_t audio_device_conv_table[][HAL_API_REV_NUM] =
-{
-        /* output devices */
-    { AudioSystem::DEVICE_OUT_EARPIECE, AUDIO_DEVICE_OUT_EARPIECE },
-    { AudioSystem::DEVICE_OUT_SPEAKER, AUDIO_DEVICE_OUT_SPEAKER },
-    { AudioSystem::DEVICE_OUT_WIRED_HEADSET, AUDIO_DEVICE_OUT_WIRED_HEADSET },
-    { AudioSystem::DEVICE_OUT_WIRED_HEADPHONE, AUDIO_DEVICE_OUT_WIRED_HEADPHONE },
-    { AudioSystem::DEVICE_OUT_BLUETOOTH_SCO, AUDIO_DEVICE_OUT_BLUETOOTH_SCO },
-    { AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET, AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET },
-    { AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT, AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT },
-    { AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP },
-    { AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES },
-    { AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER },
-    { AudioSystem::DEVICE_OUT_AUX_DIGITAL, AUDIO_DEVICE_OUT_AUX_DIGITAL },
-    { AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET, AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET },
-    { AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET, AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET },
-    { AudioSystem::DEVICE_OUT_DEFAULT, AUDIO_DEVICE_OUT_DEFAULT },
-#ifdef QCOM_ANC_HEADSET_ENABLED
-    { AudioSystem::DEVICE_OUT_ANC_HEADSET, AUDIO_DEVICE_OUT_ANC_HEADSET },
-    { AudioSystem::DEVICE_OUT_ANC_HEADPHONE, AUDIO_DEVICE_OUT_ANC_HEADPHONE },
-#endif
-#ifdef QCOM_FM_ENABLED
-    { AudioSystem::DEVICE_OUT_FM, AUDIO_DEVICE_OUT_FM },
-#endif
-#ifdef QCOM_FM_TX_ENABLED
-    { AudioSystem::DEVICE_OUT_FM_TX, AUDIO_DEVICE_OUT_FM_TX },
-#endif
-#ifdef QCOM_VOIP_ENABLED
-    { AudioSystem::DEVICE_OUT_DIRECTOUTPUT, AUDIO_DEVICE_OUT_DIRECTOUTPUT },
-#endif
-#ifdef QCOM_PROXY_DEVICE_ENABLED
-    { AudioSystem::DEVICE_OUT_PROXY, AUDIO_DEVICE_OUT_PROXY },
-#endif
-    /* input devices */
-    { AudioSystem::DEVICE_IN_COMMUNICATION, AUDIO_DEVICE_IN_COMMUNICATION },
-    { AudioSystem::DEVICE_IN_AMBIENT, AUDIO_DEVICE_IN_AMBIENT },
-    { AudioSystem::DEVICE_IN_BUILTIN_MIC, AUDIO_DEVICE_IN_BUILTIN_MIC },
-    { AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET, AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET },
-    { AudioSystem::DEVICE_IN_WIRED_HEADSET, AUDIO_DEVICE_IN_WIRED_HEADSET },
-    { AudioSystem::DEVICE_IN_AUX_DIGITAL, AUDIO_DEVICE_IN_AUX_DIGITAL },
-    { AudioSystem::DEVICE_IN_VOICE_CALL, AUDIO_DEVICE_IN_VOICE_CALL },
-    { AudioSystem::DEVICE_IN_BACK_MIC, AUDIO_DEVICE_IN_BACK_MIC },
-    { AudioSystem::DEVICE_IN_DEFAULT, AUDIO_DEVICE_IN_DEFAULT },
-#ifdef QCOM_ANC_HEADSET_ENABLED
-    { AudioSystem::DEVICE_IN_ANC_HEADSET, AUDIO_DEVICE_IN_ANC_HEADSET },
-#endif
-#ifdef QCOM_FM_ENABLED
-    { AudioSystem::DEVICE_IN_FM_RX, AUDIO_DEVICE_IN_FM_RX },
-    { AudioSystem::DEVICE_IN_FM_RX_A2DP, AUDIO_DEVICE_IN_FM_RX_A2DP },
-#endif
-};
-
-static uint32_t convert_audio_device(uint32_t from_device, int from_rev, int to_rev)
-{
-    const uint32_t k_num_devices = sizeof(audio_device_conv_table)/sizeof(uint32_t)/HAL_API_REV_NUM;
-    uint32_t to_device =  AUDIO_DEVICE_NONE;
-    uint32_t in_bit = 0;
-
-    if (from_rev != HAL_API_REV_1_0) {
-        in_bit = from_device & AUDIO_DEVICE_BIT_IN;
-        from_device &= ~AUDIO_DEVICE_BIT_IN;
-    }
-
-    while (from_device) {
-        uint32_t i = 31 - __builtin_clz(from_device);
-        uint32_t cur_device = (1 << i) | in_bit;
-
-        for (i = 0; i < k_num_devices; i++) {
-            if (audio_device_conv_table[i][from_rev] == cur_device) {
-                to_device |= audio_device_conv_table[i][to_rev];
-                break;
-            }
-        }
-        from_device &= ~cur_device;
-    }
-    return to_device;
-}
-
-/** audio_stream_out implementation **/
-static uint32_t out_get_sample_rate(const struct audio_stream *stream)
-{
-    const struct qcom_stream_out *out =
-        reinterpret_cast<const struct qcom_stream_out *>(stream);
-    return out->qcom_out->sampleRate();
-}
-
-static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
-{
-    struct qcom_stream_out *out =
-        reinterpret_cast<struct qcom_stream_out *>(stream);
-
-    ALOGE("(%s:%d) %s: Implement me!", __FILE__, __LINE__, __func__);
-    /* TODO: implement this */
-    return 0;
-}
-
-static size_t out_get_buffer_size(const struct audio_stream *stream)
-{
-    const struct qcom_stream_out *out =
-        reinterpret_cast<const struct qcom_stream_out *>(stream);
-    return out->qcom_out->bufferSize();
-}
-
-static audio_channel_mask_t out_get_channels(const struct audio_stream *stream)
-{
-    const struct qcom_stream_out *out =
-        reinterpret_cast<const struct qcom_stream_out *>(stream);
-    return out->qcom_out->channels();
-}
-
-static audio_format_t out_get_format(const struct audio_stream *stream)
-{
-    const struct qcom_stream_out *out =
-        reinterpret_cast<const struct qcom_stream_out *>(stream);
-    return (audio_format_t)out->qcom_out->format();
-}
-
-static int out_set_format(struct audio_stream *stream, audio_format_t format)
-{
-    struct qcom_stream_out *out =
-        reinterpret_cast<struct qcom_stream_out *>(stream);
-    ALOGE("(%s:%d) %s: Implement me!", __FILE__, __LINE__, __func__);
-    /* TODO: implement me */
-    return 0;
-}
-
-static int out_standby(struct audio_stream *stream)
-{
-    struct qcom_stream_out *out =
-        reinterpret_cast<struct qcom_stream_out *>(stream);
-    return out->qcom_out->standby();
-}
-
-static int out_dump(const struct audio_stream *stream, int fd)
-{
-    const struct qcom_stream_out *out =
-        reinterpret_cast<const struct qcom_stream_out *>(stream);
-    Vector<String16> args;
-    return out->qcom_out->dump(fd, args);
-}
-
-static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
-{
-    struct qcom_stream_out *out =
-        reinterpret_cast<struct qcom_stream_out *>(stream);
-    int val;
-    String8 s8 = String8(kvpairs);
-    AudioParameter parms = AudioParameter(String8(kvpairs));
-
-    if (parms.getInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val) == NO_ERROR) {
-        val = convert_audio_device(val, HAL_API_REV_2_0, HAL_API_REV_1_0);
-        parms.remove(String8(AUDIO_PARAMETER_STREAM_ROUTING));
-        parms.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val);
-        s8 = parms.toString();
-    }
-
-    return out->qcom_out->setParameters(s8);
-}
-
-static char * out_get_parameters(const struct audio_stream *stream, const char *keys)
-{
-    const struct qcom_stream_out *out =
-        reinterpret_cast<const struct qcom_stream_out *>(stream);
-    String8 s8;
-    int val;
-
-    s8 = out->qcom_out->getParameters(String8(keys));
-
-    AudioParameter parms = AudioParameter(s8);
-    if (parms.getInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val) == NO_ERROR) {
-        val = convert_audio_device(val, HAL_API_REV_1_0, HAL_API_REV_2_0);
-        parms.remove(String8(AUDIO_PARAMETER_STREAM_ROUTING));
-        parms.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val);
-        s8 = parms.toString();
-    }
-
-    return strdup(s8.string());
-}
-
-static uint32_t out_get_latency(const struct audio_stream_out *stream)
-{
-    const struct qcom_stream_out *out =
-        reinterpret_cast<const struct qcom_stream_out *>(stream);
-    return out->qcom_out->latency();
-}
-
-static int out_set_volume(struct audio_stream_out *stream, float left,
-                          float right)
-{
-    struct qcom_stream_out *out =
-        reinterpret_cast<struct qcom_stream_out *>(stream);
-    return out->qcom_out->setVolume(left, right);
-}
-
-static ssize_t out_write(struct audio_stream_out *stream, const void* buffer,
-                         size_t bytes)
-{
-    struct qcom_stream_out *out =
-        reinterpret_cast<struct qcom_stream_out *>(stream);
-    return out->qcom_out->write(buffer, bytes);
-}
-
-static int out_get_render_position(const struct audio_stream_out *stream,
-                                   uint32_t *dsp_frames)
-{
-    const struct qcom_stream_out *out =
-        reinterpret_cast<const struct qcom_stream_out *>(stream);
-    return out->qcom_out->getRenderPosition(dsp_frames);
-}
-
-static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
-{
-    return 0;
-}
-
-static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
-{
-    return 0;
-}
-
-static int out_get_next_write_timestamp(const struct audio_stream_out *stream,
-                                        int64_t *timestamp)
-{
-    const struct qcom_stream_out *out =
-        reinterpret_cast<const struct qcom_stream_out *>(stream);
-    return out->qcom_out->getNextWriteTimestamp(timestamp);
-}
-
-/** audio_stream_in implementation **/
-static uint32_t in_get_sample_rate(const struct audio_stream *stream)
-{
-    const struct qcom_stream_in *in =
-        reinterpret_cast<const struct qcom_stream_in *>(stream);
-    return in->qcom_in->sampleRate();
-}
-
-static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
-{
-    struct qcom_stream_in *in =
-        reinterpret_cast<struct qcom_stream_in *>(stream);
-
-    ALOGE("(%s:%d) %s: Implement me!", __FILE__, __LINE__, __func__);
-    /* TODO: implement this */
-    return 0;
-}
-
-static size_t in_get_buffer_size(const struct audio_stream *stream)
-{
-    const struct qcom_stream_in *in =
-        reinterpret_cast<const struct qcom_stream_in *>(stream);
-    return in->qcom_in->bufferSize();
-}
-
-static audio_channel_mask_t in_get_channels(const struct audio_stream *stream)
-{
-    const struct qcom_stream_in *in =
-        reinterpret_cast<const struct qcom_stream_in *>(stream);
-    return in->qcom_in->channels();
-}
-
-static audio_format_t in_get_format(const struct audio_stream *stream)
-{
-    const struct qcom_stream_in *in =
-        reinterpret_cast<const struct qcom_stream_in *>(stream);
-    return (audio_format_t)in->qcom_in->format();
-}
-
-static int in_set_format(struct audio_stream *stream, audio_format_t format)
-{
-    struct qcom_stream_in *in =
-        reinterpret_cast<struct qcom_stream_in *>(stream);
-    ALOGE("(%s:%d) %s: Implement me!", __FILE__, __LINE__, __func__);
-    /* TODO: implement me */
-    return 0;
-}
-
-static int in_standby(struct audio_stream *stream)
-{
-    struct qcom_stream_in *in = reinterpret_cast<struct qcom_stream_in *>(stream);
-    return in->qcom_in->standby();
-}
-
-static int in_dump(const struct audio_stream *stream, int fd)
-{
-    const struct qcom_stream_in *in =
-        reinterpret_cast<const struct qcom_stream_in *>(stream);
-    Vector<String16> args;
-    return in->qcom_in->dump(fd, args);
-}
-
-static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
-{
-    struct qcom_stream_in *in =
-        reinterpret_cast<struct qcom_stream_in *>(stream);
-    int val;
-    AudioParameter parms = AudioParameter(String8(kvpairs));
-    String8 s8 = String8(kvpairs);
-
-    if (parms.getInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val) == NO_ERROR) {
-        val = convert_audio_device(val, HAL_API_REV_2_0, HAL_API_REV_1_0);
-        parms.remove(String8(AUDIO_PARAMETER_STREAM_ROUTING));
-        parms.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val);
-        s8 = parms.toString();
-    }
-
-    return in->qcom_in->setParameters(s8);
-}
-
-static char * in_get_parameters(const struct audio_stream *stream,
-                                const char *keys)
-{
-    const struct qcom_stream_in *in =
-        reinterpret_cast<const struct qcom_stream_in *>(stream);
-    String8 s8;
-    int val;
-
-    s8 = in->qcom_in->getParameters(String8(keys));
-
-    AudioParameter parms = AudioParameter(s8);
-    if (parms.getInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val) == NO_ERROR) {
-        val = convert_audio_device(val, HAL_API_REV_1_0, HAL_API_REV_2_0);
-        parms.remove(String8(AUDIO_PARAMETER_STREAM_ROUTING));
-        parms.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val);
-        s8 = parms.toString();
-    }
-
-    return strdup(s8.string());
-}
-
-static int in_set_gain(struct audio_stream_in *stream, float gain)
-{
-    struct qcom_stream_in *in =
-        reinterpret_cast<struct qcom_stream_in *>(stream);
-    return in->qcom_in->setGain(gain);
-}
-
-static ssize_t in_read(struct audio_stream_in *stream, void* buffer,
-                       size_t bytes)
-{
-    struct qcom_stream_in *in =
-        reinterpret_cast<struct qcom_stream_in *>(stream);
-    return in->qcom_in->read(buffer, bytes);
-}
-
-static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
-{
-    struct qcom_stream_in *in =
-        reinterpret_cast<struct qcom_stream_in *>(stream);
-    return in->qcom_in->getInputFramesLost();
-}
-
-static int in_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
-{
-    const struct qcom_stream_in *in =
-        reinterpret_cast<const struct qcom_stream_in *>(stream);
-    return in->qcom_in->addAudioEffect(effect);
-}
-
-static int in_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
-{
-    const struct qcom_stream_in *in =
-        reinterpret_cast<const struct qcom_stream_in *>(stream);
-    return in->qcom_in->removeAudioEffect(effect);
-}
-
-/** audio_hw_device implementation **/
-static inline struct qcom_audio_device * to_ladev(struct audio_hw_device *dev)
-{
-    return reinterpret_cast<struct qcom_audio_device *>(dev);
-}
-
-static inline const struct qcom_audio_device * to_cladev(const struct audio_hw_device *dev)
-{
-    return reinterpret_cast<const struct qcom_audio_device *>(dev);
-}
-
-static int adev_init_check(const struct audio_hw_device *dev)
-{
-    const struct qcom_audio_device *qadev = to_cladev(dev);
-
-    return qadev->hwif->initCheck();
-}
-
-static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
-{
-    struct qcom_audio_device *qadev = to_ladev(dev);
-    return qadev->hwif->setVoiceVolume(volume);
-}
-
-static int adev_set_master_volume(struct audio_hw_device *dev, float volume)
-{
-    struct qcom_audio_device *qadev = to_ladev(dev);
-    return qadev->hwif->setMasterVolume(volume);
-}
-
-static int adev_get_master_volume(struct audio_hw_device *dev, float *volume) {
-
-    struct qcom_audio_device *qadev = to_ladev(dev);
-    return qadev->hwif->getMasterVolume(volume);
-}
-
-#ifdef QCOM_FM_ENABLED
-static int adev_set_fm_volume(struct audio_hw_device *dev, float volume)
-{
-    struct qcom_audio_device *qadev = to_ladev(dev);
-    return qadev->hwif->setFmVolume(volume);
-}
-#endif
-
-static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode)
-{
-    struct qcom_audio_device *qadev = to_ladev(dev);
-    return qadev->hwif->setMode(mode);
-}
-
-static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
-{
-    struct qcom_audio_device *qadev = to_ladev(dev);
-    return qadev->hwif->setMicMute(state);
-}
-
-static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
-{
-    const struct qcom_audio_device *qadev = to_cladev(dev);
-    return qadev->hwif->getMicMute(state);
-}
-
-static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
-{
-    struct qcom_audio_device *qadev = to_ladev(dev);
-    return qadev->hwif->setParameters(String8(kvpairs));
-}
-
-static char * adev_get_parameters(const struct audio_hw_device *dev,
-                                  const char *keys)
-{
-    const struct qcom_audio_device *qadev = to_cladev(dev);
-    String8 s8;
-
-    s8 = qadev->hwif->getParameters(String8(keys));
-    return strdup(s8.string());
-}
-
-static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
-                                         const struct audio_config *config)
-{
-    const struct qcom_audio_device *qadev = to_cladev(dev);
-    uint8_t channelCount = popcount(config->channel_mask);
-    return qadev->hwif->getInputBufferSize(config->sample_rate, config->format, channelCount);
-}
-
-#ifdef QCOM_TUNNEL_LPA_ENABLED
-static int adev_open_output_session(struct audio_hw_device *dev,
-                                   uint32_t devices,
-                                   int *format,
-                                   int sessionId,
-                                   uint32_t samplingRate,
-                                   uint32_t channels,
-                                   struct audio_stream_out **stream_out)
-{
-    struct qcom_audio_device *qadev = to_ladev(dev);
-    status_t status;
-    struct qcom_stream_out *out;
-    int ret;
-
-    out = (struct qcom_stream_out *)calloc(1, sizeof(*out));
-    if (!out)
-        return -ENOMEM;
-
-    out->qcom_out = qadev->hwif->openOutputSession(devices, format,&status,sessionId,samplingRate,channels);
-    if (!out->qcom_out) {
-        ret = status;
-        goto err_open;
-    }
-
-    out->stream.common.standby = out_standby;
-    out->stream.common.set_parameters = out_set_parameters;
-    out->stream.set_volume = out_set_volume;
-
-    *stream_out = &out->stream;
-    return 0;
-
-err_open:
-    free(out);
-    *stream_out = NULL;
-    return ret;
-}
-#endif
-
-static int adev_open_output_stream(struct audio_hw_device *dev,
-                                   audio_io_handle_t handle,
-                                   audio_devices_t devices,
-                                   audio_output_flags_t flags,
-                                   struct audio_config *config,
-                                   struct audio_stream_out **stream_out)
-{
-    struct qcom_audio_device *qadev = to_ladev(dev);
-    status_t status;
-    struct qcom_stream_out *out;
-    int ret;
-
-    out = (struct qcom_stream_out *)calloc(1, sizeof(*out));
-    if (!out)
-        return -ENOMEM;
-
-    devices = convert_audio_device(devices, HAL_API_REV_2_0, HAL_API_REV_1_0);
-    status = static_cast<audio_output_flags_t> (flags);
-
-    out->qcom_out = qadev->hwif->openOutputStream(devices,
-                                                    (int *)&config->format,
-                                                    &config->channel_mask,
-                                                    &config->sample_rate,
-                                                    &status);
-    if (!out->qcom_out) {
-        ret = status;
-        goto err_open;
-    }
-
-    out->stream.common.get_sample_rate = out_get_sample_rate;
-    out->stream.common.set_sample_rate = out_set_sample_rate;
-    out->stream.common.get_buffer_size = out_get_buffer_size;
-    out->stream.common.get_channels = out_get_channels;
-    out->stream.common.get_format = out_get_format;
-    out->stream.common.set_format = out_set_format;
-    out->stream.common.standby = out_standby;
-    out->stream.common.dump = out_dump;
-    out->stream.common.set_parameters = out_set_parameters;
-    out->stream.common.get_parameters = out_get_parameters;
-    out->stream.common.add_audio_effect = out_add_audio_effect;
-    out->stream.common.remove_audio_effect = out_remove_audio_effect;
-    out->stream.get_latency = out_get_latency;
-    out->stream.set_volume = out_set_volume;
-    out->stream.write = out_write;
-    out->stream.get_render_position = out_get_render_position;
-    out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
-
-    *stream_out = &out->stream;
-    return 0;
-
-err_open:
-    free(out);
-    *stream_out = NULL;
-    return ret;
-}
-
-static void adev_close_output_stream(struct audio_hw_device *dev,
-                                     struct audio_stream_out* stream)
-{
-    struct qcom_audio_device *qadev = to_ladev(dev);
-    struct qcom_stream_out *out = reinterpret_cast<struct qcom_stream_out *>(stream);
-
-    qadev->hwif->closeOutputStream(out->qcom_out);
-    free(out);
-}
-
-/** This method creates and opens the audio hardware input stream */
-static int adev_open_input_stream(struct audio_hw_device *dev,
-                                  audio_io_handle_t handle,
-                                  audio_devices_t devices,
-                                  audio_config *config,
-                                  audio_stream_in **stream_in)
-{
-    struct qcom_audio_device *qadev = to_ladev(dev);
-    status_t status;
-    struct qcom_stream_in *in;
-    int ret;
-
-    in = (struct qcom_stream_in *)calloc(1, sizeof(*in));
-    if (!in)
-        return -ENOMEM;
-
-    devices = convert_audio_device(devices, HAL_API_REV_2_0, HAL_API_REV_1_0);
-
-    in->qcom_in = qadev->hwif->openInputStream(devices, (int *)&config->format,
-                                    &config->channel_mask,
-                                    &config->sample_rate,
-                                    &status,
-                                    (AudioSystem::audio_in_acoustics)0);
-    if (!in->qcom_in) {
-        ret = status;
-        goto err_open;
-    }
-
-    in->stream.common.get_sample_rate = in_get_sample_rate;
-    in->stream.common.set_sample_rate = in_set_sample_rate;
-    in->stream.common.get_buffer_size = in_get_buffer_size;
-    in->stream.common.get_channels = in_get_channels;
-    in->stream.common.get_format = in_get_format;
-    in->stream.common.set_format = in_set_format;
-    in->stream.common.standby = in_standby;
-    in->stream.common.dump = in_dump;
-    in->stream.common.set_parameters = in_set_parameters;
-    in->stream.common.get_parameters = in_get_parameters;
-    in->stream.common.add_audio_effect = in_add_audio_effect;
-    in->stream.common.remove_audio_effect = in_remove_audio_effect;
-    in->stream.set_gain = in_set_gain;
-    in->stream.read = in_read;
-    in->stream.get_input_frames_lost = in_get_input_frames_lost;
-
-    *stream_in = &in->stream;
-    return 0;
-
-err_open:
-    free(in);
-    *stream_in = NULL;
-    return ret;
-}
-
-static void adev_close_input_stream(struct audio_hw_device *dev,
-                               struct audio_stream_in *stream)
-{
-    struct qcom_audio_device *qadev = to_ladev(dev);
-    struct qcom_stream_in *in =
-        reinterpret_cast<struct qcom_stream_in *>(stream);
-
-    qadev->hwif->closeInputStream(in->qcom_in);
-    free(in);
-}
-
-static int adev_dump(const struct audio_hw_device *dev, int fd)
-{
-    const struct qcom_audio_device *qadev = to_cladev(dev);
-    Vector<String16> args;
-
-    return qadev->hwif->dumpState(fd, args);
-}
-
-static int qcom_adev_close(hw_device_t* device)
-{
-    struct audio_hw_device *hwdev =
-                        reinterpret_cast<struct audio_hw_device *>(device);
-    struct qcom_audio_device *qadev = to_ladev(hwdev);
-
-    if (!qadev)
-        return 0;
-
-    if (qadev->hwif)
-        delete qadev->hwif;
-
-    free(qadev);
-    return 0;
-}
-
-static int qcom_adev_open(const hw_module_t* module, const char* name,
-                            hw_device_t** device)
-{
-    struct qcom_audio_device *qadev;
-    int ret;
-
-    if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0)
-        return -EINVAL;
-
-    qadev = (struct qcom_audio_device *)calloc(1, sizeof(*qadev));
-    if (!qadev)
-        return -ENOMEM;
-
-    qadev->device.common.tag = HARDWARE_DEVICE_TAG;
-    qadev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
-    qadev->device.common.module = const_cast<hw_module_t*>(module);
-    qadev->device.common.close = qcom_adev_close;
-
-    qadev->device.init_check = adev_init_check;
-    qadev->device.set_voice_volume = adev_set_voice_volume;
-    qadev->device.set_master_volume = adev_set_master_volume;
-    qadev->device.get_master_volume = adev_get_master_volume;
-#ifdef QCOM_FM_ENABLED
-    qadev->device.set_fm_volume = adev_set_fm_volume;
-#endif
-    qadev->device.set_mode = adev_set_mode;
-    qadev->device.set_mic_mute = adev_set_mic_mute;
-    qadev->device.get_mic_mute = adev_get_mic_mute;
-    qadev->device.set_parameters = adev_set_parameters;
-    qadev->device.get_parameters = adev_get_parameters;
-    qadev->device.get_input_buffer_size = adev_get_input_buffer_size;
-    qadev->device.open_output_stream = adev_open_output_stream;
-#ifdef QCOM_TUNNEL_LPA_ENABLED
-    qadev->device.open_output_session = adev_open_output_session;
-#endif
-    qadev->device.close_output_stream = adev_close_output_stream;
-    qadev->device.open_input_stream = adev_open_input_stream;
-    qadev->device.close_input_stream = adev_close_input_stream;
-    qadev->device.dump = adev_dump;
-
-    qadev->hwif = createAudioHardware();
-    if (!qadev->hwif) {
-        ret = -EIO;
-        goto err_create_audio_hw;
-    }
-
-    *device = &qadev->device.common;
-
-    return 0;
-
-err_create_audio_hw:
-    free(qadev);
-    return ret;
-}
-
-static struct hw_module_methods_t qcom_audio_module_methods = {
-        open: qcom_adev_open
-};
-
-struct qcom_audio_module HAL_MODULE_INFO_SYM = {
-    module: {
-        common: {
-            tag: HARDWARE_MODULE_TAG,
-            module_api_version: AUDIO_MODULE_API_VERSION_0_1,
-            hal_api_version: HARDWARE_HAL_API_VERSION,
-            id: AUDIO_HARDWARE_MODULE_ID,
-            name: "QCOM Audio HW HAL",
-            author: "The Linux Foundation",
-            methods: &qcom_audio_module_methods,
-            dso : NULL,
-            reserved : {0},
-        },
-    },
-};
-
-}; // extern "C"
-
-}; // namespace android_audio_legacy
diff --git a/legacy/alsa_sound/audio_policy_hal.cpp b/legacy/alsa_sound/audio_policy_hal.cpp
deleted file mode 100644
index a1687f7..0000000
--- a/legacy/alsa_sound/audio_policy_hal.cpp
+++ /dev/null
@@ -1,468 +0,0 @@
-/*
- * Copyright (C) 2011 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 "qcom_audio_policy_hal"
-//#define LOG_NDEBUG 0
-
-#include <stdint.h>
-
-#include <hardware/hardware.h>
-#include <system/audio.h>
-#include <system/audio_policy.h>
-#include <hardware/audio_policy.h>
-
-#include <hardware_legacy/AudioPolicyInterface.h>
-#include <hardware_legacy/AudioSystemLegacy.h>
-
-#include "AudioPolicyCompatClient.h"
-
-namespace android_audio_legacy {
-
-extern "C" {
-
-struct qcom_ap_module {
-    struct audio_policy_module module;
-};
-
-struct qcom_ap_device {
-    struct audio_policy_device device;
-};
-
-struct qcom_audio_policy {
-    struct audio_policy policy;
-
-    void *service;
-    struct audio_policy_service_ops *aps_ops;
-    AudioPolicyCompatClient *service_client;
-    AudioPolicyInterface *apm;
-};
-
-static inline struct qcom_audio_policy * to_qap(struct audio_policy *pol)
-{
-    return reinterpret_cast<struct qcom_audio_policy *>(pol);
-}
-
-static inline const struct qcom_audio_policy * to_cqap(const struct audio_policy *pol)
-{
-    return reinterpret_cast<const struct qcom_audio_policy *>(pol);
-}
-
-
-static int ap_set_device_connection_state(struct audio_policy *pol,
-                                          audio_devices_t device,
-                                          audio_policy_dev_state_t state,
-                                          const char *device_address)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    return qap->apm->setDeviceConnectionState(
-                    (AudioSystem::audio_devices)device,
-                    (AudioSystem::device_connection_state)state,
-                    device_address);
-}
-
-static audio_policy_dev_state_t ap_get_device_connection_state(
-                                            const struct audio_policy *pol,
-                                            audio_devices_t device,
-                                            const char *device_address)
-{
-    const struct qcom_audio_policy *qap = to_cqap(pol);
-    return (audio_policy_dev_state_t)qap->apm->getDeviceConnectionState(
-                    (AudioSystem::audio_devices)device,
-                    device_address);
-}
-
-static void ap_set_phone_state(struct audio_policy *pol, audio_mode_t state)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    // as this is the legacy API, don't change it to use audio_mode_t instead of int
-    qap->apm->setPhoneState((int) state);
-}
-
-    /* indicate a change in ringer mode */
-static void ap_set_ringer_mode(struct audio_policy *pol, uint32_t mode,
-                               uint32_t mask)
-{
-    // deprecated, never called
-}
-
-    /* force using a specific device category for the specified usage */
-static void ap_set_force_use(struct audio_policy *pol,
-                          audio_policy_force_use_t usage,
-                          audio_policy_forced_cfg_t config)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    qap->apm->setForceUse((AudioSystem::force_use)usage,
-                          (AudioSystem::forced_config)config);
-}
-
-    /* retreive current device category forced for a given usage */
-static audio_policy_forced_cfg_t ap_get_force_use(
-                                               const struct audio_policy *pol,
-                                               audio_policy_force_use_t usage)
-{
-    const struct qcom_audio_policy *qap = to_cqap(pol);
-    return (audio_policy_forced_cfg_t)qap->apm->getForceUse(
-                          (AudioSystem::force_use)usage);
-}
-
-/* if can_mute is true, then audio streams that are marked ENFORCED_AUDIBLE
- * can still be muted. */
-static void ap_set_can_mute_enforced_audible(struct audio_policy *pol,
-                                             bool can_mute)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    qap->apm->setSystemProperty("ro.camera.sound.forced", can_mute ? "0" : "1");
-}
-
-static int ap_init_check(const struct audio_policy *pol)
-{
-    const struct qcom_audio_policy *qap = to_cqap(pol);
-    return qap->apm->initCheck();
-}
-
-static audio_io_handle_t ap_get_output(struct audio_policy *pol,
-                                       audio_stream_type_t stream,
-                                       uint32_t sampling_rate,
-                                       audio_format_t format,
-                                       audio_channel_mask_t channelMask,
-                                       audio_output_flags_t flags)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-
-    ALOGV("%s: tid %d", __func__, gettid());
-    return qap->apm->getOutput((AudioSystem::stream_type)stream,
-                               sampling_rate, (int) format, channelMask,
-                               (AudioSystem::output_flags)flags);
-}
-
-static int ap_start_output(struct audio_policy *pol, audio_io_handle_t output,
-                           audio_stream_type_t stream, int session)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    return qap->apm->startOutput(output, (AudioSystem::stream_type)stream,
-                                 session);
-}
-
-static int ap_stop_output(struct audio_policy *pol, audio_io_handle_t output,
-                          audio_stream_type_t stream, int session)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    return qap->apm->stopOutput(output, (AudioSystem::stream_type)stream,
-                                session);
-}
-
-static void ap_release_output(struct audio_policy *pol,
-                              audio_io_handle_t output)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    qap->apm->releaseOutput(output);
-}
-
-static audio_io_handle_t ap_get_input(struct audio_policy *pol, audio_source_t inputSource,
-                                      uint32_t sampling_rate,
-                                      audio_format_t format,
-                                      audio_channel_mask_t channelMask,
-                                      audio_in_acoustics_t acoustics)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    return qap->apm->getInput((int) inputSource, sampling_rate, (int) format, channelMask,
-                              (AudioSystem::audio_in_acoustics)acoustics);
-}
-
-static int ap_start_input(struct audio_policy *pol, audio_io_handle_t input)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    return qap->apm->startInput(input);
-}
-
-static int ap_stop_input(struct audio_policy *pol, audio_io_handle_t input)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    return qap->apm->stopInput(input);
-}
-
-static void ap_release_input(struct audio_policy *pol, audio_io_handle_t input)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    qap->apm->releaseInput(input);
-}
-
-static void ap_init_stream_volume(struct audio_policy *pol,
-                                  audio_stream_type_t stream, int index_min,
-                                  int index_max)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    qap->apm->initStreamVolume((AudioSystem::stream_type)stream, index_min,
-                               index_max);
-}
-
-static int ap_set_stream_volume_index(struct audio_policy *pol,
-                                      audio_stream_type_t stream,
-                                      int index)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    return qap->apm->setStreamVolumeIndex((AudioSystem::stream_type)stream,
-                                          index,
-                                          AUDIO_DEVICE_OUT_DEFAULT);
-}
-
-static int ap_get_stream_volume_index(const struct audio_policy *pol,
-                                      audio_stream_type_t stream,
-                                      int *index)
-{
-    const struct qcom_audio_policy *qap = to_cqap(pol);
-    return qap->apm->getStreamVolumeIndex((AudioSystem::stream_type)stream,
-                                          index,
-                                          AUDIO_DEVICE_OUT_DEFAULT);
-}
-
-static int ap_set_stream_volume_index_for_device(struct audio_policy *pol,
-                                      audio_stream_type_t stream,
-                                      int index,
-                                      audio_devices_t device)
-{
-   const struct qcom_audio_policy *qap = to_cqap(pol);
-   return qap->apm->setStreamVolumeIndex((AudioSystem::stream_type)stream,
-                                          index,
-                                          device);
-}
-
-static int ap_get_stream_volume_index_for_device(const struct audio_policy *pol,
-                                      audio_stream_type_t stream,
-                                      int *index,
-                                      audio_devices_t device)
-{
-   const struct qcom_audio_policy *qap = to_cqap(pol);
-   return qap->apm->getStreamVolumeIndex((AudioSystem::stream_type)stream,
-                                          index,
-                                          device);
-}
-
-static uint32_t ap_get_strategy_for_stream(const struct audio_policy *pol,
-                                           audio_stream_type_t stream)
-{
-    const struct qcom_audio_policy *qap = to_cqap(pol);
-    return qap->apm->getStrategyForStream((AudioSystem::stream_type)stream);
-}
-
-static audio_devices_t ap_get_devices_for_stream(const struct audio_policy *pol,
-                                       audio_stream_type_t stream)
-{
-    const struct qcom_audio_policy *qap = to_cqap(pol);
-    return qap->apm->getDevicesForStream((AudioSystem::stream_type)stream);
-}
-
-static audio_io_handle_t ap_get_output_for_effect(struct audio_policy *pol,
-                                            const struct effect_descriptor_s *desc)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    return qap->apm->getOutputForEffect(desc);
-}
-
-static int ap_register_effect(struct audio_policy *pol,
-                              const struct effect_descriptor_s *desc,
-                              audio_io_handle_t io,
-                              uint32_t strategy,
-                              int session,
-                              int id)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    return qap->apm->registerEffect(desc, io, strategy, session, id);
-}
-
-static int ap_unregister_effect(struct audio_policy *pol, int id)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    return qap->apm->unregisterEffect(id);
-}
-
-static int ap_set_effect_enabled(struct audio_policy *pol, int id, bool enabled)
-{
-    struct qcom_audio_policy *qap = to_qap(pol);
-    return qap->apm->setEffectEnabled(id, enabled);
-}
-
-static bool ap_is_stream_active(const struct audio_policy *pol, 
-                                audio_stream_type_t stream,
-                                uint32_t in_past_ms)
-{
-    const struct qcom_audio_policy *qap = to_cqap(pol);
-    return qap->apm->isStreamActive((int) stream, in_past_ms);
-}
-
-static bool ap_is_stream_active_remotely(const struct audio_policy *pol,
-        audio_stream_type_t stream, uint32_t in_past_ms)
-{
-    const struct qcom_audio_policy *qap = to_cqap(pol);
-    return qap->apm->isStreamActiveRemotely((int) stream, in_past_ms);
-}
-
-static bool ap_is_source_active(const struct audio_policy *pol, audio_source_t source)
-{
-    const struct qcom_audio_policy *qap = to_cqap(pol);
-    return qap->apm->isSourceActive(source);
-}
-
-static int ap_dump(const struct audio_policy *pol, int fd)
-{
-    const struct qcom_audio_policy *qap = to_cqap(pol);
-    return qap->apm->dump(fd);
-}
-
-static int create_qcom_ap(const struct audio_policy_device *device,
-                            struct audio_policy_service_ops *aps_ops,
-                            void *service,
-                            struct audio_policy **ap)
-{
-    struct qcom_audio_policy *qap;
-    int ret;
-
-    if (!service || !aps_ops)
-        return -EINVAL;
-
-    qap = (struct qcom_audio_policy *)calloc(1, sizeof(*qap));
-    if (!qap)
-        return -ENOMEM;
-
-    qap->policy.set_device_connection_state = ap_set_device_connection_state;
-    qap->policy.get_device_connection_state = ap_get_device_connection_state;
-    qap->policy.set_phone_state = ap_set_phone_state;
-    qap->policy.set_ringer_mode = ap_set_ringer_mode;
-    qap->policy.set_force_use = ap_set_force_use;
-    qap->policy.get_force_use = ap_get_force_use;
-    qap->policy.set_can_mute_enforced_audible =
-        ap_set_can_mute_enforced_audible;
-    qap->policy.init_check = ap_init_check;
-    qap->policy.get_output = ap_get_output;
-    qap->policy.start_output = ap_start_output;
-    qap->policy.stop_output = ap_stop_output;
-    qap->policy.release_output = ap_release_output;
-    qap->policy.get_input = ap_get_input;
-    qap->policy.start_input = ap_start_input;
-    qap->policy.stop_input = ap_stop_input;
-    qap->policy.release_input = ap_release_input;
-    qap->policy.init_stream_volume = ap_init_stream_volume;
-    qap->policy.set_stream_volume_index = ap_set_stream_volume_index;
-    qap->policy.get_stream_volume_index = ap_get_stream_volume_index;
-    qap->policy.set_stream_volume_index_for_device = ap_set_stream_volume_index_for_device;
-    qap->policy.get_stream_volume_index_for_device = ap_get_stream_volume_index_for_device;
-    qap->policy.get_strategy_for_stream = ap_get_strategy_for_stream;
-    qap->policy.get_devices_for_stream = ap_get_devices_for_stream;
-    qap->policy.get_output_for_effect = ap_get_output_for_effect;
-    qap->policy.register_effect = ap_register_effect;
-    qap->policy.unregister_effect = ap_unregister_effect;
-    qap->policy.set_effect_enabled = ap_set_effect_enabled;
-    qap->policy.is_stream_active = ap_is_stream_active;
-    qap->policy.is_stream_active_remotely = ap_is_stream_active_remotely;
-    qap->policy.is_source_active = ap_is_source_active;
-    qap->policy.dump = ap_dump;
-
-    qap->service = service;
-    qap->aps_ops = aps_ops;
-    qap->service_client =
-        new AudioPolicyCompatClient(aps_ops, service);
-    if (!qap->service_client) {
-        ret = -ENOMEM;
-        goto err_new_compat_client;
-    }
-
-    qap->apm = createAudioPolicyManager(qap->service_client);
-    if (!qap->apm) {
-        ret = -ENOMEM;
-        goto err_create_apm;
-    }
-
-    *ap = &qap->policy;
-    return 0;
-
-err_create_apm:
-    delete qap->service_client;
-err_new_compat_client:
-    free(qap);
-    *ap = NULL;
-    return ret;
-}
-
-static int destroy_qcom_ap(const struct audio_policy_device *ap_dev,
-                             struct audio_policy *ap)
-{
-    struct qcom_audio_policy *qap = to_qap(ap);
-
-    if (!qap)
-        return 0;
-
-    if (qap->apm)
-        destroyAudioPolicyManager(qap->apm);
-    if (qap->service_client)
-        delete qap->service_client;
-    free(qap);
-    return 0;
-}
-
-static int qcom_ap_dev_close(hw_device_t* device)
-{
-    if (device)
-        free(device);
-    return 0;
-}
-
-static int qcom_ap_dev_open(const hw_module_t* module, const char* name,
-                                    hw_device_t** device)
-{
-    struct qcom_ap_device *dev;
-
-    if (strcmp(name, AUDIO_POLICY_INTERFACE) != 0)
-        return -EINVAL;
-
-    dev = (struct qcom_ap_device *)calloc(1, sizeof(*dev));
-    if (!dev)
-        return -ENOMEM;
-
-    dev->device.common.tag = HARDWARE_DEVICE_TAG;
-    dev->device.common.version = 0;
-    dev->device.common.module = const_cast<hw_module_t*>(module);
-    dev->device.common.close = qcom_ap_dev_close;
-    dev->device.create_audio_policy = create_qcom_ap;
-    dev->device.destroy_audio_policy = destroy_qcom_ap;
-
-    *device = &dev->device.common;
-
-    return 0;
-}
-
-static struct hw_module_methods_t qcom_ap_module_methods = {
-        open: qcom_ap_dev_open
-};
-
-struct qcom_ap_module HAL_MODULE_INFO_SYM = {
-    module: {
-        common: {
-            tag: HARDWARE_MODULE_TAG,
-            version_major: 1,
-            version_minor: 0,
-            id: AUDIO_POLICY_HARDWARE_MODULE_ID,
-            name: "QCOM Audio Policy HAL",
-            author: "The Linux Foundation",
-            methods: &qcom_ap_module_methods,
-            dso : NULL,
-            reserved : {0},
-        },
-    },
-};
-
-}; // extern "C"
-
-}; // namespace android_audio_legacy
diff --git a/legacy/libalsa-intf/Android.mk b/legacy/libalsa-intf/Android.mk
deleted file mode 100644
index 5d509b3..0000000
--- a/legacy/libalsa-intf/Android.mk
+++ /dev/null
@@ -1,54 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-
-ifeq ($(strip $(BOARD_USES_ALSA_AUDIO)),true)
-# Any prebuilt files with default TAGS can use the below:
-
-include $(CLEAR_VARS)
-#LOCAL_SRC_FILES:= aplay.c alsa_pcm.c alsa_mixer.c
-LOCAL_SRC_FILES:= aplay.c
-LOCAL_MODULE:= aplay
-LOCAL_SHARED_LIBRARIES:= libc libcutils libalsa-intf
-LOCAL_MODULE_TAGS:= debug
-include $(BUILD_EXECUTABLE)
-
-include $(CLEAR_VARS)
-#LOCAL_SRC_FILES:= arec.c alsa_pcm.c
-LOCAL_SRC_FILES:= arec.c
-LOCAL_MODULE:= arec
-LOCAL_SHARED_LIBRARIES:= libc libcutils libalsa-intf
-LOCAL_MODULE_TAGS:= debug
-include $(BUILD_EXECUTABLE)
-
-include $(CLEAR_VARS)
-LOCAL_SRC_FILES:= amix.c
-LOCAL_MODULE:= amix
-LOCAL_SHARED_LIBRARIES := libc libcutils libalsa-intf
-LOCAL_MODULE_TAGS:= debug
-include $(BUILD_EXECUTABLE)
-
-include $(CLEAR_VARS)
-LOCAL_SRC_FILES:= alsaucm_test.c
-LOCAL_MODULE:= alsaucm_test
-LOCAL_SHARED_LIBRARIES:= libc libcutils libalsa-intf
-LOCAL_MODULE_TAGS:= debug
-include $(BUILD_EXECUTABLE)
-
-include $(CLEAR_VARS)
-LOCAL_COPY_HEADERS_TO   := mm-audio/libalsa-intf
-LOCAL_COPY_HEADERS      := alsa_audio.h
-LOCAL_COPY_HEADERS      += alsa_ucm.h
-LOCAL_COPY_HEADERS      += msm8960_use_cases.h
-LOCAL_SRC_FILES:= alsa_mixer.c alsa_pcm.c alsa_ucm.c
-LOCAL_MODULE:= libalsa-intf
-LOCAL_MODULE_TAGS := optional
-LOCAL_SHARED_LIBRARIES:= libc libcutils #libutils #libmedia libhardware_legacy
-LOCAL_CFLAGS := -DQC_PROP -DCONFIG_DIR=\"/system/etc/snd_soc_msm/\"
-
-ifeq ($(TARGET_SIMULATOR),true)
- LOCAL_LDLIBS += -ldl
-else
- LOCAL_SHARED_LIBRARIES += libdl
-endif
-LOCAL_PRELINK_MODULE := false
-include $(BUILD_SHARED_LIBRARY)
-endif
diff --git a/legacy/libalsa-intf/Makefile.am b/legacy/libalsa-intf/Makefile.am
deleted file mode 100644
index a05d073..0000000
--- a/legacy/libalsa-intf/Makefile.am
+++ /dev/null
@@ -1,47 +0,0 @@
-AM_CFLAGS = -Wundef \
-        -Wstrict-prototypes \
-        -Wno-trigraphs \
-        -g -O0 \
-        -fno-inline \
-        -fno-short-enums \
-        -fpic \
-        -DQC_PROP
-
-AM_CPPFLAGS = -I. \
-               $(ACDBLOADER_CFLAGS)
-
-c_sources = alsa_mixer.c \
-            alsa_pcm.c \
-            alsa_ucm.c
-
-h_sources = alsa_ucm.h \
-            msm8960_use_cases.h \
-            alsa_audio.h
-
-library_includedir = $(pkgincludedir)
-library_include_HEADERS = $(h_sources)
-
-lib_LTLIBRARIES = libalsa_intf.la
-libalsa_intf_la_CC = @CC@
-libalsa_intf_la_SOURCES = $(c_sources) $(h_sources)
-libalsa_intfdir = $(prefix)/snd_soc_msm
-dist_libalsa_intf_DATA    = snd_soc_msm/snd_soc_msm \
-                            snd_soc_msm/snd_soc_msm_2x \
-                            snd_soc_msm/snd_soc_msm_2x_Fusion3 \
-                            snd_soc_msm/snd_soc_msm_Sitar
-libalsa_intf_la_CFLAGS = $(AM_CFLAGS) -DUSE_GLIB @GLIB_CFLAGS@ -DCONFIG_DIR=\"/etc/snd_soc_msm/\"
-libalsa_intf_la_CPPFLAGS = $(AM_CPPFLAGS) -DUSE_GLIB @GLIB_CFLAGS@
-libalsa_intf_la_LDFLAGS = $(ACDBLOADER_LIBS) -lm -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
-
-requiredlibs = libalsa_intf.la
-
-bin_PROGRAMS = aplay amix arec
-
-aplay_SOURCES = aplay.c
-aplay_LDADD = -lpthread $(requiredlibs)
-
-amix_SOURCES = amix.c
-amix_LDADD = -lpthread $(requiredlibs)
-
-arec_SOURCES = arec.c
-arec_LDADD = -lpthread $(requiredlibs)
diff --git a/legacy/libalsa-intf/alsa_audio.h b/legacy/libalsa-intf/alsa_audio.h
deleted file mode 100644
index 90fbe56..0000000
--- a/legacy/libalsa-intf/alsa_audio.h
+++ /dev/null
@@ -1,291 +0,0 @@
-/*
-** Copyright 2010, The Android Open-Source Project
-** Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
-**
-** 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.
-*/
-
-#ifndef _AUDIO_H_
-#define _AUDIO_H_
-
-#include <sound/asound.h>
-#define PCM_ERROR_MAX 128
-
-struct pcm {
-    int fd;
-    int timer_fd;
-    unsigned rate;
-    unsigned channels;
-    unsigned flags;
-    unsigned format;
-    unsigned running:1;
-    int underruns;
-    unsigned buffer_size;
-    unsigned period_size;
-    unsigned period_cnt;
-    char error[PCM_ERROR_MAX];
-    struct snd_pcm_hw_params *hw_p;
-    struct snd_pcm_sw_params *sw_p;
-    struct snd_pcm_sync_ptr *sync_ptr;
-    struct snd_pcm_channel_info ch[2];
-    void *addr;
-    int card_no;
-    int device_no;
-    int start;
-};
-
-enum decoder_alias {
-    FORMAT_MP3,
-    FORMAT_AC3_PASS_THROUGH = 2,
-};
-
-#define FORMAT(v) SNDRV_PCM_FORMAT_##v
-
-#define PCM_OUT        0x00000000
-#define PCM_IN         0x10000000
-
-#define PCM_STEREO     0x00000000
-#define PCM_MONO       0x01000000
-#define PCM_QUAD       0x02000000
-#define PCM_5POINT1    0x04000000
-
-#define PCM_44100HZ    0x00000000
-#define PCM_48000HZ    0x00100000
-#define PCM_8000HZ     0x00200000
-#define PCM_RATE_MASK  0x00F00000
-
-#define PCM_MMAP       0x00010000
-#define PCM_NMMAP      0x00000000
-
-#define DEBUG_ON       0x00000001
-#define DEBUG_OFF      0x00000000
-
-#define PCM_PERIOD_CNT_MIN 2
-#define PCM_PERIOD_CNT_SHIFT 16
-#define PCM_PERIOD_CNT_MASK (0xF << PCM_PERIOD_CNT_SHIFT)
-#define PCM_PERIOD_SZ_MIN 128
-#define PCM_PERIOD_SZ_SHIFT 12
-#define PCM_PERIOD_SZ_MASK (0xF << PCM_PERIOD_SZ_SHIFT)
-
-#define TIMEOUT_INFINITE  -1
-
-/* Acquire/release a pcm channel.
- * Returns non-zero on error
- */
-
-struct mixer_ctl {
-    struct mixer *mixer;
-    struct snd_ctl_elem_info *info;
-    char **ename;
-};
-
-#define __snd_alloca(ptr,type) do { *ptr = (type *) alloca(sizeof(type)); memset(*ptr, 0, sizeof(type)); } while (0)
-#define snd_ctl_elem_id_alloca(ptr) __snd_alloca(ptr, snd_ctl_elem_id)
-#define snd_ctl_card_info_alloca(ptr) __snd_alloca(ptr, snd_ctl_card_info)
-#define snd_ctl_event_alloca(ptr) __snd_alloca(ptr, snd_ctl_event)
-#define snd_ctl_elem_list_alloca(ptr) __snd_alloca(ptr, snd_ctl_elem_list)
-#define snd_ctl_elem_info_alloca(ptr) __snd_alloca(ptr, snd_ctl_elem_info)
-#define snd_ctl_elem_value_alloca(ptr) __snd_alloca(ptr, snd_ctl_elem_value)
-
-
-enum snd_pcm_stream_t {
-        /** Playback stream */
-        SND_PCM_STREAM_PLAYBACK = 0,
-        /** Capture stream */
-        SND_PCM_STREAM_CAPTURE,
-        SND_PCM_STREAM_LAST = SND_PCM_STREAM_CAPTURE
-};
-
-enum _snd_ctl_elem_iface {
-        /** Card level */
-        SND_CTL_ELEM_IFACE_CARD = 0,
-        /** Hardware dependent device */
-        SND_CTL_ELEM_IFACE_HWDEP,
-        /** Mixer */
-        SND_CTL_ELEM_IFACE_MIXER,
-        /** PCM */
-        SND_CTL_ELEM_IFACE_PCM,
-        /** RawMidi */
-        SND_CTL_ELEM_IFACE_RAWMIDI,
-        /** Timer */
-        SND_CTL_ELEM_IFACE_TIMER,
-        /** Sequencer */
-        SND_CTL_ELEM_IFACE_SEQUENCER,
-        SND_CTL_ELEM_IFACE_LAST = SND_CTL_ELEM_IFACE_SEQUENCER
-};
-
-struct mixer {
-    int fd;
-    struct snd_ctl_elem_info *info;
-    struct mixer_ctl *ctl;
-    unsigned count;
-};
-
-int get_format(const char* name);
-const char *get_format_name(int format);
-const char *get_format_desc(int format);
-struct pcm *pcm_open(unsigned flags, char *device);
-int pcm_close(struct pcm *pcm);
-int pcm_ready(struct pcm *pcm);
-int mmap_buffer(struct pcm *pcm);
-u_int8_t *dst_address(struct pcm *pcm);
-int sync_ptr(struct pcm *pcm);
-
-void param_init(struct snd_pcm_hw_params *p);
-void param_set_mask(struct snd_pcm_hw_params *p, int n, unsigned bit);
-void param_set_min(struct snd_pcm_hw_params *p, int n, unsigned val);
-void param_set_int(struct snd_pcm_hw_params *p, int n, unsigned val);
-void param_set_max(struct snd_pcm_hw_params *p, int n, unsigned val);
-int param_set_hw_refine(struct pcm *pcm, struct snd_pcm_hw_params *params);
-int param_set_hw_params(struct pcm *pcm, struct snd_pcm_hw_params *params);
-int param_set_sw_params(struct pcm *pcm, struct snd_pcm_sw_params *sparams);
-void param_dump(struct snd_pcm_hw_params *p);
-int pcm_prepare(struct pcm *pcm);
-long pcm_avail(struct pcm *pcm);
-
-/* Returns a human readable reason for the last error. */
-const char *pcm_error(struct pcm *pcm);
-
-/* Returns the buffer size (int bytes) that should be used for pcm_write.
- * This will be 1/2 of the actual fifo size.
- */
-int pcm_buffer_size(struct snd_pcm_hw_params *params);
-int pcm_period_size(struct snd_pcm_hw_params *params);
-
-/* Write data to the fifo.
- * Will start playback on the first write or on a write that
- * occurs after a fifo underrun.
- */
-int pcm_write(struct pcm *pcm, void *data, unsigned count);
-int pcm_read(struct pcm *pcm, void *data, unsigned count);
-
-struct mixer;
-struct mixer_ctl;
-
-struct mixer *mixer_open(const char *device);
-void mixer_close(struct mixer *mixer);
-void mixer_dump(struct mixer *mixer);
-
-struct mixer_ctl *mixer_get_control(struct mixer *mixer,
-                                    const char *name, unsigned index);
-struct mixer_ctl *mixer_get_nth_control(struct mixer *mixer, unsigned n);
-
-int mixer_ctl_set(struct mixer_ctl *ctl, unsigned percent);
-int mixer_ctl_select(struct mixer_ctl *ctl, const char *value);
-void mixer_ctl_get(struct mixer_ctl *ctl, unsigned *value);
-int mixer_ctl_set_value(struct mixer_ctl *ctl, int count, char ** argv);
-
-
-#define MAX_NUM_CODECS 32
-
-/* compressed audio support */
-#ifdef QCOM_COMPRESSED_AUDIO_ENABLED
-struct snd_compr_caps {
-        __u32 num_codecs;
-        __u32 min_fragment_size;
-        __u32 max_fragment_size;
-        __u32 min_fragments;
-        __u32 max_fragments;
-        __u32 codecs[MAX_NUM_CODECS];
-        __u32 reserved[11];
-};
-
-struct snd_enc_wma {
-        __u32 super_block_align; /* WMA Type-specific data */
-	__u32 bits_per_sample;
-	__u32 channelmask;
-	__u32 encodeopt;
-};
-
-struct snd_enc_vorbis {
-        int quality;
-        __u32 managed;
-        __u32 max_bit_rate;
-        __u32 min_bit_rate;
-        __u32 downmix;
-};
-
-struct snd_enc_real {
-        __u32 quant_bits;
-        __u32 start_region;
-        __u32 num_regions;
-};
-
-struct snd_enc_flac {
-        __u32 num;
-        __u32 gain;
-};
-
-struct snd_enc_generic {
-        __u32 bw;       /* encoder bandwidth */
-        int reserved[15];
-};
-
-union snd_codec_options {
-        struct snd_enc_wma wma;
-        struct snd_enc_vorbis vorbis;
-        struct snd_enc_real real;
-        struct snd_enc_flac flac;
-        struct snd_enc_generic generic;
-};
-
-struct snd_codec {
-        __u32 id;
-        __u32 ch_in;
-        __u32 ch_out;
-        __u32 sample_rate;
-        __u32 bit_rate;
-        __u32 rate_control;
-        __u32 profile;
-        __u32 level;
-        __u32 ch_mode;
-        __u32 format;
-        __u32 align;
-        union snd_codec_options options;
-        __u32 reserved[3];
-};
-
-struct snd_compressed_buffer {
-        size_t fragment_size;
-        int fragments;
-};
-
-/* */
-struct snd_compr_params {
-        struct snd_compressed_buffer buffer;
-        struct snd_codec codec;
-};
-
-struct snd_compr_tstamp {
-        size_t copied_bytes;
-        size_t copied_total;
-        size_t decoded;
-        size_t rendered;
-        __u32 sampling_rate;
-        uint64_t timestamp;
-};
-
-#define SNDRV_COMPRESS_GET_CAPS         _IOWR('C', 0x00, struct snd_compr_caps *)
-#define SNDRV_COMPRESS_GET_CODEC_CAPS   _IOWR('C', 0x01, struct snd_compr_codec_caps *)
-#define SNDRV_COMPRESS_SET_PARAMS       _IOW('C', 0x02, struct snd_compr_params *)
-#define SNDRV_COMPRESS_GET_PARAMS       _IOR('C', 0x03, struct snd_compr_params *)
-#define SNDRV_COMPRESS_TSTAMP           _IOR('C', 0x10, struct snd_compr_tstamp *)
-#define SNDRV_COMPRESS_AVAIL            _IOR('C', 0x11, struct snd_compr_avail *)
-#define SNDRV_COMPRESS_PAUSE            _IO('C', 0x20)
-#define SNDRV_COMPRESS_RESUME           _IO('C', 0x21)
-#define SNDRV_COMPRESS_START            _IO('C', 0x22)
-#define SNDRV_COMPRESS_STOP             _IO('C', 0x23)
-#define SNDRV_COMPRESS_DRAIN            _IO('C', 0x24)
-#endif
-
-#endif
diff --git a/legacy/libalsa-intf/alsa_mixer.c b/legacy/libalsa-intf/alsa_mixer.c
deleted file mode 100644
index c3738f0..0000000
--- a/legacy/libalsa-intf/alsa_mixer.c
+++ /dev/null
@@ -1,752 +0,0 @@
-/*
-** Copyright 2010, The Android Open-Source Project
-** Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
-**
-** 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.
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <stdint.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <ctype.h>
-#include <math.h>
-
-#include <linux/ioctl.h>
-#define __force
-#define __bitwise
-#define __user
-#include <sound/asound.h>
-#include <sound/tlv.h>
-
-#include "alsa_audio.h"
-
-#define LOG_TAG "alsa_mixer"
-#define LOG_NDEBUG 1
-
-#ifdef ANDROID
-/* definitions for Android logging */
-#include <utils/Log.h>
-#else /* ANDROID */
-#include <math.h>
-#define ALOGI(...)      fprintf(stdout, __VA_ARGS__)
-#define ALOGE(...)      fprintf(stderr, __VA_ARGS__)
-#define ALOGV(...)      fprintf(stderr, __VA_ARGS__)
-#endif /* ANDROID */
-
-#define check_range(val, min, max) \
-        (((val < min) ? (min) : (val > max) ? (max) : (val)))
-
-/* .5 for rounding before casting to non-decmal value */
-/* Should not be used if you need decmal values */
-/* or are expecting negitive indexes */
-#define percent_to_index(val, min, max) \
-        ((val) * ((max) - (min)) * 0.01 + (min) + .5)
-
-#define DEFAULT_TLV_SIZE 4096
-#define SPDIF_CHANNEL_STATUS_SIZE 24
-
-enum ctl_type {
-	CTL_GLOBAL_VOLUME,
-	CTL_PLAYBACK_VOLUME,
-	CTL_CAPTURE_VOLUME,
-};
-
-static const struct suf {
-        const char *suffix;
-        snd_ctl_elem_iface_t type;
-} suffixes[] = {
-        {" Playback Volume", CTL_PLAYBACK_VOLUME},
-        {" Capture Volume", CTL_CAPTURE_VOLUME},
-        {" Volume", CTL_GLOBAL_VOLUME},
-        {NULL, 0}
-};
-
-static int is_volume(const char *name, enum ctl_type *type)
-{
-        const struct suf *p;
-        size_t nlen = strlen(name);
-        p = suffixes;
-        while (p->suffix) {
-                size_t slen = strnlen(p->suffix, 44);
-                size_t l;
-                if (nlen > slen) {
-                        l = nlen - slen;
-                        if (strncmp(name + l, p->suffix, slen) == 0 &&
-                            (l < 1 || name[l-1] != '-')) {      /* 3D Control - Switch */
-                                *type = p->type;
-                                return l;
-                        }
-                }
-                p++;
-        }
-	return 0;
-}
-
-static const char *elem_iface_name(snd_ctl_elem_iface_t n)
-{
-    switch (n) {
-    case SNDRV_CTL_ELEM_IFACE_CARD: return "CARD";
-    case SNDRV_CTL_ELEM_IFACE_HWDEP: return "HWDEP";
-    case SNDRV_CTL_ELEM_IFACE_MIXER: return "MIXER";
-    case SNDRV_CTL_ELEM_IFACE_PCM: return "PCM";
-    case SNDRV_CTL_ELEM_IFACE_RAWMIDI: return "MIDI";
-    case SNDRV_CTL_ELEM_IFACE_TIMER: return "TIMER";
-    case SNDRV_CTL_ELEM_IFACE_SEQUENCER: return "SEQ";
-    default: return "???";
-    }
-}
-
-static const char *elem_type_name(snd_ctl_elem_type_t n)
-{
-    switch (n) {
-    case SNDRV_CTL_ELEM_TYPE_NONE: return "NONE";
-    case SNDRV_CTL_ELEM_TYPE_BOOLEAN: return "BOOL";
-    case SNDRV_CTL_ELEM_TYPE_INTEGER: return "INT32";
-    case SNDRV_CTL_ELEM_TYPE_ENUMERATED: return "ENUM";
-    case SNDRV_CTL_ELEM_TYPE_BYTES: return "BYTES";
-    case SNDRV_CTL_ELEM_TYPE_IEC958: return "IEC958";
-    case SNDRV_CTL_ELEM_TYPE_INTEGER64: return "INT64";
-    default: return "???";
-    }
-}
-
-void mixer_close(struct mixer *mixer)
-{
-    unsigned n,m;
-
-    if (mixer->fd >= 0)
-        close(mixer->fd);
-
-    if (mixer->ctl) {
-        for (n = 0; n < mixer->count; n++) {
-            if (mixer->ctl[n].ename) {
-                unsigned max = mixer->ctl[n].info->value.enumerated.items;
-                for (m = 0; m < max; m++)
-                    free(mixer->ctl[n].ename[m]);
-                free(mixer->ctl[n].ename);
-            }
-        }
-        free(mixer->ctl);
-    }
-
-    if (mixer->info)
-        free(mixer->info);
-
-    free(mixer);
-}
-
-struct mixer *mixer_open(const char *device)
-{
-    struct snd_ctl_elem_list elist;
-    struct snd_ctl_elem_info tmp;
-    struct snd_ctl_elem_id *eid = NULL;
-    struct mixer *mixer = NULL;
-    unsigned n, m;
-    int fd;
-
-    fd = open(device, O_RDWR);
-    if (fd < 0) {
-        ALOGE("Control open failed\n");
-        return 0;
-    }
-
-    memset(&elist, 0, sizeof(elist));
-    if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_LIST, &elist) < 0) {
-        ALOGE("SNDRV_CTL_IOCTL_ELEM_LIST failed\n");
-        goto fail;
-    }
-
-    mixer = calloc(1, sizeof(*mixer));
-    if (!mixer)
-        goto fail;
-
-    mixer->ctl = calloc(elist.count, sizeof(struct mixer_ctl));
-    mixer->info = calloc(elist.count, sizeof(struct snd_ctl_elem_info));
-    if (!mixer->ctl || !mixer->info)
-        goto fail;
-
-    eid = calloc(elist.count, sizeof(struct snd_ctl_elem_id));
-    if (!eid)
-        goto fail;
-
-    mixer->count = elist.count;
-    mixer->fd = fd;
-    elist.space = mixer->count;
-    elist.pids = eid;
-    if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_LIST, &elist) < 0)
-        goto fail;
-
-    for (n = 0; n < mixer->count; n++) {
-        struct snd_ctl_elem_info *ei = mixer->info + n;
-        ei->id.numid = eid[n].numid;
-        if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_INFO, ei) < 0)
-            goto fail;
-        mixer->ctl[n].info = ei;
-        mixer->ctl[n].mixer = mixer;
-        if (ei->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
-            char **enames = calloc(ei->value.enumerated.items, sizeof(char*));
-            if (!enames)
-                goto fail;
-            mixer->ctl[n].ename = enames;
-            for (m = 0; m < ei->value.enumerated.items; m++) {
-                memset(&tmp, 0, sizeof(tmp));
-                tmp.id.numid = ei->id.numid;
-                tmp.value.enumerated.item = m;
-                if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_INFO, &tmp) < 0)
-                    goto fail;
-                enames[m] = strdup(tmp.value.enumerated.name);
-                if (!enames[m])
-                    goto fail;
-            }
-        }
-    }
-
-    free(eid);
-    return mixer;
-
-fail:
-    if (eid)
-        free(eid);
-    if (mixer)
-        mixer_close(mixer);
-    else if (fd >= 0)
-        close(fd);
-    return 0;
-}
-
-void mixer_dump(struct mixer *mixer)
-{
-    unsigned n, m;
-
-    ALOGV("  id iface dev sub idx num perms     type   isvolume  name\n");
-    for (n = 0; n < mixer->count; n++) {
-	enum ctl_type type;
-        struct snd_ctl_elem_info *ei = mixer->info + n;
-
-        ALOGV("%4d %5s %3d %3d %3d %3d %c%c%c%c%c%c%c%c%c %-6s %8d  %s",
-               ei->id.numid, elem_iface_name(ei->id.iface),
-               ei->id.device, ei->id.subdevice, ei->id.index,
-               ei->count,
-               (ei->access & SNDRV_CTL_ELEM_ACCESS_READ) ? 'r' : ' ',
-               (ei->access & SNDRV_CTL_ELEM_ACCESS_WRITE) ? 'w' : ' ',
-               (ei->access & SNDRV_CTL_ELEM_ACCESS_VOLATILE) ? 'V' : ' ',
-               (ei->access & SNDRV_CTL_ELEM_ACCESS_TIMESTAMP) ? 'T' : ' ',
-               (ei->access & SNDRV_CTL_ELEM_ACCESS_TLV_READ) ? 'R' : ' ',
-               (ei->access & SNDRV_CTL_ELEM_ACCESS_TLV_WRITE) ? 'W' : ' ',
-               (ei->access & SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND) ? 'C' : ' ',
-               (ei->access & SNDRV_CTL_ELEM_ACCESS_INACTIVE) ? 'I' : ' ',
-               (ei->access & SNDRV_CTL_ELEM_ACCESS_LOCK) ? 'L' : ' ',
-               elem_type_name(ei->type),
-	       (is_volume(ei->id.name, &type)) ? 1 : 0,
-               ei->id.name);
-        switch (ei->type) {
-        case SNDRV_CTL_ELEM_TYPE_INTEGER:
-            ALOGV(ei->value.integer.step ?
-                   " { %ld-%ld, %ld }\n" : " { %ld-%ld }",
-                   ei->value.integer.min,
-                   ei->value.integer.max,
-                   ei->value.integer.step);
-            break;
-        case SNDRV_CTL_ELEM_TYPE_INTEGER64:
-            ALOGV(ei->value.integer64.step ?
-                   " { %lld-%lld, %lld }\n" : " { %lld-%lld }",
-                   ei->value.integer64.min,
-                   ei->value.integer64.max,
-                   ei->value.integer64.step);
-            break;
-        case SNDRV_CTL_ELEM_TYPE_ENUMERATED: {
-            unsigned m;
-            ALOGV(" { %s=0", mixer->ctl[n].ename[0]);
-            for (m = 1; m < ei->value.enumerated.items; m++)
-                ALOGV(", %s=%d", mixer->ctl[n].ename[m],m);
-            ALOGV(" }");
-            break;
-        }
-        }
-        ALOGV("\n");
-    }
-}
-
-struct mixer_ctl *mixer_get_control(struct mixer *mixer,
-                                    const char *name, unsigned index)
-{
-    unsigned n;
-    for (n = 0; n < mixer->count; n++) {
-        if (mixer->info[n].id.index == index) {
-            if (!strncmp(name, (char*) mixer->info[n].id.name,
-			sizeof(mixer->info[n].id.name))) {
-                return mixer->ctl + n;
-            }
-        }
-    }
-    return 0;
-}
-
-struct mixer_ctl *mixer_get_nth_control(struct mixer *mixer, unsigned n)
-{
-    if (n < mixer->count)
-        return mixer->ctl + n;
-    return 0;
-}
-
-static void print_dB(long dB)
-{
-        ALOGV("%li.%02lidB", dB / 100, (dB < 0 ? -dB : dB) % 100);
-}
-
-int mixer_ctl_read_tlv(struct mixer_ctl *ctl,
-                    unsigned int *tlv,
-		    long *min, long *max, unsigned int *tlv_type)
-{
-    unsigned int tlv_size = DEFAULT_TLV_SIZE;
-    unsigned int type;
-    unsigned int size;
-
-    if(!!(ctl->info->access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)) {
-        struct snd_ctl_tlv *xtlv;
-        tlv[0] = -1;
-        tlv[1] = 0;
-        xtlv = calloc(1, sizeof(struct snd_ctl_tlv) + tlv_size);
-        if (xtlv == NULL)
-                return -ENOMEM;
-        xtlv->numid = ctl->info->id.numid;
-        xtlv->length = tlv_size;
-        memcpy(xtlv->tlv, tlv, tlv_size);
-        if (ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_TLV_READ, xtlv) < 0) {
-            fprintf( stderr, "SNDRV_CTL_IOCTL_TLV_READ failed\n");
-            free(xtlv);
-            return -errno;
-        }
-        if (xtlv->tlv[1] + 2 * sizeof(unsigned int) > tlv_size) {
-            free(xtlv);
-            return -EFAULT;
-        }
-        memcpy(tlv, xtlv->tlv, xtlv->tlv[1] + 2 * sizeof(unsigned int));
-        free(xtlv);
-
-        type = tlv[0];
-	*tlv_type = type;
-        size = tlv[1];
-        switch (type) {
-        case SNDRV_CTL_TLVT_DB_SCALE: {
-                int idx = 2;
-                int step;
-                ALOGV("dBscale-");
-                if (size != 2 * sizeof(unsigned int)) {
-                        while (size > 0) {
-                                ALOGV("0x%08x,", tlv[idx++]);
-                                size -= sizeof(unsigned int);
-                        }
-                } else {
-                    ALOGV(" min=");
-                    print_dB((int)tlv[2]);
-                    *min = (long)tlv[2];
-                    ALOGV(" step=");
-                    step = (tlv[3] & 0xffff);
-                    print_dB(tlv[3] & 0xffff);
-                    ALOGV(" max=");
-                    *max = (ctl->info->value.integer.max);
-                    print_dB((long)ctl->info->value.integer.max);
-                    ALOGV(" mute=%i\n", (tlv[3] >> 16) & 1);
-                }
-            break;
-        }
-        case SNDRV_CTL_TLVT_DB_LINEAR: {
-                int idx = 2;
-                ALOGV("dBLiner-");
-                if (size != 2 * sizeof(unsigned int)) {
-                        while (size > 0) {
-                                ALOGV("0x%08x,", tlv[idx++]);
-                                size -= sizeof(unsigned int);
-                        }
-                } else {
-                    ALOGV(" min=");
-                    *min = tlv[2];
-                    print_dB(tlv[2]);
-                    ALOGV(" max=");
-                    *max = tlv[3];
-                    print_dB(tlv[3]);
-                }
-            break;
-        }
-        default:
-             break;
-        }
-        return 0;
-    }
-    return -EINVAL;
-}
-
-void mixer_ctl_get(struct mixer_ctl *ctl, unsigned *value)
-{
-    struct snd_ctl_elem_value ev;
-    unsigned int n;
-    unsigned int *tlv = NULL;
-    enum ctl_type type;
-    unsigned int *tlv_type;
-    long min, max;
-
-    if (is_volume(ctl->info->id.name, &type)) {
-       ALOGV("capability: volume\n");
-       tlv = calloc(1, DEFAULT_TLV_SIZE);
-       if (tlv == NULL) {
-           ALOGE("failed to allocate memory\n");
-       } else {
-	   mixer_ctl_read_tlv(ctl, tlv, &min, &max, &tlv_type);
-           free(tlv);
-       }
-    }
-
-    memset(&ev, 0, sizeof(ev));
-    ev.id.numid = ctl->info->id.numid;
-    if (ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_READ, &ev))
-        return;
-    ALOGV("%s:", ctl->info->id.name);
-
-    switch (ctl->info->type) {
-    case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
-        for (n = 0; n < ctl->info->count; n++)
-            ALOGV(" %s", ev.value.integer.value[n] ? "on" : "off");
-        *value = ev.value.integer.value[0];
-        break;
-    case SNDRV_CTL_ELEM_TYPE_INTEGER: {
-        for (n = 0; n < ctl->info->count; n++)
-            ALOGV(" %ld", ev.value.integer.value[n]);
-        *value = ev.value.integer.value[0];
-        break;
-    }
-    case SNDRV_CTL_ELEM_TYPE_INTEGER64:
-        for (n = 0; n < ctl->info->count; n++)
-            ALOGV(" %lld", ev.value.integer64.value[n]);
-        *value = ev.value.integer64.value[0];
-        break;
-    case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
-        for (n = 0; n < ctl->info->count; n++) {
-            unsigned v = ev.value.enumerated.item[n];
-            ALOGV(" %d (%s)", v,
-                   (v < ctl->info->value.enumerated.items) ? ctl->ename[v] : "???");
-        *value = ev.value.enumerated.item[0];
-        }
-        break;
-    default:
-        ALOGV(" ???");
-    }
-    ALOGV("\n");
-}
-
-static long scale_int(struct snd_ctl_elem_info *ei, unsigned _percent)
-{
-    long percent;
-
-    if (_percent > 100)
-        percent = 100;
-    else
-        percent = (long) _percent;
-
-    return (long)percent_to_index(percent, ei->value.integer.min, ei->value.integer.max);
-}
-
-static long long scale_int64(struct snd_ctl_elem_info *ei, unsigned _percent)
-{
-    long long percent;
-
-    if (_percent > 100)
-        percent = 100;
-    else
-        percent = (long) _percent;
-
-    return (long long)percent_to_index(percent, ei->value.integer.min, ei->value.integer.max);
-}
-
-/*
- * Add support for controls taking more than one parameter as input value
- * This is useful for volume controls which take two parameters as input value.
- */
-int mixer_ctl_mulvalues(struct mixer_ctl *ctl, int count, char ** argv)
-{
-    struct snd_ctl_elem_value ev;
-    unsigned n;
-
-    if (!ctl) {
-        ALOGV("can't find control\n");
-        return -1;
-    }
-    if (count < ctl->info->count || count > ctl->info->count)
-        return -EINVAL;
-
-
-    memset(&ev, 0, sizeof(ev));
-    ev.id.numid = ctl->info->id.numid;
-    switch (ctl->info->type) {
-    case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
-        for (n = 0; n < ctl->info->count; n++)
-            ev.value.integer.value[n] = !!atoi(argv[n]);
-        break;
-    case SNDRV_CTL_ELEM_TYPE_INTEGER: {
-        for (n = 0; n < ctl->info->count; n++) {
-             fprintf( stderr, "Value: %d idx:%d\n", atoi(argv[n]), n);
-             ev.value.integer.value[n] = atoi(argv[n]);
-        }
-        break;
-    }
-    case SNDRV_CTL_ELEM_TYPE_INTEGER64: {
-        for (n = 0; n < ctl->info->count; n++) {
-             long long value_ll = scale_int64(ctl->info, atoi(argv[n]));
-             fprintf( stderr, "ll_value = %lld\n", value_ll);
-             ev.value.integer64.value[n] = value_ll;
-        }
-        break;
-    }
-    default:
-        errno = EINVAL;
-        return errno;
-    }
-
-    return ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
-}
-
-int mixer_ctl_set(struct mixer_ctl *ctl, unsigned percent)
-{
-    struct snd_ctl_elem_value ev;
-    unsigned n;
-    long min, max;
-    unsigned int *tlv = NULL;
-    enum ctl_type type;
-    int volume = 0;
-    unsigned int tlv_type;
-
-    if (!ctl) {
-        ALOGV("can't find control\n");
-        return -1;
-    }
-
-    if (is_volume(ctl->info->id.name, &type)) {
-        ALOGV("capability: volume\n");
-        tlv = calloc(1, DEFAULT_TLV_SIZE);
-        if (tlv == NULL) {
-            ALOGE("failed to allocate memory\n");
-        } else if (!mixer_ctl_read_tlv(ctl, tlv, &min, &max, &tlv_type)) {
-            switch(tlv_type) {
-            case SNDRV_CTL_TLVT_DB_LINEAR:
-                ALOGV("tlv db linear: b4 %d\n", percent);
-
-		if (min < 0) {
-			max = max - min;
-			min = 0;
-		}
-                percent = check_range(percent, min, max);
-                ALOGV("tlv db linear: %d %d %d\n", percent, min, max);
-                volume = 1;
-                break;
-            default:
-                percent = (long)percent_to_index(percent, min, max);
-                percent = check_range(percent, min, max);
-                volume = 1;
-                break;
-            }
-        } else
-            ALOGV("mixer_ctl_read_tlv failed\n");
-        free(tlv);
-    }
-    memset(&ev, 0, sizeof(ev));
-    ev.id.numid = ctl->info->id.numid;
-    switch (ctl->info->type) {
-    case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
-        for (n = 0; n < ctl->info->count; n++)
-            ev.value.integer.value[n] = !!percent;
-        break;
-    case SNDRV_CTL_ELEM_TYPE_INTEGER: {
-        int value;
-        if (!volume)
-             value = scale_int(ctl->info, percent);
-        else
-             value = (int) percent;
-        for (n = 0; n < ctl->info->count; n++)
-            ev.value.integer.value[n] = value;
-        break;
-    }
-    case SNDRV_CTL_ELEM_TYPE_INTEGER64: {
-        long long value;
-        if (!volume)
-             value = scale_int64(ctl->info, percent);
-        else
-             value = (long long)percent;
-        for (n = 0; n < ctl->info->count; n++)
-            ev.value.integer64.value[n] = value;
-        break;
-    }
-    case SNDRV_CTL_ELEM_TYPE_IEC958: {
-        struct snd_aes_iec958 *iec958;
-        iec958 = (struct snd_aes_iec958 *)percent;
-        memcpy(ev.value.iec958.status,iec958->status,SPDIF_CHANNEL_STATUS_SIZE);
-        break;
-    }
-    default:
-        errno = EINVAL;
-        return errno;
-    }
-
-    return ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
-}
-
-/* the api parses the mixer control input to extract
- * the value of volume in any one of the following format
- * <volume><%>
- * <volume><dB>
- * All remaining formats are currently ignored.
- */
-
-static int set_volume_simple(struct mixer_ctl *ctl,
-    char **ptr, long pmin, long pmax, int count)
-{
-    long val, orig;
-    char *p = *ptr, *s;
-    struct snd_ctl_elem_value ev;
-    unsigned n;
-
-    if (*p == ':')
-        p++;
-    if (*p == '\0' || (!isdigit(*p) && *p != '-'))
-        goto skip;
-
-    s = p;
-    val = strtol(s, &p, 10);
-    if (*p == '.') {
-        p++;
-        strtol(p, &p, 10);
-    }
-    if (*p == '%') {
-        val = (long)percent_to_index(strtod(s, NULL), pmin, pmax);
-        p++;
-    } else if (p[0] == 'd' && p[1] == 'B') {
-        val = (long)(strtod(s, NULL) * 100.0);
-        p += 2;
-    } else {
-        if (pmin < 0) {
-            pmax = pmax - pmin;
-            pmin = 0;
-        }
-    }
-    val = check_range(val, pmin, pmax);
-    ALOGV("val = %x", val);
-
-    if (!ctl) {
-        ALOGV("can't find control\n");
-        return -EPERM;
-    }
-    if (count < ctl->info->count || count > ctl->info->count)
-        return -EINVAL;
-
-    ALOGV("Value = ");
-
-    memset(&ev, 0, sizeof(ev));
-    ev.id.numid = ctl->info->id.numid;
-    switch (ctl->info->type) {
-    case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
-        for (n = 0; n < ctl->info->count; n++)
-            ev.value.integer.value[n] = !!val;
-        print_dB(val);
-        break;
-    case SNDRV_CTL_ELEM_TYPE_INTEGER: {
-        for (n = 0; n < ctl->info->count; n++)
-             ev.value.integer.value[n] = val;
-        print_dB(val);
-        break;
-    }
-    case SNDRV_CTL_ELEM_TYPE_INTEGER64: {
-        for (n = 0; n < ctl->info->count; n++) {
-             long long value_ll = scale_int64(ctl->info, val);
-             print_dB(value_ll);
-             ev.value.integer64.value[n] = value_ll;
-        }
-        break;
-    }
-    default:
-        errno = EINVAL;
-        return errno;
-    }
-
-    ALOGV("\n");
-    return ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
-
-skip:
-        if (*p == ',')
-                p++;
-        *ptr = p;
-        return 0;
-}
-
-int mixer_ctl_set_value(struct mixer_ctl *ctl, int count, char ** argv)
-{
-    unsigned int size;
-    unsigned int *tlv = NULL;
-    long min, max;
-    enum ctl_type type;
-    unsigned int tlv_type;
-
-    if (is_volume(ctl->info->id.name, &type)) {
-        ALOGV("capability: volume\n");
-        tlv = calloc(1, DEFAULT_TLV_SIZE);
-        if (tlv == NULL) {
-            ALOGE("failed to allocate memory\n");
-        } else if (!mixer_ctl_read_tlv(ctl, tlv, &min, &max, &tlv_type)) {
-            ALOGV("min = %x max = %x", min, max);
-            if (set_volume_simple(ctl, argv, min, max, count))
-                mixer_ctl_mulvalues(ctl, count, argv);
-        } else
-            ALOGV("mixer_ctl_read_tlv failed\n");
-        free(tlv);
-    } else {
-        mixer_ctl_mulvalues(ctl, count, argv);
-    }
-    return 0;
-}
-
-
-int mixer_ctl_select(struct mixer_ctl *ctl, const char *value)
-{
-    unsigned n, max;
-    struct snd_ctl_elem_value ev;
-    unsigned int  input_str_len, str_len;
-
-    if (ctl->info->type != SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
-        errno = EINVAL;
-        return -1;
-    }
-
-    input_str_len =  strnlen(value,64);
-
-    max = ctl->info->value.enumerated.items;
-    for (n = 0; n < max; n++) {
-
-        str_len = strnlen(ctl->ename[n], 64);
-        if (str_len < input_str_len)
-            str_len = input_str_len;
-
-        if (!strncmp(value, ctl->ename[n], str_len)) {
-            memset(&ev, 0, sizeof(ev));
-            ev.value.enumerated.item[0] = n;
-            ev.id.numid = ctl->info->id.numid;
-            if (ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev) < 0)
-                return -1;
-            return 0;
-        }
-    }
-
-    errno = EINVAL;
-    return errno;
-}
diff --git a/legacy/libalsa-intf/alsa_pcm.c b/legacy/libalsa-intf/alsa_pcm.c
deleted file mode 100644
index 51c5691..0000000
--- a/legacy/libalsa-intf/alsa_pcm.c
+++ /dev/null
@@ -1,856 +0,0 @@
-/*
-** Copyright 2010, The Android Open-Source Project
-** Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
-**
-** 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 "alsa_pcm"
-#define LOG_NDEBUG 1
-#ifdef ANDROID
-/* definitions for Android logging */
-#include <utils/Log.h>
-#include <cutils/properties.h>
-#else /* ANDROID */
-#define strlcat g_strlcat
-#define strlcpy g_strlcpy
-#define ALOGI(...)      fprintf(stdout, __VA_ARGS__)
-#define ALOGE(...)      fprintf(stderr, __VA_ARGS__)
-#define ALOGV(...)      fprintf(stderr, __VA_ARGS__)
-#endif /* ANDROID */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <fcntl.h>
-#include <stdarg.h>
-#include <string.h>
-#include <errno.h>
-#include <unistd.h>
-#include <stdint.h>
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-#include <sys/time.h>
-#include <sys/poll.h>
-#include <linux/ioctl.h>
-#include <linux/types.h>
-
-#include "alsa_audio.h"
-
-#define __force
-#define __bitwise
-#define __user
-
-#define DEBUG 1
-
-enum format_alias {
-      S8 = 0,
-      U8,
-      S16_LE,
-      S16_BE,
-      U16_LE,
-      U16_BE,
-      S24_LE,
-      S24_BE,
-      U24_LE,
-      U24_BE,
-      S32_LE,
-      S32_BE,
-      U32_LE,
-      U32_BE,
-      FLOAT_LE,
-      FLOAT_BE,
-      FLOAT64_LE,
-      FLOAT64_BE,
-      IEC958_SUBFRAME_LE,
-      IEC958_SUBFRAME_BE,
-      MU_LAW,
-      A_LAW,
-      IMA_ADPCM,
-      MPEG,
-      GSM,
-      SPECIAL = 31, 
-      S24_3LE,
-      S24_3BE,
-      U24_3LE,
-      U24_3BE,
-      S20_3LE,
-      S20_3BE,
-      U20_3LE,
-      U20_3BE,
-      S18_3LE,
-      S18_3BE,
-      U18_3LE,
-      U18_3BE,
-      FORMAT_LAST,
-};
-const char *formats_list[][2] = {
-        {"S8", "Signed 8 bit"},
-        {"U8", "Unsigned 8 bit"},
-        {"S16_LE", "Signed 16 bit Little Endian"},
-        {"S16_BE", "Signed 16 bit Big Endian"},
-        {"U16_LE", "Unsigned 16 bit Little Endian"},
-        {"U16_BE", "Unsigned 16 bit Big Endian"},
-        {"S24_LE", "Signed 24 bit Little Endian"},
-        {"S24_BE", "Signed 24 bit Big Endian"},
-        {"U24_LE", "Unsigned 24 bit Little Endian"},
-        {"U24_BE", "Unsigned 24 bit Big Endian"},
-        {"S32_LE", "Signed 32 bit Little Endian"},
-        {"S32_BE", "Signed 32 bit Big Endian"},
-        {"U32_LE", "Unsigned 32 bit Little Endian"},
-        {"U32_BE", "Unsigned 32 bit Big Endian"},
-        {"FLOAT_LE", "Float 32 bit Little Endian"},
-        {"FLOAT_BE", "Float 32 bit Big Endian"},
-        {"FLOAT64_LE", "Float 64 bit Little Endian"},
-        {"FLOAT64_BE", "Float 64 bit Big Endian"},
-        {"IEC958_SUBFRAME_LE", "IEC-958 Little Endian"},
-        {"IEC958_SUBFRAME_BE", "IEC-958 Big Endian"},
-        {"MU_LAW", "Mu-Law"},
-        {"A_LAW", "A-Law"},
-        {"IMA_ADPCM", "Ima-ADPCM"},
-        {"MPEG", "MPEG"},
-        {"GSM", "GSM"}, 
-        [31] = {"SPECIAL", "Special"},
-        {"S24_3LE", "Signed 24 bit Little Endian in 3bytes"},
-        {"S24_3BE", "Signed 24 bit Big Endian in 3bytes"},
-        {"U24_3LE", "Unsigned 24 bit Little Endian in 3bytes"},
-        {"U24_3BE", "Unsigned 24 bit Big Endian in 3bytes"},
-        {"S20_3LE", "Signed 20 bit Little Endian in 3bytes"},
-        {"S20_3BE", "Signed 20 bit Big Endian in 3bytes"},
-        {"U20_3LE", "Unsigned 20 bit Little Endian in 3bytes"},
-        {"U20_3BE", "Unsigned 20 bit Big Endian in 3bytes"},
-        {"S18_3LE", "Signed 18 bit Little Endian in 3bytes"},
-        {"S18_3BE", "Signed 18 bit Big Endian in 3bytes"},
-        {"U18_3LE", "Unsigned 18 bit Little Endian in 3bytes"},
-        {"U18_3BE", "Unsigned 18 bit Big Endian in 3bytes"},
-};
-
-int get_compressed_format(const char *format)
-{
-        const char *ch = format;
-        if (strcmp(ch, "MP3") == 0) {
-                printf("MP3 is selected\n");
-                return FORMAT_MP3;
-        } else if (strcmp(ch, "AC3_PASS_THROUGH") == 0) {
-                printf("AC3 PASS THROUGH is selected\n");
-                return FORMAT_AC3_PASS_THROUGH;
-        } else {
-                printf("invalid format\n");
-                return -1;
-        }
-        return 0;
-}
-
-int get_format(const char* name)
-{
-        int format;
-        for (format = 0; format < FORMAT_LAST; format++) {
-                if (formats_list[format][0] &&
-                    strcasecmp(name, formats_list[format][0]) == 0) {
-                        ALOGV("format_names %s", name);
-                        return  format;
-                }
-        }
-        return -EINVAL;
-}
-
-const char *get_format_name(int format)
-{
-        if ((format < FORMAT_LAST) &&
-             formats_list[format][0])
-            return formats_list[format][0];
-        return NULL;
-}
-
-const char *get_format_desc(int format)
-{
-        if ((format < FORMAT_LAST) &&
-             formats_list[format][1])
-            return formats_list[format][1];
-        return NULL;
-}
-
-/* alsa parameter manipulation cruft */
-
-#define PARAM_MAX SNDRV_PCM_HW_PARAM_LAST_INTERVAL
-static int oops(struct pcm *pcm, int e, const char *fmt, ...);
-
-static inline int param_is_mask(int p)
-{
-    return (p >= SNDRV_PCM_HW_PARAM_FIRST_MASK) &&
-        (p <= SNDRV_PCM_HW_PARAM_LAST_MASK);
-}
-
-static inline int param_is_interval(int p)
-{
-    return (p >= SNDRV_PCM_HW_PARAM_FIRST_INTERVAL) &&
-        (p <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL);
-}
-
-static inline struct snd_interval *param_to_interval(struct snd_pcm_hw_params *p, int n)
-{
-    return &(p->intervals[n - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL]);
-}
-
-static inline struct snd_mask *param_to_mask(struct snd_pcm_hw_params *p, int n)
-{
-    return &(p->masks[n - SNDRV_PCM_HW_PARAM_FIRST_MASK]);
-}
-
-void param_set_mask(struct snd_pcm_hw_params *p, int n, unsigned bit)
-{
-    if (bit >= SNDRV_MASK_MAX)
-        return;
-    if (param_is_mask(n)) {
-        struct snd_mask *m = param_to_mask(p, n);
-        m->bits[0] = 0;
-        m->bits[1] = 0;
-        m->bits[bit >> 5] |= (1 << (bit & 31));
-    }
-}
-
-void param_set_min(struct snd_pcm_hw_params *p, int n, unsigned val)
-{
-    if (param_is_interval(n)) {
-        struct snd_interval *i = param_to_interval(p, n);
-        i->min = val;
-    }
-}
-
-void param_set_max(struct snd_pcm_hw_params *p, int n, unsigned val)
-{
-    if (param_is_interval(n)) {
-        struct snd_interval *i = param_to_interval(p, n);
-        i->max = val;
-    }
-}
-
-void param_set_int(struct snd_pcm_hw_params *p, int n, unsigned val)
-{
-    if (param_is_interval(n)) {
-        struct snd_interval *i = param_to_interval(p, n);
-        i->min = val;
-        i->max = val;
-        i->integer = 1;
-    }
-}
-
-void param_init(struct snd_pcm_hw_params *p)
-{
-    int n;
-    memset(p, 0, sizeof(*p));
-    for (n = SNDRV_PCM_HW_PARAM_FIRST_MASK;
-         n <= SNDRV_PCM_HW_PARAM_LAST_MASK; n++) {
-            struct snd_mask *m = param_to_mask(p, n);
-            m->bits[0] = ~0;
-            m->bits[1] = ~0;
-    }
-    for (n = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL;
-         n <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; n++) {
-            struct snd_interval *i = param_to_interval(p, n);
-            i->min = 0;
-            i->max = ~0;
-    }
-}
-
-/* debugging gunk */
-
-#if DEBUG
-static const char *param_name[PARAM_MAX+1] = {
-    [SNDRV_PCM_HW_PARAM_ACCESS] = "access",
-    [SNDRV_PCM_HW_PARAM_FORMAT] = "format",
-    [SNDRV_PCM_HW_PARAM_SUBFORMAT] = "subformat",
-
-    [SNDRV_PCM_HW_PARAM_SAMPLE_BITS] = "sample_bits",
-    [SNDRV_PCM_HW_PARAM_FRAME_BITS] = "frame_bits",
-    [SNDRV_PCM_HW_PARAM_CHANNELS] = "channels",
-    [SNDRV_PCM_HW_PARAM_RATE] = "rate",
-    [SNDRV_PCM_HW_PARAM_PERIOD_TIME] = "period_time",
-    [SNDRV_PCM_HW_PARAM_PERIOD_SIZE] = "period_size",
-    [SNDRV_PCM_HW_PARAM_PERIOD_BYTES] = "period_bytes",
-    [SNDRV_PCM_HW_PARAM_PERIODS] = "periods",
-    [SNDRV_PCM_HW_PARAM_BUFFER_TIME] = "buffer_time",
-    [SNDRV_PCM_HW_PARAM_BUFFER_SIZE] = "buffer_size",
-    [SNDRV_PCM_HW_PARAM_BUFFER_BYTES] = "buffer_bytes",
-    [SNDRV_PCM_HW_PARAM_TICK_TIME] = "tick_time",
-};
-
-void param_dump(struct snd_pcm_hw_params *p)
-{
-    int n;
-
-    for (n = SNDRV_PCM_HW_PARAM_FIRST_MASK;
-         n <= SNDRV_PCM_HW_PARAM_LAST_MASK; n++) {
-            struct snd_mask *m = param_to_mask(p, n);
-            ALOGV("%s = %08x%08x\n", param_name[n],
-                   m->bits[1], m->bits[0]);
-    }
-    for (n = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL;
-         n <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; n++) {
-            struct snd_interval *i = param_to_interval(p, n);
-            ALOGV("%s = (%d,%d) omin=%d omax=%d int=%d empty=%d\n",
-                   param_name[n], i->min, i->max, i->openmin,
-                   i->openmax, i->integer, i->empty);
-    }
-    ALOGV("info = %08x\n", p->info);
-    ALOGV("msbits = %d\n", p->msbits);
-    ALOGV("rate = %d/%d\n", p->rate_num, p->rate_den);
-    ALOGV("fifo = %d\n", (int) p->fifo_size);
-}
-
-static void info_dump(struct snd_pcm_info *info)
-{
-    ALOGV("device = %d\n", info->device);
-    ALOGV("subdevice = %d\n", info->subdevice);
-    ALOGV("stream = %d\n", info->stream);
-    ALOGV("card = %d\n", info->card);
-    ALOGV("id = '%s'\n", info->id);
-    ALOGV("name = '%s'\n", info->name);
-    ALOGV("subname = '%s'\n", info->subname);
-    ALOGV("dev_class = %d\n", info->dev_class);
-    ALOGV("dev_subclass = %d\n", info->dev_subclass);
-    ALOGV("subdevices_count = %d\n", info->subdevices_count);
-    ALOGV("subdevices_avail = %d\n", info->subdevices_avail);
-}
-#else
-void param_dump(struct snd_pcm_hw_params *p) {}
-static void info_dump(struct snd_pcm_info *info) {}
-#endif
-
-int param_set_hw_refine(struct pcm *pcm, struct snd_pcm_hw_params *params)
-{
-    if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_HW_REFINE, params)) {
-        ALOGE("SNDRV_PCM_IOCTL_HW_REFINE failed");
-        return -EPERM;
-    }
-    return 0;
-}
-
-int param_set_hw_params(struct pcm *pcm, struct snd_pcm_hw_params *params)
-{
-    if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_HW_PARAMS, params)) {
-        return -EPERM;
-    }
-    pcm->hw_p = params;
-    return 0;
-}
-
-int param_set_sw_params(struct pcm *pcm, struct snd_pcm_sw_params *sparams)
-{
-    if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_SW_PARAMS, sparams)) {
-        return -EPERM;
-    }
-    pcm->sw_p = sparams;
-    return 0;
-}
-
-int pcm_buffer_size(struct snd_pcm_hw_params *params)
-{
-    struct snd_interval *i = param_to_interval(params, SNDRV_PCM_HW_PARAM_BUFFER_BYTES);
-            ALOGV("%s = (%d,%d) omin=%d omax=%d int=%d empty=%d\n",
-                   param_name[SNDRV_PCM_HW_PARAM_BUFFER_BYTES],
-                   i->min, i->max, i->openmin,
-                   i->openmax, i->integer, i->empty);
-    return i->min;
-}
-
-int pcm_period_size(struct snd_pcm_hw_params *params)
-{
-    struct snd_interval *i = param_to_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_BYTES);
-            ALOGV("%s = (%d,%d) omin=%d omax=%d int=%d empty=%d\n",
-                   param_name[SNDRV_PCM_HW_PARAM_PERIOD_BYTES],
-                   i->min, i->max, i->openmin,
-                   i->openmax, i->integer, i->empty);
-    return i->min;
-}
-
-const char* pcm_error(struct pcm *pcm)
-{
-    return pcm->error;
-}
-
-static int oops(struct pcm *pcm, int e, const char *fmt, ...)
-{
-    va_list ap;
-    int sz;
-
-    va_start(ap, fmt);
-    vsnprintf(pcm->error, PCM_ERROR_MAX, fmt, ap);
-    va_end(ap);
-    sz = strnlen(pcm->error, PCM_ERROR_MAX);
-
-    if (errno)
-        snprintf(pcm->error + sz, PCM_ERROR_MAX - sz,
-                 ": %s", strerror(e));
-    return -1;
-}
-
-long pcm_avail(struct pcm *pcm)
-{
-     struct snd_pcm_sync_ptr *sync_ptr = pcm->sync_ptr;
-     if (pcm->flags & DEBUG_ON) {
-        ALOGV("hw_ptr = %d buf_size = %d appl_ptr = %d\n",
-                sync_ptr->s.status.hw_ptr,
-                pcm->buffer_size,
-                sync_ptr->c.control.appl_ptr);
-     }
-     if (pcm->flags & PCM_IN) {
-          long avail = sync_ptr->s.status.hw_ptr - sync_ptr->c.control.appl_ptr;
-        if (avail < 0)
-                avail += pcm->sw_p->boundary;
-        return avail;
-     } else {
-         long avail = sync_ptr->s.status.hw_ptr - sync_ptr->c.control.appl_ptr + ((pcm->flags & PCM_MONO) ? pcm->buffer_size/2 : pcm->buffer_size/4);
-         if (avail < 0)
-              avail += pcm->sw_p->boundary;
-         else if ((unsigned long) avail >= pcm->sw_p->boundary)
-              avail -= pcm->sw_p->boundary;
-         return avail;
-     }
-}
-
-int sync_ptr(struct pcm *pcm)
-{
-    int err;
-    err = ioctl(pcm->fd, SNDRV_PCM_IOCTL_SYNC_PTR, pcm->sync_ptr);
-    if (err < 0) {
-        err = errno;
-        ALOGE("SNDRV_PCM_IOCTL_SYNC_PTR failed %d \n", err);
-        return err;
-    }
-
-    return 0;
-}
-
-int mmap_buffer(struct pcm *pcm)
-{
-    int err, i;
-    char *ptr;
-    unsigned size;
-    struct snd_pcm_channel_info ch;
-    int channels = (pcm->flags & PCM_MONO) ? 1 : 2;
-
-    size = pcm->buffer_size;
-    if (pcm->flags & DEBUG_ON)
-        ALOGV("size = %d\n", size);
-    pcm->addr = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED,
-                           pcm->fd, 0);
-    if (pcm->addr)
-         return 0;
-    else
-         return -errno;
-}
-
-/*
- * Destination offset would be mod of total data written
- * (application pointer) and the buffer size of the driver.
- * Hence destination address would be base address(pcm->addr) +
- * destination offset.
- */
-u_int8_t *dst_address(struct pcm *pcm)
-{
-    unsigned long pcm_offset = 0;
-    struct snd_pcm_sync_ptr *sync_ptr = pcm->sync_ptr;
-    unsigned int appl_ptr = 0;
-
-    appl_ptr = (pcm->flags & PCM_MONO) ? sync_ptr->c.control.appl_ptr*2 : sync_ptr->c.control.appl_ptr*4;
-    pcm_offset = (appl_ptr % (unsigned long)pcm->buffer_size);
-    return pcm->addr + pcm_offset;
-
-}
-
-int mmap_transfer(struct pcm *pcm, void *data, unsigned offset,
-                  long frames)
-{
-    struct snd_pcm_sync_ptr *sync_ptr = pcm->sync_ptr;
-    unsigned size;
-    u_int8_t *dst_addr, *mmaped_addr;
-    u_int8_t *src_addr = data;
-    int channels = (pcm->flags & PCM_MONO) ? 1 : 2;
-
-    dst_addr = dst_address(pcm);
-
-    frames = frames * channels *2 ;
-
-    while (frames-- > 0) {
-        *(u_int8_t*)dst_addr = *(const u_int8_t*)src_addr;
-         src_addr++;
-         dst_addr++;
-    }
-    return 0;
-}
-
-int mmap_transfer_capture(struct pcm *pcm, void *data, unsigned offset,
-                          long frames)
-{
-    struct snd_pcm_sync_ptr *sync_ptr = pcm->sync_ptr;
-    unsigned long pcm_offset = 0;
-    unsigned size;
-    u_int8_t *dst_addr, *mmaped_addr;
-    u_int8_t *src_addr;
-    int channels = (pcm->flags & PCM_MONO) ? 1 : 2;
-    unsigned int tmp = (pcm->flags & PCM_MONO) ? sync_ptr->c.control.appl_ptr*2 : sync_ptr->c.control.appl_ptr*4;
-
-    pcm_offset = (tmp % (unsigned long)pcm->buffer_size);
-    dst_addr = data;
-    src_addr = pcm->addr + pcm_offset;
-    frames = frames * channels *2 ;
-
-    while (frames-- > 0) {
-        *(u_int8_t*)dst_addr = *(const u_int8_t*)src_addr;
-         src_addr++;
-         dst_addr++;
-    }
-    return 0;
-}
-
-int pcm_prepare(struct pcm *pcm)
-{
-    if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_PREPARE)) {
-           ALOGE("cannot prepare channel: errno =%d\n", -errno);
-           return -errno;
-    }
-    pcm->running = 1;
-    return 0;
-}
-
-static int pcm_write_mmap(struct pcm *pcm, void *data, unsigned count)
-{
-    long frames;
-    int err;
-    int bytes_written;
-
-    frames = (pcm->flags & PCM_MONO) ? (count / 2) : (count / 4);
-
-    pcm->sync_ptr->flags = SNDRV_PCM_SYNC_PTR_APPL | SNDRV_PCM_SYNC_PTR_AVAIL_MIN;
-    err = sync_ptr(pcm);
-    if (err == EPIPE) {
-        ALOGE("Failed in sync_ptr\n");
-        /* we failed to make our window -- try to restart */
-        pcm->underruns++;
-        pcm->running = 0;
-        pcm_prepare(pcm);
-    }
-    pcm->sync_ptr->c.control.appl_ptr += frames;
-    pcm->sync_ptr->flags = 0;
-
-    err = sync_ptr(pcm);
-    if (err == EPIPE) {
-        ALOGE("Failed in sync_ptr 2 \n");
-        /* we failed to make our window -- try to restart */
-        pcm->underruns++;
-        pcm->running = 0;
-        pcm_prepare(pcm);
-    }
-    bytes_written = pcm->sync_ptr->c.control.appl_ptr - pcm->sync_ptr->s.status.hw_ptr;
-    if ((bytes_written >= pcm->sw_p->start_threshold) && (!pcm->start)) {
-        if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_START)) {
-            err = -errno;
-            if (errno == EPIPE) {
-                ALOGE("Failed in SNDRV_PCM_IOCTL_START\n");
-                /* we failed to make our window -- try to restart */
-                pcm->underruns++;
-                pcm->running = 0;
-                pcm_prepare(pcm);
-            } else {
-                ALOGE("Error no %d \n", errno);
-                return -errno;
-            }
-        } else {
-             ALOGD(" start\n");
-             pcm->start = 1;
-        }
-    }
-    return 0;
-}
-
-static int pcm_write_nmmap(struct pcm *pcm, void *data, unsigned count)
-{
-    struct snd_xferi x;
-    int channels = (pcm->flags & PCM_MONO) ? 1 : ((pcm->flags & PCM_5POINT1)? 6 : 2 );
-
-    if (pcm->flags & PCM_IN)
-        return -EINVAL;
-    x.buf = data;
-    x.frames =  (count / (channels * 2)) ;
-
-    for (;;) {
-        if (!pcm->running) {
-            if (pcm_prepare(pcm))
-                return -errno;
-        }
-        if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_WRITEI_FRAMES, &x)) {
-            if (errno == EPIPE) {
-                    /* we failed to make our window -- try to restart */
-                ALOGE("Underrun Error\n");
-                pcm->underruns++;
-                pcm->running = 0;
-                continue;
-            }
-            return -errno;
-        }
-        if (pcm->flags & DEBUG_ON)
-          ALOGV("Sent frame\n");
-        return 0;
-    }
-}
-
-int pcm_write(struct pcm *pcm, void *data, unsigned count)
-{
-     if (pcm->flags & PCM_MMAP)
-         return pcm_write_mmap(pcm, data, count);
-     else
-         return pcm_write_nmmap(pcm, data, count);
-}
-
-int pcm_read(struct pcm *pcm, void *data, unsigned count)
-{
-    struct snd_xferi x;
-
-    if (!(pcm->flags & PCM_IN))
-        return -EINVAL;
-
-    x.buf = data;
-    if (pcm->flags & PCM_MONO) {
-        x.frames = (count / 2);
-    } else if (pcm->flags & PCM_QUAD) {
-        x.frames = (count / 8);
-    } else if (pcm->flags & PCM_5POINT1) {
-        x.frames = (count / 12);
-    } else {
-        x.frames = (count / 4);
-    }
-
-    for (;;) {
-        if (!pcm->running) {
-            if (pcm_prepare(pcm))
-                return -errno;
-            if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_START)) {
-                ALOGE("Arec:SNDRV_PCM_IOCTL_START failed\n");
-                return -errno;
-            }
-            pcm->running = 1;
-        }
-        if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_READI_FRAMES, &x)) {
-            if (errno == EPIPE) {
-                /* we failed to make our window -- try to restart */
-                ALOGE("Arec:Overrun Error\n");
-                pcm->underruns++;
-                pcm->running = 0;
-                continue;
-            }
-            ALOGE("Arec: error%d\n", errno);
-            return -errno;
-        }
-        return 0;
-    }
-}
-
-static struct pcm bad_pcm = {
-    .fd = -1,
-};
-
-static int enable_timer(struct pcm *pcm) {
-
-    pcm->timer_fd = open("/dev/snd/timer", O_RDWR | O_NONBLOCK);
-    if (pcm->timer_fd < 0) {
-       close(pcm->fd);
-       ALOGE("cannot open timer device 'timer'");
-       return &bad_pcm;
-    }
-    int arg = 1;
-    struct snd_timer_params timer_param;
-    struct snd_timer_select sel;
-    if (ioctl(pcm->timer_fd, SNDRV_TIMER_IOCTL_TREAD, &arg) < 0) {
-           ALOGE("extended read is not supported (SNDRV_TIMER_IOCTL_TREAD)\n");
-    }
-    memset(&sel, 0, sizeof(sel));
-    sel.id.dev_class = SNDRV_TIMER_CLASS_PCM;
-    sel.id.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
-    sel.id.card = pcm->card_no;
-    sel.id.device = pcm->device_no;
-    if (pcm->flags & PCM_IN)
-        sel.id.subdevice = 1;
-    else
-        sel.id.subdevice = 0;
-
-    if (pcm->flags & DEBUG_ON) {
-        ALOGD("sel.id.dev_class= %d\n", sel.id.dev_class);
-        ALOGD("sel.id.dev_sclass = %d\n", sel.id.dev_sclass);
-        ALOGD("sel.id.card = %d\n", sel.id.card);
-        ALOGD("sel.id.device = %d\n", sel.id.device);
-        ALOGD("sel.id.subdevice = %d\n", sel.id.subdevice);
-    }
-    if (ioctl(pcm->timer_fd, SNDRV_TIMER_IOCTL_SELECT, &sel) < 0) {
-          ALOGE("SNDRV_TIMER_IOCTL_SELECT failed.\n");
-          close(pcm->timer_fd);
-          close(pcm->fd);
-          return &bad_pcm;
-    }
-    memset(&timer_param, 0, sizeof(struct snd_timer_params));
-    timer_param.flags |= SNDRV_TIMER_PSFLG_AUTO;
-    timer_param.ticks = 1;
-    timer_param.filter = (1<<SNDRV_TIMER_EVENT_MSUSPEND) | (1<<SNDRV_TIMER_EVENT_MRESUME) | (1<<SNDRV_TIMER_EVENT_TICK);
-
-    if (ioctl(pcm->timer_fd, SNDRV_TIMER_IOCTL_PARAMS, &timer_param)< 0) {
-           ALOGE("SNDRV_TIMER_IOCTL_PARAMS failed\n");
-    }
-    if (ioctl(pcm->timer_fd, SNDRV_TIMER_IOCTL_START) < 0) {
-           close(pcm->timer_fd);
-           ALOGE("SNDRV_TIMER_IOCTL_START failed\n");
-    }
-    return 0;
-}
-
-static int disable_timer(struct pcm *pcm) {
-     if (pcm == &bad_pcm)
-         return 0;
-     if (ioctl(pcm->timer_fd, SNDRV_TIMER_IOCTL_STOP) < 0)
-         ALOGE("SNDRV_TIMER_IOCTL_STOP failed\n");
-     return close(pcm->timer_fd);
-}
-
-int pcm_close(struct pcm *pcm)
-{
-    if (pcm == &bad_pcm)
-        return 0;
-
-    if (pcm->flags & PCM_MMAP) {
-        disable_timer(pcm);
-        if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_DROP) < 0) {
-            ALOGE("Reset failed");
-        }
-
-        if (munmap(pcm->addr, pcm->buffer_size))
-            ALOGE("munmap failed");
-
-        if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_HW_FREE) < 0) {
-            ALOGE("HW_FREE failed");
-        }
-    }
-
-    if (pcm->fd >= 0)
-        close(pcm->fd);
-    pcm->running = 0;
-    pcm->buffer_size = 0;
-    pcm->fd = -1;
-    if (pcm->sw_p)
-        free(pcm->sw_p);
-    if (pcm->hw_p)
-        free(pcm->hw_p);
-    if (pcm->sync_ptr)
-        free(pcm->sync_ptr);
-    free(pcm);
-    return 0;
-}
-
-struct pcm *pcm_open(unsigned flags, char *device)
-{
-    char dname[19];
-    struct pcm *pcm;
-    struct snd_pcm_info info;
-    struct snd_pcm_hw_params params;
-    struct snd_pcm_sw_params sparams;
-    unsigned period_sz;
-    unsigned period_cnt;
-    char *tmp;
-
-    if (flags & DEBUG_ON) {
-        ALOGV("pcm_open(0x%08x)",flags);
-        ALOGV("device %s\n",device);
-    }
-
-    pcm = calloc(1, sizeof(struct pcm));
-    if (!pcm)
-        return &bad_pcm;
-
-    tmp = device+4;
-    if ((strncmp(device, "hw:",3) != 0) || (strncmp(tmp, ",",1) != 0)){
-        ALOGE("Wrong device fromat\n");
-        free(pcm);
-        return -EINVAL;
-    }
-
-    if (flags & PCM_IN) {
-        strlcpy(dname, "/dev/snd/pcmC", sizeof(dname));
-        tmp = device+3;
-        strlcat(dname, tmp, (2+strlen(dname))) ;
-        pcm->card_no = atoi(tmp);
-        strlcat(dname, "D", (sizeof("D")+strlen(dname)));
-        tmp = device+5;
-        pcm->device_no = atoi(tmp);
-	/* should be safe to assume pcm dev ID never exceed 99 */
-        if (pcm->device_no > 9)
-            strlcat(dname, tmp, (3+strlen(dname)));
-        else
-            strlcat(dname, tmp, (2+strlen(dname)));
-        strlcat(dname, "c", (sizeof("c")+strlen(dname)));
-    } else {
-        strlcpy(dname, "/dev/snd/pcmC", sizeof(dname));
-        tmp = device+3;
-        strlcat(dname, tmp, (2+strlen(dname))) ;
-        pcm->card_no = atoi(tmp);
-        strlcat(dname, "D", (sizeof("D")+strlen(dname)));
-        tmp = device+5;
-        pcm->device_no = atoi(tmp);
-	/* should be safe to assume pcm dev ID never exceed 99 */
-        if (pcm->device_no > 9)
-            strlcat(dname, tmp, (3+strlen(dname)));
-        else
-            strlcat(dname, tmp, (2+strlen(dname)));
-        strlcat(dname, "p", (sizeof("p")+strlen(dname)));
-    }
-    if (pcm->flags & DEBUG_ON)
-        ALOGV("Device name %s\n", dname);
-
-    pcm->sync_ptr = calloc(1, sizeof(struct snd_pcm_sync_ptr));
-    if (!pcm->sync_ptr) {
-         free(pcm);
-         return &bad_pcm;
-    }
-    pcm->flags = flags;
-
-    pcm->fd = open(dname, O_RDWR|O_NONBLOCK);
-    if (pcm->fd < 0) {
-        free(pcm->sync_ptr);
-        free(pcm);
-        ALOGE("cannot open device '%s', errno %d", dname, errno);
-        return &bad_pcm;
-    }
-
-    if (fcntl(pcm->fd, F_SETFL, fcntl(pcm->fd, F_GETFL) &
-            ~O_NONBLOCK) < 0) {
-        close(pcm->fd);
-        free(pcm->sync_ptr);
-        free(pcm);
-        ALOGE("failed to change the flag, errno %d", errno);
-        return &bad_pcm;
-    }
-
-    if (pcm->flags & PCM_MMAP)
-        enable_timer(pcm);
-
-    if (pcm->flags & DEBUG_ON)
-        ALOGV("pcm_open() %s\n", dname);
-    if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_INFO, &info)) {
-        ALOGE("cannot get info - %s", dname);
-    }
-    if (pcm->flags & DEBUG_ON)
-       info_dump(&info);
-
-    return pcm;
-}
-
-int pcm_ready(struct pcm *pcm)
-{
-    return pcm->fd >= 0;
-}
diff --git a/legacy/libalsa-intf/alsa_ucm.c b/legacy/libalsa-intf/alsa_ucm.c
deleted file mode 100644
index fac8498..0000000
--- a/legacy/libalsa-intf/alsa_ucm.c
+++ /dev/null
@@ -1,3917 +0,0 @@
-/*
- * Copyright (c) 2011-2012, 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 "alsa_ucm"
-//#define LOG_NDDEBUG 0
-
-#ifdef ANDROID
-/* definitions for Android logging */
-#include <utils/Log.h>
-#include <cutils/properties.h>
-#else /* ANDROID */
-#include <math.h>
-#define strlcat g_strlcat
-#define strlcpy g_strlcpy
-#define ALOGI(...)      fprintf(stdout, __VA_ARGS__)
-#define ALOGE(...)      fprintf(stderr, __VA_ARGS__)
-#define ALOGV(...)      fprintf(stderr, __VA_ARGS__)
-#define ALOGD(...)      fprintf(stderr, __VA_ARGS__)
-#endif /* ANDROID */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <fcntl.h>
-#include <stdarg.h>
-#include <string.h>
-#include <errno.h>
-#include <unistd.h>
-#include <pthread.h>
-#include <ctype.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-#include <sys/time.h>
-#include <sys/poll.h>
-#include <stdint.h>
-#include <dlfcn.h>
-
-#include <linux/ioctl.h>
-#include "msm8960_use_cases.h"
-#if defined(QC_PROP)
-    static void (*acdb_send_audio_cal)(int,int);
-    static void (*acdb_send_voice_cal)(int,int);
-#endif
-#define PARSE_DEBUG 0
-
-/**
- * Create an identifier
- * fmt - sprintf like format,
- * ... - Optional arguments
- * returns - string allocated or NULL on error
- */
-char *snd_use_case_identifier(const char *fmt, ...)
-{
-    ALOGE("API not implemented for now, to be updated if required");
-    return NULL;
-}
-
-/**
- * Free a list
- * list - list to free
- * items -  Count of strings
- * Return Zero on success, otherwise a negative error code
- */
-int snd_use_case_free_list(const char *list[], int items)
-{
-    /* list points to UCM internal static tables,
-     * hence there is no need to do a free call
-     * just set the list to NULL and return */
-    list = NULL;
-    return 0;
-}
-
-/**
- * Obtain a list of entries
- * uc_mgr - UCM structure pointer or  NULL for card list
- * identifier - NULL for card list
- * list - Returns allocated list
- * returns Number of list entries on success, otherwise a negative error code
- */
-int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr,
-                          const char *identifier,
-                          const char **list[])
-{
-    use_case_verb_t *verb_list;
-    int verb_index, list_size, index = 0;
-
-    if (identifier == NULL) {
-        *list = card_list;
-        return ((int)MAX_NUM_CARDS);
-    }
-
-    pthread_mutex_lock(&uc_mgr->card_ctxt_ptr->card_lock);
-    if ((uc_mgr->snd_card_index >= (int)MAX_NUM_CARDS) ||
-        (uc_mgr->snd_card_index < 0) || (uc_mgr->card_ctxt_ptr == NULL)) {
-        ALOGE("snd_use_case_get_list(): failed, invalid arguments");
-        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-        return -EINVAL;
-    }
-
-    if (!strncmp(identifier, "_verbs", 6)) {
-        while(strncmp(uc_mgr->card_ctxt_ptr->verb_list[index],
-            SND_UCM_END_OF_LIST, strlen(SND_UCM_END_OF_LIST))) {
-            ALOGV("Index:%d Verb:%s", index,
-                 uc_mgr->card_ctxt_ptr->verb_list[index]);
-            index++;
-        }
-        *list = (char ***)uc_mgr->card_ctxt_ptr->verb_list;
-        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-        return index;
-    } else  if (!strncmp(identifier, "_devices", 8)) {
-        if (!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
-            SND_USE_CASE_VERB_INACTIVE, strlen(SND_USE_CASE_VERB_INACTIVE))) {
-            ALOGE("Use case verb name not set, invalid current verb");
-            pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-            return -EINVAL;
-        }
-        verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
-        while(strncmp(uc_mgr->card_ctxt_ptr->current_verb,
-            verb_list[index].use_case_name,
-            (strlen(verb_list[index].use_case_name)+1))) {
-            index++;
-        }
-        verb_index = index;
-        index = 0;
-        while(strncmp(verb_list[verb_index].device_list[index],
-            SND_UCM_END_OF_LIST, strlen(SND_UCM_END_OF_LIST))) {
-            ALOGV("Index:%d Device:%s", index,
-                 verb_list[verb_index].device_list[index]);
-            index++;
-        }
-        *list = verb_list[verb_index].device_list;
-        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-        return index;
-    } else  if (!strncmp(identifier, "_modifiers", 10)) {
-        if (!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
-                    SND_USE_CASE_VERB_INACTIVE, MAX_STR_LEN)) {
-            ALOGE("Use case verb name not set, invalid current verb");
-            pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-            return -EINVAL;
-        }
-        verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
-        while(strncmp(uc_mgr->card_ctxt_ptr->current_verb,
-            verb_list[index].use_case_name,
-            (strlen(verb_list[index].use_case_name)+1))) {
-            index++;
-        }
-        verb_index = index;
-        index = 0;
-        while(strncmp(verb_list[verb_index].modifier_list[index],
-                    SND_UCM_END_OF_LIST, strlen(SND_UCM_END_OF_LIST))) {
-            ALOGV("Index:%d Modifier:%s", index,
-                 verb_list[verb_index].modifier_list[index]);
-            index++;
-        }
-        *list = verb_list[verb_index].modifier_list;
-        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-        return index;
-    } else  if (!strncmp(identifier, "_enadevs", 8)) {
-        if (uc_mgr->device_list_count) {
-            for (index = 0; index < uc_mgr->device_list_count; index++) {
-                free(uc_mgr->current_device_list[index]);
-                uc_mgr->current_device_list[index] = NULL;
-            }
-            free(uc_mgr->current_device_list);
-            uc_mgr->current_device_list = NULL;
-            uc_mgr->device_list_count = 0;
-        }
-        list_size =
-            snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
-        uc_mgr->device_list_count = list_size;
-    if (list_size > 0) {
-            uc_mgr->current_device_list =
-                (char **)malloc(sizeof(char *)*list_size);
-            if (uc_mgr->current_device_list == NULL) {
-                *list = NULL;
-                pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-                return -ENOMEM;
-            }
-            for (index = 0; index < list_size; index++) {
-                uc_mgr->current_device_list[index] =
-                snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
-                index);
-            }
-        }
-        *list = (const char **)uc_mgr->current_device_list;
-        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-        return (list_size);
-    } else  if (!strncmp(identifier, "_enamods", 8)) {
-        if (uc_mgr->modifier_list_count) {
-            for (index = 0; index < uc_mgr->modifier_list_count; index++) {
-                free(uc_mgr->current_modifier_list[index]);
-                uc_mgr->current_modifier_list[index] = NULL;
-            }
-            free(uc_mgr->current_modifier_list);
-            uc_mgr->current_modifier_list = NULL;
-            uc_mgr->modifier_list_count = 0;
-        }
-        list_size =
-            snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->mod_list_head);
-        uc_mgr->modifier_list_count = list_size;
-    if (list_size > 0) {
-            uc_mgr->current_modifier_list =
-                (char **)malloc(sizeof(char *) * list_size);
-            if (uc_mgr->current_modifier_list == NULL) {
-                *list = NULL;
-                pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-                return -ENOMEM;
-            }
-            for (index = 0; index < list_size; index++) {
-                uc_mgr->current_modifier_list[index] =
-                snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->mod_list_head,
-                index);
-            }
-        }
-        *list = (const char **)uc_mgr->current_modifier_list;
-        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-        return (list_size);
-    } else {
-        ALOGE("Invalid identifier: %s", identifier);
-        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-        return -EINVAL;
-    }
-}
-
-
-/**
- * Get current value of the identifier
- * identifier - NULL for current card
- *        _verb
- *        <Name>/<_device/_modifier>
- *    Name -    PlaybackPCM
- *        CapturePCM
- *        PlaybackCTL
- *        CaptureCTL
- * value - Value pointer
- * returns Zero if success, otherwise a negative error code
- */
-int snd_use_case_get(snd_use_case_mgr_t *uc_mgr,
-                     const char *identifier,
-                     const char **value)
-{
-    card_mctrl_t *ctrl_list;
-    use_case_verb_t *verb_list;
-    char ident[MAX_STR_LEN], *ident1, *ident2, *temp_ptr;
-    int index, verb_index = 0, ret = 0;
-
-    pthread_mutex_lock(&uc_mgr->card_ctxt_ptr->card_lock);
-    if ((uc_mgr->snd_card_index >= (int)MAX_NUM_CARDS) ||
-        (uc_mgr->snd_card_index < 0) || (uc_mgr->card_ctxt_ptr == NULL)) {
-        ALOGE("snd_use_case_get(): failed, invalid arguments");
-        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-        return -EINVAL;
-    }
-
-    if (identifier == NULL) {
-        if (uc_mgr->card_ctxt_ptr->card_name != NULL) {
-            *value = strdup(uc_mgr->card_ctxt_ptr->card_name);
-        } else {
-            *value = NULL;
-        }
-        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-        return 0;
-    }
-
-    if (!strncmp(identifier, "_verb", 5)) {
-        if (uc_mgr->card_ctxt_ptr->current_verb != NULL) {
-            *value = strdup(uc_mgr->card_ctxt_ptr->current_verb);
-        } else {
-            *value = NULL;
-        }
-        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-        return 0;
-    }
-
-    strlcpy(ident, identifier, sizeof(ident));
-    if(!(ident1 = strtok_r(ident, "/", &temp_ptr))) {
-        ALOGE("No valid identifier found: %s", ident);
-        ret = -EINVAL;
-    } else {
-        if ((!strncmp(ident1, "PlaybackPCM", 11)) ||
-            (!strncmp(ident1, "CapturePCM", 10))) {
-            ident2 = strtok_r(NULL, "/", &temp_ptr);
-            index = 0;
-            if (ident2 != NULL) {
-                verb_index = uc_mgr->card_ctxt_ptr->current_verb_index;
-                verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
-                if((get_usecase_type(uc_mgr, ident2)) == CTRL_LIST_VERB) {
-                    ctrl_list = verb_list[verb_index].verb_ctrls;
-                } else {
-                    ctrl_list = verb_list[verb_index].mod_ctrls;
-                }
-                if((verb_index < 0) ||
-                    (!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
-                    SND_UCM_END_OF_LIST, 3)) || (ctrl_list == NULL)) {
-                    ALOGE("Invalid current verb value: %s - %d",
-                         uc_mgr->card_ctxt_ptr->current_verb, verb_index);
-                    pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-                    return -EINVAL;
-                }
-                while(strncmp(ctrl_list[index].case_name, ident2,
-                    (strlen(ident2)+1))) {
-                    if (!strncmp(ctrl_list[index].case_name,
-                        SND_UCM_END_OF_LIST, strlen(SND_UCM_END_OF_LIST))){
-                        *value = NULL;
-                        ret = -EINVAL;
-                        break;
-                    } else {
-                        index++;
-                    }
-                }
-            } else {
-                ret = -EINVAL;
-            }
-            if (ret < 0) {
-                ALOGE("No valid device/modifier found with given identifier: %s",
-                     ident2);
-            } else {
-                if(!strncmp(ident1, "PlaybackPCM", 11)) {
-                    if (ctrl_list[index].playback_dev_name) {
-                        *value = strdup(ctrl_list[index].playback_dev_name);
-                    } else {
-                        *value = NULL;
-                        ret = -ENODEV;
-                    }
-                } else if(!strncmp(ident1, "CapturePCM", 10)) {
-                    if (ctrl_list[index].capture_dev_name) {
-                        *value = strdup(ctrl_list[index].capture_dev_name);
-                    } else {
-                        *value = NULL;
-                        ret = -ENODEV;
-                    }
-                } else {
-                    ALOGE("No valid device name exists for given identifier: %s",
-                         ident2);
-                    *value = NULL;
-                    ret = -ENODEV;
-                }
-            }
-        } else if ((!strncmp(ident1, "PlaybackCTL", 11)) ||
-                   (!strncmp(ident1, "CaptureCTL", 10))) {
-            if(uc_mgr->card_ctxt_ptr->control_device != NULL) {
-                *value = strdup(uc_mgr->card_ctxt_ptr->control_device);
-            } else {
-                ALOGE("No valid control device found");
-                *value = NULL;
-                ret = -ENODEV;
-            }
-        } else if (!strncmp(ident1, "ACDBID", 11)) {
-            ident2 = strtok_r(NULL, "/", &temp_ptr);
-            index = 0; verb_index = 0;
-            verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
-            if((verb_index < 0) ||
-               (!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
-                SND_UCM_END_OF_LIST, 3)) ||
-                (verb_list[verb_index].verb_ctrls == NULL)) {
-                ALOGE("Invalid current verb value: %s - %d",
-                     uc_mgr->card_ctxt_ptr->current_verb, verb_index);
-                pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-                return -EINVAL;
-            }
-            ctrl_list = verb_list[verb_index].device_ctrls;
-            if (ident2 != NULL) {
-                while(strncmp(ctrl_list[index].case_name, ident2,
-                    MAX_LEN(ctrl_list[index].case_name,ident2))) {
-                    if (!strncmp(ctrl_list[index].case_name, SND_UCM_END_OF_LIST,
-                        strlen(SND_UCM_END_OF_LIST))){
-                        ret = -EINVAL;
-                        break;
-                    } else {
-                        index++;
-                    }
-                }
-            }
-            if (ret < 0) {
-                ALOGE("No valid device/modifier found with given identifier: %s",
-                      ident2);
-            } else {
-                if (verb_list[verb_index].device_ctrls[index].acdb_id) {
-                    ret = verb_list[verb_index].device_ctrls[index].acdb_id;
-                } else {
-                    ret = -ENODEV;
-                }
-            }
-        } else if (!strncmp(ident1, "EffectsMixerCTL", 11)) {
-            ident2 = strtok_r(NULL, "/", &temp_ptr);
-            index = 0; verb_index = 0;
-            verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
-            if((verb_index < 0) ||
-               (!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
-                SND_UCM_END_OF_LIST, 3)) ||
-                (verb_list[verb_index].verb_ctrls == NULL)) {
-                ALOGE("Invalid current verb value: %s - %d",
-                     uc_mgr->card_ctxt_ptr->current_verb, verb_index);
-                pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-                return -EINVAL;
-            }
-            ctrl_list = verb_list[verb_index].device_ctrls;
-            if (ident2 != NULL) {
-                while(strncmp(ctrl_list[index].case_name, ident2, strlen(ident2)+1)) {
-                    if (!strncmp(ctrl_list[index].case_name, SND_UCM_END_OF_LIST,
-                        strlen(SND_UCM_END_OF_LIST))){
-                        ret = -EINVAL;
-                        break;
-                    } else {
-                        index++;
-                    }
-                }
-            }
-            if (ret < 0) {
-                ALOGE("No valid device/modifier found with given identifier: %s",
-                      ident2);
-            } else {
-                if (verb_list[verb_index].device_ctrls[index].effects_mixer_ctl) {
-                    *value = strdup(verb_list[verb_index].device_ctrls[index].effects_mixer_ctl);
-                } else {
-                    *value = NULL;
-                    ret = -ENODEV;
-                }
-            }
-        } else {
-            ALOGE("Unsupported identifier value: %s", ident1);
-            *value = NULL;
-            ret = -EINVAL;
-        }
-    }
-    pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-    return ret;
-}
-
-/**
- * Get current status
- * uc_mgr - UCM structure
- * identifier - _devstatus/<device>,
-        _modstatus/<modifier>
- * value - result
- * returns 0 on success, otherwise a negative error code
- */
-int snd_use_case_geti(snd_use_case_mgr_t *uc_mgr,
-              const char *identifier,
-              long *value)
-{
-    char ident[MAX_STR_LEN], *ident1, *ident2, *ident_value, *temp_ptr;
-    int index, list_size, ret = -EINVAL;
-
-    pthread_mutex_lock(&uc_mgr->card_ctxt_ptr->card_lock);
-    if ((uc_mgr->snd_card_index >= (int)MAX_NUM_CARDS) ||
-        (uc_mgr->snd_card_index < 0) || (uc_mgr->card_ctxt_ptr == NULL)) {
-        ALOGE("snd_use_case_geti(): failed, invalid arguments");
-        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-        return -EINVAL;
-    }
-
-    *value = 0;
-    strlcpy(ident, identifier, sizeof(ident));
-    if(!(ident1 = strtok_r(ident, "/", &temp_ptr))) {
-        ALOGE("No valid identifier found: %s", ident);
-        ret = -EINVAL;
-    } else {
-        if (!strncmp(ident1, "_devstatus", 10)) {
-            ident2 = strtok_r(NULL, "/", &temp_ptr);
-            if (ident2 != NULL) {
-                list_size =
-                snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
-                for (index = 0; index < list_size; index++) {
-                if ((ident_value =
-                snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
-                index))) {
-                        if (!strncmp(ident2, ident_value,
-                            (strlen(ident_value)+1))) {
-                            *value = 1;
-                            free(ident_value);
-                            ident_value = NULL;
-                            break;
-                        } else {
-                            free(ident_value);
-                            ident_value = NULL;
-                        }
-                    }
-                }
-                ret = 0;
-            }
-        } else if (!strncmp(ident1, "_modstatus", 10)) {
-            ident2 = strtok_r(NULL, "/", &temp_ptr);
-            if (ident2 != NULL) {
-                list_size =
-                snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->mod_list_head);
-                for (index = 0; index < list_size; index++) {
-                if((ident_value =
-                snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->mod_list_head,
-                index))) {
-                        if (!strncmp(ident2, ident_value,
-                            (strlen(ident_value)+1))) {
-                            *value = 1;
-                            free(ident_value);
-                            ident_value = NULL;
-                            break;
-                        } else {
-                            free(ident_value);
-                            ident_value = NULL;
-                        }
-                    }
-                }
-                ret = 0;
-            }
-        } else {
-            ALOGE("Unknown identifier: %s", ident1);
-        }
-    }
-    pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-    return ret;
-}
-
-static int check_devices_for_voice_call(snd_use_case_mgr_t *uc_mgr,
-const char *use_case)
-{
-    struct snd_ucm_ident_node *dev_node = NULL;
-    int index = 0, list_size = 0, rx_dev_status = 0, tx_dev_status = 0;
-
-    if ((!strncmp(use_case, SND_USE_CASE_VERB_VOICECALL,
-        strlen(SND_USE_CASE_VERB_VOICECALL))) ||
-        (!strncmp(use_case, SND_USE_CASE_VERB_IP_VOICECALL,
-        strlen(SND_USE_CASE_VERB_IP_VOICECALL))) ||
-        (!strncmp(use_case, SND_USE_CASE_MOD_PLAY_VOICE,
-        strlen(SND_USE_CASE_MOD_PLAY_VOICE))) ||
-        (!strncmp(use_case, SND_USE_CASE_MOD_PLAY_VOIP,
-        strlen(SND_USE_CASE_MOD_PLAY_VOIP)))) {
-        ALOGV("check_devices_for_voice_call(): voice cap detected\n");
-        list_size =
-        snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
-        for (index = 0; index < list_size; index++) {
-            if ((dev_node =
-                snd_ucm_get_device_node(uc_mgr->card_ctxt_ptr->dev_list_head,
-                index))) {
-                if (dev_node->capability == CAP_RX && dev_node->active == 1) {
-                    rx_dev_status = 1;
-                } else if (dev_node->capability == CAP_TX && dev_node->active == 1) {
-                    tx_dev_status = 1;
-                }
-            }
-        }
-        if (rx_dev_status == 1 && tx_dev_status == 1) {
-            ALOGV("check_devices_for_voice_call(): Rx and Tx devices enabled\n");
-            return 0;
-        } else {
-            ALOGV("check_devices_for_voice_call(): Rx/Tx dev not enabled: \
-                  %d,%d\n", rx_dev_status, tx_dev_status);
-            return 1;
-        }
-    }
-    return 0;
-}
-
-static int snd_use_case_apply_voice_acdb(snd_use_case_mgr_t *uc_mgr,
-int use_case_index)
-{
-    card_mctrl_t *ctrl_list;
-    int list_size, index, verb_index, ret = 0, voice_acdb = 0, rx_id, tx_id;
-    char *ident_value = NULL;
-
-    /* Check if voice call use case/modifier exists */
-    if ((!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
-        SND_USE_CASE_VERB_VOICECALL, strlen(SND_USE_CASE_VERB_VOICECALL))) ||
-        (!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
-        SND_USE_CASE_VERB_IP_VOICECALL,
-        strlen(SND_USE_CASE_VERB_IP_VOICECALL)))) {
-        voice_acdb = 1;
-    }
-    if (voice_acdb != 1) {
-        list_size =
-        snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->mod_list_head);
-        for (index = 0; index < list_size; index++) {
-            if ((ident_value =
-                snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->mod_list_head,
-                index))) {
-                if ((!strncmp(ident_value, SND_USE_CASE_MOD_PLAY_VOICE,
-                    strlen(SND_USE_CASE_MOD_PLAY_VOICE))) ||
-                    (!strncmp(ident_value, SND_USE_CASE_MOD_PLAY_VOIP,
-                    strlen(SND_USE_CASE_MOD_PLAY_VOIP)))) {
-                    voice_acdb = 1;
-                    free(ident_value);
-                    ident_value = NULL;
-                    break;
-                }
-                free(ident_value);
-                ident_value = NULL;
-            }
-        }
-    }
-
-    verb_index = uc_mgr->card_ctxt_ptr->current_verb_index;
-    if((verb_index < 0) ||
-        (!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
-        SND_UCM_END_OF_LIST, 3))) {
-        ALOGE("Invalid current verb value: %s - %d",
-            uc_mgr->card_ctxt_ptr->current_verb, verb_index);
-        return -EINVAL;
-    }
-    if (voice_acdb == 1) {
-        ctrl_list =
-        uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].device_ctrls;
-        list_size =
-        snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
-        for (index = 0; index < list_size; index++) {
-            if ((ident_value =
-                snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
-                index))) {
-                if (strncmp(ident_value, ctrl_list[use_case_index].case_name,
-                    (strlen(ctrl_list[use_case_index].case_name)+1))) {
-                    break;
-                }
-                free(ident_value);
-                ident_value = NULL;
-            }
-        }
-        index = 0;
-        if (ident_value != NULL) {
-            while(strncmp(ctrl_list[index].case_name, ident_value,
-                  (strlen(ident_value)+1))) {
-                if (!strncmp(ctrl_list[index].case_name, SND_UCM_END_OF_LIST,
-                    strlen(SND_UCM_END_OF_LIST))) {
-                    ret = -EINVAL;
-                    break;
-                }
-                index++;
-            }
-            if (ret < 0) {
-                ALOGE("No valid device found: %s",ident_value);
-            } else {
-                if (ctrl_list[use_case_index].capability == CAP_RX) {
-                    rx_id = ctrl_list[use_case_index].acdb_id;
-                    tx_id = ctrl_list[index].acdb_id;
-                } else {
-                    rx_id = ctrl_list[index].acdb_id;
-                    tx_id = ctrl_list[use_case_index].acdb_id;
-                }
-                if(((rx_id == DEVICE_SPEAKER_MONO_RX_ACDB_ID)||(rx_id == DEVICE_SPEAKER_STEREO_RX_ACDB_ID))
-                    && tx_id == DEVICE_HANDSET_TX_ACDB_ID) {
-                    tx_id = DEVICE_SPEAKER_TX_ACDB_ID;
-                } else if (((rx_id == DEVICE_SPEAKER_MONO_RX_ACDB_ID )||(rx_id == DEVICE_SPEAKER_STEREO_RX_ACDB_ID))
-                    && tx_id == DEVICE_HANDSET_TX_FV5_ACDB_ID) {
-                    tx_id = DEVICE_SPEAKER_TX_FV5_ACDB_ID;
-                }
-
-                if ((rx_id != uc_mgr->current_rx_device) ||
-                    (tx_id != uc_mgr->current_tx_device)) {
-                    uc_mgr->current_rx_device = rx_id;
-                    uc_mgr->current_tx_device = tx_id;
-                    ALOGD("Voice acdb: rx id %d tx id %d",
-                          uc_mgr->current_rx_device,
-                          uc_mgr->current_tx_device);
-                    if (uc_mgr->acdb_handle && !uc_mgr->isFusion3Platform) {
-                        acdb_send_voice_cal = dlsym(uc_mgr->acdb_handle,"acdb_loader_send_voice_cal");
-                        if (acdb_send_voice_cal == NULL) {
-                            ALOGE("ucm: dlsym: Error:%s Loading acdb_loader_send_voice_cal", dlerror());
-                        }else {
-                            acdb_send_voice_cal(uc_mgr->current_rx_device,
-                                       uc_mgr->current_tx_device);
-                        }
-                   }
-                } else {
-                    ALOGV("Voice acdb: Required acdb already pushed \
-                         rx id %d tx id %d", uc_mgr->current_rx_device,
-                         uc_mgr->current_tx_device);
-                }
-            }
-            free(ident_value);
-            ident_value = NULL;
-        }
-    } else {
-        ALOGV("No voice use case found");
-        uc_mgr->current_rx_device = -1; uc_mgr->current_tx_device = -1;
-        ret = -ENODEV;
-    }
-    return ret;
-}
-
-int get_use_case_index(snd_use_case_mgr_t *uc_mgr, const char *use_case,
-int ctrl_list_type)
-{
-    use_case_verb_t *verb_list;
-    card_mctrl_t *ctrl_list;
-    int ret = 0, index = 0, verb_index;
-
-    verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
-    verb_index = uc_mgr->card_ctxt_ptr->current_verb_index;
-    if (ctrl_list_type == CTRL_LIST_VERB) {
-        ctrl_list =
-            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].verb_ctrls;
-    } else if (ctrl_list_type == CTRL_LIST_DEVICE) {
-        ctrl_list =
-            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].device_ctrls;
-    } else if (ctrl_list_type == CTRL_LIST_MODIFIER) {
-        ctrl_list =
-            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].mod_ctrls;
-    } else {
-        ctrl_list = NULL;
-    }
-    if((verb_index < 0) ||
-      (!strncmp(uc_mgr->card_ctxt_ptr->current_verb, SND_UCM_END_OF_LIST, 3)) ||
-      (ctrl_list == NULL) || (ctrl_list[index].case_name == NULL)) {
-        ALOGE("Invalid current verb value: %s - %d",
-                uc_mgr->card_ctxt_ptr->current_verb, verb_index);
-        return -EINVAL;
-    }
-    while(strncmp(ctrl_list[index].case_name, use_case, (strlen(use_case)+1))) {
-        if (!strncmp(ctrl_list[index].case_name, SND_UCM_END_OF_LIST,
-            strlen(SND_UCM_END_OF_LIST))) {
-            ret = -EINVAL;
-            break;
-        }
-        index++;
-        if (ctrl_list[index].case_name == NULL) {
-            ALOGE("Invalid case_name at index %d", index);
-            ret = -EINVAL;
-            break;
-        }
-    }
-    if (ret < 0) {
-        return ret;
-    } else {
-        return index;
-    }
-}
-
-/* Apply the required mixer controls for specific use case
- * uc_mgr - UCM structure pointer
- * use_case - use case name
- * return 0 on sucess, otherwise a negative error code
- */
-int snd_use_case_apply_mixer_controls(snd_use_case_mgr_t *uc_mgr,
-const char *use_case, int enable, int ctrl_list_type, int uc_index)
-{
-    card_mctrl_t *ctrl_list;
-    mixer_control_t *mixer_list;
-    struct mixer_ctl *ctl;
-    int i, ret = 0, index = 0, verb_index, mixer_count;
-
-    verb_index = uc_mgr->card_ctxt_ptr->current_verb_index;
-    if (ctrl_list_type == CTRL_LIST_VERB) {
-        ctrl_list =
-            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].verb_ctrls;
-    } else if (ctrl_list_type == CTRL_LIST_DEVICE) {
-        ctrl_list =
-            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].device_ctrls;
-    } else if (ctrl_list_type == CTRL_LIST_MODIFIER) {
-        ctrl_list =
-            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].mod_ctrls;
-    } else {
-        ctrl_list = NULL;
-    }
-    if((verb_index < 0) ||
-      (!strncmp(uc_mgr->card_ctxt_ptr->current_verb, SND_UCM_END_OF_LIST, 3)) ||
-      (ctrl_list == NULL)) {
-        ALOGE("Invalid current verb value: %s - %d",
-            uc_mgr->card_ctxt_ptr->current_verb, verb_index);
-        return -EINVAL;
-    }
-    if (uc_index < 0) {
-        ALOGE("No valid use case found with the use case: %s", use_case);
-        ret = -ENODEV;
-    } else {
-        if (!uc_mgr->card_ctxt_ptr->mixer_handle) {
-            ALOGE("Control device not initialized");
-            ret = -ENODEV;
-        } else {
-            if (enable &&
-                (check_devices_for_voice_call(uc_mgr, use_case) != NULL))
-                return ret;
-            ALOGD("Set mixer controls for %s enable %d", use_case, enable);
-            if (ctrl_list[uc_index].acdb_id && ctrl_list[uc_index].capability) {
-                if (enable) {
-                    if (snd_use_case_apply_voice_acdb(uc_mgr, uc_index)) {
-                        ALOGV("acdb_id %d cap %d enable %d",
-                            ctrl_list[uc_index].acdb_id,
-                            ctrl_list[uc_index].capability, enable);
-                        if (uc_mgr->acdb_handle) {
-                            acdb_send_audio_cal = dlsym(uc_mgr->acdb_handle,"acdb_loader_send_audio_cal");
-                            if (acdb_send_audio_cal == NULL) {
-                                ALOGE("ucm:dlsym:Error:%s Loading acdb_loader_send_audio_cal", dlerror());
-                            } else {
-                                acdb_send_audio_cal(ctrl_list[uc_index].acdb_id,
-                                                     ctrl_list[uc_index].capability);
-                            }
-                        }
-                    }
-                }
-            }
-            if (enable) {
-                mixer_list = ctrl_list[uc_index].ena_mixer_list;
-                mixer_count = ctrl_list[uc_index].ena_mixer_count;
-            } else {
-                mixer_list = ctrl_list[uc_index].dis_mixer_list;
-                mixer_count = ctrl_list[uc_index].dis_mixer_count;
-            }
-            for(index = 0; index < mixer_count; index++) {
-                if (mixer_list == NULL) {
-                    ALOGE("No valid controls exist for this case: %s", use_case);
-                    break;
-                }
-                ctl = mixer_get_control(uc_mgr->card_ctxt_ptr->mixer_handle,
-                          mixer_list[index].control_name, 0);
-                if (ctl) {
-                    if (mixer_list[index].type == TYPE_INT) {
-                        ALOGV("Setting mixer control: %s, value: %d",
-                             mixer_list[index].control_name,
-                             mixer_list[index].value);
-                        ret = mixer_ctl_set(ctl, mixer_list[index].value);
-                    } else if (mixer_list[index].type == TYPE_MULTI_VAL) {
-                        ALOGD("Setting multi value: %s",
-                            mixer_list[index].control_name);
-                        ret = mixer_ctl_set_value(ctl, mixer_list[index].value,
-                                mixer_list[index].mulval);
-                        if (ret < 0)
-                            ALOGE("Failed to set multi value control %s\n",
-                                mixer_list[index].control_name);
-                    } else {
-                        ALOGV("Setting mixer control: %s, value: %s",
-                            mixer_list[index].control_name,
-                            mixer_list[index].string);
-                        ret = mixer_ctl_select(ctl, mixer_list[index].string);
-                    }
-                    if ((ret != 0) && enable) {
-                       /* Disable all the mixer controls which are
-                        * already enabled before failure */
-                       mixer_list = ctrl_list[uc_index].dis_mixer_list;
-                       mixer_count = ctrl_list[uc_index].dis_mixer_count;
-                       for(i = 0; i < mixer_count; i++) {
-                           ctl = mixer_get_control(
-                                     uc_mgr->card_ctxt_ptr->mixer_handle,
-                                     mixer_list[i].control_name, 0);
-                           if (ctl) {
-                               if (mixer_list[i].type == TYPE_INT) {
-                                   ret = mixer_ctl_set(ctl,
-                                             mixer_list[i].value);
-                               } else {
-                                   ret = mixer_ctl_select(ctl,
-                                             mixer_list[i].string);
-                               }
-                           }
-                       }
-                       ALOGE("Failed to enable the mixer controls for %s",
-                            use_case);
-                       break;
-                    }
-                }
-            }
-        }
-    }
-    return ret;
-}
-
-int getUseCaseType(const char *useCase)
-{
-    ALOGV("getUseCaseType: use case is %s\n", useCase);
-    if (!strncmp(useCase, SND_USE_CASE_VERB_HIFI,
-           MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC,
-           MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_HIFI_LOW_POWER,
-           MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_LOW_POWER)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_HIFI_TUNNEL,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_TUNNEL)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_HIFI2,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI2)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_DIGITAL_RADIO,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_DIGITAL_RADIO)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_MUSIC,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_MUSIC)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_LOWLATENCY_MUSIC,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_LOWLATENCY_MUSIC)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_MUSIC2,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_MUSIC2)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_LPA,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_LPA)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_TUNNEL,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_TUNNEL)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_FM,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_FM))) {
-        return CAP_RX;
-    } else if (!strncmp(useCase, SND_USE_CASE_VERB_HIFI_REC,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_REC)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_FM_REC,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_FM_REC)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_FM_A2DP_REC,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_FM_A2DP_REC)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_MUSIC,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_MUSIC)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_REC,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_LOWLATENCY_REC)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_LOWLATENCY_MUSIC,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_LOWLATENCY_MUSIC)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_FM,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_FM)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_A2DP_FM,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_A2DP_FM))) {
-        return CAP_TX;
-    } else if (!strncmp(useCase, SND_USE_CASE_VERB_VOICECALL,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_VOICECALL)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_IP_VOICECALL,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_IP_VOICECALL)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_DL_REC,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_DL_REC)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_UL_DL_REC,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_UL_DL_REC)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_INCALL_REC,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_INCALL_REC)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_VOICE,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_VOICE)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_VOIP,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_VOIP)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_VOICE_DL,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_VOICE_DL)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_VOICE_UL_DL,
-            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_VOICE_UL_DL)) ||
-        !strncmp(useCase, SND_USE_CASE_VERB_VOLTE,
-            MAX_LEN(useCase,SND_USE_CASE_VERB_VOLTE)) ||
-        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_VOLTE,
-            MAX_LEN(useCase, SND_USE_CASE_MOD_PLAY_VOLTE))) {
-        return CAP_VOICE;
-    } else {
-        ALOGE("unknown use case %s, returning voice capablity", useCase);
-        return CAP_VOICE;
-    }
-}
-
-/* Set/Reset mixer controls of specific use case for all current devices
- * uc_mgr - UCM structure pointer
- * ident  - use case name (verb or modifier)
- * enable - 1 for enable and 0 for disable
- * return 0 on sucess, otherwise a negative error code
- */
-static int set_controls_of_usecase_for_all_devices(snd_use_case_mgr_t *uc_mgr,
-const char *ident, int enable, int ctrl_list_type)
-{
-    card_mctrl_t *dev_list, *uc_list;
-    char *current_device, use_case[MAX_UC_LEN];
-    int list_size, index, uc_index, ret = 0, intdev_flag = 0;
-    int verb_index, capability = 0, ident_cap = 0, dev_cap =0;
-
-    ALOGV("set_use_case_ident_for_all_devices(): %s", ident);
-    if ((verb_index = uc_mgr->card_ctxt_ptr->current_verb_index) < 0)
-        verb_index = 0;
-    dev_list =
-        uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].device_ctrls;
-    if (ctrl_list_type == CTRL_LIST_VERB) {
-        uc_list =
-            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].verb_ctrls;
-    } else if (ctrl_list_type == CTRL_LIST_MODIFIER) {
-        uc_list =
-            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].mod_ctrls;
-    } else {
-        uc_list = NULL;
-    }
-    ident_cap = getUseCaseType(ident);
-    list_size = snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
-    for (index = 0; index < list_size; index++) {
-        current_device =
-        snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->dev_list_head, index);
-        if (current_device != NULL) {
-            uc_index = get_use_case_index(uc_mgr, current_device,
-                       CTRL_LIST_DEVICE);
-            dev_cap = dev_list[uc_index].capability;
-            if (!capability) {
-                capability = dev_list[uc_index].capability;
-            } else if (capability != dev_list[uc_index].capability) {
-                capability = CAP_VOICE;
-            }
-            if (ident_cap == CAP_VOICE  || ident_cap == dev_cap) {
-                if (enable) {
-                    if (!snd_ucm_get_status_at_index(
-                        uc_mgr->card_ctxt_ptr->dev_list_head, current_device)) {
-                        if (uc_index >= 0) {
-                            ALOGV("Applying mixer controls for device: %s",
-                                  current_device);
-                            ret = snd_use_case_apply_mixer_controls(uc_mgr,
-                                  current_device, enable, CTRL_LIST_DEVICE, uc_index);
-                            if (!ret)
-                                snd_ucm_set_status_at_index(
-                                  uc_mgr->card_ctxt_ptr->dev_list_head,
-                                  current_device, enable, dev_cap);
-                        }
-                     } else if (ident_cap == CAP_VOICE) {
-                        snd_use_case_apply_voice_acdb(uc_mgr, uc_index);
-                     }
-                 }
-                 strlcpy(use_case, ident, sizeof(use_case));
-                 strlcat(use_case, current_device, sizeof(use_case));
-                 ALOGV("Applying mixer controls for use case: %s", use_case);
-                 if ((uc_index =
-                      get_use_case_index(uc_mgr, use_case, ctrl_list_type)) < 0) {
-                      ALOGV("No valid use case found: %s", use_case);
-                      intdev_flag++;
-                 } else {
-                      if (capability == CAP_VOICE || ident_cap == CAP_VOICE ||
-                          capability == ident_cap) {
-                          ret = snd_use_case_apply_mixer_controls(uc_mgr, use_case,
-                                enable, ctrl_list_type, uc_index);
-                      }
-                 }
-                 use_case[0] = 0;
-                 free(current_device);
-             }
-        }
-    }
-    if (intdev_flag) {
-        if ((uc_index = get_use_case_index(uc_mgr, ident, ctrl_list_type)) < 0) {
-            ALOGE("use case %s not valid without device combination", ident);
-        } else {
-            if (capability == CAP_VOICE || capability == ident_cap ||
-                ident_cap == CAP_VOICE) {
-                snd_use_case_apply_mixer_controls(uc_mgr, ident, enable,
-                ctrl_list_type, uc_index);
-            }
-        }
-    }
-    return ret;
-}
-
-/* Set/Reset mixer controls of specific use case for a specific device
- * uc_mgr - UCM structure pointer
- * ident  - use case name (verb or modifier)
- * device - device for which use case needs to be set/reset
- * enable - 1 for enable and 0 for disable
- * return 0 on sucess, otherwise a negative error code
- */
-static int set_controls_of_usecase_for_device(snd_use_case_mgr_t *uc_mgr,
-const char *ident, const char *device, int enable, int ctrl_list_type)
-{
-    card_mctrl_t *dev_list;
-    char use_case[MAX_UC_LEN];
-    int list_size, index, dev_index, uc_index, ret = 0;
-    int verb_index, capability = 0;
-
-    ALOGV("set_use_case_ident_for_device(): use case %s device %s", ident,
-        device);
-    if ((verb_index = uc_mgr->card_ctxt_ptr->current_verb_index) < 0)
-        verb_index = 0;
-    dev_list =
-        uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].device_ctrls;
-    if (device != NULL) {
-        if (enable) {
-            dev_index = get_use_case_index(uc_mgr, device, CTRL_LIST_DEVICE);
-            capability = dev_list[dev_index].capability;
-            if (!snd_ucm_get_status_at_index(
-                uc_mgr->card_ctxt_ptr->dev_list_head, device)) {
-                ret = snd_use_case_apply_mixer_controls(uc_mgr, device,
-                         enable, CTRL_LIST_DEVICE, dev_index);
-                if (!ret)
-                    snd_ucm_set_status_at_index(
-                    uc_mgr->card_ctxt_ptr->dev_list_head, device, enable,
-                    capability);
-            }
-        }
-        strlcpy(use_case, ident, sizeof(use_case));
-        strlcat(use_case, device, sizeof(use_case));
-    ALOGV("Applying mixer controls for use case: %s", use_case);
-        if ((uc_index = get_use_case_index(uc_mgr, use_case, ctrl_list_type)) < 0) {
-            ALOGV("No valid use case found: %s", use_case );
-            uc_index = get_use_case_index(uc_mgr, ident, ctrl_list_type);
-            if (snd_use_case_apply_mixer_controls(uc_mgr, ident, enable,
-                ctrl_list_type, uc_index) < 0) {
-                 ALOGV("use case %s not valid without device combination also",
-                     ident);
-            }
-        } else {
-            ret = snd_use_case_apply_mixer_controls(uc_mgr, use_case, enable,
-                      ctrl_list_type, uc_index);
-        }
-    } else {
-        uc_index = get_use_case_index(uc_mgr, ident, ctrl_list_type);
-        if (snd_use_case_apply_mixer_controls(uc_mgr, ident, enable,
-            ctrl_list_type, uc_index) < 0) {
-             ALOGV("use case %s not valid without device combination also",
-                 ident);
-        }
-    }
-    return ret;
-}
-
-/* Set/Reset mixer controls of specific device for all use cases
- * uc_mgr - UCM structure pointer
- * device - device name
- * enable - 1 for enable and 0 for disable
- * return 0 on sucess, otherwise a negative error code
- */
-static int set_controls_of_device_for_all_usecases(snd_use_case_mgr_t *uc_mgr,
-const char *device, int enable)
-{
-    card_mctrl_t *dev_list, *uc_list;
-    char *ident_value, use_case[MAX_UC_LEN];
-    int verb_index, uc_index, dev_index, capability = 0;
-    int list_size, index = 0, ret = -ENODEV, flag = 0, intdev_flag = 0;
-
-    ALOGV("set_controls_of_device_for_all_usecases: %s", device);
-    if ((verb_index = uc_mgr->card_ctxt_ptr->current_verb_index) < 0)
-        verb_index = 0;
-    dev_list =
-         uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].device_ctrls;
-    dev_index = get_use_case_index(uc_mgr, device, CTRL_LIST_DEVICE);
-    if (dev_index >= 0)
-        capability = dev_list[dev_index].capability;
-    if (strncmp(uc_mgr->card_ctxt_ptr->current_verb, SND_USE_CASE_VERB_INACTIVE,
-        strlen(SND_USE_CASE_VERB_INACTIVE))) {
-        uc_list =
-            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].verb_ctrls;
-        if (capability == CAP_VOICE ||
-            capability == getUseCaseType(uc_mgr->card_ctxt_ptr->current_verb) ||
-            getUseCaseType(uc_mgr->card_ctxt_ptr->current_verb) == CAP_VOICE) {
-            strlcpy(use_case, uc_mgr->card_ctxt_ptr->current_verb,
-                sizeof(use_case));
-            strlcat(use_case, device, sizeof(use_case));
-            if ((uc_index =
-                get_use_case_index(uc_mgr, use_case, CTRL_LIST_VERB)) < 0) {
-                ALOGV("No valid use case found: %s", use_case);
-                intdev_flag = 1;
-            } else {
-                if (enable) {
-                    if (!snd_ucm_get_status_at_index(
-                        uc_mgr->card_ctxt_ptr->dev_list_head, device)) {
-                        ret = snd_use_case_apply_mixer_controls(uc_mgr, device,
-                                  enable, CTRL_LIST_DEVICE, dev_index);
-                        if (!ret)
-                            snd_ucm_set_status_at_index(
-                            uc_mgr->card_ctxt_ptr->dev_list_head, device,
-                            enable, capability);
-                            flag = 1;
-                    }
-                }
-                ALOGV("set %d for use case value: %s", enable, use_case);
-                ret = snd_use_case_apply_mixer_controls(uc_mgr, use_case,
-                          enable, CTRL_LIST_VERB, uc_index);
-                if (ret != 0)
-                     ALOGE("No valid controls exists for usecase %s and device \
-                          %s, enable: %d", use_case, device, enable);
-            }
-        }
-        if (intdev_flag) {
-            if (enable && !flag) {
-                if (!snd_ucm_get_status_at_index(
-                    uc_mgr->card_ctxt_ptr->dev_list_head, device)) {
-                    ret = snd_use_case_apply_mixer_controls(uc_mgr,
-                              device, enable, CTRL_LIST_DEVICE, dev_index);
-                    if (!ret)
-                        snd_ucm_set_status_at_index(
-                        uc_mgr->card_ctxt_ptr->dev_list_head, device, enable,
-                        capability);
-                    flag = 1;
-                }
-            }
-            use_case[0] = 0;
-            strlcpy(use_case, uc_mgr->card_ctxt_ptr->current_verb,
-                sizeof(use_case));
-            uc_index = get_use_case_index(uc_mgr, use_case, CTRL_LIST_VERB);
-            if (capability == CAP_VOICE ||
-                capability ==
-                getUseCaseType(uc_mgr->card_ctxt_ptr->current_verb) ||
-                getUseCaseType(uc_mgr->card_ctxt_ptr->current_verb) ==
-                CAP_VOICE) {
-                ALOGV("set %d for use case value: %s", enable, use_case);
-                ret = snd_use_case_apply_mixer_controls(uc_mgr, use_case,
-                          enable, CTRL_LIST_VERB, uc_index);
-                if (ret != 0)
-                      ALOGE("No valid controls exists for usecase %s and \
-                           device %s, enable: %d", use_case, device, enable);
-            }
-            intdev_flag = 0;
-        }
-        use_case[0] = 0;
-    }
-    snd_ucm_print_list(uc_mgr->card_ctxt_ptr->mod_list_head);
-    uc_list =
-        uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].mod_ctrls;
-    list_size = snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->mod_list_head);
-    for (index = 0; index < list_size; index++) {
-        if ((ident_value =
-            snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->mod_list_head,
-            index))) {
-            if (capability == CAP_VOICE ||
-                getUseCaseType(ident_value) == CAP_VOICE ||
-                capability == getUseCaseType(ident_value)) {
-                strlcpy(use_case, ident_value, sizeof(use_case));
-                strlcat(use_case, device, sizeof(use_case));
-                if ((uc_index = get_use_case_index(uc_mgr, use_case,
-                    CTRL_LIST_MODIFIER)) < 0) {
-                    ALOGV("No valid use case found: %s", use_case);
-                    intdev_flag = 1;
-                } else {
-                    if (enable && !flag) {
-                        if (!snd_ucm_get_status_at_index(
-                            uc_mgr->card_ctxt_ptr->dev_list_head, device)) {
-                            ret = snd_use_case_apply_mixer_controls(uc_mgr,
-                                      device, enable, CTRL_LIST_DEVICE,
-                                      dev_index);
-                            if (!ret)
-                                snd_ucm_set_status_at_index(
-                                    uc_mgr->card_ctxt_ptr->dev_list_head,
-                                    device, enable, capability);
-                            flag = 1;
-                        }
-                    }
-                    ALOGV("set %d for use case value: %s", enable, use_case);
-                    ret = snd_use_case_apply_mixer_controls(uc_mgr,
-                          use_case, enable, CTRL_LIST_MODIFIER, uc_index);
-                    if (ret != 0)
-                        ALOGE("No valid controls exists for usecase %s and \
-                            device %s, enable: %d", use_case, device, enable);
-                }
-            }
-            if (intdev_flag) {
-                if (enable && !flag) {
-                    if (!snd_ucm_get_status_at_index(
-                         uc_mgr->card_ctxt_ptr->dev_list_head, device)) {
-                        ret = snd_use_case_apply_mixer_controls(uc_mgr,
-                                  device, enable, CTRL_LIST_DEVICE, dev_index);
-                        if (!ret)
-                            snd_ucm_set_status_at_index(
-                            uc_mgr->card_ctxt_ptr->dev_list_head, device,
-                            enable, capability);
-                        flag = 1;
-                    }
-                }
-                use_case[0] = 0;
-                strlcpy(use_case, ident_value, sizeof(use_case));
-                uc_index =
-                    get_use_case_index(uc_mgr, ident_value, CTRL_LIST_MODIFIER);
-                if (capability == CAP_VOICE ||
-                    capability == getUseCaseType(ident_value) ||
-                    getUseCaseType(ident_value) == CAP_VOICE) {
-                    ALOGV("set %d for use case value: %s", enable, use_case);
-                    ret = snd_use_case_apply_mixer_controls(uc_mgr, use_case,
-                          enable, CTRL_LIST_MODIFIER, uc_index);
-                    if (ret != 0)
-                         ALOGE("No valid controls exists for usecase %s and \
-                              device %s, enable: %d", use_case, device, enable);
-                }
-                intdev_flag = 0;
-            }
-            use_case[0] = 0;
-            free(ident_value);
-        }
-    }
-    if (!enable) {
-        ret = snd_use_case_apply_mixer_controls(uc_mgr, device, enable,
-                  CTRL_LIST_DEVICE, dev_index);
-        if (!ret)
-            snd_ucm_set_status_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
-                device, enable, capability);
-    }
-    return ret;
-}
-
-/* Returns usecase type i.e. either verb or modifier
- * uc_mgr - UCM structure pointer
- * usecase - usecase name either verb or modifier
- * return CTRL_LIST_VERB or CTRL_LIST_MODIFIER for verb/modifier respectively
- */
-static int get_usecase_type(snd_use_case_mgr_t *uc_mgr, const char *usecase)
-{
-    int ret = -EINVAL, index = 0;
-
-    while (strncmp(uc_mgr->card_ctxt_ptr->verb_list[index],
-        SND_UCM_END_OF_LIST, strlen(SND_UCM_END_OF_LIST))) {
-        if (!strncmp(uc_mgr->card_ctxt_ptr->verb_list[index], usecase,
-            (strlen(usecase)+1))) {
-            ret = 0;
-            break;
-        }
-        index++;
-    }
-    if (ret == 0)
-        return CTRL_LIST_VERB;
-    else
-        return CTRL_LIST_MODIFIER;
-}
-
-/* Set/Reset mixer controls of specific device and specific use cases
- * uc_mgr - UCM structure pointer
- * device - device name
- * usecase - use case for which device needs to be enabled
- * enable - 1 for enable and 0 for disable
- * return 0 on sucess, otherwise a negative error code
- */
-static int set_controls_of_device_for_usecase(snd_use_case_mgr_t *uc_mgr,
-    const char *device, const char *usecase, int enable)
-{
-    card_mctrl_t *dev_list;
-    char use_case[MAX_UC_LEN];
-    int ret = -ENODEV, uc_index, dev_index;
-    int verb_index, capability = 0;
-
-    ALOGV("set_device_for_ident(): %s %s", device, usecase);
-    if ((verb_index = uc_mgr->card_ctxt_ptr->current_verb_index) < 0)
-        verb_index = 0;
-    dev_list =
-         uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].device_ctrls;
-    dev_index = get_use_case_index(uc_mgr, device, CTRL_LIST_DEVICE);
-    capability = dev_list[dev_index].capability;
-    if (usecase != NULL) {
-        strlcpy(use_case, usecase, sizeof(use_case));
-        strlcat(use_case, device, sizeof(use_case));
-        if ((uc_index = get_use_case_index(uc_mgr, use_case,
-            get_usecase_type(uc_mgr, usecase))) < 0) {
-            ALOGV("No valid use case found: %s", use_case);
-        } else {
-            if (enable) {
-                if (!snd_ucm_get_status_at_index(
-                    uc_mgr->card_ctxt_ptr->dev_list_head, device)) {
-                    ret = snd_use_case_apply_mixer_controls(uc_mgr, device,
-                          enable, CTRL_LIST_DEVICE, dev_index);
-                    if (!ret)
-                        snd_ucm_set_status_at_index
-                        (uc_mgr->card_ctxt_ptr->dev_list_head, device, enable,
-                        capability);
-                }
-            }
-            ALOGV("set %d for use case value: %s", enable, use_case);
-            ret = snd_use_case_apply_mixer_controls(uc_mgr, use_case, enable,
-                      get_usecase_type(uc_mgr, usecase), uc_index);
-            if (ret != 0)
-                ALOGE("No valid controls exists for usecase %s and device %s, \
-                     enable: %d", use_case, device, enable);
-        }
-        use_case[0] = 0;
-    } else {
-        if (enable) {
-            if (!snd_ucm_get_status_at_index(
-                 uc_mgr->card_ctxt_ptr->dev_list_head, device)) {
-                ret = snd_use_case_apply_mixer_controls(uc_mgr, device, enable,
-                          CTRL_LIST_DEVICE, dev_index);
-                if (!ret)
-                    snd_ucm_set_status_at_index(
-                        uc_mgr->card_ctxt_ptr->dev_list_head, device, enable,
-                        capability);
-            }
-        }
-    }
-    if (!enable) {
-        ret = snd_use_case_apply_mixer_controls(uc_mgr, device, enable,
-                  CTRL_LIST_DEVICE, dev_index);
-        if (!ret)
-            snd_ucm_set_status_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
-                device, enable, capability);
-    }
-    return ret;
-}
-
-/**
- * Set new value for an identifier
- * uc_mgr - UCM structure
- * identifier - _verb, _enadev, _disdev, _enamod, _dismod
- *        _swdev, _swmod
- * value - Value to be set
- * returns 0 on success, otherwise a negative error code
- */
-int snd_use_case_set(snd_use_case_mgr_t *uc_mgr,
-                     const char *identifier,
-                     const char *value)
-{
-    use_case_verb_t *verb_list;
-    char ident[MAX_STR_LEN], *ident1, *ident2, *temp_ptr;
-    int verb_index, list_size, index = 0, ret = -EINVAL;
-
-    pthread_mutex_lock(&uc_mgr->card_ctxt_ptr->card_lock);
-    if ((uc_mgr->snd_card_index >= (int)MAX_NUM_CARDS) || (value == NULL) ||
-        (uc_mgr->snd_card_index < 0) || (uc_mgr->card_ctxt_ptr == NULL) ||
-        (identifier == NULL)) {
-        ALOGE("snd_use_case_set(): failed, invalid arguments");
-        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-        return -EINVAL;
-    }
-
-    ALOGD("snd_use_case_set(): uc_mgr %p identifier %s value %s", uc_mgr,
-         identifier, value);
-    strlcpy(ident, identifier, sizeof(ident));
-    if(!(ident1 = strtok_r(ident, "/", &temp_ptr))) {
-        ALOGV("No multiple identifiers found in identifier value");
-        ident[0] = 0;
-    } else {
-        if (!strncmp(ident1, "_swdev", 6)) {
-            if(!(ident2 = strtok_r(NULL, "/", &temp_ptr))) {
-                ALOGD("Invalid disable device value: %s, but enabling new \
-                     device", ident2);
-            } else {
-                ret = snd_ucm_del_ident_from_list(
-                          &uc_mgr->card_ctxt_ptr->dev_list_head, ident2);
-                if (ret < 0) {
-                    ALOGV("Ignore device %s disable, device not part of \
-                         enabled list", ident2);
-                } else {
-                    ALOGV("swdev: device value to be disabled: %s", ident2);
-                    /* Disable mixer controls for
-                     * corresponding use cases and device */
-                    ret = set_controls_of_device_for_all_usecases(uc_mgr,
-                              ident2, 0);
-                    if (ret < 0) {
-                        ALOGV("Device %s not disabled, no valid use case \
-                              found: %d", ident2, errno);
-                    }
-                }
-            }
-            pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-            ret = snd_use_case_set(uc_mgr, "_enadev", value);
-            if (ret < 0) {
-                ALOGV("Device %s not enabled, no valid use case found: %d",
-                    value, errno);
-            }
-            return ret;
-        } else if (!strncmp(ident1, "_swmod", 6)) {
-            pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-            if(!(ident2 = strtok_r(NULL, "/", &temp_ptr))) {
-                ALOGD("Invalid modifier value: %s, but enabling new modifier",
-                    ident2);
-            } else {
-                ret = snd_use_case_set(uc_mgr, "_dismod", ident2);
-                if (ret < 0) {
-                    ALOGV("Modifier %s not disabled, no valid use case \
-                         found: %d", ident2, errno);
-                }
-            }
-            ret = snd_use_case_set(uc_mgr, "_enamod", value);
-            if (ret < 0) {
-                ALOGV("Modifier %s not enabled, no valid use case found: %d",
-                    value, errno);
-            }
-            return ret;
-        } else {
-            ALOGV("No switch device/modifier option found: %s", ident1);
-        }
-        ident[0] = 0;
-    }
-
-    if (!strncmp(identifier, "_verb", 5)) {
-        /* Check if value is valid verb */
-        while (strncmp(uc_mgr->card_ctxt_ptr->verb_list[index],
-               SND_UCM_END_OF_LIST, strlen(SND_UCM_END_OF_LIST))) {
-            if (!strncmp(uc_mgr->card_ctxt_ptr->verb_list[index], value,
-                (strlen(value)+1))) {
-                ret = 0;
-                break;
-            }
-            index++;
-        }
-        if ((ret < 0) && (strncmp(value, SND_USE_CASE_VERB_INACTIVE,
-            strlen(SND_USE_CASE_VERB_INACTIVE)))) {
-            ALOGE("Invalid verb identifier value");
-        } else {
-            ALOGV("Index:%d Verb:%s", index,
-                uc_mgr->card_ctxt_ptr->verb_list[index]);
-            /* Disable the mixer controls for current use case
-             * for all the enabled devices */
-            if (strncmp(uc_mgr->card_ctxt_ptr->current_verb,
-                SND_USE_CASE_VERB_INACTIVE,
-                strlen(SND_USE_CASE_VERB_INACTIVE))) {
-                ret = set_controls_of_usecase_for_all_devices(uc_mgr,
-                      uc_mgr->card_ctxt_ptr->current_verb, 0, CTRL_LIST_VERB);
-                if (ret != 0)
-                    ALOGE("Failed to disable controls for use case: %s",
-                        uc_mgr->card_ctxt_ptr->current_verb);
-            }
-            strlcpy(uc_mgr->card_ctxt_ptr->current_verb, value, MAX_STR_LEN);
-            /* Enable the mixer controls for the new use case
-             * for all the enabled devices */
-            if (strncmp(uc_mgr->card_ctxt_ptr->current_verb,
-               SND_USE_CASE_VERB_INACTIVE,
-               strlen(SND_USE_CASE_VERB_INACTIVE))) {
-               uc_mgr->card_ctxt_ptr->current_verb_index = index;
-               ret = set_controls_of_usecase_for_all_devices(uc_mgr,
-                     uc_mgr->card_ctxt_ptr->current_verb, 1, CTRL_LIST_VERB);
-            }
-        }
-    } else if (!strncmp(identifier, "_enadev", 7)) {
-        index = 0; ret = 0;
-        list_size =
-            snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
-        for (index = 0; index < list_size; index++) {
-            if ((ident1 =
-                snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
-                index))) {
-                if (!strncmp(ident1, value, (strlen(value)+1))) {
-                    ALOGV("Ignore enable as %s device is already part of \
-                         enabled list", value);
-                    free(ident1);
-                    break;
-                }
-                free(ident1);
-            }
-        }
-        if (index == list_size) {
-            ALOGV("enadev: device value to be enabled: %s", value);
-            snd_ucm_add_ident_to_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
-                value);
-        }
-        snd_ucm_print_list(uc_mgr->card_ctxt_ptr->dev_list_head);
-        /* Apply Mixer controls of all verb and modifiers for this device*/
-        ret = set_controls_of_device_for_all_usecases(uc_mgr, value, 1);
-    } else if (!strncmp(identifier, "_disdev", 7)) {
-        ret = snd_ucm_get_status_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
-                  value);
-        if (ret < 0) {
-            ALOGD("disdev: device %s not enabled, no need to disable", value);
-        } else if (ret == 0) {
-            ALOGV("disdev: device %s not active, remove from the list", value);
-            ret =
-            snd_ucm_del_ident_from_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
-            value);
-            if (ret < 0) {
-                ALOGE("Invalid device: Device not part of enabled device list");
-            }
-        } else {
-            ret =
-            snd_ucm_del_ident_from_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
-            value);
-            if (ret < 0) {
-                ALOGE("Invalid device: Device not part of enabled device list");
-            } else {
-                ALOGV("disdev: device value to be disabled: %s", value);
-                index = get_use_case_index(uc_mgr, value, CTRL_LIST_DEVICE);
-                /* Apply Mixer controls for corresponding device and modifier */
-                ret = snd_use_case_apply_mixer_controls(uc_mgr, value, 0,
-                          CTRL_LIST_DEVICE, index);
-            }
-        }
-    } else if (!strncmp(identifier, "_enamod", 7)) {
-        index = 0; ret = 0;
-        verb_index = uc_mgr->card_ctxt_ptr->current_verb_index;
-        if (verb_index < 0) {
-            ALOGE("Invalid verb identifier value");
-        } else {
-            ALOGV("Index:%d Verb:%s", verb_index,
-                 uc_mgr->card_ctxt_ptr->verb_list[verb_index]);
-            verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
-            while(strncmp(verb_list[verb_index].modifier_list[index], value,
-                  (strlen(value)+1))) {
-                if (!strncmp(verb_list[verb_index].modifier_list[index],
-                    SND_UCM_END_OF_LIST, strlen(SND_UCM_END_OF_LIST))){
-                    ret = -EINVAL;
-                    break;
-                }
-                index++;
-            }
-            if (ret < 0) {
-                ALOGE("Invalid modifier identifier value");
-            } else {
-                snd_ucm_add_ident_to_list(&uc_mgr->card_ctxt_ptr->mod_list_head,
-                    value);
-                /* Enable the mixer controls for the new use case
-                 * for all the enabled devices */
-                ret = set_controls_of_usecase_for_all_devices(uc_mgr, value, 1,
-                          CTRL_LIST_MODIFIER);
-            }
-        }
-    } else if (!strncmp(identifier, "_dismod", 7)) {
-        ret = snd_ucm_del_ident_from_list(&uc_mgr->card_ctxt_ptr->mod_list_head,
-                  value);
-        if (ret < 0) {
-            ALOGE("Modifier not enabled currently, invalid modifier");
-        } else {
-            ALOGV("dismod: modifier value to be disabled: %s", value);
-            /* Enable the mixer controls for the new use case
-             * for all the enabled devices */
-            ret = set_controls_of_usecase_for_all_devices(uc_mgr, value, 0,
-                      CTRL_LIST_MODIFIER);
-        }
-    } else {
-        ALOGE("Unknown identifier value: %s", identifier);
-    }
-    pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-    return ret;
-}
-
-/**
- * Set new value for an identifier based on use case
- * uc_mgr - UCM structure
- * identifier - _verb, _enadev, _disdev, _enamod, _dismod
- *        _swdev, _swmod
- * value - Value to be set
- * usecase - usecase/device for which this command needs to be executed
- * returns 0 on success, otherwise a negative error code
- */
-int snd_use_case_set_case(snd_use_case_mgr_t *uc_mgr,
-                     const char *identifier,
-                     const char *value, const char *usecase)
-{
-    use_case_verb_t *verb_list;
-    char ident[MAX_STR_LEN], *ident1, *ident2, *temp_ptr;
-    int verb_index, list_size, index = 0, ret = -EINVAL;
-
-    pthread_mutex_lock(&uc_mgr->card_ctxt_ptr->card_lock);
-    if ((uc_mgr->snd_card_index >= (int)MAX_NUM_CARDS) || (value == NULL) ||
-        (uc_mgr->snd_card_index < 0) || (uc_mgr->card_ctxt_ptr == NULL) ||
-        (identifier == NULL)) {
-        ALOGE("snd_use_case_set_case(): failed, invalid arguments");
-        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-        return -EINVAL;
-    }
-
-    ALOGD("snd_use_case_set_case(): uc_mgr %p identifier %s value %s",
-        uc_mgr, identifier, value);
-    strlcpy(ident, identifier, sizeof(ident));
-    if(!(ident1 = strtok_r(ident, "/", &temp_ptr))) {
-        ALOGV("No multiple identifiers found in identifier value");
-        ident[0] = 0;
-    } else {
-        if (!strncmp(ident1, "_swdev", 6)) {
-            if(!(ident2 = strtok_r(NULL, "/", &temp_ptr))) {
-                ALOGD("Invalid disable device value: %s, but enabling new \
-                     device", ident2);
-            } else {
-                ret = snd_ucm_del_ident_from_list(
-                          &uc_mgr->card_ctxt_ptr->dev_list_head, ident2);
-                if (ret < 0) {
-                    ALOGV("Ignore device %s disable, device not part of \
-                         enabled list", ident2);
-                } else {
-                    ALOGV("swdev: device value to be disabled: %s", ident2);
-                    /* Disable mixer controls for
-                     * corresponding use cases and device */
-                    ret = set_controls_of_device_for_usecase(uc_mgr, ident2,
-                              usecase, 0);
-                    if (ret < 0) {
-                        ALOGV("Device %s not disabled, no valid use case \
-                             found: %d", ident2, errno);
-                    }
-                }
-            }
-            pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-            ret = snd_use_case_set_case(uc_mgr, "_enadev", value, usecase);
-            if (ret < 0) {
-                ALOGV("Device %s not enabled, no valid use case found: %d",
-                    value, errno);
-            }
-            return ret;
-        } else if (!strncmp(ident1, "_swmod", 6)) {
-            pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-            if(!(ident2 = strtok_r(NULL, "/", &temp_ptr))) {
-                ALOGD("Invalid modifier value: %s, but enabling new modifier",
-                    ident2);
-            } else {
-                ret = snd_use_case_set_case(uc_mgr, "_dismod", ident2, usecase);
-                if (ret < 0) {
-                    ALOGV("Modifier %s not disabled, no valid use case \
-                         found: %d", ident2, errno);
-                }
-            }
-            ret = snd_use_case_set_case(uc_mgr, "_enamod", value, usecase);
-            if (ret < 0) {
-                ALOGV("Modifier %s not enabled, no valid use case found: %d",
-                    value, errno);
-            }
-            return ret;
-        } else {
-            ALOGV("No switch device/modifier option found: %s", ident1);
-        }
-        ident[0] = 0;
-    }
-
-    if (!strncmp(identifier, "_verb", 5)) {
-        /* Check if value is valid verb */
-        while (strncmp(uc_mgr->card_ctxt_ptr->verb_list[index],
-               SND_UCM_END_OF_LIST, MAX_STR_LEN)) {
-            if (!strncmp(uc_mgr->card_ctxt_ptr->verb_list[index],
-                value, MAX_STR_LEN)) {
-                ret = 0;
-                break;
-            }
-            index++;
-        }
-        if ((ret < 0) && (strncmp(value, SND_USE_CASE_VERB_INACTIVE,
-            MAX_STR_LEN))) {
-            ALOGE("Invalid verb identifier value");
-        } else {
-            ALOGV("Index:%d Verb:%s", index,
-                 uc_mgr->card_ctxt_ptr->verb_list[index]);
-            /* Disable the mixer controls for current use case
-             * for specified device */
-            if (strncmp(uc_mgr->card_ctxt_ptr->current_verb,
-                SND_USE_CASE_VERB_INACTIVE, MAX_STR_LEN)) {
-                ret = set_controls_of_usecase_for_device(uc_mgr,
-                          uc_mgr->card_ctxt_ptr->current_verb, usecase,
-                          0, CTRL_LIST_VERB);
-                if (ret != 0)
-                    ALOGE("Failed to disable controls for use case: %s",
-                        uc_mgr->card_ctxt_ptr->current_verb);
-            }
-            strlcpy(uc_mgr->card_ctxt_ptr->current_verb, value, MAX_STR_LEN);
-            /* Enable the mixer controls for the new use case
-             * for specified device */
-            if (strncmp(uc_mgr->card_ctxt_ptr->current_verb,
-                SND_USE_CASE_VERB_INACTIVE, MAX_STR_LEN)) {
-               uc_mgr->card_ctxt_ptr->current_verb_index = index;
-               index = 0;
-               list_size =
-               snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
-               for (index = 0; index < list_size; index++) {
-                   if ((ident1 = snd_ucm_get_value_at_index(
-                       uc_mgr->card_ctxt_ptr->dev_list_head, index))) {
-                       if (!strncmp(ident1, usecase, MAX_STR_LEN)) {
-                           ALOGV("Device already part of enabled list: %s",
-                               usecase);
-                           free(ident1);
-                           break;
-                       }
-                       free(ident1);
-                   }
-               }
-               if (index == list_size) {
-                   ALOGV("enadev: device value to be enabled: %s", usecase);
-                   snd_ucm_add_ident_to_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
-                        usecase);
-               }
-               ret = set_controls_of_usecase_for_device(uc_mgr,
-                         uc_mgr->card_ctxt_ptr->current_verb, usecase,
-                         1, CTRL_LIST_VERB);
-            }
-        }
-    } else if (!strncmp(identifier, "_enadev", 7)) {
-        index = 0; ret = 0;
-        list_size =
-            snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
-        for (index = 0; index < list_size; index++) {
-            if ((ident1 =
-                snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
-                index))) {
-                if (!strncmp(ident1, value, MAX_STR_LEN)) {
-                    ALOGV("Device already part of enabled list: %s", value);
-                    free(ident1);
-                    break;
-                }
-                free(ident1);
-            }
-        }
-        if (index == list_size) {
-            ALOGV("enadev: device value to be enabled: %s", value);
-            snd_ucm_add_ident_to_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
-                value);
-        }
-        snd_ucm_print_list(uc_mgr->card_ctxt_ptr->dev_list_head);
-        /* Apply Mixer controls of usecase for this device*/
-        ret = set_controls_of_device_for_usecase(uc_mgr, value, usecase, 1);
-    } else if (!strncmp(identifier, "_disdev", 7)) {
-        ret = snd_ucm_get_status_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
-                  value);
-        if (ret < 0) {
-            ALOGD("disdev: device %s not enabled, no need to disable", value);
-        } else if (ret == 0) {
-            ALOGV("disdev: device %s not active, remove from the list", value);
-            ret =
-            snd_ucm_del_ident_from_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
-            value);
-            if (ret < 0) {
-                ALOGE("Invalid device: Device not part of enabled device list");
-            }
-        } else {
-            ret =
-            snd_ucm_del_ident_from_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
-            value);
-            if (ret < 0) {
-                ALOGE("Invalid device: Device not part of enabled device list");
-            } else {
-                ALOGV("disdev: device value to be disabled: %s", value);
-                /* Apply Mixer controls of usecase for this device*/
-                ret = set_controls_of_device_for_usecase(uc_mgr, value,
-                          usecase, 0);
-            }
-        }
-    } else if (!strncmp(identifier, "_enamod", 7)) {
-        if (!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
-            SND_USE_CASE_VERB_INACTIVE, MAX_STR_LEN)) {
-            ALOGE("Invalid use case verb value");
-            ret = -EINVAL;
-        } else {
-            ret = 0;
-            while(strncmp(uc_mgr->card_ctxt_ptr->verb_list[index],
-                  uc_mgr->card_ctxt_ptr->current_verb, MAX_STR_LEN)) {
-                if (!strncmp(uc_mgr->card_ctxt_ptr->verb_list[index],
-                    SND_UCM_END_OF_LIST, MAX_STR_LEN)){
-                    ret = -EINVAL;
-                    break;
-                }
-                index++;
-            }
-        }
-        if (ret < 0) {
-            ALOGE("Invalid verb identifier value");
-        } else {
-            verb_index = index; index = 0; ret = 0;
-            verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
-            ALOGV("Index:%d Verb:%s", verb_index,
-                 uc_mgr->card_ctxt_ptr->verb_list[verb_index]);
-            while(strncmp(verb_list[verb_index].modifier_list[index],
-                value, MAX_STR_LEN)) {
-                if (!strncmp(verb_list[verb_index].modifier_list[index],
-                    SND_UCM_END_OF_LIST, MAX_STR_LEN)){
-                    ret = -EINVAL;
-                    break;
-                }
-                index++;
-            }
-            if (ret < 0) {
-                ALOGE("Invalid modifier identifier value");
-            } else {
-                index = 0;
-                list_size =
-                snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
-                for (index = 0; index < list_size; index++) {
-                    if ((ident1 = snd_ucm_get_value_at_index(
-                        uc_mgr->card_ctxt_ptr->dev_list_head, index))) {
-                        if (!strncmp(ident1, usecase, MAX_STR_LEN)) {
-                            ALOGV("Device already part of enabled list: %s",
-                                usecase);
-                            free(ident1);
-                            break;
-                        }
-                        free(ident1);
-                    }
-                }
-                if (index == list_size) {
-                    ALOGV("enadev: device value to be enabled: %s", usecase);
-                    snd_ucm_add_ident_to_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
-                         usecase);
-                }
-                snd_ucm_add_ident_to_list(&uc_mgr->card_ctxt_ptr->mod_list_head,
-                    value);
-                /* Enable the mixer controls for the new use case
-                 * for all the enabled devices */
-                ret = set_controls_of_usecase_for_device(uc_mgr, value,
-                      usecase, 1, CTRL_LIST_MODIFIER);
-            }
-        }
-    } else if (!strncmp(identifier, "_dismod", 7)) {
-        ret = snd_ucm_del_ident_from_list(&uc_mgr->card_ctxt_ptr->mod_list_head,
-              value);
-        if (ret < 0) {
-            ALOGE("Modifier not enabled currently, invalid modifier");
-        } else {
-            ALOGV("dismod: modifier value to be disabled: %s", value);
-            /* Enable the mixer controls for the new use case
-             * for all the enabled devices */
-            ret = set_controls_of_usecase_for_device(uc_mgr, value, usecase,
-                      0, CTRL_LIST_MODIFIER);
-        }
-    } else {
-        ALOGE("Unknown identifier value: %s", identifier);
-    }
-    pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-    return ret;
-}
-
-/**
- * Open and initialise use case core for sound card
- * uc_mgr - Returned use case manager pointer
- * card_name - Sound card name.
- * returns 0 on success, otherwise a negative error code
- */
-int snd_use_case_mgr_open(snd_use_case_mgr_t **uc_mgr, const char *card_name)
-{
-    snd_use_case_mgr_t *uc_mgr_ptr = NULL;
-    int index, ret = -EINVAL;
-    char tmp[2];
-
-    ALOGV("snd_use_case_open(): card_name %s", card_name);
-
-    if (card_name == NULL) {
-        ALOGE("snd_use_case_mgr_open: failed, invalid arguments");
-        return ret;
-    }
-
-    for (index = 0; index < (int)MAX_NUM_CARDS; index++) {
-        if(!strncmp(card_name, card_mapping_list[index].card_name,
-           (strlen(card_mapping_list[index].card_name)+1))) {
-            ret = 0;
-            break;
-        }
-    }
-
-    if (ret < 0) {
-        ALOGE("Card %s not found", card_name);
-    } else {
-        uc_mgr_ptr = (snd_use_case_mgr_t *)calloc(1,
-                         sizeof(snd_use_case_mgr_t));
-        if (uc_mgr_ptr == NULL) {
-            ALOGE("Failed to allocate memory for instance");
-            return -ENOMEM;
-        }
-        uc_mgr_ptr->snd_card_index = index;
-        uc_mgr_ptr->card_ctxt_ptr = (card_ctxt_t *)calloc(1,
-                                        sizeof(card_ctxt_t));
-        if (uc_mgr_ptr->card_ctxt_ptr == NULL) {
-            ALOGE("Failed to allocate memory for card context");
-            free(uc_mgr_ptr);
-            uc_mgr_ptr = NULL;
-            return -ENOMEM;
-        }
-        uc_mgr_ptr->card_ctxt_ptr->card_number =
-            card_mapping_list[index].card_number;
-        uc_mgr_ptr->card_ctxt_ptr->card_name =
-            (char *)malloc((strlen(card_name)+1)*sizeof(char));
-        if (uc_mgr_ptr->card_ctxt_ptr->card_name == NULL) {
-            ALOGE("Failed to allocate memory for card name");
-            free(uc_mgr_ptr->card_ctxt_ptr);
-            free(uc_mgr_ptr);
-            uc_mgr_ptr = NULL;
-            return -ENOMEM;
-        }
-        strlcpy(uc_mgr_ptr->card_ctxt_ptr->card_name, card_name,
-            ((strlen(card_name)+1)*sizeof(char)));
-        uc_mgr_ptr->card_ctxt_ptr->control_device =
-            (char *)malloc((strlen("/dev/snd/controlC")+2)*sizeof(char));
-        if (uc_mgr_ptr->card_ctxt_ptr->control_device == NULL) {
-            ALOGE("Failed to allocate memory for control device string");
-            free(uc_mgr_ptr->card_ctxt_ptr->card_name);
-            free(uc_mgr_ptr->card_ctxt_ptr);
-            free(uc_mgr_ptr);
-            uc_mgr_ptr = NULL;
-            return -ENOMEM;
-        }
-        strlcpy(uc_mgr_ptr->card_ctxt_ptr->control_device,
-            "/dev/snd/controlC", 18);
-        snprintf(tmp, sizeof(tmp), "%d",
-            uc_mgr_ptr->card_ctxt_ptr->card_number);
-        strlcat(uc_mgr_ptr->card_ctxt_ptr->control_device, tmp,
-            (strlen("/dev/snd/controlC")+2)*sizeof(char));
-        uc_mgr_ptr->device_list_count = 0;
-        uc_mgr_ptr->modifier_list_count = 0;
-        uc_mgr_ptr->current_device_list = NULL;
-        uc_mgr_ptr->current_modifier_list = NULL;
-        uc_mgr_ptr->current_tx_device = -1;
-        uc_mgr_ptr->current_rx_device = -1;
-        pthread_mutexattr_init(&uc_mgr_ptr->card_ctxt_ptr->card_lock_attr);
-        pthread_mutex_init(&uc_mgr_ptr->card_ctxt_ptr->card_lock,
-            &uc_mgr_ptr->card_ctxt_ptr->card_lock_attr);
-        strlcpy(uc_mgr_ptr->card_ctxt_ptr->current_verb,
-                SND_USE_CASE_VERB_INACTIVE, MAX_STR_LEN);
-        /* Reset all mixer controls if any applied
-         * previously for the same card */
-    snd_use_case_mgr_reset(uc_mgr_ptr);
-        uc_mgr_ptr->card_ctxt_ptr->current_verb_index = -1;
-        /* Parse config files and update mixer controls */
-        ret = snd_ucm_parse(&uc_mgr_ptr);
-        if(ret < 0) {
-            ALOGE("Failed to parse config files: %d", ret);
-            snd_ucm_free_mixer_list(&uc_mgr_ptr);
-        }
-        ALOGV("Open mixer device: %s",
-            uc_mgr_ptr->card_ctxt_ptr->control_device);
-        uc_mgr_ptr->card_ctxt_ptr->mixer_handle =
-            mixer_open(uc_mgr_ptr->card_ctxt_ptr->control_device);
-        ALOGV("Mixer handle %p", uc_mgr_ptr->card_ctxt_ptr->mixer_handle);
-        *uc_mgr = uc_mgr_ptr;
-    }
-    ALOGV("snd_use_case_open(): returning instance %p", uc_mgr_ptr);
-    return ret;
-}
-
-
-/**
- * \brief Reload and re-parse use case configuration files for sound card.
- * \param uc_mgr Use case manager
- * \return zero if success, otherwise a negative error code
- */
-int snd_use_case_mgr_reload(snd_use_case_mgr_t *uc_mgr) {
-    ALOGE("Reload is not implemented for now as there is no use case currently");
-    return 0;
-}
-
-/**
- * \brief Close use case manager
- * \param uc_mgr Use case manager
- * \return zero if success, otherwise a negative error code
- */
-int snd_use_case_mgr_close(snd_use_case_mgr_t *uc_mgr)
-{
-    int ret = 0;
-
-    if ((uc_mgr->snd_card_index >= (int)MAX_NUM_CARDS) ||
-        (uc_mgr->snd_card_index < 0) || (uc_mgr->card_ctxt_ptr == NULL)) {
-        ALOGE("snd_use_case_mgr_close(): failed, invalid arguments");
-        return -EINVAL;
-    }
-
-    ALOGV("snd_use_case_close(): instance %p", uc_mgr);
-    ret = snd_use_case_mgr_reset(uc_mgr);
-    if (ret < 0)
-        ALOGE("Failed to reset ucm session");
-    snd_ucm_free_mixer_list(&uc_mgr);
-    pthread_mutexattr_destroy(&uc_mgr->card_ctxt_ptr->card_lock_attr);
-    pthread_mutex_destroy(&uc_mgr->card_ctxt_ptr->card_lock);
-    if (uc_mgr->card_ctxt_ptr->mixer_handle) {
-        mixer_close(uc_mgr->card_ctxt_ptr->mixer_handle);
-        uc_mgr->card_ctxt_ptr->mixer_handle = NULL;
-    }
-    uc_mgr->snd_card_index = -1;
-    uc_mgr->current_tx_device = -1;
-    uc_mgr->current_rx_device = -1;
-    free(uc_mgr->card_ctxt_ptr->control_device);
-    free(uc_mgr->card_ctxt_ptr->card_name);
-    free(uc_mgr->card_ctxt_ptr);
-    uc_mgr->card_ctxt_ptr = NULL;
-    free(uc_mgr);
-    uc_mgr = NULL;
-    ALOGV("snd_use_case_mgr_close(): card instace closed successfully");
-    return ret;
-}
-
-/**
- * \brief Reset use case manager verb, device, modifier to deafult settings.
- * \param uc_mgr Use case manager
- * \return zero if success, otherwise a negative error code
- */
-int snd_use_case_mgr_reset(snd_use_case_mgr_t *uc_mgr)
-{
-    char *ident_value;
-    int index, list_size, ret = 0;
-
-    ALOGV("snd_use_case_reset(): instance %p", uc_mgr);
-    pthread_mutex_lock(&uc_mgr->card_ctxt_ptr->card_lock);
-    if ((uc_mgr->snd_card_index >= (int)MAX_NUM_CARDS) ||
-        (uc_mgr->snd_card_index < 0) || (uc_mgr->card_ctxt_ptr == NULL)) {
-        ALOGE("snd_use_case_mgr_reset(): failed, invalid arguments");
-        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-        return -EINVAL;
-    }
-
-    /* Disable mixer controls of all the enabled modifiers */
-    list_size = snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->mod_list_head);
-    for (index = (list_size-1); index >= 0; index--) {
-        if ((ident_value =
-            snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->mod_list_head,
-                index))) {
-            snd_ucm_del_ident_from_list(&uc_mgr->card_ctxt_ptr->mod_list_head,
-                ident_value);
-            ret = set_controls_of_usecase_for_all_devices(uc_mgr,
-                      ident_value, 0, CTRL_LIST_MODIFIER);
-        if (ret != 0)
-                ALOGE("Failed to disable mixer controls for %s", ident_value);
-            free(ident_value);
-        }
-    }
-    /* Clear the enabled modifiers list */
-    if (uc_mgr->modifier_list_count) {
-        for (index = 0; index < uc_mgr->modifier_list_count; index++) {
-            free(uc_mgr->current_modifier_list[index]);
-            uc_mgr->current_modifier_list[index] = NULL;
-        }
-        free(uc_mgr->current_modifier_list);
-        uc_mgr->current_modifier_list = NULL;
-        uc_mgr->modifier_list_count = 0;
-    }
-    /* Disable mixer controls of current use case verb */
-    if(strncmp(uc_mgr->card_ctxt_ptr->current_verb, SND_USE_CASE_VERB_INACTIVE,
-       strlen(SND_USE_CASE_VERB_INACTIVE))) {
-        ret = set_controls_of_usecase_for_all_devices(uc_mgr,
-                  uc_mgr->card_ctxt_ptr->current_verb, 0, CTRL_LIST_VERB);
-        if (ret != 0)
-            ALOGE("Failed to disable mixer controls for %s",
-                uc_mgr->card_ctxt_ptr->current_verb);
-        strlcpy(uc_mgr->card_ctxt_ptr->current_verb, SND_USE_CASE_VERB_INACTIVE,
-            MAX_STR_LEN);
-    }
-    /* Disable mixer controls of all the enabled devices */
-    list_size = snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
-    for (index = (list_size-1); index >= 0; index--) {
-        if ((ident_value =
-            snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
-                index))) {
-            snd_ucm_del_ident_from_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
-                ident_value);
-            ret = set_controls_of_device_for_all_usecases(uc_mgr,
-                      ident_value, 0);
-        if (ret != 0)
-                ALOGE("Failed to disable or no mixer controls set for %s",
-                    ident_value);
-        free(ident_value);
-        }
-    }
-    /* Clear the enabled devices list */
-    if (uc_mgr->device_list_count) {
-        for (index = 0; index < uc_mgr->device_list_count; index++) {
-            free(uc_mgr->current_device_list[index]);
-            uc_mgr->current_device_list[index] = NULL;
-        }
-        free(uc_mgr->current_device_list);
-        uc_mgr->current_device_list = NULL;
-        uc_mgr->device_list_count = 0;
-    }
-    uc_mgr->current_tx_device = -1;
-    uc_mgr->current_rx_device = -1;
-    pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-    return ret;
-}
-
-/* 2nd stage parsing done in seperate thread */
-void *second_stage_parsing_thread(void *uc_mgr_ptr)
-{
-    use_case_verb_t *verb_list;
-    char path[200];
-    struct stat st;
-    int fd, index = 0, ret = 0, rc = 0;
-    char *read_buf = NULL, *next_str = NULL, *current_str = NULL, *buf = NULL;
-    char *p = NULL, *verb_name = NULL, *file_name = NULL, *temp_ptr = NULL;
-    snd_use_case_mgr_t **uc_mgr = (snd_use_case_mgr_t **)&uc_mgr_ptr;
-
-    strlcpy(path, CONFIG_DIR, (strlen(CONFIG_DIR)+1));
-    strlcat(path, (*uc_mgr)->card_ctxt_ptr->card_name, sizeof(path));
-    ALOGV("master config file path:%s", path);
-    fd = open(path, O_RDONLY);
-    if (fd < 0) {
-        ALOGE("failed to open config file %s error %d\n", path, errno);
-        return NULL;
-    }
-    if (fstat(fd, &st) < 0) {
-        ALOGE("failed to stat %s error %d\n", path, errno);
-        close(fd);
-        return NULL;
-    }
-    read_buf = (char *) mmap(0, st.st_size, PROT_READ | PROT_WRITE,
-               MAP_PRIVATE, fd, 0);
-    if (read_buf == MAP_FAILED) {
-        ALOGE("failed to mmap file error %d\n", errno);
-        close(fd);
-        return NULL;
-    }
-    current_str = read_buf;
-    verb_name = NULL;
-    while (*current_str != (char)EOF)  {
-        next_str = strchr(current_str, '\n');
-        if (!next_str)
-            break;
-        *next_str++ = '\0';
-        if (verb_name == NULL) {
-            buf = strstr(current_str, "SectionUseCase");
-            if (buf == NULL) {
-                if((current_str = next_str) == NULL)
-                    break;
-                else
-                    continue;
-            }
-            /* Ignore parsing first use case (HiFi) as it is already parsed
-             * in 1st stage of parsing */
-            if (index == 0) {
-                index++;
-                if((current_str = next_str) == NULL)
-                    break;
-                else
-                    continue;
-            }
-            p = strtok_r(buf, ".", &temp_ptr);
-            while (p != NULL) {
-                p = strtok_r(NULL, "\"", &temp_ptr);
-                if (p == NULL)
-                    break;
-                verb_name = (char *)malloc((strlen(p)+1)*sizeof(char));
-                if(verb_name == NULL) {
-                    ret = -ENOMEM;
-                    break;
-                }
-                strlcpy(verb_name, p, (strlen(p)+1)*sizeof(char));
-                break;
-            }
-        } else {
-            buf = strstr(current_str, "File");
-            if (buf == NULL) {
-                if((current_str = next_str) == NULL)
-                    break;
-                else
-                    continue;
-            }
-            p = strtok_r(buf, "\"", &temp_ptr);
-            while (p != NULL) {
-                p = strtok_r(NULL, "\"", &temp_ptr);
-                if (p == NULL)
-                    break;
-                file_name = (char *)malloc((strlen(p)+1)*sizeof(char));
-                if(file_name == NULL) {
-                    ret = -ENOMEM;
-                    break;
-                }
-                strlcpy(file_name, p, (strlen(p)+1)*sizeof(char));
-                break;
-            }
-            verb_list = (*uc_mgr)->card_ctxt_ptr->use_case_verb_list;
-            if (file_name != NULL) {
-                ret = snd_ucm_parse_verb(uc_mgr, file_name, index);
-                verb_list[index].use_case_name =
-                    (char *)malloc((strlen(verb_name)+1)*sizeof(char));
-                strlcpy(verb_list[index].use_case_name, verb_name,
-                    ((strlen(verb_name)+1)*sizeof(char)));
-                /* Verb list might have been appended with END OF LIST in
-                 * 1st stage parsing. Delete this entry so that new verbs
-                 * are appended from here and END OF LIST will be added
-                 * again at the end of 2nd stage parsing
-                 */
-                if((*uc_mgr)->card_ctxt_ptr->verb_list[index]) {
-                    free((*uc_mgr)->card_ctxt_ptr->verb_list[index]);
-                    (*uc_mgr)->card_ctxt_ptr->verb_list[index] = NULL;
-                }
-                (*uc_mgr)->card_ctxt_ptr->verb_list[index] =
-                    (char *)malloc((strlen(verb_name)+1)*sizeof(char));
-                strlcpy((*uc_mgr)->card_ctxt_ptr->verb_list[index], verb_name,
-                    ((strlen(verb_name)+1)*sizeof(char)));
-                free(verb_name);
-                verb_name = NULL;
-                free(file_name);
-                file_name = NULL;
-            }
-            index++;
-            (*uc_mgr)->card_ctxt_ptr->verb_list[index] =
-                (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-            strlcpy((*uc_mgr)->card_ctxt_ptr->verb_list[index],
-                 SND_UCM_END_OF_LIST,
-                 ((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)));
-        }
-        if((current_str = next_str) == NULL)
-            break;
-    }
-    if (verb_name != NULL) {
-        free(verb_name);
-        verb_name = NULL;
-    }
-    if (file_name != NULL) {
-        free(file_name);
-        file_name = NULL;
-    }
-    munmap(read_buf, st.st_size);
-    close(fd);
-#if PARSE_DEBUG
-        /* Prints use cases and mixer controls parsed from config files */
-        snd_ucm_print((*uc_mgr));
-#endif
-    if(ret < 0)
-        ALOGE("Failed to parse config files: %d", ret);
-    ALOGE("Exiting parsing thread uc_mgr %p\n", uc_mgr);
-    return NULL;
-}
-
-/* Function can be used by UCM clients to wait until parsing completes
- * uc_mgr - use case manager structure
- * Returns 0 on success, error number otherwise
-*/
-int snd_use_case_mgr_wait_for_parsing(snd_use_case_mgr_t *uc_mgr)
-{
-    int ret;
-
-    ret = pthread_join(uc_mgr->thr, NULL);
-    return ret;
-}
-
-/* Parse config files and update mixer controls for the use cases
- * 1st stage parsing done to parse HiFi config file
- * uc_mgr - use case manager structure
- * Returns 0 on sucess, negative error code otherwise
- */
-static int snd_ucm_parse(snd_use_case_mgr_t **uc_mgr)
-{
-    use_case_verb_t *verb_list;
-    struct stat st;
-    int fd, verb_count, index = 0, ret = 0, rc;
-    char *read_buf, *next_str, *current_str, *buf, *p, *verb_name;
-    char *file_name = NULL, *temp_ptr;
-    char path[200];
-
-    strlcpy(path, CONFIG_DIR, (strlen(CONFIG_DIR)+1));
-    strlcat(path, (*uc_mgr)->card_ctxt_ptr->card_name, sizeof(path));
-    ALOGV("master config file path:%s", path);
-    fd = open(path, O_RDONLY);
-    if (fd < 0) {
-        ALOGE("failed to open config file %s error %d\n", path, errno);
-        return -EINVAL;
-    }
-    if (fstat(fd, &st) < 0) {
-        ALOGE("failed to stat %s error %d\n", path, errno);
-        close(fd);
-        return -EINVAL;
-    }
-    read_buf = (char *) mmap(0, st.st_size, PROT_READ | PROT_WRITE,
-               MAP_PRIVATE, fd, 0);
-    if (read_buf == MAP_FAILED) {
-        ALOGE("failed to mmap file error %d\n", errno);
-        close(fd);
-        return -EINVAL;
-    }
-    current_str = read_buf;
-    verb_count = get_verb_count(current_str);
-    (*uc_mgr)->card_ctxt_ptr->use_case_verb_list =
-        (use_case_verb_t *)malloc((verb_count+1)*(sizeof(use_case_verb_t)));
-    if ((*uc_mgr)->card_ctxt_ptr->use_case_verb_list == NULL) {
-        ALOGE("failed to allocate memory for use case verb list\n");
-        munmap(read_buf, st.st_size);
-        close(fd);
-        return -ENOMEM;
-    }
-    if (((*uc_mgr)->card_ctxt_ptr->verb_list =
-        (char **)malloc((verb_count+2)*(sizeof(char *)))) == NULL) {
-        ALOGE("failed to allocate memory for verb list\n");
-        munmap(read_buf, st.st_size);
-        close(fd);
-        return -ENOMEM;
-    }
-    verb_name = NULL;
-    if ((ret = is_single_config_format(current_str))) {
-        ALOGD("Single config file format detected\n");
-        ret = parse_single_config_format(uc_mgr, current_str, verb_count);
-        munmap(read_buf, st.st_size);
-        close(fd);
-        return ret;
-    }
-    while (*current_str != (char)EOF)  {
-        next_str = strchr(current_str, '\n');
-        if (!next_str)
-            break;
-        *next_str++ = '\0';
-        if (verb_name == NULL) {
-            buf = strstr(current_str, "SectionUseCase");
-            if (buf == NULL) {
-                if((current_str = next_str) == NULL)
-                    break;
-                else
-                    continue;
-            }
-            verb_list = (*uc_mgr)->card_ctxt_ptr->use_case_verb_list;
-            p = strtok_r(buf, ".", &temp_ptr);
-            while (p != NULL) {
-                p = strtok_r(NULL, "\"", &temp_ptr);
-                if (p == NULL)
-                    break;
-                verb_name = (char *)malloc((strlen(p)+1)*sizeof(char));
-                if(verb_name == NULL) {
-                    ret = -ENOMEM;
-                    break;
-                }
-                strlcpy(verb_name, p, (strlen(p)+1)*sizeof(char));
-                if ((verb_list[index].use_case_name =
-                    (char *)malloc((strlen(verb_name)+1)*sizeof(char)))) {
-                    strlcpy(verb_list[index].use_case_name,
-                        verb_name, ((strlen(verb_name)+1)*sizeof(char)));
-                } else {
-                    ret = -ENOMEM;
-                    break;
-                }
-                if (((*uc_mgr)->card_ctxt_ptr->verb_list[index] =
-                    (char *)malloc((strlen(verb_name)+1)*sizeof(char)))) {
-                    strlcpy((*uc_mgr)->card_ctxt_ptr->verb_list[index],
-                        verb_name, ((strlen(verb_name)+1)*sizeof(char)));
-                } else {
-                    ret = -ENOMEM;
-                    break;
-                }
-                break;
-            }
-        } else {
-            buf = strstr(current_str, "File");
-            if (buf == NULL) {
-                if((current_str = next_str) == NULL)
-                    break;
-                else
-                    continue;
-            }
-            p = strtok_r(buf, "\"", &temp_ptr);
-            while (p != NULL) {
-                p = strtok_r(NULL, "\"", &temp_ptr);
-                if (p == NULL)
-                    break;
-                file_name = (char *)malloc((strlen(p)+1)*sizeof(char));
-                if(file_name == NULL) {
-                    ret = -ENOMEM;
-                    break;
-                }
-                strlcpy(file_name, p, (strlen(p)+1)*sizeof(char));
-                break;
-            }
-            if (file_name != NULL) {
-                ret = snd_ucm_parse_verb(uc_mgr, file_name, index);
-                if (ret < 0)
-                    ALOGE("Failed to parse config file %s\n", file_name);
-                free(verb_name);
-                verb_name = NULL;
-                free(file_name);
-                file_name = NULL;
-            }
-            index++;
-            /* Break here so that only one first use case config file (HiFi)
-             * from master config file is parsed initially and all other
-             * config files are parsed in seperate thread created below so
-             * that audio HAL can initialize faster during boot-up
-             */
-            break;
-        }
-        if((current_str = next_str) == NULL)
-            break;
-    }
-    munmap(read_buf, st.st_size);
-    close(fd);
-    if (((*uc_mgr)->card_ctxt_ptr->verb_list[index] =
-        (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)))) {
-        strlcpy((*uc_mgr)->card_ctxt_ptr->verb_list[index], SND_UCM_END_OF_LIST,
-                ((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)));
-    } else {
-        ALOGE("Failed to allocate memory\n");
-        ret = -ENOMEM;
-    }
-    if (!ret) {
-        ALOGD("Creating Parsing thread uc_mgr %p\n", uc_mgr);
-        rc = pthread_create(&(*uc_mgr)->thr, 0, second_stage_parsing_thread,
-                 (void*)(*uc_mgr));
-        if(rc < 0) {
-            ALOGE("Failed to create parsing thread rc %d errno %d\n", rc, errno);
-        } else {
-            ALOGV("Prasing thread created successfully\n");
-        }
-    }
-    if (verb_name)
-        free(verb_name);
-    if (file_name)
-        free(file_name);
-    return ret;
-}
-
-/* Parse a single config file format
- * uc_mgr - use case manager structure
- * buf - config file buffer to be parsed
- * Returns 0 on sucess, negative error code otherwise
- */
-static int parse_single_config_format(snd_use_case_mgr_t **uc_mgr,
-char *current_str, int num_verbs)
-{
-    struct stat st;
-    card_mctrl_t *list;
-    use_case_verb_t *verb_list;
-    int verb_count = 0, device_count = 0, mod_count = 0, index = -1, ret = 0;
-    char *next_str, *buf, *p, *verb_ptr, *temp_ptr;
-
-    verb_list = (*uc_mgr)->card_ctxt_ptr->use_case_verb_list;
-    while (*current_str != (char)EOF)  {
-        next_str = strchr(current_str, '\n');
-        if (!next_str)
-            break;
-        *next_str++ = '\0';
-        if ((buf = strcasestr(current_str, "SectionUseCase")) != NULL) {
-            if (index != -1) {
-                list = (verb_list[index].verb_ctrls +
-                            verb_list[index].verb_count);
-                list->case_name = (char *)
-                    malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-                if(list->case_name == NULL) {
-                    free(verb_list[index].verb_ctrls);
-                    return -ENOMEM;
-                }
-                strlcpy(list->case_name, SND_UCM_END_OF_LIST,
-                   (strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-                list->ena_mixer_list = NULL;
-                list->dis_mixer_list = NULL;
-                list->ena_mixer_count = 0;
-                list->dis_mixer_count = 0;
-                list->playback_dev_name = NULL;
-                list->capture_dev_name = NULL;
-                list->acdb_id = 0;
-                list->capability = 0;
-            }
-            index++;
-            p = strtok_r(buf, ".", &temp_ptr);
-            while (p != NULL) {
-                p = strtok_r(NULL, "\"", &temp_ptr);
-                if (p == NULL)
-                    break;
-                if ((verb_list[index].use_case_name =
-                    (char *)malloc((strlen(p)+1)*sizeof(char)))) {
-                    strlcpy(verb_list[index].use_case_name,
-                        p, ((strlen(p)+1)*sizeof(char)));
-                } else {
-                    ret = -ENOMEM;
-                    break;
-                }
-                if (((*uc_mgr)->card_ctxt_ptr->verb_list[index] =
-                    (char *)malloc((strlen(p)+1)*sizeof(char)))) {
-                    strlcpy((*uc_mgr)->card_ctxt_ptr->verb_list[index],
-                       p, ((strlen(p)+1)*sizeof(char)));
-                } else {
-                    ret = -ENOMEM;
-                    break;
-                }
-                break;
-            }
-            verb_list[index].verb_count = 0;
-            verb_list[index].device_count = 0;
-            verb_list[index].mod_count = 0;
-            verb_list[index].device_list = NULL;
-            verb_list[index].modifier_list = NULL;
-            verb_list[index].verb_ctrls = NULL;
-            verb_list[index].device_ctrls = NULL;
-            verb_list[index].mod_ctrls = NULL;
-            verb_count = get_num_verbs_config_format(next_str);
-            verb_list[index].verb_ctrls = (card_mctrl_t *)
-                malloc((verb_count+1)*sizeof(card_mctrl_t));
-            if (verb_list[index].verb_ctrls == NULL) {
-               ret = -ENOMEM;
-               break;
-            }
-            verb_list[index].verb_count = 0;
-        } else if (!strncasecmp(current_str, "SectionVerb", 11)) {
-            ret = snd_ucm_parse_section(uc_mgr, &current_str,
-                    &next_str, index, CTRL_LIST_VERB);
-            if (ret < 0)
-                break;
-        } else if (!strncasecmp(current_str, "SectionDevice", 13)) {
-            if (device_count == 0) {
-                device_count = get_num_device_config_format(next_str);
-                verb_list[0].device_ctrls = (card_mctrl_t *)
-                    malloc((device_count+1)*sizeof(card_mctrl_t));
-                if (verb_list[0].device_ctrls == NULL) {
-                    ret = -ENOMEM;
-                    break;
-                }
-                verb_list[0].device_list =
-                    (char **)malloc((device_count+1)*sizeof(char *));
-                if (verb_list[0].device_list == NULL)
-                    return -ENOMEM;
-                verb_list[0].device_count = 0;
-            }
-            ret = snd_ucm_parse_section(uc_mgr, &current_str,
-                      &next_str, 0, CTRL_LIST_DEVICE);
-            if (ret < 0) {
-                break;
-            } else {
-                list = (verb_list[0].device_ctrls +
-                           (verb_list[0].device_count - 1));
-                verb_ptr = (char *)
-                    malloc((strlen(list->case_name)+1)*sizeof(char));
-                    if (verb_ptr == NULL) {
-                        ret = -ENOMEM;
-                        break;
-                    }
-                    strlcpy(verb_ptr, list->case_name,
-                        ((strlen(list->case_name)+1)*sizeof(char)));
-                    verb_list[0].device_list[(verb_list[0].device_count-1)]
-                        = verb_ptr;
-            }
-        } else if (!strncasecmp(current_str, "SectionModifier", 15)) {
-            if (mod_count == 0) {
-                mod_count = get_num_mod_config_format(next_str);
-                verb_list[0].mod_ctrls = (card_mctrl_t *)
-                    malloc((mod_count+1)*sizeof(card_mctrl_t));
-                if (verb_list[0].mod_ctrls == NULL) {
-                    ret = -ENOMEM;
-                    break;
-                }
-                verb_list[0].modifier_list =
-                    (char **)malloc((mod_count+1)*sizeof(char *));
-                if (verb_list[0].modifier_list == NULL)
-                    return -ENOMEM;
-                verb_list[0].mod_count = 0;
-            }
-            ret = snd_ucm_parse_section(uc_mgr, &current_str,
-                     &next_str, 0, CTRL_LIST_MODIFIER);
-            if (ret < 0) {
-                break;
-            } else {
-                list = (verb_list[0].mod_ctrls +
-                        (verb_list[0].mod_count - 1));
-                verb_ptr = (char *)
-                    malloc((strlen(list->case_name)+1)*sizeof(char));
-                if (verb_ptr == NULL) {
-                    ret = -ENOMEM;
-                    break;
-                }
-                strlcpy(verb_ptr, list->case_name,
-                   ((strlen(list->case_name)+1)*sizeof(char)));
-                verb_list[0].modifier_list[(verb_list[0].mod_count - 1)]
-                    = verb_ptr;
-            }
-        }
-        if((current_str = next_str) == NULL)
-            break;
-    }
-    list = (verb_list[index].verb_ctrls +
-            verb_list[index].verb_count);
-    list->case_name =
-        (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-    if(list->case_name == NULL) {
-        free(verb_list[index].verb_ctrls);
-        return -ENOMEM;
-    }
-    strlcpy(list->case_name, SND_UCM_END_OF_LIST,
-        (strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-    list->ena_mixer_list = NULL;
-    list->dis_mixer_list = NULL;
-    list->ena_mixer_count = 0;
-    list->dis_mixer_count = 0;
-    list->playback_dev_name = NULL;
-    list->capture_dev_name = NULL;
-    list->acdb_id = 0;
-    list->capability = 0;
-    index++;
-    if (index != -1) {
-        if (((*uc_mgr)->card_ctxt_ptr->verb_list[index] =
-            (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)))) {
-            strlcpy((*uc_mgr)->card_ctxt_ptr->verb_list[index],
-                SND_UCM_END_OF_LIST,
-                ((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)));
-        } else {
-            ALOGE("Failed to allocate memory\n");
-            ret = -ENOMEM;
-        }
-    }
-    /* Add end of list to device list */
-    verb_ptr =
-       (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-    if (verb_ptr == NULL)
-        return -ENOMEM;
-    strlcpy(verb_ptr, SND_UCM_END_OF_LIST,
-        ((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)));
-    verb_list[0].device_list[verb_list[0].device_count] = verb_ptr;
-    /* Add end of list to modifier list */
-    verb_ptr =
-    (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-        if (verb_ptr == NULL)
-            return -ENOMEM;
-    strlcpy(verb_ptr, SND_UCM_END_OF_LIST,
-        ((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)));
-    verb_list[0].modifier_list[verb_list[0].mod_count] = verb_ptr;
-    /* Add end of list to device controls list */
-    list = (verb_list[0].device_ctrls +
-               verb_list[0].device_count);
-    list->case_name =
-        (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-    if(list->case_name == NULL) {
-        free(verb_list[0].device_ctrls);
-        return -ENOMEM;
-    }
-    strlcpy(list->case_name, SND_UCM_END_OF_LIST,
-        (strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-    list->ena_mixer_list = NULL;
-    list->dis_mixer_list = NULL;
-    list->ena_mixer_count = 0;
-    list->dis_mixer_count = 0;
-    list->playback_dev_name = NULL;
-    list->capture_dev_name = NULL;
-    list->acdb_id = 0;
-    list->capability = 0;
-    /* Add end of list to modifier controls list */
-    list = (verb_list[0].mod_ctrls +
-        verb_list[0].mod_count);
-    list->case_name =
-        (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-    if(list->case_name == NULL) {
-        free(verb_list[0].mod_ctrls);
-        return -ENOMEM;
-    }
-    strlcpy(list->case_name, SND_UCM_END_OF_LIST,
-        (strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-    list->ena_mixer_list = NULL;
-    list->dis_mixer_list = NULL;
-    list->ena_mixer_count = 0;
-    list->dis_mixer_count = 0;
-    list->playback_dev_name = NULL;
-    list->capture_dev_name = NULL;
-    list->acdb_id = 0;
-    list->capability = 0;
-    for (index = 1; index < num_verbs; index++) {
-        verb_list[index].device_ctrls = verb_list[0].device_ctrls;
-        verb_list[index].device_list = verb_list[0].device_list;
-        verb_list[index].device_count = verb_list[0].device_count;
-        verb_list[index].mod_ctrls = verb_list[0].mod_ctrls;
-        verb_list[index].modifier_list = verb_list[0].modifier_list;
-        verb_list[index].mod_count = verb_list[0].mod_count;
-    }
-    if (ret < 0) {
-        ALOGE("Failed to parse config file ret %d errno %d\n", ret, errno);
-    } else {
-        ALOGV("Prasing done successfully\n");
-#if PARSE_DEBUG
-        /* Prints use cases and mixer controls parsed from config files */
-        snd_ucm_print((*uc_mgr));
-#endif
-    }
-    return ret;
-}
-
-/* Returns number of verb sections for specific use case verb*/
-static int get_num_verbs_config_format(const char *nxt_str)
-{
-    char *current_str, *next_str, *str_addr, *buf;
-    int count = 0;
-
-    next_str = (char *)malloc((strlen(nxt_str)+1)*sizeof(char));
-    if (next_str == NULL) {
-        ALOGE("Failed to allocate memory");
-        return -ENOMEM;
-    }
-    strlcpy(next_str, nxt_str, ((strlen(nxt_str)+1)*sizeof(char)));
-    str_addr = next_str;
-    current_str = next_str;
-    while(1) {
-        next_str = strchr(current_str, '\n');
-        if (!next_str)
-            break;
-        *next_str++ = '\0';
-        buf = strcasestr(current_str, "SectionUseCase");
-        if (buf != NULL)
-            break;
-        buf = strcasestr(current_str, "SectionVerb");
-        if (buf != NULL)
-            count++;
-        if (*next_str == (char)EOF)
-            break;
-        if((current_str = next_str) == NULL)
-            break;
-    }
-    free(str_addr);
-    return count;
-}
-
-/* Returns number of common device sections for all use case verbs*/
-static int get_num_device_config_format(const char *nxt_str)
-{
-    char *current_str, *next_str, *str_addr, *buf;
-    int count = 1;
-
-    next_str = (char *)malloc((strlen(nxt_str)+1)*sizeof(char));
-    if (next_str == NULL) {
-        ALOGE("Failed to allocate memory");
-        return -ENOMEM;
-    }
-    strlcpy(next_str, nxt_str, ((strlen(nxt_str)+1)*sizeof(char)));
-    str_addr = next_str;
-    current_str = next_str;
-    while(1) {
-        next_str = strchr(current_str, '\n');
-        if (!next_str)
-            break;
-        *next_str++ = '\0';
-        buf = strcasestr(current_str, "SectionDevice");
-        if (buf != NULL)
-            count++;
-        if (*next_str == (char)EOF)
-            break;
-        if((current_str = next_str) == NULL)
-            break;
-    }
-    free(str_addr);
-    return count;
-}
-
-/* Returns number of common modifier sections for all use case verbs*/
-static int get_num_mod_config_format(const char *nxt_str)
-{
-    char *current_str, *next_str, *str_addr, *buf;
-    int count = 1;
-
-    next_str = (char *)malloc((strlen(nxt_str)+1)*sizeof(char));
-    if (next_str == NULL) {
-        ALOGE("Failed to allocate memory");
-        return -ENOMEM;
-    }
-    strlcpy(next_str, nxt_str, ((strlen(nxt_str)+1)*sizeof(char)));
-    str_addr = next_str;
-    current_str = next_str;
-    while(1) {
-        next_str = strchr(current_str, '\n');
-        if (!next_str)
-            break;
-        *next_str++ = '\0';
-        buf = strcasestr(current_str, "SectionModifier");
-        if (buf != NULL)
-            count++;
-        if (*next_str == (char)EOF)
-            break;
-        if((current_str = next_str) == NULL)
-            break;
-    }
-    free(str_addr);
-    return count;
-}
-
-/* Gets the number of use case verbs defined by master config file */
-static int get_verb_count(const char *nxt_str)
-{
-    char *current_str, *next_str, *str_addr, *buf, *p;
-    int count = 0;
-
-    next_str = (char *)malloc((strlen(nxt_str)+1)*sizeof(char));
-    if (next_str == NULL) {
-        ALOGE("Failed to allocate memory");
-        return -ENOMEM;
-    }
-    strlcpy(next_str, nxt_str, ((strlen(nxt_str)+1)*sizeof(char)));
-    str_addr = next_str;
-    current_str = next_str;
-    while(1) {
-        next_str = strchr(current_str, '\n');
-        if (!next_str)
-            break;
-        *next_str++ = '\0';
-        buf = strstr(current_str, "SectionUseCase");
-        if (buf != NULL)
-            count++;
-        if (*next_str == (char)EOF)
-            break;
-        if((current_str = next_str) == NULL)
-            break;
-    }
-    free(str_addr);
-    return count;
-}
-
-/* Returns one if single config file per sound card format is being used */
-static int is_single_config_format(const char *nxt_str)
-{
-    char *current_str, *next_str, *str_addr, *buf;
-    int ret = 1, count = 0;
-
-    next_str = (char *)malloc((strlen(nxt_str)+1)*sizeof(char));
-    if (next_str == NULL) {
-        ALOGE("Failed to allocate memory");
-        return -ENOMEM;
-    }
-    strlcpy(next_str, nxt_str, ((strlen(nxt_str)+1)*sizeof(char)));
-    str_addr = next_str;
-    current_str = next_str;
-    while(1) {
-        next_str = strchr(current_str, '\n');
-        if (!next_str)
-            break;
-        *next_str++ = '\0';
-        buf = strstr(current_str, "SectionUseCase");
-        if (buf != NULL)
-            count++;
-        buf = strstr(current_str, "File");
-        if (buf != NULL)
-            ret = 0;
-        if ((*next_str == (char)EOF) || (count == 2))
-            break;
-        if((current_str = next_str) == NULL)
-            break;
-    }
-    free(str_addr);
-    return ret;
-}
-
-/* Parse a use case verb config files and update mixer controls for the verb
- * uc_mgr - use case manager structure
- * file_name - use case verb config file name
- * index - index of the verb in the list
- * Returns 0 on sucess, negative error code otherwise
- */
-static int snd_ucm_parse_verb(snd_use_case_mgr_t **uc_mgr,
-const char *file_name, int index)
-{
-    struct stat st;
-    card_mctrl_t *list;
-    int device_count, modifier_count;
-    int fd, ret = 0, parse_count = 0;
-    char *read_buf, *next_str, *current_str, *verb_ptr;
-    char path[200];
-    use_case_verb_t *verb_list;
-
-    strlcpy(path, CONFIG_DIR, (strlen(CONFIG_DIR)+1));
-    strlcat(path, file_name, sizeof(path));
-    ALOGV("path:%s", path);
-    verb_list = (*uc_mgr)->card_ctxt_ptr->use_case_verb_list;
-    while(1) {
-        device_count = 0; modifier_count = 0;
-        if (parse_count == 0) {
-            verb_list[index].verb_count = 0;
-            verb_list[index].device_count = 0;
-            verb_list[index].mod_count = 0;
-            verb_list[index].device_list = NULL;
-            verb_list[index].modifier_list = NULL;
-            verb_list[index].verb_ctrls = NULL;
-            verb_list[index].device_ctrls = NULL;
-            verb_list[index].mod_ctrls = NULL;
-        }
-        fd = open(path, O_RDONLY);
-        if (fd < 0) {
-             ALOGE("failed to open config file %s error %d\n", path, errno);
-             return -EINVAL;
-        }
-        if (fstat(fd, &st) < 0) {
-            ALOGE("failed to stat %s error %d\n", path, errno);
-            close(fd);
-            return -EINVAL;
-        }
-        read_buf = (char *) mmap(0, st.st_size, PROT_READ | PROT_WRITE,
-                   MAP_PRIVATE, fd, 0);
-        if (read_buf == MAP_FAILED) {
-            ALOGE("failed to mmap file error %d\n", errno);
-            close(fd);
-            return -EINVAL;
-        }
-        current_str = read_buf;
-        while (*current_str != (char)EOF)  {
-            next_str = strchr(current_str, '\n');
-            if (!next_str)
-                break;
-            *next_str++ = '\0';
-            if (!strncasecmp(current_str, "SectionVerb", 11)) {
-                if (parse_count == 0) {
-                    verb_list[index].verb_count++;
-                } else {
-                    ret = snd_ucm_parse_section(uc_mgr, &current_str,
-                              &next_str, index, CTRL_LIST_VERB);
-                    if (ret < 0)
-                        break;
-                }
-            } else if (!strncasecmp(current_str, "SectionDevice", 13)) {
-                if (parse_count == 0) {
-                    verb_list[index].device_count++;
-                    device_count++;
-                } else {
-                    ret = snd_ucm_parse_section(uc_mgr, &current_str,
-                              &next_str, index, CTRL_LIST_DEVICE);
-                    if (ret < 0) {
-                        break;
-                    } else {
-                        list = (verb_list[index].device_ctrls +
-                                   (verb_list[index].device_count - 1));
-                        verb_ptr = (char *)
-                            malloc((strlen(list->case_name)+1)*sizeof(char));
-                        if (verb_ptr == NULL) {
-                            ret = -ENOMEM;
-                            break;
-                        }
-                        strlcpy(verb_ptr, list->case_name,
-                            ((strlen(list->case_name)+1)*sizeof(char)));
-                        verb_list[index].device_list[device_count] = verb_ptr;
-                        device_count++;
-                    }
-                }
-            } else if (!strncasecmp(current_str, "SectionModifier", 15)) {
-                if (parse_count == 0) {
-                    verb_list[index].mod_count++;
-                    modifier_count++;
-                } else {
-                    ret = snd_ucm_parse_section(uc_mgr, &current_str,
-                              &next_str, index, CTRL_LIST_MODIFIER);
-                    if (ret < 0) {
-                        break;
-                    } else {
-                        list = (verb_list[index].mod_ctrls +
-                               (verb_list[index].mod_count - 1));
-                        verb_ptr = (char *)
-                            malloc((strlen(list->case_name)+1)*sizeof(char));
-                        if (verb_ptr == NULL) {
-                            ret = -ENOMEM;
-                            break;
-                        }
-                        strlcpy(verb_ptr, list->case_name,
-                            ((strlen(list->case_name)+1)*sizeof(char)));
-                        verb_list[index].modifier_list[modifier_count]
-                            = verb_ptr;
-                        modifier_count++;
-                    }
-                }
-            }
-            if((current_str = next_str) == NULL)
-                break;
-        }
-        munmap(read_buf, st.st_size);
-        close(fd);
-        if(ret < 0)
-            return ret;
-        if (parse_count == 0) {
-            verb_list[index].device_list =
-                (char **)malloc((device_count+1)*sizeof(char *));
-            if (verb_list[index].device_list == NULL)
-                return -ENOMEM;
-            verb_list[index].modifier_list =
-                (char **)malloc((modifier_count+1)*sizeof(char *));
-            if (verb_list[index].modifier_list == NULL)
-                return -ENOMEM;
-            parse_count += verb_list[index].verb_count;
-            verb_list[index].verb_ctrls = (card_mctrl_t *)
-                malloc((verb_list[index].verb_count+1)*sizeof(card_mctrl_t));
-            if (verb_list[index].verb_ctrls == NULL) {
-               ret = -ENOMEM;
-               break;
-            }
-            verb_list[index].verb_count = 0;
-            parse_count += verb_list[index].device_count;
-            verb_list[index].device_ctrls = (card_mctrl_t *)
-                malloc((verb_list[index].device_count+1)*sizeof(card_mctrl_t));
-            if (verb_list[index].device_ctrls == NULL) {
-               ret = -ENOMEM;
-               break;
-            }
-            verb_list[index].device_count = 0;
-            parse_count += verb_list[index].mod_count;
-            verb_list[index].mod_ctrls = (card_mctrl_t *)
-                malloc((verb_list[index].mod_count+1)*sizeof(card_mctrl_t));
-            if (verb_list[index].mod_ctrls == NULL) {
-               ret = -ENOMEM;
-               break;
-            }
-            verb_list[index].mod_count = 0;
-            continue;
-        } else {
-            verb_ptr =
-            (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-            if (verb_ptr == NULL)
-                return -ENOMEM;
-            strlcpy(verb_ptr, SND_UCM_END_OF_LIST,
-                ((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)));
-            verb_list[index].device_list[device_count] = verb_ptr;
-            verb_ptr =
-            (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-            if (verb_ptr == NULL)
-                return -ENOMEM;
-            strlcpy(verb_ptr, SND_UCM_END_OF_LIST,
-                ((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)));
-            verb_list[index].modifier_list[modifier_count] = verb_ptr;
-            list = (verb_list[index].verb_ctrls +
-                       verb_list[index].verb_count);
-            list->case_name =
-                 (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-            if(list->case_name == NULL) {
-                free(verb_list[index].verb_ctrls);
-                return -ENOMEM;
-            }
-            strlcpy(list->case_name, SND_UCM_END_OF_LIST,
-               (strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-            list->ena_mixer_list = NULL;
-            list->dis_mixer_list = NULL;
-            list->ena_mixer_count = 0;
-            list->dis_mixer_count = 0;
-            list->playback_dev_name = NULL;
-            list->capture_dev_name = NULL;
-            list->acdb_id = 0;
-            list->capability = 0;
-            list = (verb_list[index].device_ctrls +
-                       verb_list[index].device_count);
-            list->case_name =
-                 (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-            if(list->case_name == NULL) {
-                free(verb_list[index].device_ctrls);
-                return -ENOMEM;
-            }
-            strlcpy(list->case_name, SND_UCM_END_OF_LIST,
-               (strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-            list->ena_mixer_list = NULL;
-            list->dis_mixer_list = NULL;
-            list->ena_mixer_count = 0;
-            list->dis_mixer_count = 0;
-            list->playback_dev_name = NULL;
-            list->capture_dev_name = NULL;
-            list->acdb_id = 0;
-            list->capability = 0;
-            list = (verb_list[index].mod_ctrls +
-                       verb_list[index].mod_count);
-            list->case_name =
-                 (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-            if(list->case_name == NULL) {
-                free(verb_list[index].mod_ctrls);
-                return -ENOMEM;
-            }
-            strlcpy(list->case_name, SND_UCM_END_OF_LIST,
-               (strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
-            list->ena_mixer_list = NULL;
-            list->dis_mixer_list = NULL;
-            list->ena_mixer_count = 0;
-            list->dis_mixer_count = 0;
-            list->playback_dev_name = NULL;
-            list->capture_dev_name = NULL;
-            list->acdb_id = 0;
-            list->capability = 0;
-            parse_count = 0;
-            break;
-        }
-    }
-    return ret;
-}
-
-/* Print mixer controls in a specific list
- * list - list to be printed
- * verb_index - verb index
- * count - number of elements in the list
- * Returns 0 on sucess, negative error code otherwise
- */
-static int print_list(card_mctrl_t *list, int verb_index, int count)
-{
-    int i, j;
-
-    for(i=0; i < count; i++) {
-        ALOGD("\tcase name: %s\n", list[i].case_name);
-        ALOGD("\tEnable sequence: %d\n", list[i].ena_mixer_count);
-        for(j=0; j<list[i].ena_mixer_count; j++) {
-            ALOGD("\t\t%s : %d : %d: %s\n",
-                list[i].ena_mixer_list[j].control_name,
-                list[i].ena_mixer_list[j].type,
-                list[i].ena_mixer_list[j].value,
-                list[i].ena_mixer_list[j].string);
-        }
-        ALOGD("\tDisable sequence: %d\n", list[i].dis_mixer_count);
-        for(j=0; j<list[i].dis_mixer_count; j++) {
-            ALOGD("\t\t%s : %d : %d : %s\n",
-                list[i].dis_mixer_list[j].control_name,
-                list[i].dis_mixer_list[j].type,
-                list[i].dis_mixer_list[j].value,
-                list[i].dis_mixer_list[j].string);
-        }
-    }
-    return 0;
-}
-
-/* Print mixer controls extracted from config files
- * uc_mgr - use case manager structure
- * Returns 0 on sucess, negative error code otherwise
- */
-static int snd_ucm_print(snd_use_case_mgr_t *uc_mgr)
-{
-    card_mctrl_t *list;
-    int i, j, verb_index = 0;
-    use_case_verb_t *verb_list;
-
-    pthread_mutex_lock(&uc_mgr->card_ctxt_ptr->card_lock);
-    verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
-    while(strncmp(uc_mgr->card_ctxt_ptr->verb_list[verb_index],
-         SND_UCM_END_OF_LIST, 3)) {
-        ALOGD("\nuse case verb: %s\n",
-            uc_mgr->card_ctxt_ptr->verb_list[verb_index]);
-        if(verb_list[verb_index].device_list) {
-            ALOGD("\tValid device list:");
-            i = 0;
-            while(strncmp(verb_list[verb_index].device_list[i],
-                  SND_UCM_END_OF_LIST, 3)) {
-                ALOGD("\t\t%s", verb_list[verb_index].device_list[i]);
-                i++;
-            }
-        }
-        if(verb_list[verb_index].modifier_list) {
-            ALOGD("\tValid modifier list:");
-            i = 0;
-            while(strncmp(verb_list[verb_index].modifier_list[i],
-                  SND_UCM_END_OF_LIST, 3)) {
-                ALOGD("\t\t%s", verb_list[verb_index].modifier_list[i]);
-                i++;
-            }
-        }
-        ALOGD("Verbs:\n");
-        list = verb_list[verb_index].verb_ctrls;
-        print_list(list, verb_index, verb_list[verb_index].verb_count);
-        ALOGD("Devices:\n");
-        list = verb_list[verb_index].device_ctrls;
-        print_list(list, verb_index, verb_list[verb_index].device_count);
-        ALOGD("Modifier:\n");
-        list = verb_list[verb_index].mod_ctrls;
-        print_list(list, verb_index, verb_list[verb_index].mod_count);
-        verb_index++;
-    }
-    pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
-    return 0;
-}
-
-/* Gets the number of controls for specific sequence of a use cae */
-static int get_controls_count(const char *nxt_str)
-{
-    char *current_str, *next_str, *str_addr;
-    int count = 0;
-
-    next_str = (char *)malloc((strlen(nxt_str)+1)*sizeof(char));
-    if (next_str == NULL) {
-        ALOGE("Failed to allocate memory");
-        return -ENOMEM;
-    }
-    strlcpy(next_str, nxt_str, ((strlen(nxt_str)+1)*sizeof(char)));
-    str_addr = next_str;
-    while(1) {
-        current_str = next_str;
-        next_str = strchr(current_str, '\n');
-        if ((!next_str) || (!strncasecmp(current_str, "EndSection", 10)))
-            break;
-        *next_str++ = '\0';
-        if (strcasestr(current_str, "EndSequence") != NULL) {
-            break;
-        } else {
-            count++;
-        }
-        if (*next_str == (char)EOF)
-            break;
-        if(!strncasecmp(current_str, "EndSection", 10))
-            break;
-    }
-    free(str_addr);
-    return count;
-}
-
-/* Parse a section of config files
- * uc_mgr - use case manager structure
- * Returns 0 on sucess, negative error code otherwise
- */
-static int snd_ucm_parse_section(snd_use_case_mgr_t **uc_mgr, char **cur_str,
-char **nxt_str, int verb_index, int ctrl_list_type)
-{
-    use_case_verb_t *verb_list;
-    card_mctrl_t *list;
-    int enable_seq = 0, disable_seq = 0, controls_count = 0, ret = 0;
-    char *p, *current_str, *next_str, *name;
-
-    verb_list = (*uc_mgr)->card_ctxt_ptr->use_case_verb_list;
-    if (ctrl_list_type == CTRL_LIST_VERB) {
-        list = (verb_list[verb_index].verb_ctrls +
-            verb_list[verb_index].verb_count);
-    } else if (ctrl_list_type == CTRL_LIST_DEVICE) {
-        list = (verb_list[verb_index].device_ctrls +
-            verb_list[verb_index].device_count);
-    } else if (ctrl_list_type == CTRL_LIST_MODIFIER) {
-        list = (verb_list[verb_index].mod_ctrls +
-            verb_list[verb_index].mod_count);
-    } else {
-        ALOGE("Invalid list type: %d\n", ctrl_list_type);
-        return -EINVAL;
-    }
-    list->case_name = NULL;
-    list->ena_mixer_list = NULL;
-    list->dis_mixer_list = NULL;
-    list->ena_mixer_count = 0;
-    list->dis_mixer_count = 0;
-    list->playback_dev_name = NULL;
-    list->capture_dev_name = NULL;
-    list->acdb_id = 0;
-    list->capability = 0;
-    list->effects_mixer_ctl = NULL;
-    current_str = *cur_str; next_str = *nxt_str;
-    while(strncasecmp(current_str, "EndSection", 10)) {
-        current_str = next_str;
-        next_str = strchr(current_str, '\n');
-        if ((!next_str) || (!strncasecmp(current_str, "EndSection", 10)))
-            break;
-        *next_str++ = '\0';
-        if (strcasestr(current_str, "EndSequence") != NULL) {
-            if (enable_seq == 1)
-                enable_seq = 0;
-            else if (disable_seq == 1)
-                disable_seq = 0;
-            else
-                ALOGE("Error: improper config file\n");
-        }
-        if (enable_seq == 1) {
-            ret = snd_ucm_extract_controls(current_str, &list->ena_mixer_list,
-                  list->ena_mixer_count);
-            if (ret < 0)
-                break;
-            list->ena_mixer_count++;
-        } else if (disable_seq == 1) {
-            ret = snd_ucm_extract_controls(current_str, &list->dis_mixer_list,
-                  list->dis_mixer_count);
-            if (ret < 0)
-                break;
-            list->dis_mixer_count++;
-        } else if (strcasestr(current_str, "Name") != NULL) {
-            ret = snd_ucm_extract_name(current_str, &list->case_name);
-            if (ret < 0)
-                break;
-            ALOGV("Name of section is %s\n", list->case_name);
-        } else if (strcasestr(current_str, "PlaybackPCM") != NULL) {
-            ret = snd_ucm_extract_dev_name(current_str,
-                      &list->playback_dev_name);
-            if (ret < 0)
-                break;
-            ALOGV("Device name of playback is %s\n",
-                list->playback_dev_name);
-        } else if (strcasestr(current_str, "CapturePCM") != NULL) {
-            ret = snd_ucm_extract_dev_name(current_str,
-                      &list->capture_dev_name);
-            if (ret < 0)
-                break;
-            ALOGV("Device name of capture is %s\n", list->capture_dev_name);
-        } else if (strcasestr(current_str, "ACDBID") != NULL) {
-            ret = snd_ucm_extract_acdb(current_str, &list->acdb_id,
-                      &list->capability);
-            if (ret < 0)
-                break;
-            ALOGV("ACDB ID: %d CAPABILITY: %d\n", list->acdb_id,
-                list->capability);
-        } else if (strcasestr(current_str, "EffectsMixerCTL") != NULL) {
-            ret = snd_ucm_extract_effects_mixer_ctl(current_str,
-                      &list->effects_mixer_ctl);
-            if (ret < 0)
-                break;
-            ALOGV("Effects mixer ctl: %s: %d\n", list->effects_mixer_ctl);
-        }
-        if (strcasestr(current_str, "EnableSequence") != NULL) {
-            controls_count = get_controls_count(next_str);
-            if (controls_count < 0) {
-                ret = -ENOMEM;
-                break;
-            }
-            list->ena_mixer_list =
-            (mixer_control_t *)malloc((controls_count*sizeof(mixer_control_t)));
-            if (list->ena_mixer_list == NULL) {
-                ret = -ENOMEM;
-                break;
-            }
-            enable_seq = 1;
-        } else if (strcasestr(current_str, "DisableSequence") != NULL) {
-            controls_count = get_controls_count(next_str);
-            if (controls_count < 0) {
-                ret = -ENOMEM;
-                break;
-            }
-            list->dis_mixer_list =
-            (mixer_control_t *)malloc((controls_count*sizeof(mixer_control_t)));
-            if (list->dis_mixer_list == NULL) {
-                ret = -ENOMEM;
-                break;
-            }
-            disable_seq = 1;
-        }
-        if (*next_str == (char)EOF)
-             break;
-    }
-    if(ret == 0) {
-        *cur_str = current_str; *nxt_str = next_str;
-        if (ctrl_list_type == CTRL_LIST_VERB) {
-            verb_list[verb_index].verb_count++;
-        } else if (ctrl_list_type == CTRL_LIST_DEVICE) {
-            verb_list[verb_index].device_count++;
-        } else if (ctrl_list_type == CTRL_LIST_MODIFIER) {
-            verb_list[verb_index].mod_count++;
-        }
-    }
-    return ret;
-}
-
-/* Extract a mixer control name from config file
- * Returns 0 on sucess, negative error code otherwise
- */
-static int snd_ucm_extract_name(char *buf, char **case_name)
-{
-    int ret = 0;
-    char *p, *name = *case_name, *temp_ptr;
-
-    p = strtok_r(buf, "\"", &temp_ptr);
-    while (p != NULL) {
-        p = strtok_r(NULL, "\"", &temp_ptr);
-        if (p == NULL)
-            break;
-        name = (char *)malloc((strlen(p)+1)*sizeof(char));
-        if(name == NULL) {
-            ret = -ENOMEM;
-            break;
-        }
-        strlcpy(name, p, (strlen(p)+1)*sizeof(char));
-        *case_name = name;
-        break;
-    }
-    return ret;
-}
-
-/* Extract a ACDB ID and capability of use case from config file
- * Returns 0 on sucess, negative error code otherwise
- */
-static int snd_ucm_extract_acdb(char *buf, int *id, int *cap)
-{
-    char *p, key[] = "0123456789", *temp_ptr;
-
-    p = strpbrk(buf, key);
-    if (p == NULL) {
-        *id = 0;
-        *cap = 0;
-    } else {
-        p = strtok_r(p, ":", &temp_ptr);
-        while (p != NULL) {
-            *id = atoi(p);
-            p = strtok_r(NULL, "\0", &temp_ptr);
-            if (p == NULL)
-                break;
-            *cap = atoi(p);
-            break;
-        }
-    }
-    return 0;
-}
-
-/* Extract Effects Mixer ID of device from config file
- * Returns 0 on sucess, negative error code otherwise
- */
-static int snd_ucm_extract_effects_mixer_ctl(char *buf, char **mixer_name)
-{
-    int ret = 0;
-    char *p, *name = *mixer_name, *temp_ptr;
-
-    p = strtok_r(buf, "\"", &temp_ptr);
-    while (p != NULL) {
-        p = strtok_r(NULL, "\"", &temp_ptr);
-        if (p == NULL)
-            break;
-        name = (char *)malloc((strlen(p)+1)*sizeof(char));
-        if(name == NULL) {
-            ret = -ENOMEM;
-            break;
-        }
-        strlcpy(name, p, (strlen(p)+1)*sizeof(char));
-        *mixer_name = name;
-        break;
-    }
-    return ret;
-}
-
-/* Extract a playback and capture device name of use case from config file
- * Returns 0 on sucess, negative error code otherwise
- */
-static int snd_ucm_extract_dev_name(char *buf, char **dev_name)
-{
-    char key[] = "0123456789";
-    char *p, *name = *dev_name;
-    char dev_pre[] = "hw:0,";
-    char *temp_ptr;
-
-    p = strpbrk(buf, key);
-    if (p == NULL) {
-        *dev_name = NULL;
-    } else {
-        p = strtok_r(p, "\r\n", &temp_ptr);
-        if (p == NULL) {
-            *dev_name = NULL;
-        } else {
-            name = (char *)malloc((strlen(p)+strlen(dev_pre)+1)*sizeof(char));
-            if(name == NULL)
-                 return -ENOMEM;
-            strlcpy(name, dev_pre, (strlen(p)+strlen(dev_pre)+1)*sizeof(char));
-            strlcat(name, p, (strlen(p)+strlen(dev_pre)+1)*sizeof(char));
-            *dev_name = name;
-        }
-    }
-    return 0;
-}
-
-static int get_num_values(const char *buf)
-{
-    char *buf_addr, *p;
-    int count = 0;
-    char *temp_ptr;
-
-    buf_addr = (char *)malloc((strlen(buf)+1)*sizeof(char));
-    if (buf_addr == NULL) {
-        ALOGE("Failed to allocate memory");
-        return -ENOMEM;
-    }
-    strlcpy(buf_addr, buf, ((strlen(buf)+1)*sizeof(char)));
-    p = strtok_r(buf_addr, " ", &temp_ptr);
-    while (p != NULL) {
-        count++;
-        p = strtok_r(NULL, " ", &temp_ptr);
-        if (p == NULL)
-            break;
-    }
-    free(buf_addr);
-    return count;
-}
-
-/* Extract a mixer control from config file
- * Returns 0 on sucess, negative error code otherwise
- */
-static int snd_ucm_extract_controls(char *buf, mixer_control_t **mixer_list,
-int size)
-{
-    unsigned long temp;
-    int ret = -EINVAL, i, index = 0, count = 0;
-    char *p, *ps, *pmv, temp_coeff[20];
-    mixer_control_t *list;
-    static const char *const seps = "\r\n";
-    char *temp_ptr, *temp_vol_ptr;
-
-    p = strtok_r(buf, "'", &temp_ptr);
-    while (p != NULL) {
-        p = strtok_r(NULL, "'", &temp_ptr);
-        if (p == NULL)
-            break;
-        list = ((*mixer_list)+size);
-        list->control_name = (char *)malloc((strlen(p)+1)*sizeof(char));
-        if(list->control_name == NULL) {
-            ret = -ENOMEM;
-            free((*mixer_list));
-            break;
-        }
-        strlcpy(list->control_name, p, (strlen(p)+1)*sizeof(char));
-        p = strtok_r(NULL, ":", &temp_ptr);
-        if (p == NULL)
-            break;
-        if(!strncmp(p, "0", 1)) {
-            list->type = TYPE_STR;
-        } else if(!strncmp(p, "1", 1)) {
-            list->type = TYPE_INT;
-        } else if(!strncmp(p, "2", 1)) {
-            list->type = TYPE_MULTI_VAL;
-        } else {
-            ALOGE("Unknown type: p %s\n", p);
-        }
-        p = strtok_r(NULL, seps, &temp_ptr);
-        if (p == NULL)
-            break;
-        if(list->type == TYPE_INT) {
-            list->value = atoi(p);
-            list->string = NULL;
-            list->mulval = NULL;
-        } else if(list->type == TYPE_STR) {
-            list->value = -1;
-            list->string = (char *)malloc((strlen(p)+1)*sizeof(char));
-            list->mulval = NULL;
-            if(list->string == NULL) {
-                ret = -ENOMEM;
-                free((*mixer_list));
-                free(list->control_name);
-                break;
-            }
-            strlcpy(list->string, p, (strlen(p)+1)*sizeof(char));
-        } else if(list->type == TYPE_MULTI_VAL) {
-            if (p != NULL) {
-                count = get_num_values(p);
-                list->mulval = (char **)malloc(count*sizeof(char *));
-                if (list->mulval == NULL) {
-                    ret = -ENOMEM;
-                    free((*mixer_list));
-                    free(list->control_name);
-                    break;
-                }
-                index = 0;
-                /* To support volume values in percentage */
-                if ((count == 1) && (strstr(p, "%") != NULL)) {
-                    pmv = strtok_r(p, " ", &temp_vol_ptr);
-                    while (pmv != NULL) {
-                        list->mulval[index] =
-                            (char *)malloc((strlen(pmv)+1)*sizeof(char));
-                        strlcpy(list->mulval[index], pmv, (strlen(pmv)+1));
-                        index++;
-                        pmv = strtok_r(NULL, " ", &temp_vol_ptr);
-                        if (pmv == NULL)
-                            break;
-                    }
-                } else {
-                    pmv = strtok_r(p, " ", &temp_vol_ptr);
-                    while (pmv != NULL) {
-                        temp = strtoul(pmv, &ps, 16);
-                        snprintf(temp_coeff, sizeof(temp_coeff),"%lu", temp);
-                        list->mulval[index] =
-                            (char *)malloc((strlen(temp_coeff)+1)*sizeof(char));
-                        strlcpy(list->mulval[index], temp_coeff,
-                            (strlen(temp_coeff)+1));
-                        index++;
-                        pmv = strtok_r(NULL, " ", &temp_vol_ptr);
-                        if (pmv == NULL)
-                            break;
-                    }
-                }
-                list->value = count;
-                list->string = NULL;
-            }
-        } else {
-            ALOGE("Unknown type: p %s\n", p);
-            list->value = -1;
-            list->string = NULL;
-        }
-        ret = 0;
-        break;
-    }
-    return ret;
-}
-
-void free_list(card_mctrl_t *list, int verb_index, int count)
-{
-    int case_index = 0, index = 0, mindex = 0;
-
-    for(case_index = 0; case_index < count; case_index++) {
-        for(index = 0; index < list[case_index].ena_mixer_count; index++) {
-            if(list[case_index].ena_mixer_list[index].control_name) {
-                free(list[case_index].ena_mixer_list[index].control_name);
-            }
-            if(list[case_index].ena_mixer_list[index].string) {
-                free(list[case_index].ena_mixer_list[index].string);
-            }
-            if(list[case_index].ena_mixer_list[index].mulval) {
-                for(mindex = 0;
-                    mindex < list[case_index].ena_mixer_list[index].value;
-                    mindex++) {
-                    free(list[case_index].ena_mixer_list[index].mulval[mindex]);
-                }
-                if(list[case_index].ena_mixer_list[index].mulval) {
-                    free(list[case_index].ena_mixer_list[index].mulval);
-                }
-            }
-        }
-        for(index = 0; index < list[case_index].dis_mixer_count; index++) {
-            if(list[case_index].dis_mixer_list[index].control_name) {
-                free(list[case_index].dis_mixer_list[index].control_name);
-            }
-            if(list[case_index].dis_mixer_list[index].string) {
-                free(list[case_index].dis_mixer_list[index].string);
-            }
-            if(list[case_index].dis_mixer_list[index].mulval) {
-                for(mindex = 0;
-                    mindex < list[case_index].dis_mixer_list[index].value;
-                    mindex++) {
-                    free(list[case_index].dis_mixer_list[index].mulval[mindex]);
-                }
-                if(list[case_index].dis_mixer_list[index].mulval) {
-                    free(list[case_index].dis_mixer_list[index].mulval);
-                }
-            }
-        }
-        if(list[case_index].case_name) {
-            free(list[case_index].case_name);
-        }
-        if(list[case_index].ena_mixer_list) {
-            free(list[case_index].ena_mixer_list);
-        }
-        if(list[case_index].dis_mixer_list) {
-            free(list[case_index].dis_mixer_list);
-        }
-        if(list[case_index].playback_dev_name) {
-            free(list[case_index].playback_dev_name);
-        }
-        if(list[case_index].capture_dev_name) {
-            free(list[case_index].capture_dev_name);
-        }
-        if(list[case_index].effects_mixer_ctl) {
-            list[case_index].effects_mixer_ctl = NULL;
-        }
-    }
-}
-
-void snd_ucm_free_mixer_list(snd_use_case_mgr_t **uc_mgr)
-{
-    card_mctrl_t *ctrl_list;
-    use_case_verb_t *verb_list;
-    int index = 0, verb_index = 0;
-
-    pthread_mutex_lock(&(*uc_mgr)->card_ctxt_ptr->card_lock);
-    verb_list = (*uc_mgr)->card_ctxt_ptr->use_case_verb_list;
-    while(strncmp((*uc_mgr)->card_ctxt_ptr->verb_list[verb_index],
-          SND_UCM_END_OF_LIST, 3)) {
-        ctrl_list = verb_list[verb_index].verb_ctrls;
-        free_list(ctrl_list, verb_index, verb_list[verb_index].verb_count);
-        if(verb_list[verb_index].use_case_name)
-            free(verb_list[verb_index].use_case_name);
-        if((*uc_mgr)->card_ctxt_ptr->verb_list[verb_index]) {
-            free((*uc_mgr)->card_ctxt_ptr->verb_list[verb_index]);
-        }
-        verb_index++;
-    }
-    verb_index -= 1;
-    ctrl_list = verb_list[verb_index].device_ctrls;
-    free_list(ctrl_list, verb_index, verb_list[verb_index].device_count);
-    ctrl_list = verb_list[verb_index].mod_ctrls;
-    free_list(ctrl_list, verb_index, verb_list[verb_index].mod_count);
-    index = 0;
-    while(1) {
-        if (verb_list[verb_index].device_list[index]) {
-            if (!strncmp(verb_list[verb_index].device_list[index],
-                SND_UCM_END_OF_LIST, 3)) {
-                free(verb_list[verb_index].device_list[index]);
-                break;
-            } else {
-                free(verb_list[verb_index].device_list[index]);
-                index++;
-            }
-        }
-    }
-    if (verb_list[verb_index].device_list)
-        free(verb_list[verb_index].device_list);
-    index = 0;
-    while(1) {
-        if (verb_list[verb_index].modifier_list[index]) {
-            if (!strncmp(verb_list[verb_index].modifier_list[index],
-                SND_UCM_END_OF_LIST, 3)) {
-                free(verb_list[verb_index].modifier_list[index]);
-                break;
-            } else {
-                free(verb_list[verb_index].modifier_list[index]);
-                index++;
-            }
-        }
-    }
-    if (verb_list[verb_index].modifier_list)
-        free(verb_list[verb_index].modifier_list);
-    if((*uc_mgr)->card_ctxt_ptr->use_case_verb_list)
-        free((*uc_mgr)->card_ctxt_ptr->use_case_verb_list);
-    if((*uc_mgr)->card_ctxt_ptr->verb_list)
-        free((*uc_mgr)->card_ctxt_ptr->verb_list);
-    pthread_mutex_unlock(&(*uc_mgr)->card_ctxt_ptr->card_lock);
-}
-
-/* Add an identifier to the respective list
- * head - list head
- * value - node value that needs to be added
- * Returns 0 on sucess, negative error code otherwise
- */
-static int snd_ucm_add_ident_to_list(struct snd_ucm_ident_node **head,
-const char *value)
-{
-    struct snd_ucm_ident_node *temp, *node;
-
-    node =
-        (struct snd_ucm_ident_node *)malloc(sizeof(struct snd_ucm_ident_node));
-    if (node == NULL) {
-        ALOGE("Failed to allocate memory for new node");
-        return -ENOMEM;
-    } else {
-        node->next = NULL;
-        strlcpy(node->ident, value, MAX_STR_LEN);
-        node->active = 0;
-        node->capability = 0;
-    }
-    if (*head == NULL) {
-        *head = node;
-    } else {
-        temp = *head;
-        while (temp->next != NULL) {
-            temp = temp->next;
-        }
-        temp->next = node;
-    }
-    ALOGV("add_to_list: head %p, value %s", *head, node->ident);
-    return 0;
-}
-
-/* Get the status of identifier at particulare index of the list
- * head - list head
- * ident - identifier value for which status needs to be get
- * status - status to be set (1 - active, 0 - inactive)
- */
-static int snd_ucm_get_status_at_index(struct snd_ucm_ident_node *head,
-const char *ident)
-{
-    while (head != NULL) {
-        if(!strncmp(ident, head->ident, (strlen(head->ident)+1))) {
-            break;
-        }
-        head = head->next;
-    }
-    if (head == NULL) {
-        ALOGV("Element not found in the list");
-    } else {
-        return(head->active);
-    }
-    return -EINVAL;
-}
-
-/* Get the node at particular index
- * head - list head
- * index - index value
- */
-struct snd_ucm_ident_node *snd_ucm_get_device_node(struct snd_ucm_ident_node *head,
-int index)
-{
-    if (head == NULL) {
-        ALOGV("Empty list");
-        return NULL;
-    }
-
-    if ((index < 0) || (index >= (snd_ucm_get_size_of_list(head)))) {
-        ALOGE("Element with given index %d doesn't exist in the list", index);
-        return NULL;
-    }
-
-    while (index) {
-        head = head->next;
-        index--;
-    }
-
-    return head;
-}
-
-/* Set the status of identifier at particulare index of the list
- * head - list head
- * ident - identifier value for which status needs to be set
- * status - status to be set (1 - active, 0 - inactive)
- */
-static void snd_ucm_set_status_at_index(struct snd_ucm_ident_node *head,
-const char *ident, int status, int capability)
-{
-    while (head != NULL) {
-        if(!strncmp(ident, head->ident, (strlen(head->ident)+1))) {
-            break;
-        }
-        head = head->next;
-    }
-    if (head == NULL) {
-        ALOGE("Element not found to set the status");
-    } else {
-        head->active = status;
-        head->capability = capability;
-    }
-}
-
-/* Get the identifier value at particulare index of the list
- * head - list head
- * index - node index value
- * Returns node idetifier value at index on sucess, NULL otherwise
- */
-static char *snd_ucm_get_value_at_index(struct snd_ucm_ident_node *head,
-int index)
-{
-    if (head == NULL) {
-        ALOGV("Empty list");
-        return NULL;
-    }
-
-    if ((index < 0) || (index >= (snd_ucm_get_size_of_list(head)))) {
-        ALOGE("Element with given index %d doesn't exist in the list", index);
-        return NULL;
-    }
-
-    while (index) {
-        head = head->next;
-        index--;
-    }
-
-    return (strdup(head->ident));
-}
-
-/* Get the size of the list
- * head - list head
- * Returns size of list on sucess, negative error code otherwise
- */
-static int snd_ucm_get_size_of_list(struct snd_ucm_ident_node *head)
-{
-    int index = 0;
-
-    if (head == NULL) {
-        ALOGV("Empty list");
-        return 0;
-    }
-
-    while (head->next != NULL) {
-        index++;
-        head = head->next;
-    }
-
-    return (index+1);
-}
-
-static void snd_ucm_print_list(struct snd_ucm_ident_node *head)
-{
-    int index = 0;
-
-    ALOGV("print_list: head %p", head);
-    if (head == NULL) {
-        ALOGV("Empty list");
-        return;
-    }
-
-    while (head->next != NULL) {
-        ALOGV("index: %d, value: %s", index, head->ident);
-        index++;
-        head = head->next;
-    }
-    ALOGV("index: %d, value: %s", index, head->ident);
-}
-
-/* Delete an identifier from respective list
- * head - list head
- * value - node value that needs to be deleted
- * Returns 0 on sucess, negative error code otherwise
- *
- */
-static int snd_ucm_del_ident_from_list(struct snd_ucm_ident_node **head,
-const char *value)
-{
-    struct snd_ucm_ident_node *temp1, *temp2;
-    int ret = -EINVAL;
-
-    if (*head == NULL) {
-        ALOGE("del_from_list: Empty list");
-        return -EINVAL;
-    } else if (!strncmp((*head)->ident, value, (strlen(value)+1))) {
-            temp2 = *head;
-            *head = temp2->next;
-            ret = 0;
-    } else {
-        temp1 = *head;
-        temp2 = temp1->next;
-        while (temp2 != NULL) {
-            if (!strncmp(temp2->ident, value, (strlen(value)+1))) {
-                temp1->next = temp2->next;
-                ret = 0;
-                break;
-            }
-            temp1 = temp1->next;
-            temp2 = temp1->next;
-        }
-    }
-    if (ret < 0) {
-        ALOGE("Element not found in enabled list");
-    } else {
-        temp2->next = NULL;
-        temp2->ident[0] = 0;
-        temp2->active = 0;
-        temp2->capability = 0;
-        free(temp2);
-        temp2 = NULL;
-    }
-    return ret;
-}
diff --git a/legacy/libalsa-intf/alsa_ucm.h b/legacy/libalsa-intf/alsa_ucm.h
deleted file mode 100644
index a72ca27..0000000
--- a/legacy/libalsa-intf/alsa_ucm.h
+++ /dev/null
@@ -1,381 +0,0 @@
-/**
- * \file include/use-case.h
- * \brief use case interface for the ALSA driver
- * \author Liam Girdwood <lrg@slimlogic.co.uk>
- * \author Stefan Schmidt <stefan@slimlogic.co.uk>
- * \author Jaroslav Kysela <perex@perex.cz>
- * \author Justin Xu <justinx@slimlogic.co.uk>
- * \date 2008-2010
- */
-/*
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as
- *  published by the Free Software Foundation; either version 2.1 of
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public
- *  License along with this library; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- *
- *  Copyright (C) 2008-2010 SlimLogic Ltd
- *  Copyright (C) 2010 Wolfson Microelectronics PLC
- *  Copyright (C) 2010 Texas Instruments Inc.
- *
- *  Support for the verb/device/modifier core logic and API,
- *  command line tool and file parser was kindly sponsored by
- *  Texas Instruments Inc.
- *  Support for multiple active modifiers and devices,
- *  transition sequences, multiple client access and user defined use
- *  cases was kindly sponsored by Wolfson Microelectronics PLC.
- */
-
-#ifndef __ALSA_USE_CASE_H
-#define __ALSA_USE_CASE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- *  \defgroup Use Case Interface
- *  The ALSA Use Case manager interface.
- *  See \ref Usecase page for more details.
- *  \{
- */
-
-/**
- * ALSA Use Case Interface
- *
- * The use case manager works by configuring the sound card ALSA kcontrols to
- * change the hardware digital and analog audio routing to match the requested
- * device use case. The use case manager kcontrol configurations are stored in
- * easy to modify text files.
- *
- * An audio use case can be defined by a verb and device parameter. The verb
- * describes the use case action i.e. a phone call, listening to music, recording
- * a conversation etc. The device describes the physical audio capture and playback
- * hardware i.e. headphones, phone handset, bluetooth headset, etc.
- *
- * It's intended clients will mostly only need to set the use case verb and
- * device for each system use case change (as the verb and device parameters
- * cover most audio use cases).
- *
- * However there are times when a use case has to be modified at runtime. e.g.
- *
- *  o Incoming phone call when the device is playing music
- *  o Recording sections of a phone call
- *  o Playing tones during a call.
- *
- * In order to allow asynchronous runtime use case adaptations, we have a third
- * optional modifier parameter that can be used to further configure
- * the use case during live audio runtime.
- *
- * This interface allows clients to :-
- *
- *  o Query the supported use case verbs, devices and modifiers for the machine.
- *  o Set and Get use case verbs, devices and modifiers for the machine.
- *  o Get the ALSA PCM playback and capture device PCMs for use case verb,
- *     use case device and modifier.
- *  o Get the TQ parameter for each use case verb, use case device and
- *     modifier.
- *  o Get the ALSA master playback and capture volume/switch kcontrols
- *     for each use case.
- */
-
-
-/*
- * Use Case Verb.
- *
- * The use case verb is the main device audio action. e.g. the "HiFi" use
- * case verb will configure the audio hardware for HiFi Music playback
- * and capture.
- */
-#define SND_USE_CASE_VERB_INACTIVE		"Inactive"
-#define SND_USE_CASE_VERB_HIFI			"HiFi"
-#define SND_USE_CASE_VERB_HIFI_LOW_POWER	"HiFi Low Power"
-#define SND_USE_CASE_VERB_VOICE			"Voice"
-#define SND_USE_CASE_VERB_VOICE_LOW_POWER	"Voice Low Power"
-#define SND_USE_CASE_VERB_VOICECALL		"Voice Call"
-#define SND_USE_CASE_VERB_IP_VOICECALL		"Voice Call IP"
-#define SND_USE_CASE_VERB_ANALOG_RADIO		"FM Analog Radio"
-#define SND_USE_CASE_VERB_DIGITAL_RADIO		"FM Digital Radio"
-/* add new verbs to end of list */
-
-
-/*
- * Use Case Device.
- *
- * Physical system devices the render and capture audio. Devices can be OR'ed
- * together to support audio on simultaneous devices.
- */
-#define SND_USE_CASE_DEV_NONE		"None"
-#define SND_USE_CASE_DEV_SPEAKER	"Speaker"
-#define SND_USE_CASE_DEV_LINE		"Line"
-#define SND_USE_CASE_DEV_HEADPHONES	"Headphones"
-#define SND_USE_CASE_DEV_HEADSET	"Headset"
-#define SND_USE_CASE_DEV_HANDSET	"Handset"
-#define SND_USE_CASE_DEV_BLUETOOTH	"Bluetooth"
-#define SND_USE_CASE_DEV_EARPIECE	"Earpiece"
-#define SND_USE_CASE_DEV_SPDIF		"SPDIF"
-#define SND_USE_CASE_DEV_HDMI		"HDMI"
-/* add new devices to end of list */
-
-
-/*
- * Use Case Modifiers.
- *
- * The use case modifier allows runtime configuration changes to deal with
- * asynchronous events.
- *
- * e.g. to record a voice call :-
- *  1. Set verb to SND_USE_CASE_VERB_VOICECALL (for voice call)
- *  2. Set modifier SND_USE_CASE_MOD_CAPTURE_VOICE when capture required.
- *  3. Call snd_use_case_get("CapturePCM") to get ALSA source PCM name
- *     with captured voice pcm data.
- *
- * e.g. to play a ring tone when listenin to MP3 Music :-
- *  1. Set verb to SND_USE_CASE_VERB_HIFI (for MP3 playback)
- *  2. Set modifier to SND_USE_CASE_MOD_PLAY_TONE when incoming call happens.
- *  3. Call snd_use_case_get("PlaybackPCM") to get ALSA PCM sink name for
- *     ringtone pcm data.
- */
-#define SND_USE_CASE_MOD_CAPTURE_VOICE		"Capture Voice"
-#define SND_USE_CASE_MOD_CAPTURE_MUSIC		"Capture Music"
-#define SND_USE_CASE_MOD_PLAY_MUSIC		"Play Music"
-#define SND_USE_CASE_MOD_PLAY_VOICE		"Play Voice"
-#define SND_USE_CASE_MOD_PLAY_TONE		"Play Tone"
-#define SND_USE_CASE_MOD_ECHO_REF		"Echo Reference"
-/* add new modifiers to end of list */
-
-
-/**
- * TQ - Tone Quality
- *
- * The interface allows clients to determine the audio TQ required for each
- * use case verb and modifier. It's intended as an optional hint to the
- * audio driver in order to lower power consumption.
- *
- */
-#define SND_USE_CASE_TQ_MUSIC		"Music"
-#define SND_USE_CASE_TQ_VOICE		"Voice"
-#define SND_USE_CASE_TQ_TONES		"Tones"
-
-/** use case container */
-typedef struct snd_use_case_mgr snd_use_case_mgr_t;
-
-/**
- * \brief Create an identifier
- * \param fmt Format (sprintf like)
- * \param ... Optional arguments for sprintf like format
- * \return Allocated string identifier or NULL on error
- */
-char *snd_use_case_identifier(const char *fmt, ...);
-
-/**
- * \brief Free a string list
- * \param list The string list to free
- * \param items Count of strings
- * \return Zero if success, otherwise a negative error code
- */
-int snd_use_case_free_list(const char *list[], int items);
-
-/**
- * \brief Obtain a list of entries
- * \param uc_mgr Use case manager (may be NULL - card list)
- * \param identifier (may be NULL - card list)
- * \param list Returned allocated list
- * \return Number of list entries if success, otherwise a negative error code
- *
- * Defined identifiers:
- *   NULL 		- get card list
- *			  (in pair cardname+comment)
- *   _verbs		- get verb list
- *			  (in pair verb+comment)
- *   _devices[/<verb>]	- get list of supported devices
- *			  (in pair device+comment)
- *   _modifiers[/<verb>]- get list of supported modifiers
- *			  (in pair modifier+comment)
- *   TQ[/<verb>]	- get list of TQ identifiers
- *   _enadevs		- get list of enabled devices
- *   _enamods		- get list of enabled modifiers
- *
- *   _supporteddevs/<modifier>|<device>[/<verb>]   - list of supported devices
- *   _conflictingdevs/<modifier>|<device>[/<verb>] - list of conflicting devices
- *   Note that at most one of the supported/conflicting devs lists has
- *   any entries, and when neither is present, all devices are supported.
- *
- */
-int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr,
-                          const char *identifier,
-                          const char **list[]);
-
-
-/**
- * \brief Get current - string
- * \param uc_mgr Use case manager
- * \param identifier
- * \param value Value pointer
- * \return Zero if success, otherwise a negative error code
- *
- * Note: String is dynamically allocated, use free() to
- * deallocate this string.
- *
- * Known identifiers:
- *   NULL 		- return current card
- *   _verb		- return current verb
- *
- *   [=]<NAME>[/[<modifier>|</device>][/<verb>]]
- *                      - value identifier <NAME>
- *                      - Search starts at given modifier or device if any,
- *                          else at a verb
- *                      - Search starts at given verb if any,
- *                          else current verb
- *                      - Searches modifier/device, then verb, then defaults
- *                      - Specify a leading "=" to search only the exact
- *                        device/modifier/verb specified, and not search
- *                        through each object in turn.
- *                      - Examples:
- *                          "PlaybackPCM/Play Music"
- *                          "CapturePCM/SPDIF"
- *                        From ValueDefaults only:
- *                          "=Variable"
- *                        From current active verb:
- *                          "=Variable//"
- *                        From verb "Verb":
- *                          "=Variable//Verb"
- *                        From "Modifier" in current active verb:
- *                          "=Variable/Modifier/"
- *                        From "Modifier" in "Verb":
- *                          "=Variable/Modifier/Verb"
- *
- * Recommended names for values:
- *   TQ			- Tone Quality
- *   PlaybackPCM	- full PCM playback device name
- *   CapturePCM		- full PCM capture device name
- *   PlaybackCTL	- playback control device name
- *   PlaybackVolume	- playback control volume ID string
- *   PlaybackSwitch	- playback control switch ID string
- *   CaptureCTL		- capture control device name
- *   CaptureVolume	- capture control volume ID string
- *   CaptureSwitch	- capture control switch ID string
- *   PlaybackMixer	- name of playback mixer
- *   PlaybackMixerID	- mixer playback ID
- *   CaptureMixer	- name of capture mixer
- *   CaptureMixerID	- mixer capture ID
- */
-int snd_use_case_get(snd_use_case_mgr_t *uc_mgr,
-                     const char *identifier,
-                     const char **value);
-
-/**
- * \brief Get current - integer
- * \param uc_mgr Use case manager
- * \param identifier
- * \param value result
- * \return Zero if success, otherwise a negative error code
- *
- * Known identifiers:
- *   _devstatus/<device>	- return status for given device
- *   _modstatus/<modifier>	- return status for given modifier
- */
-int snd_use_case_geti(snd_use_case_mgr_t *uc_mgr,
-		      const char *identifier,
-		      long *value);
-
-/**
- * \brief Set new
- * \param uc_mgr Use case manager
- * \param identifier
- * \param value Value
- * \return Zero if success, otherwise a negative error code
- *
- * Known identifiers:
- *   _verb 		- set current verb = value
- *   _enadev		- enable given device = value
- *   _disdev		- disable given device = value
- *   _swdev/<old_device> - new_device = value
- *			- disable old_device and then enable new_device
- *			- if old_device is not enabled just return
- *			- check transmit sequence firstly
- *   _enamod		- enable given modifier = value
- *   _dismod		- disable given modifier = value
- *   _swmod/<old_modifier> - new_modifier = value
- *			- disable old_modifier and then enable new_modifier
- *			- if old_modifier is not enabled just return
- *			- check transmit sequence firstly
- */
-int snd_use_case_set(snd_use_case_mgr_t *uc_mgr,
-                     const char *identifier,
-                     const char *value);
-
-/**
- * \brief Open and initialise use case core for sound card
- * \param uc_mgr Returned use case manager pointer
- * \param card_name Sound card name.
- * \return zero if success, otherwise a negative error code
- */
-int snd_use_case_mgr_open(snd_use_case_mgr_t **uc_mgr, const char *card_name);
-
-
-/**
- * \brief Reload and re-parse use case configuration files for sound card.
- * \param uc_mgr Use case manager
- * \return zero if success, otherwise a negative error code
- */
-int snd_use_case_mgr_reload(snd_use_case_mgr_t *uc_mgr);
-
-/**
- * \brief Close use case manager
- * \param uc_mgr Use case manager
- * \return zero if success, otherwise a negative error code
- */
-int snd_use_case_mgr_close(snd_use_case_mgr_t *uc_mgr);
-
-/**
- * \brief Reset use case manager verb, device, modifier to deafult settings.
- * \param uc_mgr Use case manager
- * \return zero if success, otherwise a negative error code
- */
-int snd_use_case_mgr_reset(snd_use_case_mgr_t *uc_mgr);
-
-/*
- * helper functions
- */
-
-/**
- * \brief Obtain a list of cards
- * \param list Returned allocated list
- * \return Number of list entries if success, otherwise a negative error code
- */
-static inline int snd_use_case_card_list(const char **list[])
-{
-	return snd_use_case_get_list(NULL, NULL, list);
-}
-
-/**
- * \brief Obtain a list of verbs
- * \param uc_mgr Use case manager
- * \param list Returned list of verbs
- * \return Number of list entries if success, otherwise a negative error code
- */
-static inline int snd_use_case_verb_list(snd_use_case_mgr_t *uc_mgr,
-					 const char **list[])
-{
-	return snd_use_case_get_list(uc_mgr, "_verbs", list);
-}
-
-/**
- *  \}
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __ALSA_USE_CASE_H */
diff --git a/legacy/libalsa-intf/alsaucm_test.c b/legacy/libalsa-intf/alsaucm_test.c
deleted file mode 100644
index aaed38e..0000000
--- a/legacy/libalsa-intf/alsaucm_test.c
+++ /dev/null
@@ -1,324 +0,0 @@
-/*
- * Copyright (c) 2012, 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.
- */
-
-#include <sys/ioctl.h>
-#include <sys/stat.h>
-#include <linux/ioctl.h>
-#include <fcntl.h>
-#include <string.h>
-#include <stdio.h>
-#include <errno.h>
-#include <stdlib.h>
-
-#include "alsa_ucm.h"
-#include "msm8960_use_cases.h"
-
-/* Function prototypes */
-static void print_help_menu(void);
-static void alsaucm_test_cmd_svr(void);
-static int process_cmd(char *cmdStr);
-
-/* Global data */
-snd_use_case_mgr_t *uc_mgr;
-
-/* Defines */
-enum ucm_cmd_id {
-    UCM_OPEN = 0,
-    UCM_SET,
-    UCM_LISTCARDS,
-    UCM_LIST,
-    UCM_GET,
-    UCM_GETI,
-    UCM_RESET,
-    UCM_RELOAD,
-    UCM_HELP,
-    UCM_QUIT,
-    UCM_UNKNOWN
-};
-
-struct cmd {
-    enum ucm_cmd_id code;
-    const char *cmd_str;
-};
-
-static struct cmd cmds[] = {
-    { UCM_OPEN, "open" },
-    { UCM_SET,  "set" },
-    { UCM_LISTCARDS,  "listcards" },
-    { UCM_LIST,  "list" },
-    { UCM_GET,  "get" },
-    { UCM_GETI,  "geti" },
-    { UCM_RESET,  "reset" },
-    { UCM_RELOAD,  "reload" },
-    { UCM_HELP,  "help" },
-    { UCM_QUIT,  "quit" },
-    { UCM_UNKNOWN, NULL }
-};
-
-static void alsaucm_test_cmd_svr(void)
-{
-    int fd;
-    ssize_t read_count;
-    char cmdstr[256] = {'\0'};
-    char ch;
-    char *exit_str = "quit";
-
-    if (mknod("/data/alsaucm_test", S_IFIFO | 0666, 0) == 0) {
-        fd = open("/data/alsaucm_test", O_RDONLY);
-        while (1) {
-            read_count = read(fd, &ch, 1);
-            if (read_count == 0) {
-                sleep(2);
-                continue;
-            } else if (read_count < 0) {
-                fprintf(stderr, "alsaucm_test: error reading cmd\n");
-                break;
-            }
-
-            if (ch != '\n') {
-                strlcat(cmdstr, &ch , (2+strlen(cmdstr)));
-                continue;
-            } else {
-                if (!strncmp(cmdstr, exit_str, strlen(cmdstr))) {
-                    /* free UCM instace */
-                    if (uc_mgr) {
-                        snd_use_case_mgr_close(uc_mgr);
-                        uc_mgr = NULL;
-                    }
-                    break;
-                } else {
-                    process_cmd(cmdstr);
-                    memset(cmdstr, 0, sizeof(cmdstr));
-                }
-            }
-        }
-        printf("alsaucm_test: exit server mode\n");
-        close(fd);
-        remove("/data/alsaucm_test");
-    } else {
-        fprintf(stderr, "alsaucm_test: Failed to create server\n");
-    }
-}
-
-
-static void print_help_menu(void)
-{
-    printf("\nAvailable commands:\n"
-           "  open NAME                  open card NAME\n"
-           "  reset                      reset sound card to default state\n"
-           "  reload                     reload configuration\n"
-           "  listcards                  list available cards\n"
-           "  list IDENTIFIER            list command\n"
-           "  get IDENTIFIER             get string value\n"
-           "  geti IDENTIFIER            get integer value\n"
-           "  set IDENTIFIER VALUE       set string value\n"
-           "  help                     help\n"
-           "  quit                     quit\n");
-}
-
-int main(int argc, char **argv)
-{
-    char *help_str = "help";
-    argc--;
-    argv++;
-
-    if (argc > 0) {
-        if (!strncmp(argv[0], help_str, strlen(argv[0])))
-            print_help_menu();
-    } else
-	    alsaucm_test_cmd_svr();
-    return 0;
-}
-
-static int process_cmd(char *cmdStr)
-{
-    const char **list = NULL , *str = NULL;
-    long lval;
-    int err, i;
-    char *command = NULL;
-    int count = 0;
-    char *identifier = NULL, *value = NULL;
-    struct cmd *cmd = NULL;
-
-    command = strtok_r(cmdStr, " ", &value);
-    identifier = strtok_r(NULL, " ", &value);
-
-    if (command == NULL) {
-        fprintf(stderr, "NULL pointer encountered. Invalid value for command");
-        return -1;
-    }
-
-    for (cmd = cmds; cmd->cmd_str != NULL; cmd++) {
-        if (strncmp(cmd->cmd_str, command, strlen(cmd->cmd_str)) == 0)
-            break;
-    }
-
-    if (cmd->cmd_str == NULL) {
-        fprintf(stderr, "Unknown command '%s'\n", command);
-        return -EINVAL;
-    }
-
-    if ((identifier == NULL) && ((cmd->code != UCM_HELP) &&
-        (cmd->code != UCM_LISTCARDS) && (cmd->code != UCM_RESET) &&
-        (cmd->code != UCM_RELOAD)))
-    {
-        fprintf(stderr, "NULL pointer encountered. Invalid value for identifier");
-        return -1;
-    }
-
-    switch (cmd->code) {
-    case UCM_HELP:
-        print_help_menu();
-        break;
-
-    case UCM_OPEN:
-        if (uc_mgr) {
-            snd_use_case_mgr_close(uc_mgr);
-            uc_mgr = NULL;
-        }
-
-        err = snd_use_case_mgr_open(&uc_mgr, identifier);
-        if (err < 0) {
-            fprintf(stderr, "%s: error failed to open sound card %s: %d\n", cmd->cmd_str, identifier, err);
-            return err;
-        }
-        snd_use_case_mgr_wait_for_parsing(uc_mgr);
-        break;
-
-    case UCM_LISTCARDS:
-        err = snd_use_case_card_list(&list);
-        if (err < 0) {
-            fprintf(stderr, "%s: error failed to get card list: %d\n", cmd->cmd_str, err);
-            return err;
-        }
-        if (err == 0) {
-            printf("list is empty\n");
-            return 0;
-        }
-
-        for (i = 0; i < err; i++)
-            printf("  %i: %s\n", i+1, list[i]);
-        snd_use_case_free_list(list, err);
-        break;
-
-    case UCM_RESET:
-        if (!uc_mgr) {
-            fprintf(stderr, "No card is opened before. %s command can't be executed\n", cmd->cmd_str);
-            return -EINVAL;
-        }
-
-        err = snd_use_case_mgr_reset(uc_mgr);
-        if (err < 0) {
-            fprintf(stderr, "%s: error failed to reset sound card %d\n", cmd->cmd_str, err);
-            return err;
-        }
-        break;
-
-    case UCM_RELOAD:
-        if (!uc_mgr) {
-            fprintf(stderr, "No card is opened before. %s command can't be executed\n", cmd->cmd_str);
-            return -EINVAL;
-        }
-
-        err = snd_use_case_mgr_reload(uc_mgr);
-        if (err < 0) {
-            fprintf(stderr, "%s: error failed to reload manager %d\n", cmd->cmd_str, err);
-            return err;
-        }
-        break;
-
-    case UCM_LIST:
-        if (!uc_mgr) {
-            fprintf(stderr, "No card is opened before. %s command can't be executed\n", cmd->cmd_str);
-            return -EINVAL;
-        }
-
-        err = snd_use_case_get_list(uc_mgr, identifier, &list);
-        if (err < 0) {
-            fprintf(stderr, "%s: error failed to get list %s: %d\n", cmd->cmd_str, identifier, err);
-            return err;
-        }
-        if (err == 0) {
-           printf("list is empty\n");
-           return 0;
-        }
-        for (i = 0; i < err; i++) {
-            printf("  %i: %s\n", i+1, list[i]);
-        }
-        snd_use_case_free_list(list, err);
-        break;
-
-    case UCM_SET:
-        if (!uc_mgr) {
-            fprintf(stderr, "No card is opened before. %s command can't be executed\n", cmd->cmd_str);
-            return -EINVAL;
-        }
-
-        err = snd_use_case_set(uc_mgr, identifier, value);
-        if (err < 0) {
-            fprintf(stderr, "%s: error failed to set %s=%s: %d\n", cmd->cmd_str, identifier, value, err);
-            return err;
-        }
-        break;
-
-    case UCM_GET:
-        if (!uc_mgr) {
-            fprintf(stderr, "No card is opened before. %s command can't be executed\n", cmd->cmd_str);
-            return -EINVAL;
-        }
-
-        err = snd_use_case_get(uc_mgr, identifier, &str);
-        if (err < 0) {
-            fprintf(stderr, "%s: error failed to get %s: %d\n", cmd->cmd_str, identifier, err);
-            return err;
-        }
-        printf("  %s=%s\n", identifier, str);
-        free((void *)str);
-        break;
-
-    case UCM_GETI:
-        if (!uc_mgr) {
-           fprintf(stderr, "No card is opened before. %s command can't be executed\n", cmd->cmd_str);
-           return -EINVAL;
-        }
-
-        err = snd_use_case_geti(uc_mgr, identifier, &lval);
-        if (err < 0) {
-            fprintf(stderr, "%s: error failed to get integer %s: %d\n", cmd->cmd_str, identifier, err);
-            return lval;
-        }
-        printf("  %s=%li\n", identifier, lval);
-        break;
-
-    default:
-        break;
-    }
-    return 0;
-}
-
diff --git a/legacy/libalsa-intf/amix.c b/legacy/libalsa-intf/amix.c
deleted file mode 100644
index b425ed5..0000000
--- a/legacy/libalsa-intf/amix.c
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
-** Copyright 2010, The Android Open-Source Project
-** Copyright (c) 2011, The Linux Foundation. All rights reserved.
-**
-** 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.
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-#include <ctype.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "alsa_audio.h"
-
-
-struct mixer_ctl *get_ctl(struct mixer *mixer, char *name)
-{
-    char *p;
-    unsigned idx = 0;
-
-    if (isdigit(name[0]))
-        return mixer_get_nth_control(mixer, atoi(name) - 1);
-
-    p = strrchr(name, '#');
-    if (p) {
-        *p++ = 0;
-        idx = atoi(p);
-    }
-
-    return mixer_get_control(mixer, name, idx);
-}
-
-int main(int argc, char **argv)
-{
-    struct mixer *mixer;
-    struct mixer_ctl *ctl;
-    unsigned value;
-    int r;
-    const char* device = "/dev/snd/controlC0";
-
-    mixer = mixer_open(device);
-    if (!mixer){
-        fprintf(stderr,"oops: %s: %d\n", strerror(errno), __LINE__);
-        return -1;
-    }
-
-    if (argc == 1) {
-        mixer_dump(mixer);
-        mixer_close(mixer);
-        return 0;
-    }
-
-    ctl = get_ctl(mixer, argv[1]);
-    argc -= 2;
-    argv += 2;
-
-    if (!ctl) {
-        fprintf(stderr,"can't find control\n");
-        mixer_close(mixer);
-        return -1;
-    }
-    if (argc) {
-        if (isdigit(argv[0][0]))
-            r = mixer_ctl_set_value(ctl, argc, argv);
-        else
-            r = mixer_ctl_select(ctl, argv[0]);
-        if (r)
-            fprintf(stderr,"oops: %s: %d\n", strerror(errno), __LINE__);
-    } else {
-        mixer_ctl_get(ctl, &value);
-    }
-    mixer_close(mixer);
-    return 0;
-}
diff --git a/legacy/libalsa-intf/aplay.c b/legacy/libalsa-intf/aplay.c
deleted file mode 100644
index 120febd..0000000
--- a/legacy/libalsa-intf/aplay.c
+++ /dev/null
@@ -1,669 +0,0 @@
-/*
-** Copyright 2010, The Android Open-Source Project
-** Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
-**
-** 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.
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <stdint.h>
-#include <string.h>
-#include <errno.h>
-#include <sys/poll.h>
-#include <sys/ioctl.h>
-#include <getopt.h>
-
-#include <sound/asound.h>
-#include "alsa_audio.h"
-
-#ifndef ANDROID
-#define strlcat g_strlcat
-#define strlcpy g_strlcpy
-#endif
-
-#define ID_RIFF 0x46464952
-#define ID_WAVE 0x45564157
-#define ID_FMT  0x20746d66
-#define ID_DATA 0x61746164
-
-#define FORMAT_PCM 1
-#define LOG_NDEBUG 1
-static pcm_flag = 1;
-static debug = 0;
-static uint32_t play_max_sz = 2147483648LL;
-static int format = SNDRV_PCM_FORMAT_S16_LE;
-static int period = 0;
-static int compressed = 0;
-static char *compr_codec;
-static int piped = 0;
-
-static struct option long_options[] =
-{
-    {"pcm", 0, 0, 'P'},
-    {"debug", 0, 0, 'V'},
-    {"Mmap", 0, 0, 'M'},
-    {"HW", 1, 0, 'D'},
-    {"Rate", 1, 0, 'R'},
-    {"channel", 1, 0, 'C'},
-    {"format", 1, 0, 'F'},
-    {"period", 1, 0, 'B'},
-    {"compressed", 0, 0, 'T'},
-    {0, 0, 0, 0}
-};
-
-struct wav_header {
-    uint32_t riff_id;
-    uint32_t riff_sz;
-    uint32_t riff_fmt;
-    uint32_t fmt_id;
-    uint32_t fmt_sz;
-    uint16_t audio_format;
-    uint16_t num_channels;
-    uint32_t sample_rate;
-    uint32_t byte_rate;       /* sample_rate * num_channels * bps / 8 */
-    uint16_t block_align;     /* num_channels * bps / 8 */
-    uint16_t bits_per_sample;
-    uint32_t data_id;
-    uint32_t data_sz;
-};
-
-static int set_params(struct pcm *pcm)
-{
-     struct snd_pcm_hw_params *params;
-     struct snd_pcm_sw_params *sparams;
-
-     unsigned long periodSize, bufferSize, reqBuffSize;
-     unsigned int periodTime, bufferTime;
-     unsigned int requestedRate = pcm->rate;
-     int channels = (pcm->flags & PCM_MONO) ? 1 : ((pcm->flags & PCM_5POINT1)? 6 : 2 );
-
-     params = (struct snd_pcm_hw_params*) calloc(1, sizeof(struct snd_pcm_hw_params));
-     if (!params) {
-          fprintf(stderr, "Aplay:Failed to allocate ALSA hardware parameters!");
-          return -ENOMEM;
-     }
-
-     param_init(params);
-
-     param_set_mask(params, SNDRV_PCM_HW_PARAM_ACCESS,
-                    (pcm->flags & PCM_MMAP)? SNDRV_PCM_ACCESS_MMAP_INTERLEAVED : SNDRV_PCM_ACCESS_RW_INTERLEAVED);
-     param_set_mask(params, SNDRV_PCM_HW_PARAM_FORMAT, pcm->format);
-     param_set_mask(params, SNDRV_PCM_HW_PARAM_SUBFORMAT,
-                    SNDRV_PCM_SUBFORMAT_STD);
-     if (period)
-         param_set_min(params, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, period);
-     else
-         param_set_min(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 10);
-     param_set_int(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 16);
-     param_set_int(params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
-                    pcm->channels * 16);
-     param_set_int(params, SNDRV_PCM_HW_PARAM_CHANNELS,
-                    pcm->channels);
-     param_set_int(params, SNDRV_PCM_HW_PARAM_RATE, pcm->rate);
-     param_set_hw_refine(pcm, params);
-
-     if (param_set_hw_params(pcm, params)) {
-         fprintf(stderr, "Aplay:cannot set hw params\n");
-         return -errno;
-     }
-     if (debug)
-         param_dump(params);
-
-     pcm->buffer_size = pcm_buffer_size(params);
-     pcm->period_size = pcm_period_size(params);
-     pcm->period_cnt = pcm->buffer_size/pcm->period_size;
-     if (debug) {
-        fprintf (stderr,"period_cnt = %d\n", pcm->period_cnt);
-        fprintf (stderr,"period_size = %d\n", pcm->period_size);
-        fprintf (stderr,"buffer_size = %d\n", pcm->buffer_size);
-     }
-     sparams = (struct snd_pcm_sw_params*) calloc(1, sizeof(struct snd_pcm_sw_params));
-     if (!sparams) {
-         fprintf(stderr, "Aplay:Failed to allocate ALSA software parameters!\n");
-         return -ENOMEM;
-     }
-     // Get the current software parameters
-    sparams->tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
-    sparams->period_step = 1;
-
-    sparams->avail_min = pcm->period_size/(channels * 2) ;
-    sparams->start_threshold =  pcm->period_size/(channels * 2) ;
-    sparams->stop_threshold =  pcm->buffer_size ;
-    sparams->xfer_align =  pcm->period_size/(channels * 2) ; /* needed for old kernels */
-
-    sparams->silence_size = 0;
-    sparams->silence_threshold = 0;
-
-    if (param_set_sw_params(pcm, sparams)) {
-        fprintf(stderr, "Aplay:cannot set sw params");
-        return -errno;
-    }
-    if (debug) {
-       fprintf (stderr,"sparams->avail_min= %lu\n", sparams->avail_min);
-       fprintf (stderr," sparams->start_threshold= %lu\n", sparams->start_threshold);
-       fprintf (stderr," sparams->stop_threshold= %lu\n", sparams->stop_threshold);
-       fprintf (stderr," sparams->xfer_align= %lu\n", sparams->xfer_align);
-       fprintf (stderr," sparams->boundary= %lu\n", sparams->boundary);
-    }
-    return 0;
-}
-
-static int play_file(unsigned rate, unsigned channels, int fd,
-              unsigned flags, const char *device, unsigned data_sz)
-{
-    struct pcm *pcm;
-    struct mixer *mixer;
-    struct pcm_ctl *ctl = NULL;
-    unsigned bufsize;
-    char *data;
-    long avail;
-    long frames;
-    int nfds = 1;
-    struct snd_xferi x;
-    unsigned offset = 0;
-    int err;
-    static int start = 0;
-    struct pollfd pfd[1];
-    int remainingData = 0;
-
-    flags |= PCM_OUT;
-
-    if (channels == 1)
-        flags |= PCM_MONO;
-    else if (channels == 6)
-	flags |= PCM_5POINT1;
-    else
-        flags |= PCM_STEREO;
-
-    if (debug)
-        flags |= DEBUG_ON;
-    else
-        flags |= DEBUG_OFF;
-
-    pcm = pcm_open(flags, device);
-    if (pcm < 0)
-        return pcm;
-
-    if (!pcm_ready(pcm)) {
-        pcm_close(pcm);
-        return -EBADFD;
-    }
-
-#ifdef QCOM_COMPRESSED_AUDIO_ENABLED
-    if (compressed) {
-       struct snd_compr_caps compr_cap;
-       struct snd_compr_params compr_params;
-       if (ioctl(pcm->fd, SNDRV_COMPRESS_GET_CAPS, &compr_cap)) {
-          fprintf(stderr, "Aplay: SNDRV_COMPRESS_GET_CAPS, failed Error no %d \n", errno);
-          pcm_close(pcm);
-          return -errno;
-       }
-       if (!period)
-           period = compr_cap.min_fragment_size;
-           switch (get_compressed_format(compr_codec)) {
-           case FORMAT_MP3:
-               compr_params.codec.id = compr_cap.codecs[FORMAT_MP3];
-               break;
-           case FORMAT_AC3_PASS_THROUGH:
-               compr_params.codec.id = compr_cap.codecs[FORMAT_AC3_PASS_THROUGH];
-               printf("codec -d = %x\n", compr_params.codec.id);
-               break;
-           default:
-               break;
-           }
-       if (ioctl(pcm->fd, SNDRV_COMPRESS_SET_PARAMS, &compr_params)) {
-          fprintf(stderr, "Aplay: SNDRV_COMPRESS_SET_PARAMS,failed Error no %d \n", errno);
-          pcm_close(pcm);
-          return -errno;
-       }
-    }
-#endif
-    pcm->channels = channels;
-    pcm->rate = rate;
-    pcm->flags = flags;
-    pcm->format = format;
-    if (set_params(pcm)) {
-        fprintf(stderr, "Aplay:params setting failed\n");
-        pcm_close(pcm);
-        return -errno;
-    }
-
-    if (!pcm_flag) {
-       if (pcm_prepare(pcm)) {
-          fprintf(stderr, "Aplay:Failed in pcm_prepare\n");
-          pcm_close(pcm);
-          return -errno;
-       }
-       if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_START)) {
-          fprintf(stderr, "Aplay: Hostless IOCTL_START Error no %d \n", errno);
-          pcm_close(pcm);
-          return -errno;
-       }
-        while(1);
-    }
-
-    remainingData = data_sz;
-
-    if (flags & PCM_MMAP) {
-        u_int8_t *dst_addr = NULL;
-        struct snd_pcm_sync_ptr *sync_ptr1 = pcm->sync_ptr;
-        if (mmap_buffer(pcm)) {
-             fprintf(stderr, "Aplay:params setting failed\n");
-             pcm_close(pcm);
-             return -errno;
-        }
-        if (pcm_prepare(pcm)) {
-          fprintf(stderr, "Aplay:Failed in pcm_prepare\n");
-          pcm_close(pcm);
-          return -errno;
-        }
-
-        bufsize = pcm->period_size;
-        if (debug)
-          fprintf(stderr, "Aplay:bufsize = %d\n", bufsize);
-
-        pfd[0].fd = pcm->timer_fd;
-        pfd[0].events = POLLIN;
-
-        frames = (pcm->flags & PCM_MONO) ? (bufsize / 2) : (bufsize / 4);
-        for (;;) {
-             if (!pcm->running) {
-                  if (pcm_prepare(pcm)) {
-                      fprintf(stderr, "Aplay:Failed in pcm_prepare\n");
-                      pcm_close(pcm);
-                      return -errno;
-                  }
-                  pcm->running = 1;
-                  start = 0;
-             }
-             /* Sync the current Application pointer from the kernel */
-             pcm->sync_ptr->flags = SNDRV_PCM_SYNC_PTR_APPL | SNDRV_PCM_SYNC_PTR_AVAIL_MIN;//SNDRV_PCM_SYNC_PTR_HWSYNC;
-             err = sync_ptr(pcm);
-             if (err == EPIPE) {
-                 fprintf(stderr, "Aplay:Failed in sync_ptr \n");
-                 /* we failed to make our window -- try to restart */
-                 pcm->underruns++;
-                 pcm->running = 0;
-                 continue;
-             }
-             /*
-              * Check for the available buffer in driver. If available buffer is
-              * less than avail_min we need to wait
-              */
-             avail = pcm_avail(pcm);
-             if (avail < 0) {
-                 fprintf(stderr, "Aplay:Failed in pcm_avail\n");
-                 pcm_close(pcm);
-                 return avail;
-             }
-             if (avail < pcm->sw_p->avail_min) {
-                 poll(pfd, nfds, TIMEOUT_INFINITE);
-                 continue;
-             }
-             /*
-              * Now that we have buffer size greater than avail_min available to
-              * to be written we need to calcutate the buffer offset where we can
-              * start writting.
-              */
-             dst_addr = dst_address(pcm);
-
-             if (debug) {
-                 fprintf(stderr, "dst_addr = 0x%08x\n", dst_addr);
-                 fprintf(stderr, "Aplay:avail = %d frames = %d\n",avail, frames);
-                 fprintf(stderr, "Aplay:sync_ptr->s.status.hw_ptr %ld  pcm->buffer_size %d  sync_ptr->c.control.appl_ptr %ld\n",
-                            pcm->sync_ptr->s.status.hw_ptr,
-                            pcm->buffer_size,
-                            pcm->sync_ptr->c.control.appl_ptr);
-             }
-
-             /*
-              * Read from the file to the destination buffer in kernel mmaped buffer
-              * This reduces a extra copy of intermediate buffer.
-              */
-             memset(dst_addr, 0x0, bufsize);
-
-             if (data_sz && !piped) {
-                 if (remainingData < bufsize) {
-                     bufsize = remainingData;
-                     frames = (pcm->flags & PCM_MONO) ? (remainingData / 2) : (remainingData / 4);
-                 }
-             }
-
-             err = read(fd, dst_addr , bufsize);
-             if (debug)
-                 fprintf(stderr, "read %d bytes from file\n", err);
-             if (err <= 0)
-                 break;
-
-             if (data_sz && !piped) {
-                 remainingData -= bufsize;
-                 if (remainingData <= 0)
-                     break;
-             }
-
-             /*
-              * Increment the application pointer with data written to kernel.
-              * Update kernel with the new sync pointer.
-              */
-             pcm->sync_ptr->c.control.appl_ptr += frames;
-             pcm->sync_ptr->flags = 0;
-
-             err = sync_ptr(pcm);
-             if (err == EPIPE) {
-                 fprintf(stderr, "Aplay:Failed in sync_ptr 2 \n");
-                 /* we failed to make our window -- try to restart */
-                 pcm->underruns++;
-                 pcm->running = 0;
-                 continue;
-             }
-
-             if (debug) {
-                 fprintf(stderr, "Aplay:sync_ptr->s.status.hw_ptr %ld  sync_ptr->c.control.appl_ptr %ld\n",
-                            pcm->sync_ptr->s.status.hw_ptr,
-                            pcm->sync_ptr->c.control.appl_ptr);
-#ifdef QCOM_COMPRESSED_AUDIO_ENABLED
-                 if (compressed && start) {
-                    struct snd_compr_tstamp tstamp;
-		    if (ioctl(pcm->fd, SNDRV_COMPRESS_TSTAMP, &tstamp))
-			fprintf(stderr, "Aplay: failed SNDRV_COMPRESS_TSTAMP\n");
-                    else
-	                fprintf(stderr, "timestamp = %lld\n", tstamp.timestamp);
-		}
-#endif
-             }
-             /*
-              * If we have reached start threshold of buffer prefill,
-              * its time to start the driver.
-              */
-                 if(start)
-                     goto start_done;
-                 if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_START)) {
-                     err = -errno;
-                     if (errno == EPIPE) {
-                         fprintf(stderr, "Aplay:Failed in SNDRV_PCM_IOCTL_START\n");
-                         /* we failed to make our window -- try to restart */
-                         pcm->underruns++;
-                         pcm->running = 0;
-                         continue;
-                    } else {
-                        fprintf(stderr, "Aplay:Error no %d \n", errno);
-                        pcm_close(pcm);
-                        return -errno;
-                    }
-                } else
-                    start = 1;
-
-start_done:
-                offset += frames;
-        }
-        while(1) {
-            pcm->sync_ptr->flags = SNDRV_PCM_SYNC_PTR_APPL | SNDRV_PCM_SYNC_PTR_AVAIL_MIN;//SNDRV_PCM_SYNC_PTR_HWSYNC;
-            sync_ptr(pcm);
-            /*
-             * Check for the available buffer in driver. If available buffer is
-             * less than avail_min we need to wait
-             */
-            if (pcm->sync_ptr->s.status.hw_ptr >= pcm->sync_ptr->c.control.appl_ptr) {
-                fprintf(stderr, "Aplay:sync_ptr->s.status.hw_ptr %ld  sync_ptr->c.control.appl_ptr %ld\n",
-                           pcm->sync_ptr->s.status.hw_ptr,
-                           pcm->sync_ptr->c.control.appl_ptr);
-                break;
-            } else
-                poll(pfd, nfds, TIMEOUT_INFINITE);
-        }
-    } else {
-        if (pcm_prepare(pcm)) {
-            fprintf(stderr, "Aplay:Failed in pcm_prepare\n");
-            pcm_close(pcm);
-            return -errno;
-        }
-
-        bufsize = pcm->period_size;
-
-        data = calloc(1, bufsize);
-        if (!data) {
-            fprintf(stderr, "Aplay:could not allocate %d bytes\n", bufsize);
-            pcm_close(pcm);
-            return -ENOMEM;
-        }
-
-        if (data_sz && !piped) {
-            if (remainingData < bufsize)
-                bufsize = remainingData;
-        }
-
-        while (read(fd, data, bufsize) > 0) {
-            if (pcm_write(pcm, data, bufsize)){
-                fprintf(stderr, "Aplay: pcm_write failed\n");
-                free(data);
-                pcm_close(pcm);
-                return -errno;
-            }
-            memset(data, 0, bufsize);
-
-            if (data_sz && !piped) {
-                remainingData -= bufsize;
-                if (remainingData <= 0)
-                    break;
-                if (remainingData < bufsize)
-                       bufsize = remainingData;
-            }
-        }
-        free(data);
-    }
-    fprintf(stderr, "Aplay: Done playing\n");
-    pcm_close(pcm);
-    return 0;
-}
-
-int play_raw(const char *fg, int rate, int ch, const char *device, const char *fn)
-{
-    int fd;
-    unsigned flag = 0;
-
-    if(!fn) {
-        fd = fileno(stdin);
-        piped = 1;
-    } else {
-        fd = open(fn, O_RDONLY);
-        if (fd < 0) {
-            fprintf(stderr, "Aplay:aplay: cannot open '%s'\n", fn);
-            return fd;
-        }
-    }
-
-    if (!strncmp(fg, "M", sizeof("M")))
-        flag = PCM_MMAP;
-    else if (!strncmp(fg, "N", sizeof("N")))
-        flag = PCM_NMMAP;
-
-    fprintf(stderr, "aplay: Playing '%s': format %s ch = %d\n",
-		    fn, get_format_desc(format), ch );
-    return play_file(rate, ch, fd, flag, device, 0);
-}
-
-int play_wav(const char *fg, int rate, int ch, const char *device, const char *fn)
-{
-    struct wav_header hdr;
-    int fd;
-    unsigned flag = 0;
-
-    if (pcm_flag) {
-        if(!fn) {
-            fd = fileno(stdin);
-            piped = 1;
-        } else {
-            fd = open(fn, O_RDONLY);
-            if (fd < 0) {
-                fprintf(stderr, "Aplay:aplay: cannot open '%s'\n", fn);
-                return fd;
-            }
-        }
-        if (compressed) {
-            hdr.sample_rate = rate;
-            hdr.num_channels = ch;
-            hdr.data_sz = 0;
-            goto ignore_header;
-        }
-
-        if (read(fd, &hdr, sizeof(hdr)) != sizeof(hdr)) {
-            fprintf(stderr, "Aplay:aplay: cannot read header\n");
-            return -errno;
-        }
-
-        if ((hdr.riff_id != ID_RIFF) ||
-            (hdr.riff_fmt != ID_WAVE) ||
-            (hdr.fmt_id != ID_FMT)) {
-            fprintf(stderr, "Aplay:aplay: '%s' is not a riff/wave file\n", fn);
-            return -EINVAL;
-        }
-        if ((hdr.audio_format != FORMAT_PCM) ||
-            (hdr.fmt_sz != 16)) {
-            fprintf(stderr, "Aplay:aplay: '%s' is not pcm format\n", fn);
-            return -EINVAL;
-        }
-        if (hdr.bits_per_sample != 16) {
-            fprintf(stderr, "Aplay:aplay: '%s' is not 16bit per sample\n", fn);
-            return -EINVAL;
-        }
-    } else {
-        fd = -EBADFD;
-        hdr.sample_rate = rate;
-        hdr.num_channels = ch;
-        hdr.data_sz = 0;
-    }
-
-ignore_header:
-    if (!strncmp(fg, "M", sizeof("M")))
-        flag = PCM_MMAP;
-    else if (!strncmp(fg, "N", sizeof("N")))
-        flag = PCM_NMMAP;
-    fprintf(stderr, "aplay: Playing '%s':%s\n", fn, get_format_desc(format) );
-
-    return play_file(hdr.sample_rate, hdr.num_channels, fd, flag, device, hdr.data_sz);
-}
-
-int main(int argc, char **argv)
-{
-    int option_index = 0;
-    int c,i;
-    int ch = 2;
-    int rate = 44100;
-    char *mmap = "N";
-    char *device = "hw:0,0";
-    char *filename;
-    int rc = 0;
-
-    if (argc <2) {
-          printf("\nUsage: aplay [options] <file>\n"
-                "options:\n"
-                "-D <hw:C,D>	-- Alsa PCM by name\n"
-                "-M		-- Mmap stream\n"
-                "-P		-- Hostless steam[No PCM]\n"
-		"-C             -- Channels\n"
-		"-R             -- Rate\n"
-                "-V		-- verbose\n"
-		"-F             -- Format\n"
-                "-B             -- Period\n"
-                "-T <MP3, AAC, AC3_PASS_THROUGH>  -- Compressed\n"
-                "<file> \n");
-           fprintf(stderr, "Formats Supported:\n");
-           for (i = 0; i <= SNDRV_PCM_FORMAT_LAST; ++i)
-               if (get_format_name(i))
-                   fprintf(stderr, "%s ", get_format_name(i));
-           fprintf(stderr, "\nSome of these may not be available on selected hardware\n");
-           return 0;
-     }
-     while ((c = getopt_long(argc, argv, "PVMD:R:C:F:B:T:", long_options, &option_index)) != -1) {
-       switch (c) {
-       case 'P':
-          pcm_flag = 0;
-          break;
-       case 'V':
-          debug = 1;
-          break;
-       case 'M':
-          mmap = "M";
-          break;
-       case 'D':
-          device = optarg;
-          break;
-       case 'R':
-          rate = (int)strtol(optarg, NULL, 0);
-          break;
-       case 'C':
-          ch = (int)strtol(optarg, NULL, 0);
-          break;
-       case 'F':
-          printf("optarg = %s\n", optarg);
-          format = get_format(optarg);
-          break;
-       case 'B':
-          period = (int)strtol(optarg, NULL, 0);
-          break;
-       case 'T':
-          compressed = 1;
-          printf("compressed codec type requested = %s\n", optarg);
-          compr_codec = optarg;
-          break;
-       default:
-          printf("\nUsage: aplay [options] <file>\n"
-                "options:\n"
-                "-D <hw:C,D>	-- Alsa PCM by name\n"
-                "-M		-- Mmap stream\n"
-                "-P		-- Hostless steam[No PCM]\n"
-                "-V		-- verbose\n"
-                "-C		-- Channels\n"
-		"-R             -- Rate\n"
-		"-F             -- Format\n"
-                "-B             -- Period\n"
-                "-T             -- Compressed\n"
-                "<file> \n");
-           fprintf(stderr, "Formats Supported:\n");
-           for (i = 0; i < SNDRV_PCM_FORMAT_LAST; ++i)
-               if (get_format_name(i))
-                   fprintf(stderr, "%s ", get_format_name(i));
-           fprintf(stderr, "\nSome of these may not be available on selected hardware\n");
-          return -EINVAL;
-       }
-
-    }
-    filename = (char*) calloc(1, 30);
-    if (!filename) {
-          fprintf(stderr, "Aplay:Failed to allocate filename!");
-          return -ENOMEM;
-    }
-    if (optind > argc - 1) {
-       free(filename);
-       filename = NULL;
-    } else {
-       strlcpy(filename, argv[optind++], 30);
-    }
-
-    if (pcm_flag) {
-	 if (format == SNDRV_PCM_FORMAT_S16_LE) 
-             rc = play_wav(mmap, rate, ch, device, filename);
-         else
-             rc = play_raw(mmap, rate, ch, device, filename);
-    } else {
-        rc = play_wav(mmap, rate, ch, device, "dummy");
-    }
-    if (filename)
-        free(filename);
-
-    return rc;
-}
-
diff --git a/legacy/libalsa-intf/arec.c b/legacy/libalsa-intf/arec.c
deleted file mode 100644
index 30e710c..0000000
--- a/legacy/libalsa-intf/arec.c
+++ /dev/null
@@ -1,620 +0,0 @@
-/*
-** Copyright 2010, The Android Open-Source Project
-** Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
-**
-** 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.
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <stdint.h>
-#include <string.h>
-#include <signal.h>
-#include <errno.h>
-#include <sys/poll.h>
-#include <sys/ioctl.h>
-#include <getopt.h>
-#include <limits.h>
-
-#include "alsa_audio.h"
-
-#define ID_RIFF 0x46464952
-#define ID_WAVE 0x45564157
-#define ID_FMT  0x20746d66
-#define ID_DATA 0x61746164
-
-#define FORMAT_PCM 1
-
-#ifndef ANDROID
-#define strlcat g_strlcat
-#define strlcpy g_strlcpy
-#endif
-
-static struct wav_header hdr;
-static int fd;
-static struct pcm *pcm;
-static int debug = 0;
-static int pcm_flag = 1;
-static int duration = 0;
-static char *filename;
-static char *data;
-static int format = SNDRV_PCM_FORMAT_S16_LE;
-static int period = 0;
-static int piped = 0;
-
-static struct option long_options[] =
-{
-    {"pcm", 0, 0, 'P'},
-    {"debug", 0, 0, 'V'},
-    {"Mmap", 0, 0, 'M'},
-    {"HW", 1, 0, 'D'},
-    {"Rate", 1, 0, 'R'},
-    {"channel", 1, 0, 'C'},
-    {"duration", 1, 0, 'T'},
-    {"format", 1, 0, 'F'},
-    {"period", 1, 0, 'B'},
-    {0, 0, 0, 0}
-};
-
-struct wav_header {
-    uint32_t riff_id;
-    uint32_t riff_sz;
-    uint32_t riff_fmt;
-    uint32_t fmt_id;
-    uint32_t fmt_sz;
-    uint16_t audio_format;
-    uint16_t num_channels;
-    uint32_t sample_rate;
-    uint32_t byte_rate;       /* sample_rate * num_channels * bps / 8 */
-    uint16_t block_align;     /* num_channels * bps / 8 */
-    uint16_t bits_per_sample;
-    uint32_t data_id;
-    uint32_t data_sz;
-};
-
-static int set_params(struct pcm *pcm)
-{
-     struct snd_pcm_hw_params *params;
-     struct snd_pcm_sw_params *sparams;
-
-     unsigned long periodSize, bufferSize, reqBuffSize;
-     unsigned int periodTime, bufferTime;
-     unsigned int requestedRate = pcm->rate;
-
-     params = (struct snd_pcm_hw_params*) calloc(1, sizeof(struct snd_pcm_hw_params));
-     if (!params) {
-          fprintf(stderr, "Arec:Failed to allocate ALSA hardware parameters!");
-          return -ENOMEM;
-     }
-
-     param_init(params);
-
-     param_set_mask(params, SNDRV_PCM_HW_PARAM_ACCESS,
-                    (pcm->flags & PCM_MMAP)? SNDRV_PCM_ACCESS_MMAP_INTERLEAVED : SNDRV_PCM_ACCESS_RW_INTERLEAVED);
-     param_set_mask(params, SNDRV_PCM_HW_PARAM_FORMAT, pcm->format);
-     param_set_mask(params, SNDRV_PCM_HW_PARAM_SUBFORMAT,
-                    SNDRV_PCM_SUBFORMAT_STD);
-     if (period)
-         param_set_min(params, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, period);
-     else
-         param_set_min(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 10);
-     param_set_int(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 16);
-     param_set_int(params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
-                    pcm->channels * 16);
-     param_set_int(params, SNDRV_PCM_HW_PARAM_CHANNELS,
-                    pcm->channels);
-     param_set_int(params, SNDRV_PCM_HW_PARAM_RATE, pcm->rate);
-
-     param_set_hw_refine(pcm, params);
-
-     if (param_set_hw_params(pcm, params)) {
-         fprintf(stderr, "Arec:cannot set hw params");
-         return -errno;
-     }
-     if (debug)
-          param_dump(params);
-
-     pcm->buffer_size = pcm_buffer_size(params);
-     pcm->period_size = pcm_period_size(params);
-     pcm->period_cnt = pcm->buffer_size/pcm->period_size;
-     if (debug) {
-        fprintf (stderr,"period_size (%d)", pcm->period_size);
-        fprintf (stderr," buffer_size (%d)", pcm->buffer_size);
-        fprintf (stderr," period_cnt  (%d)\n", pcm->period_cnt);
-     }
-     sparams = (struct snd_pcm_sw_params*) calloc(1, sizeof(struct snd_pcm_sw_params));
-     if (!sparams) {
-         fprintf(stderr, "Arec:Failed to allocate ALSA software parameters!\n");
-         return -ENOMEM;
-     }
-    sparams->tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
-    sparams->period_step = 1;
-
-    if (pcm->flags & PCM_MONO) {
-        sparams->avail_min = pcm->period_size/2;
-        sparams->xfer_align = pcm->period_size/2;
-    } else if (pcm->flags & PCM_QUAD) {
-        sparams->avail_min = pcm->period_size/8;
-        sparams->xfer_align = pcm->period_size/8;
-    } else if (pcm->flags & PCM_5POINT1) {
-        sparams->avail_min = pcm->period_size/12;
-        sparams->xfer_align = pcm->period_size/12;
-    } else {
-        sparams->avail_min = pcm->period_size/4;
-        sparams->xfer_align = pcm->period_size/4;
-    }
-
-    sparams->start_threshold = 1;
-    sparams->stop_threshold = INT_MAX;
-    sparams->silence_size = 0;
-    sparams->silence_threshold = 0;
-
-    if (param_set_sw_params(pcm, sparams)) {
-         fprintf(stderr, "Arec:cannot set sw params");
-         return -errno;
-    }
-    if (debug) {
-        fprintf (stderr,"avail_min (%lu)\n", sparams->avail_min);
-        fprintf (stderr,"start_threshold (%lu)\n", sparams->start_threshold);
-        fprintf (stderr,"stop_threshold (%lu)\n", sparams->stop_threshold);
-        fprintf (stderr,"xfer_align (%lu)\n", sparams->xfer_align);
-    }
-    return 0;
-
-}
-
-int record_file(unsigned rate, unsigned channels, int fd, unsigned count,  unsigned flags, const char *device)
-{
-    unsigned xfer, bufsize;
-    int r, avail;
-    int nfds = 1;
-    static int start = 0;
-    struct snd_xferi x;
-    long frames;
-    unsigned offset = 0;
-    int err;
-    struct pollfd pfd[1];
-    int rec_size = 0;
-
-    flags |= PCM_IN;
-
-    if (channels == 1)
-        flags |= PCM_MONO;
-    else if (channels == 4)
-        flags |= PCM_QUAD;
-    else if (channels == 6)
-        flags |= PCM_5POINT1;
-    else
-        flags |= PCM_STEREO;
-
-    pcm = pcm_open(flags, device);
-    if (!pcm_ready(pcm)) {
-        pcm_close(pcm);
-        goto fail;
-    }
-    pcm->channels = channels;
-    pcm->rate = rate;
-    pcm->flags = flags;
-    pcm->format = format;
-    if (set_params(pcm)) {
-        fprintf(stderr, "Arec:params setting failed\n");
-        pcm_close(pcm);
-        return -EINVAL;
-    }
-
-    if (!pcm_flag) {
-        if (pcm_prepare(pcm)) {
-            fprintf(stderr, "Arec:Failed in pcm_prepare\n");
-            pcm_close(pcm);
-            return -errno;
-        }
-	if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_START)) {
-            fprintf(stderr, "Arec: Hostless IOCTL_START Error no %d \n", errno);
-            pcm_close(pcm);
-            return -errno;
-	}
-        while(1);
-   }
-
-    if (flags & PCM_MMAP) {
-        u_int8_t *dst_addr = NULL;
-        struct snd_pcm_sync_ptr *sync_ptr1 = pcm->sync_ptr;
-        unsigned int tmp;
-
-        if (mmap_buffer(pcm)) {
-             fprintf(stderr, "Arec:params setting failed\n");
-             pcm_close(pcm);
-             return -EINVAL;
-        }
-        if (debug)
-            fprintf(stderr, "Arec:mmap_buffer done\n");
-
-        if (pcm_prepare(pcm)) {
-            fprintf(stderr, "Arec:Failed in pcm_prepare\n");
-            pcm_close(pcm);
-            return -errno;
-        }
-
-        bufsize = pcm->period_size;
-        if (debug)
-	    fprintf(stderr, "Arec:bufsize = %d\n", bufsize);
-        if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_START)) {
-		if (errno == EPIPE) {
-			fprintf(stderr, "Arec:Failed in SNDRV_PCM_IOCTL_START\n");
-			/* we failed to make our window -- try to restart */
-			pcm->running = 0;
-		} else {
-			fprintf(stderr, "Arec:Error no %d \n", errno);
-			return -errno;
-		}
-        }
-
-        pfd[0].fd = pcm->fd;
-        pfd[0].events = POLLIN;
-
-        hdr.data_sz = 0;
-        if (pcm->flags & PCM_MONO) {
-                frames = bufsize / 2;
-        } else if (pcm->flags & PCM_QUAD) {
-                frames = bufsize / 8;
-        } else if (pcm->flags & PCM_5POINT1) {
-                frames = bufsize / 12;
-        } else{
-                frames = bufsize / 4;
-        }
-        x.frames = frames;
-        for(;;) {
-		if (!pcm->running) {
-                    if (pcm_prepare(pcm))
-                        return --errno;
-                    start = 0;
-                }
-                /* Sync the current Application pointer from the kernel */
-		pcm->sync_ptr->flags = SNDRV_PCM_SYNC_PTR_APPL | SNDRV_PCM_SYNC_PTR_AVAIL_MIN;//SNDRV_PCM_SYNC_PTR_HWSYNC;
-                err = sync_ptr(pcm);
-                if (err == EPIPE) {
-                     fprintf(stderr, "Arec:Failed in sync_ptr \n");
-                     /* we failed to make our window -- try to restart */
-                     //pcm->overruns++;
-                     pcm->running = 0;
-                     continue;
-                }
-               /*
-                * Check for the available data in driver. If available data is
-                * less than avail_min we need to wait
-                */
-                avail = pcm_avail(pcm);
-                if (debug)
-                     fprintf(stderr, "Arec:avail 1 = %d frames = %ld\n",avail, frames);
-                if (avail < 0)
-                        return avail;
-                if (avail < pcm->sw_p->avail_min) {
-                        poll(pfd, nfds, TIMEOUT_INFINITE);
-                        continue;
-                }
-	 	if (x.frames > avail)
-                        frames = avail;
-               /*
-                * Now that we have data size greater than avail_min available to
-                * to be read we need to calcutate the buffer offset where we can
-                * start reading from.
-                */
-                dst_addr = dst_address(pcm);
-
-               /*
-                * Write to the file at the destination address from kernel mmaped buffer
-                * This reduces a extra copy of intermediate buffer.
-                */
-                if (write(fd, dst_addr, bufsize) != bufsize) {
-                    fprintf(stderr, "Arec:could not write %d bytes\n", bufsize);
-                    return -errno;
-                }
-                x.frames -= frames;
-                pcm->sync_ptr->c.control.appl_ptr += frames;
-		pcm->sync_ptr->flags = 0;
-                err = sync_ptr(pcm);
-                if (err == EPIPE) {
-                     fprintf(stderr, "Arec:Failed in sync_ptr \n");
-                     /* we failed to make our window -- try to restart */
-                     pcm->running = 0;
-                     continue;
-                }
-                rec_size += bufsize;
-                hdr.data_sz += bufsize;
-                hdr.riff_sz = hdr.data_sz + 44 - 8;
-                if (!piped) {
-                    lseek(fd, 0, SEEK_SET);
-                    write(fd, &hdr, sizeof(hdr));
-                    lseek(fd, 0, SEEK_END);
-                }
-                if (rec_size >= count)
-                      break;
-           }
-    } else {
-	    bufsize = pcm->period_size;
-            if (pcm_prepare(pcm)) {
-                fprintf(stderr, "Arec:Failed in pcm_prepare\n");
-                pcm_close(pcm);
-                return -errno;
-            }
-
-	    data = calloc(1, bufsize);
-	    if (!data) {
-		fprintf(stderr, "Arec:could not allocate %d bytes\n", bufsize);
-		return -ENOMEM;
-	    }
-
-	    while (!pcm_read(pcm, data, bufsize)) {
-		if (write(fd, data, bufsize) != bufsize) {
-		    fprintf(stderr, "Arec:could not write %d bytes\n", bufsize);
-		    break;
-		}
-                rec_size += bufsize;
-                hdr.data_sz += bufsize;
-                hdr.riff_sz = hdr.data_sz + 44 - 8;
-                if (!piped) {
-                    lseek(fd, 0, SEEK_SET);
-                    write(fd, &hdr, sizeof(hdr));
-                    lseek(fd, 0, SEEK_END);
-                }
-                if (rec_size >= count)
-                    break;
-	    }
-    }
-    fprintf(stderr, " rec_size =%d count =%d\n", rec_size, count);
-    close(fd);
-    free(data);
-    pcm_close(pcm);
-    return hdr.data_sz;
-
-fail:
-    fprintf(stderr, "Arec:pcm error: %s\n", pcm_error(pcm));
-    return -errno;
-}
-
-int rec_raw(const char *fg, const char *device, int rate, int ch,
-                    const char *fn)
-{
-    unsigned flag = 0;
-    uint32_t rec_max_sz = 2147483648LL;
-    uint32_t count;
-    int i = 0;
-
-    if (!fn) {
-        fd = fileno(stdout);
-        piped = 1;
-    } else {
-        fd = open(fn, O_WRONLY | O_CREAT | O_TRUNC, 0664);
-        if (fd < 0) {
-            fprintf(stderr, "Arec:arec: cannot open '%s'\n", fn);
-            return -EBADFD;
-        }
-    }
-    if (duration == 0) {
-         count = rec_max_sz;
-    } else {
-         count = rate * ch * 2;
-         count *= (uint32_t)duration;
-    }
-    count = count < rec_max_sz ? count : rec_max_sz;
-    if (debug)
-        fprintf(stderr, "arec: %d ch, %d hz, %d bit, format %x\n",
-        ch, rate, 16, format);
-
-    if (!strncmp(fg, "M", sizeof("M"))) {
-        flag = PCM_MMAP;
-    } else if (!strncmp(fg, "N", sizeof("N"))) {
-        flag = PCM_NMMAP;
-    }
-    return record_file(rate, ch, fd, count, flag, device);
-}
-
-int rec_wav(const char *fg, const char *device, int rate, int ch, const char *fn)
-{
-    unsigned flag = 0;
-    uint32_t rec_max_sz = 2147483648LL;
-    uint32_t count = 0;
-    int i = 0;
-
-    if (pcm_flag) {
-            if (!fn) {
-              fd = fileno(stdout);
-              piped = 1;
-            } else {
-	       fd = open(fn, O_WRONLY | O_CREAT | O_TRUNC, 0664);
-	       if (fd < 0) {
-	            fprintf(stderr, "Arec:arec: cannot open '%s'\n", fn);
-		    return -EBADFD;
-	       }
-            }
-	    memset(&hdr, 0, sizeof(struct wav_header));
-	    hdr.riff_id = ID_RIFF;
-	    hdr.riff_fmt = ID_WAVE;
-	    hdr.fmt_id = ID_FMT;
-	    hdr.fmt_sz = 16;
-	    hdr.audio_format = FORMAT_PCM;
-	    hdr.num_channels = ch;
-	    hdr.sample_rate = rate;
-            hdr.bits_per_sample = 16;
-            hdr.byte_rate = (rate * ch * hdr.bits_per_sample) / 8;
-            hdr.block_align = ( hdr.bits_per_sample * ch ) / 8;
-	    hdr.data_id = ID_DATA;
-	    hdr.data_sz = 0;
-
-            if (duration == 0) {
-                count = rec_max_sz;
-            } else {
-                count = rate * ch * 2;
-                count *= (uint32_t)duration;
-            }
-            hdr.riff_sz = hdr.data_sz + 44 - 8;
-	    if (write(fd, &hdr, sizeof(hdr)) != sizeof(hdr)) {
-		if (debug)
-		    fprintf(stderr, "arec: cannot write header\n");
-		return -errno;
-	    }
-	    if (debug)
-		fprintf(stderr, "arec: %d ch, %d hz, %d bit, %s\n",
-		    hdr.num_channels, hdr.sample_rate, hdr.bits_per_sample,
-		    hdr.audio_format == FORMAT_PCM ? "PCM" : "unknown");
-    } else {
-            hdr.sample_rate = rate;
-            hdr.num_channels = ch;
-    }
-
-    if (!strncmp(fg, "M", sizeof("M"))) {
-        flag = PCM_MMAP;
-    } else if (!strncmp(fg, "N", sizeof("N"))) {
-        flag = PCM_NMMAP;
-    }
-    return record_file(hdr.sample_rate, hdr.num_channels, fd, count, flag, device);
-}
-
-static void signal_handler(int sig)
-{
-    long file_size;
-    FILE *fp;
-
-    fprintf(stderr, "Arec:Aborted by signal %s...\n", strsignal(sig));
-    fprintf(stderr, "Arec:lseeked to %d", (int) lseek(fd, 0, SEEK_SET));
-    hdr.riff_sz = hdr.data_sz + 44 - 8;
-    fprintf(stderr, "Arec: hdr.data_sz =%d\n", hdr.data_sz);
-    fprintf(stderr, "Arec: hdr.riff_sz =%d\n", hdr.riff_sz);
-    if (write(fd, &hdr, sizeof(hdr)) != sizeof(hdr)) {
-	if (debug)
-            fprintf(stderr, "Arec:arec: cannot write header\n");
-    } else
-       fd = -1;
-
-    if (fd > 1) {
-        close(fd);
-        fd = -1;
-    }
-    free(filename);
-    free(data);
-    pcm = NULL;
-    raise(sig);
-}
-
-int main(int argc, char **argv)
-{
-    int rate = 48000;
-    int ch = 1;
-    int i = 0;
-    int option_index = 0;
-    int c;
-    char *mmap = "N";
-    char *device = "hw:0,0";
-    struct sigaction sa;
-    int rc = 0;
-
-    if (argc < 2) {
-          printf("\nUsage: arec [options] <file>\n"
-                "options:\n"
-                "-D <hw:C,D>	-- Alsa PCM by name\n"
-                "-M		-- Mmap stream\n"
-                "-P		-- Hostless steam[No PCM]\n"
-                "-V		-- verbose\n"
-                "-C		-- Channels\n"
-                "-R		-- Rate\n"
-                "-T		-- Time in seconds for recording\n"
-		"-F             -- Format\n"
-                "-B             -- Period\n"
-                "<file> \n");
-           for (i = 0; i < SNDRV_PCM_FORMAT_LAST; ++i)
-               if (get_format_name(i))
-                   fprintf(stderr, "%s ", get_format_name(i));
-           fprintf(stderr, "\nSome of these may not be available on selected hardware\n");
-          return 0;
-    }
-    while ((c = getopt_long(argc, argv, "PVMD:R:C:T:F:B:", long_options, &option_index)) != -1) {
-       switch (c) {
-       case 'P':
-          pcm_flag = 0;
-          break;
-       case 'V':
-          debug = 1;
-          break;
-       case 'M':
-          mmap = "M";
-          break;
-       case 'D':
-          device = optarg;
-          break;
-       case 'R':
-          rate = (int)strtol(optarg, NULL, 0);
-          break;
-       case 'C':
-          ch  = (int)strtol(optarg, NULL, 0);
-          break;
-       case 'T':
-          duration = (int)strtol(optarg, NULL, 0);
-          break;
-       case 'F':
-          format = (int)get_format(optarg);
-          break;
-       case 'B':
-          period = (int)strtol(optarg, NULL, 0);
-          break;
-       default:
-          printf("\nUsage: arec [options] <file>\n"
-                "options:\n"
-                "-D <hw:C,D>	-- Alsa PCM by name\n"
-                "-M		-- Mmap stream\n"
-                "-P		-- Hostless steam[No PCM]\n"
-                "-V		-- verbose\n"
-                "-C		-- Channels\n"
-                "-R		-- Rate\n"
-                "-T		-- Time in seconds for recording\n"
-		"-F             -- Format\n"
-                "-B             -- Period\n"
-                "<file> \n");
-           for (i = 0; i < SNDRV_PCM_FORMAT_LAST; ++i)
-               if (get_format_name(i))
-                   fprintf(stderr, "%s ", get_format_name(i));
-           fprintf(stderr, "\nSome of these may not be available on selected hardware\n");
-          return -EINVAL;
-       }
-    }
-    filename = (char*) calloc(1, 30);
-     if (!filename) {
-          fprintf(stderr, "Arec:Failed to allocate filename!");
-          return -ENOMEM;
-    }
-    if (optind > argc - 1) {
-        free(filename);
-        filename = NULL;
-    } else {
-        strlcpy(filename, argv[optind++], 30);
-    }
-
-    memset(&sa, 0, sizeof(sa));
-    sa.sa_handler = &signal_handler;
-    sigaction(SIGABRT, &sa, NULL);
-
-    if (pcm_flag) {
-	 if (format == SNDRV_PCM_FORMAT_S16_LE)
-             rc = rec_wav(mmap, device, rate, ch, filename);
-         else
-             rc = rec_raw(mmap, device, rate, ch, filename);
-    } else {
-        rc = rec_wav(mmap, device, rate, ch, "dummy");
-    }
-    if (filename)
-        free(filename);
-
-    return rc;
-}
-
diff --git a/legacy/libalsa-intf/msm8960_use_cases.h b/legacy/libalsa-intf/msm8960_use_cases.h
deleted file mode 100644
index 7f98df1..0000000
--- a/legacy/libalsa-intf/msm8960_use_cases.h
+++ /dev/null
@@ -1,321 +0,0 @@
-/*
- * Copyright (c) 2011-2012, 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.
- */
-#ifndef _MSM8960_USE_CASES_H_
-#define _MSM8960_USE_CASES_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "alsa_ucm.h"
-#include "alsa_audio.h"
-#include <stdbool.h>
-#include <pthread.h>
-#define SND_UCM_END_OF_LIST "end"
-
-/* ACDB Device ID macros */
-#define CAP_RX 0x1
-#define CAP_TX 0x2
-#define CAP_VOICE 0x4
-#define DEVICE_HANDSET_RX_ACDB_ID                       7 // HANDSET_SPKR
-#define DEVICE_HANDSET_RX_TMUS_ACDB_ID                  81// HANDSET_SPKR
-#define DEVICE_HANDSET_TX_ACDB_ID                       4 // HANDSET_MIC
-#define DEVICE_SPEAKER_MONO_RX_ACDB_ID                  14// SPKR_PHONE_SPKR_MONO
-#define DEVICE_SPEAKER_STEREO_RX_ACDB_ID                15// SPKR_PHONE_SPKR_STEREO
-#define DEVICE_SPEAKER_TX_ACDB_ID                       11// SPKR_PHONE_MIC
-#define DEVICE_HEADSET_RX_ACDB_ID                       10// HEADSET_SPKR_STEREO
-#define DEVICE_HEADSET_TX_ACDB_ID                       8 // HEADSET_MIC
-#define DEVICE_DUALMIC_HANDSET_TX_BROADSIDE_ACDB_ID     5 // HANDSET_MIC_BROADSIDE
-#define DEVICE_DUALMIC_HANDSET_TX_ENDFIRE_ACDB_ID       6 // HANDSET_MIC_ENDFIRE
-#define DEVICE_DUALMIC_HANDSET_TX_ENDFIRE_TMUS_ACDB_ID  91// HANDSET_MIC_ENDFIRE
-#define DEVICE_DUALMIC_SPEAKER_TX_BROADSIDE_ACDB_ID     12// SPKR_PHONE_MIC_BROADSIDE
-#define DEVICE_DUALMIC_SPEAKER_TX_ENDFIRE_ACDB_ID       13// SPKR_PHONE_MIC_ENDFIRE
-#define DEVICE_TTY_HEADSET_MONO_RX_ACDB_ID              17// TTY_HEADSET_SPKR
-#define DEVICE_TTY_HEADSET_MONO_TX_ACDB_ID              16// TTY_HEADSET_MIC
-#define DEVICE_BT_SCO_RX_ACDB_ID                        22// BT_SCO_SPKR
-#define DEVICE_BT_SCO_TX_ACDB_ID                        21// BT_SCO_SPKR
-#define DEVICE_BT_SCO_RX_WB_ACDB_ID                     39// BT_SCO_WB_SPKR
-#define DEVICE_BT_SCO_TX_WB_ACDB_ID                     38// BT_SCO_WB_MIC
-#define DEVICE_SPEAKER_HEADSET_RX_ACDB_ID               DEVICE_HEADSET_RX_ACDB_ID // Use headset calibration
-#define DEVICE_HDMI_STEREO_RX_ACDB_ID                   18// HDMI_SPKR
-#define DEVICE_ANC_HEADSET_STEREO_RX_ACDB_ID            26// ANC RX, same as regular headset
-#define DEVICE_QUADMIC_ACDB_ID                          19// QUADMIC_SKPR
-#define DEVICE_PROXY_RX_ACDB_ID                         DEVICE_HDMI_STEREO_RX_ACDB_ID
-#define DEVICE_TTY_VCO_HANDSET_TX_ACDB_ID               36// TTY_VCO_HANDSET_MIC
-#define DEVICE_TTY_HCO_HANDSET_RX_ACDB_ID               37// TTY_HCO_HANDSET_SPRK
-#define DEVICE_HANDSET_TX_FV5_ACDB_ID                   50
-#define DEVICE_DUALMIC_HANDSET_TX_ENDFIRE_FV5_ACDB_ID   51
-#define DEVICE_SPEAKER_TX_FV5_ACDB_ID                   52
-#define DEVICE_DUALMIC_SPEAKER_TX_ENDFIRE_FV5_ACDB_ID   53
-#define DEVICE_INCALL_VOICE_RECORD_STEREO_ACDB_ID       45
-#define DEVICE_INCALL_MUSIC_DELIVERY_MONO_ACDB_ID       46
-#define DEVICE_INCALL_VOICE_RECORD_MONO_ACDB_ID         47
-#define DEVICE_CAMCORDER_TX_ACDB_ID                     61// CAMCORDER_TX
-#define DEVICE_VOICE_RECOGNITION_ACDB_ID                62// VOICE_RECOGNITION
-
-/* mixer control type */
-#define TYPE_INT            0
-#define TYPE_STR            1
-#define TYPE_MULTI_VAL      2
-
-/* Maximum string length of use case and device combination */
-#define MAX_UC_LEN 100
-/* Maximum string length of use case or device */
-#define MAX_STR_LEN 50
-
-/* Returns maximum length of strings x and y */
-#define MAX_LEN(x,y) ((strlen(x)>strlen(y))?strlen(x):strlen(y))
-
-/* Mixer control list type enum*/
-enum {
-    CTRL_LIST_VERB,
-    CTRL_LIST_DEVICE,
-    CTRL_LIST_MODIFIER,
-};
-
-/* mixer control structure */
-typedef struct mixer_control {
-    char *control_name;
-    unsigned type;
-    unsigned value;
-    char *string;
-    char **mulval;
-}mixer_control_t;
-
-/* Use case mixer controls structure */
-typedef struct card_mctrl {
-    char *case_name;
-    int ena_mixer_count;
-    mixer_control_t *ena_mixer_list;
-    int dis_mixer_count;
-    mixer_control_t *dis_mixer_list;
-    char *playback_dev_name;
-    char *capture_dev_name;
-    int acdb_id;
-    int capability;
-    char *effects_mixer_ctl;
-}card_mctrl_t;
-
-/* identifier node structure for identifier list*/
-struct snd_ucm_ident_node {
-    int active;
-    int capability;
-    char ident[MAX_STR_LEN];
-    struct snd_ucm_ident_node *next;
-};
-
-/* Structure to maintain the valid devices and
- * modifiers list per each use case */
-typedef struct use_case_verb {
-    char *use_case_name;
-    char **device_list;
-    char **modifier_list;
-    int verb_count;
-    int device_count;
-    int mod_count;
-    card_mctrl_t *verb_ctrls;
-    card_mctrl_t *device_ctrls;
-    card_mctrl_t *mod_ctrls;
-}use_case_verb_t;
-
-/* SND card context structure */
-typedef struct card_ctxt {
-    char *card_name;
-    int card_number;
-    char *control_device;
-    struct mixer *mixer_handle;
-    char current_verb[MAX_STR_LEN];
-    struct snd_ucm_ident_node *dev_list_head;
-    struct snd_ucm_ident_node *mod_list_head;
-    pthread_mutex_t card_lock;
-    pthread_mutexattr_t card_lock_attr;
-    int current_verb_index;
-    use_case_verb_t *use_case_verb_list;
-    char **verb_list;
-}card_ctxt_t;
-
-/** use case manager structure */
-struct snd_use_case_mgr {
-    int snd_card_index;
-    int device_list_count;
-    int modifier_list_count;
-    char **current_device_list;
-    char **current_modifier_list;
-    int current_tx_device;
-    int current_rx_device;
-    card_ctxt_t *card_ctxt_ptr;
-    pthread_t thr;
-    void *acdb_handle;
-    bool isFusion3Platform;
-};
-
-#define MAX_NUM_CARDS (sizeof(card_list)/sizeof(char *))
-
-/* Valid sound cards list */
-static const char *card_list[] = {
-    "snd_soc_msm",
-    "snd_soc_msm_2x",
-    "snd_soc_msm_2x_Fusion3",
-    "snd_soc_msm_Sitar",
-};
-
-typedef struct card_mapping {
-    char card_name[50];
-    int card_number;
-}card_mapping_t;
-
-/* sound card name and number mapping */
-static card_mapping_t card_mapping_list[] = {
-    {"snd_soc_msm", 0},
-    {"snd_soc_msm_2x", 0},
-    {"snd_soc_msm_2x_Fusion3", 0},
-    {"snd_soc_msm_Sitar", 0},
-};
-
-/* New use cases, devices and modifiers added
- * which are not part of existing macros
- */
-#define SND_USE_CASE_VERB_FM_REC         "FM REC"
-#define SND_USE_CASE_VERB_FM_A2DP_REC   "FM A2DP REC"
-#define SND_USE_CASE_VERB_HIFI_REC       "HiFi Rec"
-#define SND_USE_CASE_VERB_HIFI_LOWLATENCY_REC       "HiFi Lowlatency Rec"
-#define SND_USE_CASE_VERB_DL_REC	 "DL REC"
-#define SND_USE_CASE_VERB_UL_DL_REC      "UL DL REC"
-#define SND_USE_CASE_VERB_HIFI_TUNNEL    "HiFi Tunnel"
-#define SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC    "HiFi Lowlatency"
-#define SND_USE_CASE_VERB_HIFI2       "HiFi2"
-#define SND_USE_CASE_VERB_INCALL_REC   "Incall REC"
-#define SND_USE_CASE_VERB_MI2S        "MI2S"
-#define SND_USE_CASE_VERB_VOLTE    "VoLTE"
-#define SND_USE_CASE_VERB_ADSP_TESTFWK "ADSP testfwk"
-
-#define SND_USE_CASE_DEV_FM_TX           "FM Tx"
-#define SND_USE_CASE_DEV_ANC_HEADSET     "ANC Headset"
-#define SND_USE_CASE_DEV_BTSCO_NB_RX        "BT SCO Rx"
-#define SND_USE_CASE_DEV_BTSCO_NB_TX        "BT SCO Tx"
-#define SND_USE_CASE_DEV_BTSCO_WB_RX        "BT SCO WB Rx"
-#define SND_USE_CASE_DEV_BTSCO_WB_TX        "BT SCO WB Tx"
-#define SND_USE_CASE_DEV_SPEAKER_HEADSET "Speaker Headset"
-#define SND_USE_CASE_DEV_SPEAKER_ANC_HEADSET "Speaker ANC Headset"
-#define SND_USE_CASE_DEV_SPEAKER_FM_TX   "Speaker FM Tx"
-#define SND_USE_CASE_DEV_TTY_HEADSET_RX  "TTY Headset Rx"
-#define SND_USE_CASE_DEV_TTY_HEADSET_TX  "TTY Headset Tx"
-#define SND_USE_CASE_DEV_TTY_FULL_RX  "TTY Full Rx"
-#define SND_USE_CASE_DEV_TTY_FULL_TX  "TTY Full Tx"
-#define SND_USE_CASE_DEV_TTY_HANDSET_RX  "TTY Handset Rx"
-#define SND_USE_CASE_DEV_TTY_HANDSET_TX  "TTY Handset Tx"
-#define SND_USE_CASE_DEV_TTY_HANDSET_ANALOG_TX  "TTY Handset Analog Tx"
-#define SND_USE_CASE_DEV_DUAL_MIC_BROADSIDE "DMIC Broadside"
-#define SND_USE_CASE_DEV_DUAL_MIC_BROADSIDE_VREC "DMIC Broadside Voice Rec"
-#define SND_USE_CASE_DEV_DUAL_MIC_ENDFIRE "DMIC Endfire"
-#define SND_USE_CASE_DEV_DUAL_MIC_ENDFIRE_TMUS "DMIC Endfire TMUS"
-#define SND_USE_CASE_DEV_DUAL_MIC_ENDFIRE_VREC "DMIC Endfire Voice Rec"
-#define SND_USE_CASE_DEV_SPEAKER_DUAL_MIC_BROADSIDE "Speaker DMIC Broadside"
-#define SND_USE_CASE_DEV_SPEAKER_DUAL_MIC_ENDFIRE "Speaker DMIC Endfire"
-#define SND_USE_CASE_DEV_HDMI_TX             "HDMI Tx"
-#define SND_USE_CASE_DEV_HDMI_SPDIF          "HDMI SPDIF"
-#define SND_USE_CASE_DEV_QUAD_MIC "QMIC"
-#define SND_USE_CASE_DEV_SSR_QUAD_MIC "SSR QMIC"
-#define SND_USE_CASE_DEV_PROXY_RX     "PROXY Rx"
-#define SND_USE_CASE_DEV_PROXY_TX     "PROXY Tx"
-#define SND_USE_CASE_DEV_HDMI_SPEAKER     "HDMI Speaker"
-#define SND_USE_CASE_DEV_SPDIF_SPEAKER     "SPDIF Speaker"
-#define SND_USE_CASE_DEV_SPDIF_HANDSET     "SPDIF Earpiece"
-#define SND_USE_CASE_DEV_SPDIF_HEADSET     "SPDIF Headphones"
-#define SND_USE_CASE_DEV_SPDIF_ANC_HEADSET     "SPDIF ANC Headset"
-#define SND_USE_CASE_DEV_SPDIF_SPEAKER_HEADSET "SPDIF Speaker Headset"
-#define SND_USE_CASE_DEV_SPDIF_SPEAKER_ANC_HEADSET "SPDIF Speaker ANC Headset"
-#define SND_USE_CASE_DEV_DUMMY_TX "Dummy Tx"
-#define SND_USE_CASE_DEV_PROXY_RX_SPEAKER     "PROXY Rx Speaker"
-#define SND_USE_CASE_DEV_PROXY_RX_HANDSET     "PROXY Rx Earpiece"
-#define SND_USE_CASE_DEV_PROXY_RX_HEADSET     "PROXY Rx Headphones"
-#define SND_USE_CASE_DEV_PROXY_RX_ANC_HEADSET     "PROXY Rx ANC Headset"
-#define SND_USE_CASE_DEV_PROXY_RX_SPEAKER_HEADSET "PROXY Rx Speaker Headset"
-#define SND_USE_CASE_DEV_PROXY_RX_SPEAKER_ANC_HEADSET "PROXY Rx Speaker ANC Headset"
-#define SND_USE_CASE_DEV_CAMCORDER_TX       "Camcorder Tx"
-#define SND_USE_CASE_DEV_VOICE_RECOGNITION  "Voice Recognition"
-#define SND_USE_CASE_DEV_VOC_EARPIECE       "Voice Earpiece"
-#define SND_USE_CASE_DEV_VOC_EARPIECE_TMUS  "Voice Earpiece TMUS"
-#define SND_USE_CASE_DEV_VOC_HEADPHONE      "Voice Headphones"
-#define SND_USE_CASE_DEV_VOC_HEADSET        "Voice Headset"
-#define SND_USE_CASE_DEV_VOC_ANC_HEADSET    "Voice ANC Headset"
-#define SND_USE_CASE_DEV_VOC_SPEAKER        "Voice Speaker"
-#define SND_USE_CASE_DEV_VOC_LINE           "Voice Line"
-
-#define SND_USE_CASE_MOD_PLAY_FM         "Play FM"
-#define SND_USE_CASE_MOD_CAPTURE_FM      "Capture FM"
-#define SND_USE_CASE_MOD_CAPTURE_LOWLATENCY_MUSIC     "Capture Lowlatency Music"
-#define SND_USE_CASE_MOD_CAPTURE_A2DP_FM "Capture A2DP FM"
-#define SND_USE_CASE_MOD_PLAY_LPA        "Play LPA"
-#define SND_USE_CASE_MOD_PLAY_VOIP       "Play VOIP"
-#define SND_USE_CASE_MOD_CAPTURE_VOIP    "Capture VOIP"
-#define SND_USE_CASE_MOD_CAPTURE_VOICE_DL       "Capture Voice Downlink"
-#define SND_USE_CASE_MOD_CAPTURE_VOICE_UL_DL    "Capture Voice Uplink Downlink"
-#define SND_USE_CASE_MOD_PLAY_TUNNEL     "Play Tunnel"
-#define SND_USE_CASE_MOD_PLAY_LOWLATENCY_MUSIC     "Play Lowlatency Music"
-#define SND_USE_CASE_MOD_PLAY_MUSIC2       "Play Music2"
-#define SND_USE_CASE_MOD_PLAY_MI2S       "Play MI2S"
-#define SND_USE_CASE_MOD_PLAY_VOLTE   "Play VoLTE"
-
-/* List utility functions for maintaining enabled devices and modifiers */
-static int snd_ucm_add_ident_to_list(struct snd_ucm_ident_node **head, const char *value);
-static char *snd_ucm_get_value_at_index(struct snd_ucm_ident_node *head, int index);
-static int snd_ucm_get_size_of_list(struct snd_ucm_ident_node *head);
-static int snd_ucm_del_ident_from_list(struct snd_ucm_ident_node **head, const char *value);
-static int snd_ucm_free_list(struct snd_ucm_ident_node **head);
-static void snd_ucm_print_list(struct snd_ucm_ident_node *head);
-static void snd_ucm_set_status_at_index(struct snd_ucm_ident_node *head, const char *ident, int status, int capability);
-static int snd_ucm_get_status_at_index(struct snd_ucm_ident_node *head, const char *ident);
-struct snd_ucm_ident_node *snd_ucm_get_device_node(struct snd_ucm_ident_node *head, int index);
-static int snd_ucm_parse_verb(snd_use_case_mgr_t **uc_mgr, const char *file_name, int index);
-static int get_verb_count(const char *nxt_str);
-int snd_use_case_mgr_wait_for_parsing(snd_use_case_mgr_t *uc_mgr);
-int snd_use_case_set_case(snd_use_case_mgr_t *uc_mgr, const char *identifier,
-                          const char *value, const char *usecase);
-static int get_usecase_type(snd_use_case_mgr_t *uc_mgr, const char *usecase);
-static int parse_single_config_format(snd_use_case_mgr_t **uc_mgr, char *current_str, int num_verbs);
-static int get_num_verbs_config_format(const char *nxt_str);
-static int get_num_device_config_format(const char *nxt_str);
-static int get_num_mod_config_format(const char *nxt_str);
-static int is_single_config_format(const char *nxt_str);
-/* Parse functions */
-static int snd_ucm_parse(snd_use_case_mgr_t **uc_mgr);
-static int snd_ucm_parse_section(snd_use_case_mgr_t **uc_mgr, char **cur_str, char **nxt_str, int verb_index, int ctrl_list_type);
-static int snd_ucm_extract_name(char *buf, char **case_name);
-static int snd_ucm_extract_acdb(char *buf, int *id, int *cap);
-static int snd_ucm_extract_effects_mixer_ctl(char *buf, char **mixer_name);
-static int snd_ucm_extract_dev_name(char *buf, char **dev_name);
-static int snd_ucm_extract_controls(char *buf, mixer_control_t **mixer_list, int count);
-static int snd_ucm_print(snd_use_case_mgr_t *uc_mgr);
-static void snd_ucm_free_mixer_list(snd_use_case_mgr_t **uc_mgr);
-#ifdef __cplusplus
-}
-#endif
-
-#endif