diff --git a/hal/Android.mk b/hal/Android.mk
index 062e3d3..c2801db 100644
--- a/hal/Android.mk
+++ b/hal/Android.mk
@@ -74,11 +74,6 @@
   LOCAL_SRC_FILES +=  $(AUDIO_PLATFORM)/hw_info.c
 endif
 
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_USB_TUNNEL)),true)
-    LOCAL_CFLAGS += -DUSB_TUNNEL_ENABLED
-    LOCAL_SRC_FILES += audio_extn/usb.c
-endif
-
 LOCAL_SHARED_LIBRARIES := \
 	liblog \
 	libcutils \
diff --git a/hal/audio_extn/audio_extn.h b/hal/audio_extn/audio_extn.h
index b734cb6..f53c9f2 100644
--- a/hal/audio_extn/audio_extn.h
+++ b/hal/audio_extn/audio_extn.h
@@ -70,31 +70,6 @@
 
 #endif
 
-#ifndef USB_TUNNEL_ENABLED
-#define audio_extn_usb_init(adev)                                      (0)
-#define audio_extn_usb_deinit()                                        (0)
-#define audio_extn_usb_add_device(device, card)                        (0)
-#define audio_extn_usb_remove_device(device, card)                     (0)
-#define audio_extn_usb_is_config_supported(bit_width, sample_rate, ch, pb) (false)
-#define audio_extn_usb_enable_sidetone(device, enable)                 (0)
-#define audio_extn_usb_set_sidetone_gain(parms, value, len)            (0)
-#define audio_extn_usb_is_capture_supported()                          (false)
-#else
-void audio_extn_usb_init(void *adev);
-void audio_extn_usb_deinit();
-void audio_extn_usb_add_device(audio_devices_t device, int card);
-void audio_extn_usb_remove_device(audio_devices_t device, int card);
-bool audio_extn_usb_is_config_supported(unsigned int *bit_width,
-                                        unsigned int *sample_rate,
-                                        unsigned int *ch,
-                                        bool is_playback);
-int audio_extn_usb_enable_sidetone(int device, bool enable);
-int audio_extn_usb_set_sidetone_gain(struct str_parms *parms,
-                                     char *value, int len);
-bool audio_extn_usb_is_capture_supported();
-#endif
-
-
 #ifndef SOUND_TRIGGER_ENABLED
 #define audio_extn_sound_trigger_init(adev)                            (0)
 #define audio_extn_sound_trigger_deinit(adev)                          (0)
diff --git a/hal/audio_extn/usb.c b/hal/audio_extn/usb.c
deleted file mode 100644
index 3747318..0000000
--- a/hal/audio_extn/usb.c
+++ /dev/null
@@ -1,1034 +0,0 @@
-/*
- * Copyright (C) 2017 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_usb"
-
-#include <errno.h>
-#include <pthread.h>
-#include <stdlib.h>
-#include <cutils/log.h>
-#include <cutils/str_parms.h>
-#include <sys/ioctl.h>
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <system/audio.h>
-#include <tinyalsa/asoundlib.h>
-#include <audio_hw.h>
-#include <cutils/properties.h>
-#include <ctype.h>
-#include <math.h>
-
-#ifdef USB_TUNNEL_ENABLED
-#define USB_BUFF_SIZE           2048
-#define CHANNEL_NUMBER_STR      "Channels: "
-#define PLAYBACK_PROFILE_STR    "Playback:"
-#define CAPTURE_PROFILE_STR     "Capture:"
-#define USB_SIDETONE_GAIN_STR   "usb_sidetone_gain"
-#define ABS_SUB(A, B) (((A) > (B)) ? ((A) - (B)):((B) - (A)))
-#define SAMPLE_RATE_8000          8000
-#define SAMPLE_RATE_11025         11025
-/* TODO: dynamically populate supported sample rates */
-static uint32_t supported_sample_rates[] =
-    {44100, 48000, 64000, 88200, 96000, 176400, 192000, 384000};
-
-#define  MAX_SAMPLE_RATE_SIZE  sizeof(supported_sample_rates)/sizeof(supported_sample_rates[0])
-
-enum usb_usecase_type{
-    USB_PLAYBACK = 0,
-    USB_CAPTURE,
-};
-
-enum {
-    USB_SIDETONE_ENABLE_INDEX = 0,
-    USB_SIDETONE_VOLUME_INDEX,
-    USB_SIDETONE_MAX_INDEX,
-};
-
-struct usb_device_config {
-    struct listnode list;
-    unsigned int bit_width;
-    unsigned int channel_count;
-    unsigned int rate_size;
-    unsigned int rates[MAX_SAMPLE_RATE_SIZE];
-};
-
-struct usb_card_config {
-    struct listnode list;
-    audio_devices_t usb_device_type;
-    int usb_card;
-    struct listnode usb_device_conf_list;
-    struct mixer *usb_snd_mixer;
-    int usb_sidetone_index[USB_SIDETONE_MAX_INDEX];
-    int usb_sidetone_vol_min;
-    int usb_sidetone_vol_max;
-};
-
-struct usb_module {
-    struct listnode usb_card_conf_list;
-    struct audio_device *adev;
-    int sidetone_gain;
-    bool is_capture_supported;
-};
-
-static struct usb_module *usbmod = NULL;
-static bool usb_audio_debug_enable = false;
-static int usb_sidetone_gain = 0;
-
-static const char * const usb_sidetone_enable_str[] = {
-    "Sidetone Playback Switch",
-    "Mic Playback Switch",
-};
-
-static const char * const usb_sidetone_volume_str[] = {
-    "Sidetone Playback Volume",
-    "Mic Playback Volume",
-};
-
-static void usb_mixer_print_enum(struct mixer_ctl *ctl)
-{
-    unsigned int num_enums;
-    unsigned int i;
-    const char *string;
-
-    num_enums = mixer_ctl_get_num_enums(ctl);
-
-    for (i = 0; i < num_enums; i++) {
-        string = mixer_ctl_get_enum_string(ctl, i);
-        ALOGI("\t%s%s", mixer_ctl_get_value(ctl, 0) == (int)i ? ">" : "", string);
-    }
-}
-
-static void usb_soundcard_detail_control(struct mixer *mixer, const char *control)
-{
-    struct mixer_ctl *ctl;
-    enum mixer_ctl_type type;
-    unsigned int num_values;
-    unsigned int i;
-    int min, max;
-
-    if (isdigit(control[0]))
-        ctl = mixer_get_ctl(mixer, atoi(control));
-    else
-        ctl = mixer_get_ctl_by_name(mixer, control);
-
-    if (!ctl) {
-        fprintf(stderr, "Invalid mixer control\n");
-        return;
-    }
-
-    type = mixer_ctl_get_type(ctl);
-    num_values = mixer_ctl_get_num_values(ctl);
-
-    ALOGV("%s:", mixer_ctl_get_name(ctl));
-
-    for (i = 0; i < num_values; i++) {
-        switch (type) {
-            case MIXER_CTL_TYPE_INT:
-                ALOGV(" %d", mixer_ctl_get_value(ctl, i));
-                break;
-            case MIXER_CTL_TYPE_BOOL:
-                ALOGV(" %s", mixer_ctl_get_value(ctl, i) ? "On" : "Off");
-                break;
-            case MIXER_CTL_TYPE_ENUM:
-                usb_mixer_print_enum(ctl);
-                break;
-            case MIXER_CTL_TYPE_BYTE:
-                ALOGV(" 0x%02x", mixer_ctl_get_value(ctl, i));
-                break;
-            default:
-                ALOGV(" unknown");
-                break;
-        }
-    }
-
-    if (type == MIXER_CTL_TYPE_INT) {
-        min = mixer_ctl_get_range_min(ctl);
-        max = mixer_ctl_get_range_max(ctl);
-        ALOGV(" (range %d->%d)", min, max);
-    }
-}
-
-static void usb_soundcard_list_controls(struct mixer *mixer)
-{
-    struct mixer_ctl *ctl;
-    const char *name, *type;
-    unsigned int num_ctls, num_values;
-    unsigned int i;
-
-    num_ctls = mixer_get_num_ctls(mixer);
-
-    ALOGV("Number of controls: %d\n", num_ctls);
-
-    ALOGV("ctl\ttype\tnum\t%-40s value\n", "name");
-    for (i = 0; i < num_ctls; i++) {
-        ctl = mixer_get_ctl(mixer, i);
-        if (ctl != NULL) {
-            name = mixer_ctl_get_name(ctl);
-            type = mixer_ctl_get_type_string(ctl);
-            num_values = mixer_ctl_get_num_values(ctl);
-            ALOGV("%d\t%s\t%d\t%-40s", i, type, num_values, name);
-            if (name != NULL)
-                usb_soundcard_detail_control(mixer, name);
-        }
-    }
-}
-
-static int usb_set_dev_id_mixer_ctl(unsigned int usb_usecase_type, int card,
-                                    char *dev_mixer_ctl_name)
-{
-    struct mixer_ctl *ctl;
-    unsigned int dev_token;
-    const unsigned int pcm_device_number = 0;
-
-    /*
-     * usb_dev_token_id is 32 bit number and is defined as below:
-     * usb_sound_card_idx(31:16) | usb PCM device ID(15:8) | usb_usecase_type(7:0)
-     */
-    dev_token = (card << 16 ) |
-                (pcm_device_number << 8) | (usb_usecase_type & 0xFF);
-
-    ctl = mixer_get_ctl_by_name(usbmod->adev->mixer, dev_mixer_ctl_name);
-    if (!ctl) {
-       ALOGE("%s: Could not get ctl for mixer cmd - %s",
-             __func__, dev_mixer_ctl_name);
-       return -EINVAL;
-    }
-    mixer_ctl_set_value(ctl, 0, dev_token);
-
-    return 0;
-}
-
-static int usb_get_sample_rates(char *rates_str,
-                                struct usb_device_config *config)
-{
-    uint32_t i;
-    char *next_sr_string, *temp_ptr;
-    uint32_t sr, min_sr, max_sr, sr_size = 0;
-
-    /* Sample rate string can be in any of the folloing two bit_widthes:
-     * Rates: 8000 - 48000 (continuous)
-     * Rates: 8000, 44100, 48000
-     * Support both the bit_widths
-     */
-    ALOGV("%s: rates_str %s", __func__, rates_str);
-    next_sr_string = strtok_r(rates_str, "Rates: ", &temp_ptr);
-    if (next_sr_string == NULL) {
-        ALOGE("%s: could not find min rates string", __func__);
-        return -EINVAL;
-    }
-    if (strstr(rates_str, "continuous") != NULL) {
-        min_sr = (uint32_t)atoi(next_sr_string);
-        next_sr_string = strtok_r(NULL, " ,.-", &temp_ptr);
-        if (next_sr_string == NULL) {
-            ALOGE("%s: could not find max rates string", __func__);
-            return -EINVAL;
-        }
-        max_sr = (uint32_t)atoi(next_sr_string);
-
-        for (i = 0; i < MAX_SAMPLE_RATE_SIZE; i++) {
-            if (supported_sample_rates[i] >= min_sr &&
-                supported_sample_rates[i] <= max_sr) {
-                config->rates[sr_size++] = supported_sample_rates[i];
-                ALOGI_IF(usb_audio_debug_enable,
-                    "%s: continuous sample rate supported_sample_rates[%d] %d",
-                    __func__, i, supported_sample_rates[i]);
-            }
-        }
-    } else {
-        do {
-            sr = (uint32_t)atoi(next_sr_string);
-            for (i = 0; i < MAX_SAMPLE_RATE_SIZE; i++) {
-                if (supported_sample_rates[i] == sr) {
-                    ALOGI_IF(usb_audio_debug_enable,
-                        "%s: sr %d, supported_sample_rates[%d] %d -> matches!!",
-                        __func__, sr, i, supported_sample_rates[i]);
-                    config->rates[sr_size++] = supported_sample_rates[i];
-                }
-            }
-            next_sr_string = strtok_r(NULL, " ,.-", &temp_ptr);
-        } while (next_sr_string != NULL);
-    }
-    config->rate_size = sr_size;
-    return 0;
-}
-
-static int usb_get_capability(int type,
-                              struct usb_card_config *usb_card_info,
-                              int card)
-{
-    int32_t size = 0;
-    int32_t fd=-1;
-    int32_t channels_no;
-    char *str_start = NULL;
-    char *str_end = NULL;
-    char *channel_start = NULL;
-    char *bit_width_start = NULL;
-    char *rates_str_start = NULL;
-    char *target = NULL;
-    char *read_buf = NULL;
-    char *rates_str = NULL;
-    char path[128];
-    int ret = 0;
-    char *bit_width_str = NULL;
-    struct usb_device_config * usb_device_info;
-    bool check = false;
-
-    memset(path, 0, sizeof(path));
-    ALOGV("%s: for %s", __func__, (type == USB_PLAYBACK) ?
-          PLAYBACK_PROFILE_STR : CAPTURE_PROFILE_STR);
-
-    /* TODO: convert the below to using alsa_utils */
-    ret = snprintf(path, sizeof(path), "/proc/asound/card%u/stream0",
-             card);
-    if(ret < 0) {
-        ALOGE("%s: failed on snprintf (%d) to path %s\n",
-          __func__, ret, path);
-        goto done;
-    }
-
-    fd = open(path, O_RDONLY);
-    if (fd <0) {
-        ALOGE("%s: error failed to open config file %s error: %d\n",
-              __func__, path, errno);
-        ret = -EINVAL;
-        goto done;
-    }
-
-    read_buf = (char *)calloc(1, USB_BUFF_SIZE + 1);
-
-    if (!read_buf) {
-        ALOGE("Failed to create read_buf");
-        ret = -ENOMEM;
-        goto done;
-    }
-
-    if(read(fd, read_buf, USB_BUFF_SIZE) < 0) {
-        ALOGE("file read error\n");
-        goto done;
-    }
-    str_start = strstr(read_buf, ((type == USB_PLAYBACK) ?
-                       PLAYBACK_PROFILE_STR : CAPTURE_PROFILE_STR));
-    if (str_start == NULL) {
-        ALOGE("%s: error %s section not found in usb config file",
-               __func__, ((type == USB_PLAYBACK) ?
-               PLAYBACK_PROFILE_STR : CAPTURE_PROFILE_STR));
-        ret = -EINVAL;
-        goto done;
-    }
-    str_end = strstr(read_buf, ((type == USB_PLAYBACK) ?
-                       CAPTURE_PROFILE_STR : PLAYBACK_PROFILE_STR));
-    if (str_end > str_start)
-        check = true;
-
-    ALOGV("%s: usb_config = %s, check %d\n", __func__, str_start, check);
-
-    while (str_start != NULL) {
-        str_start = strstr(str_start, "Altset");
-        if ((str_start == NULL) || (check  && (str_start >= str_end))) {
-            ALOGV("%s: done parsing %s\n", __func__, str_start);
-            break;
-        }
-        ALOGV("%s: remaining string %s\n", __func__, str_start);
-        str_start += sizeof("Altset");
-        usb_device_info = calloc(1, sizeof(struct usb_device_config));
-        if (usb_device_info == NULL) {
-            ALOGE("%s: error unable to allocate memory",
-                  __func__);
-            ret = -ENOMEM;
-            break;
-        }
-        /* Bit bit_width parsing */
-        bit_width_start = strstr(str_start, "Format: ");
-        if (bit_width_start == NULL) {
-            ALOGI("%s: Could not find bit_width string", __func__);
-            free(usb_device_info);
-            continue;
-        }
-        target = strchr(bit_width_start, '\n');
-        if (target == NULL) {
-            ALOGI("%s:end of line not found", __func__);
-            free(usb_device_info);
-            continue;
-        }
-        size = target - bit_width_start;
-        if ((bit_width_str = (char *)malloc(size + 1)) == NULL) {
-            ALOGE("%s: unable to allocate memory to hold bit width strings",
-                  __func__);
-            ret = -EINVAL;
-            free(usb_device_info);
-            break;
-        }
-        memcpy(bit_width_str, bit_width_start, size);
-        bit_width_str[size] = '\0';
-        if (strstr(bit_width_str, "S16_LE"))
-            usb_device_info->bit_width = 16;
-        else if (strstr(bit_width_str, "S24_LE"))
-            usb_device_info->bit_width = 24;
-        else if (strstr(bit_width_str, "S24_3LE"))
-            usb_device_info->bit_width = 24;
-        else if (strstr(bit_width_str, "S32_LE"))
-            usb_device_info->bit_width = 32;
-
-        if (bit_width_str)
-            free(bit_width_str);
-
-        /* channels parsing */
-        channel_start = strstr(str_start, CHANNEL_NUMBER_STR);
-        if (channel_start == NULL) {
-            ALOGI("%s: could not find Channels string", __func__);
-            free(usb_device_info);
-            continue;
-        }
-        channels_no = atoi(channel_start + strlen(CHANNEL_NUMBER_STR));
-        usb_device_info->channel_count =  channels_no;
-
-        /* Sample rates parsing */
-        rates_str_start = strstr(str_start, "Rates: ");
-        if (rates_str_start == NULL) {
-            ALOGI("%s: cant find rates string", __func__);
-            free(usb_device_info);
-            continue;
-        }
-        target = strchr(rates_str_start, '\n');
-        if (target == NULL) {
-            ALOGI("%s: end of line not found", __func__);
-            free(usb_device_info);
-            continue;
-        }
-        size = target - rates_str_start;
-        if ((rates_str = (char *)malloc(size + 1)) == NULL) {
-            ALOGE("%s: unable to allocate memory to hold sample rate strings",
-                  __func__);
-            ret = -EINVAL;
-            free(usb_device_info);
-            break;
-        }
-        memcpy(rates_str, rates_str_start, size);
-        rates_str[size] = '\0';
-        ret = usb_get_sample_rates(rates_str, usb_device_info);
-        if (rates_str)
-            free(rates_str);
-        if (ret < 0) {
-            ALOGE("%s: error unable to get sample rate values",
-                  __func__);
-            free(usb_device_info);
-            continue;
-        }
-        /* Add to list if every field is valid */
-        list_add_tail(&usb_card_info->usb_device_conf_list,
-                      &usb_device_info->list);
-    }
-
-done:
-    if (fd >= 0) close(fd);
-    if (read_buf) free(read_buf);
-    return ret;
-}
-
-static int usb_get_device_playback_config(struct usb_card_config *usb_card_info,
-                                    int card)
-{
-    int ret;
-
-    /* get capabilities */
-    if ((ret = usb_get_capability(USB_PLAYBACK, usb_card_info, card))) {
-        ALOGE("%s: could not get Playback capabilities from usb device",
-               __func__);
-        goto exit;
-    }
-    usb_set_dev_id_mixer_ctl(USB_PLAYBACK, card, "USB_AUDIO_RX dev_token");
-
-exit:
-
-    return ret;
-}
-
-static int usb_get_device_capture_config(struct usb_card_config *usb_card_info,
-                                      int card)
-{
-    int ret;
-
-    /* get capabilities */
-    if ((ret = usb_get_capability(USB_CAPTURE, usb_card_info, card))) {
-        ALOGE("%s: could not get Playback capabilities from usb device",
-               __func__);
-        goto exit;
-    }
-    usb_set_dev_id_mixer_ctl(USB_CAPTURE, card, "USB_AUDIO_TX dev_token");
-
-exit:
-    return ret;
-}
-
-static void usb_get_sidetone_mixer(struct usb_card_config *usb_card_info)
-{
-    struct mixer_ctl *ctl;
-    unsigned int index;
-
-    for (index = 0; index < USB_SIDETONE_MAX_INDEX; index++)
-        usb_card_info->usb_sidetone_index[index] = -1;
-
-    usb_card_info->usb_snd_mixer = mixer_open(usb_card_info->usb_card);
-    for (index = 0;
-         index < sizeof(usb_sidetone_enable_str)/sizeof(usb_sidetone_enable_str[0]);
-         index++) {
-        ctl = mixer_get_ctl_by_name(usb_card_info->usb_snd_mixer,
-                                    usb_sidetone_enable_str[index]);
-        if (ctl) {
-            usb_card_info->usb_sidetone_index[USB_SIDETONE_ENABLE_INDEX] = index;
-            /* Disable device sidetone by default */
-            mixer_ctl_set_value(ctl, 0, false);
-            break;
-        }
-    }
-    for (index = 0;
-         index < sizeof(usb_sidetone_volume_str)/sizeof(usb_sidetone_volume_str[0]);
-         index++) {
-        ctl = mixer_get_ctl_by_name(usb_card_info->usb_snd_mixer,
-                                    usb_sidetone_volume_str[index]);
-        if (ctl) {
-            usb_card_info->usb_sidetone_index[USB_SIDETONE_VOLUME_INDEX] = index;
-            usb_card_info->usb_sidetone_vol_min = mixer_ctl_get_range_min(ctl);
-            usb_card_info->usb_sidetone_vol_max = mixer_ctl_get_range_max(ctl);
-            break;
-        }
-    }
-
-    if ((usb_card_info->usb_snd_mixer != NULL) && (usb_audio_debug_enable))
-        usb_soundcard_list_controls(usb_card_info->usb_snd_mixer);
-
-    return;
-}
-
-static bool usb_valid_device(audio_devices_t device)
-{
-    if ((popcount(device) == 1) && (device & AUDIO_DEVICE_OUT_USB_DEVICE))
-        return true;
-
-    if ((device & AUDIO_DEVICE_BIT_IN) != 0) {
-        device &= ~AUDIO_DEVICE_BIT_IN;
-        if (popcount(device) == 1 && (device & AUDIO_DEVICE_IN_USB_DEVICE) != 0)
-            return true;
-    }
-
-    return false;
-}
-
-static void usb_print_active_device(void){
-    struct listnode *node_i, *node_j;
-    struct usb_device_config *dev_info;
-    struct usb_card_config *card_info;
-    unsigned int i;
-
-    ALOGI("%s", __func__);
-    list_for_each(node_i, &usbmod->usb_card_conf_list) {
-        card_info = node_to_item(node_i, struct usb_card_config, list);
-        ALOGI("%s: card_dev_type (0x%x), card_no(%d)",
-               __func__,  card_info->usb_device_type, card_info->usb_card);
-        list_for_each(node_j, &card_info->usb_device_conf_list) {
-            dev_info = node_to_item(node_j, struct usb_device_config, list);
-            ALOGI("%s: bit-width(%d) channel(%d)",
-                   __func__, dev_info->bit_width, dev_info->channel_count);
-            for (i =  0; i < dev_info->rate_size; i++)
-                ALOGI("%s: rate %d", __func__, dev_info->rates[i]);
-        }
-    }
-}
-
-static bool usb_get_best_match_for_bit_width(
-                            struct listnode *dev_list,
-                            unsigned int stream_bit_width,
-                            unsigned int *bit_width)
-{
-    struct listnode *node_i;
-    struct usb_device_config *dev_info;
-    unsigned int candidate = 0;
-
-    list_for_each(node_i, dev_list) {
-        dev_info = node_to_item(node_i, struct usb_device_config, list);
-        ALOGI_IF(usb_audio_debug_enable,
-                 "%s: USB bw(%d), stream bw(%d), candidate(%d)",
-                 __func__, dev_info->bit_width,
-                 stream_bit_width, candidate);
-        if (dev_info->bit_width == stream_bit_width) {
-            *bit_width = dev_info->bit_width;
-            ALOGV("%s: Found match bit-width (%d)",
-                  __func__, dev_info->bit_width);
-            goto exit;
-        } else if (candidate == 0) {
-                candidate = dev_info->bit_width;
-        }
-        /*
-        * If stream bit is 24, USB supports both 16 bit and 32 bit, then
-        *  higher bit width 32 is picked up instead of 16-bit
-        */
-        else if (ABS_SUB(stream_bit_width, dev_info->bit_width) <
-                 ABS_SUB(stream_bit_width, candidate)) {
-            candidate = dev_info->bit_width;
-        }
-        else if ((ABS_SUB(stream_bit_width, dev_info->bit_width) ==
-                  ABS_SUB(stream_bit_width, candidate)) &&
-                 (dev_info->bit_width > candidate)) {
-            candidate = dev_info->bit_width;
-        }
-    }
-    ALOGV("%s: No match found, use the best candidate bw(%d)",
-          __func__, candidate);
-    *bit_width = candidate;
-exit:
-    return true;
-}
-
-static bool usb_get_best_match_for_channels(
-                            struct listnode *dev_list,
-                            unsigned int bit_width,
-                            unsigned int stream_ch,
-                            unsigned int *channel_count)
-{
-    struct listnode *node_i;
-    struct usb_device_config *dev_info;
-    unsigned int candidate = 0;
-
-    list_for_each(node_i, dev_list) {
-        dev_info = node_to_item(node_i, struct usb_device_config, list);
-        ALOGI_IF(usb_audio_debug_enable,
-                 "%s: USB ch(%d)bw(%d), stream ch(%d)bw(%d), candidate(%d)",
-                 __func__, dev_info->channel_count, dev_info->bit_width,
-                 stream_ch, bit_width, candidate);
-        if (dev_info->bit_width != bit_width)
-            continue;
-        if (dev_info->channel_count== stream_ch) {
-            *channel_count = dev_info->channel_count;
-            ALOGV("%s: Found match channels (%d)",
-                  __func__, dev_info->channel_count);
-            goto exit;
-        } else if (candidate == 0)
-                candidate = dev_info->channel_count;
-            /*
-            * If stream channel is 4, USB supports both 3 and 5, then
-            *  higher channel 5 is picked up instead of 3
-            */
-        else if (ABS_SUB(stream_ch, dev_info->channel_count) <
-                 ABS_SUB(stream_ch, candidate)) {
-            candidate = dev_info->channel_count;
-        } else if ((ABS_SUB(stream_ch, dev_info->channel_count) ==
-                    ABS_SUB(stream_ch, candidate)) &&
-                   (dev_info->channel_count > candidate)) {
-            candidate = dev_info->channel_count;
-        }
-    }
-    ALOGV("%s: No match found, use the best candidate ch(%d)",
-          __func__, candidate);
-    *channel_count = candidate;
-exit:
-    return true;
-
-}
-
-static bool usb_sample_rate_multiple(
-                                     unsigned int stream_sample_rate,
-                                     unsigned int base)
-{
-    return (((stream_sample_rate / base) * base) == stream_sample_rate);
-}
-
-static bool usb_find_sample_rate_candidate(unsigned int base,
-                                           unsigned stream_rate,
-                                           unsigned int usb_rate,
-                                           unsigned int cur_candidate,
-                                           unsigned int *update_candidate)
-{
-    /* For sample rate, we should consider  fracational sample rate as high priority.
-    * For example, if the stream is 88.2kHz and USB device support both 44.1kH and
-    * 48kHz sample rate, we should pick 44.1kHz instead of 48kHz
-    */
-    if (!usb_sample_rate_multiple(cur_candidate, base) &&
-       usb_sample_rate_multiple(usb_rate, base)) {
-        *update_candidate = usb_rate;
-    } else if (usb_sample_rate_multiple(cur_candidate, base) &&
-               usb_sample_rate_multiple(usb_rate, base)) {
-        if (ABS_SUB(stream_rate, usb_rate) <
-            ABS_SUB(stream_rate, cur_candidate)) {
-            *update_candidate = usb_rate;
-        } else if ((ABS_SUB(stream_rate, usb_rate) ==
-                    ABS_SUB(stream_rate, cur_candidate)) &&
-                   (usb_rate > cur_candidate)) {
-            *update_candidate = usb_rate;
-        }
-    } else if (!usb_sample_rate_multiple(cur_candidate, base) &&
-               !usb_sample_rate_multiple(usb_rate, base)) {
-        if (ABS_SUB(stream_rate, usb_rate) <
-            ABS_SUB(stream_rate, cur_candidate)) {
-            *update_candidate = usb_rate;
-        } else if ((ABS_SUB(stream_rate, usb_rate) ==
-                    ABS_SUB(stream_rate, cur_candidate)) &&
-                   (usb_rate > cur_candidate)) {
-            *update_candidate = usb_rate;
-        }
-    }
-    return true;
-}
-
-static bool usb_get_best_match_for_sample_rate(
-                            struct listnode *dev_list,
-                            unsigned int bit_width,
-                            unsigned int channel_count,
-                            unsigned int stream_sample_rate,
-                            unsigned int *sr)
-{
-    struct listnode *node_i;
-    struct usb_device_config *dev_info;
-    unsigned int candidate = 48000;
-    unsigned int base = SAMPLE_RATE_8000;
-    bool multiple_8k = usb_sample_rate_multiple(stream_sample_rate, base);
-    unsigned int i;
-
-    ALOGV("%s: stm ch(%d)bw(%d)sr(%d), stream sample multiple of 8kHz(%d)",
-        __func__, channel_count, bit_width, stream_sample_rate, multiple_8k);
-
-    list_for_each(node_i, dev_list) {
-        dev_info = node_to_item(node_i, struct usb_device_config, list);
-        ALOGI_IF(usb_audio_debug_enable,
-                 "%s: USB ch(%d)bw(%d), stm ch(%d)bw(%d)sr(%d), candidate(%d)",
-                 __func__, dev_info->channel_count, dev_info->bit_width,
-                 channel_count, bit_width, stream_sample_rate, candidate);
-        if ((dev_info->bit_width != bit_width) || dev_info->channel_count != channel_count)
-            continue;
-
-        candidate = 0;
-        for (i = 0; i < dev_info->rate_size; i++) {
-            ALOGI_IF(usb_audio_debug_enable,
-                     "%s: USB ch(%d)bw(%d)sr(%d), stm ch(%d)bw(%d)sr(%d), candidate(%d)",
-                     __func__, dev_info->channel_count,
-                     dev_info->bit_width, dev_info->rates[i],
-                     channel_count, bit_width, stream_sample_rate, candidate);
-            if (stream_sample_rate == dev_info->rates[i]) {
-                *sr = dev_info->rates[i];
-                ALOGV("%s: Found match sample rate (%d)",
-                      __func__, dev_info->rates[i]);
-                goto exit;
-            } else if (candidate == 0) {
-                    candidate = dev_info->rates[i];
-                /*
-                * For sample rate, we should consider  fracational sample rate as high priority.
-                * For example, if the stream is 88.2kHz and USB device support both 44.1kH and
-                * 48kHz sample rate, we should pick 44.1kHz instead of 48kHz
-                */
-            } else if (multiple_8k) {
-                usb_find_sample_rate_candidate(SAMPLE_RATE_8000,
-                                               stream_sample_rate,
-                                               dev_info->rates[i],
-                                               candidate,
-                                               &candidate);
-            } else {
-                usb_find_sample_rate_candidate(SAMPLE_RATE_11025,
-                                               stream_sample_rate,
-                                               dev_info->rates[i],
-                                               candidate,
-                                               &candidate);
-            }
-        }
-    }
-    ALOGV("%s: No match found, use the best candidate sr(%d)",
-          __func__, candidate);
-    *sr = candidate;
-exit:
-    return true;
-}
-
-static bool usb_audio_backend_apply_policy(struct listnode *dev_list,
-                                           unsigned int *bit_width,
-                                           unsigned int *sample_rate,
-                                           unsigned int *channel_count)
-{
-    ALOGV("%s: from stream: bit-width(%d) sample_rate(%d) channels (%d)",
-           __func__, *bit_width, *sample_rate, *channel_count);
-    if (list_empty(dev_list)) {
-        *sample_rate = 48000;
-        *bit_width = 16;
-        *channel_count = 2;
-        ALOGE("%s: list is empty,fall back to default setting", __func__);
-        goto exit;
-    }
-    usb_get_best_match_for_bit_width(dev_list, *bit_width, bit_width);
-    usb_get_best_match_for_channels(dev_list,
-                                    *bit_width,
-                                    *channel_count,
-                                    channel_count);
-    usb_get_best_match_for_sample_rate(dev_list,
-                                       *bit_width,
-                                       *channel_count,
-                                       *sample_rate,
-                                       sample_rate);
-exit:
-    ALOGV("%s: Updated sample rate per profile: bit-width(%d) rate(%d) chs(%d)",
-           __func__, *bit_width, *sample_rate, *channel_count);
-    return true;
-}
-
-static int usb_get_sidetone_gain(struct usb_card_config *card_info)
-{
-    int gain = card_info->usb_sidetone_vol_min + usbmod->sidetone_gain;
-    if (gain > card_info->usb_sidetone_vol_max)
-        gain = card_info->usb_sidetone_vol_max;
-    return gain;
-}
-
-void audio_extn_usb_set_sidetone_gain(struct str_parms *parms,
-                                char *value, int len)
-{
-    int err;
-
-    err = str_parms_get_str(parms, USB_SIDETONE_GAIN_STR,
-                            value, len);
-    if (err >= 0) {
-        usb_sidetone_gain = pow(10.0, (float)(atoi(value))/10.0);
-        ALOGV("%s: sidetone gain(%s) decimal %d",
-              __func__, value, usb_sidetone_gain);
-        str_parms_del(parms, USB_SIDETONE_GAIN_STR);
-    }
-    return;
-}
-
-int audio_extn_usb_enable_sidetone(int device, bool enable)
-{
-    int ret = -ENODEV;
-    struct listnode *node_i;
-    struct usb_card_config *card_info;
-    int i;
-    ALOGV("%s: card_dev_type (0x%x), sidetone enable(%d)",
-           __func__,  device, enable);
-
-    list_for_each(node_i, &usbmod->usb_card_conf_list) {
-        card_info = node_to_item(node_i, struct usb_card_config, list);
-        ALOGV("%s: card_dev_type (0x%x), card_no(%d)",
-               __func__,  card_info->usb_device_type, card_info->usb_card);
-        if (card_info->usb_device_type == AUDIO_DEVICE_OUT_USB_DEVICE) {
-            if ((i = card_info->usb_sidetone_index[USB_SIDETONE_ENABLE_INDEX]) != -1) {
-                struct mixer_ctl *ctl = mixer_get_ctl_by_name(
-                                card_info->usb_snd_mixer,
-                                usb_sidetone_enable_str[i]);
-                if (ctl)
-                    mixer_ctl_set_value(ctl, 0, enable);
-                else
-                    break;
-
-                if ((i = card_info->usb_sidetone_index[USB_SIDETONE_VOLUME_INDEX]) != -1) {
-                    ctl = mixer_get_ctl_by_name(
-                                card_info->usb_snd_mixer,
-                                usb_sidetone_volume_str[i]);
-                    if (ctl == NULL)
-                        ALOGV("%s: sidetone gain mixer command is not found",
-                               __func__);
-                    else if (enable)
-                        mixer_ctl_set_value(ctl, 0,
-                                            usb_get_sidetone_gain(card_info));
-                }
-                ret = 0;
-                break;
-            }
-        }
-    }
-    return ret;
-}
-
-bool audio_extn_usb_is_config_supported(unsigned int *bit_width,
-                                        unsigned int *sample_rate,
-                                        unsigned int *channel_count,
-                                        bool is_playback)
-{
-    struct listnode *node_i;
-    struct usb_card_config *card_info;
-
-    ALOGV("%s: from stream: bit-width(%d) sample_rate(%d) ch(%d) is_playback(%d)",
-           __func__, *bit_width, *sample_rate, *channel_count, is_playback);
-    list_for_each(node_i, &usbmod->usb_card_conf_list) {
-        card_info = node_to_item(node_i, struct usb_card_config, list);
-        ALOGI_IF(usb_audio_debug_enable,
-                 "%s: card_dev_type (0x%x), card_no(%d)",
-                 __func__,  card_info->usb_device_type, card_info->usb_card);
-        /* Currently only apply the first playback sound card configuration */
-        if ((is_playback && card_info->usb_device_type == AUDIO_DEVICE_OUT_USB_DEVICE) ||
-            ((!is_playback) && card_info->usb_device_type == AUDIO_DEVICE_IN_USB_DEVICE)){
-            usb_audio_backend_apply_policy(&card_info->usb_device_conf_list,
-                                           bit_width,
-                                           sample_rate,
-                                           channel_count);
-            break;
-        }
-    }
-    ALOGV("%s: updated: bit-width(%d) sample_rate(%d) channels (%d)",
-           __func__, *bit_width, *sample_rate, *channel_count);
-
-    return true;
-}
-
-bool audio_extn_usb_is_capture_supported()
-{
-    if (usbmod == NULL) {
-        ALOGE("%s: USB device object is NULL", __func__);
-        return false;
-    }
-    ALOGV("%s: capture_supported %d",__func__,usbmod->is_capture_supported);
-    return usbmod->is_capture_supported;
-}
-
-void audio_extn_usb_add_device(audio_devices_t device, int card)
-{
-    struct usb_card_config *usb_card_info;
-    char check_debug_enable[PROPERTY_VALUE_MAX];
-    struct listnode *node_i;
-
-    property_get("audio.usb.enable.debug", check_debug_enable, NULL);
-    if (atoi(check_debug_enable)) {
-        usb_audio_debug_enable = true;
-    }
-
-    ALOGI_IF(usb_audio_debug_enable,
-             "%s: parameters device(0x%x), card(%d)",
-             __func__, device, card);
-    if (usbmod == NULL) {
-        ALOGE("%s: USB device object is NULL", __func__);
-        goto exit;
-    }
-
-    if (!(usb_valid_device(device)) || (card < 0)) {
-        ALOGE("%s:device(0x%x), card(%d)",
-              __func__, device, card);
-        goto exit;
-    }
-
-    list_for_each(node_i, &usbmod->usb_card_conf_list) {
-        usb_card_info = node_to_item(node_i, struct usb_card_config, list);
-        ALOGI_IF(usb_audio_debug_enable,
-                 "%s: list has capability for card_dev_type (0x%x), card_no(%d)",
-                 __func__,  usb_card_info->usb_device_type, usb_card_info->usb_card);
-        /* If we have cached the capability */
-        if ((usb_card_info->usb_device_type == device) && (usb_card_info->usb_card == card)) {
-            ALOGV("%s: capability for device(0x%x), card(%d) is cached, no need to update",
-                  __func__, device, card);
-            goto exit;
-        }
-    }
-    usb_card_info = calloc(1, sizeof(struct usb_card_config));
-    if (usb_card_info == NULL) {
-        ALOGE("%s: error unable to allocate memory",
-              __func__);
-        goto exit;
-    }
-    list_init(&usb_card_info->usb_device_conf_list);
-    if (device & AUDIO_DEVICE_OUT_USB_DEVICE) {
-        if (!usb_get_device_playback_config(usb_card_info, card)){
-            usb_card_info->usb_card = card;
-            usb_card_info->usb_device_type = AUDIO_DEVICE_OUT_USB_DEVICE;
-            usb_get_sidetone_mixer(usb_card_info);
-            list_add_tail(&usbmod->usb_card_conf_list, &usb_card_info->list);
-            goto exit;
-        }
-    } else if (device & AUDIO_DEVICE_IN_USB_DEVICE) {
-        if (!usb_get_device_capture_config(usb_card_info, card)) {
-            usb_card_info->usb_card = card;
-            usb_card_info->usb_device_type = AUDIO_DEVICE_IN_USB_DEVICE;
-            usbmod->is_capture_supported = true;
-            list_add_tail(&usbmod->usb_card_conf_list, &usb_card_info->list);
-            goto exit;
-        }
-    }
-    /* free memory in error case */
-    if (usb_card_info != NULL)
-        free(usb_card_info);
-exit:
-    if (usb_audio_debug_enable)
-        usb_print_active_device();
-    return;
-}
-
-void audio_extn_usb_remove_device(audio_devices_t device, int card)
-{
-    struct listnode *node_i, *temp_i;
-    struct listnode *node_j, *temp_j;
-    struct usb_device_config *dev_info;
-    struct usb_card_config *card_info;
-    unsigned int i;
-
-    ALOGV("%s: device(0x%x), card(%d)",
-           __func__, device, card);
-
-    if (usbmod == NULL) {
-        ALOGE("%s: USB device object is NULL", __func__);
-        goto exit;
-    }
-
-    if (!(usb_valid_device(device)) || (card < 0)) {
-        ALOGE("%s: Invalid parameters device(0x%x), card(%d)",
-              __func__, device, card);
-        goto exit;
-    }
-    list_for_each_safe(node_i, temp_i, &usbmod->usb_card_conf_list) {
-        card_info = node_to_item(node_i, struct usb_card_config, list);
-        ALOGV("%s: card_dev_type (0x%x), card_no(%d)",
-               __func__,  card_info->usb_device_type, card_info->usb_card);
-        if ((device == card_info->usb_device_type) && (card == card_info->usb_card)){
-            list_for_each_safe(node_j, temp_j, &card_info->usb_device_conf_list) {
-                dev_info = node_to_item(node_j, struct usb_device_config, list);
-                ALOGV("%s: bit-width(%d) channel(%d)",
-                       __func__, dev_info->bit_width, dev_info->channel_count);
-                for (i =  0; i < dev_info->rate_size; i++)
-                    ALOGV("%s: rate %d", __func__, dev_info->rates[i]);
-
-                list_remove(node_j);
-                free(node_to_item(node_j, struct usb_device_config, list));
-            }
-            list_remove(node_i);
-            free(node_to_item(node_i, struct usb_card_config, list));
-        }
-    }
-    usbmod->is_capture_supported = false;
-exit:
-    if (usb_audio_debug_enable)
-        usb_print_active_device();
-
-    return;
-}
-
-void audio_extn_usb_init(void *adev)
-{
-    if (usbmod == NULL) {
-        usbmod = calloc(1, sizeof(struct usb_module));
-        if (usbmod == NULL) {
-            ALOGE("%s: error unable to allocate memory", __func__);
-            goto exit;
-        }
-    } else {
-        memset(usbmod, 0, sizeof(*usbmod));
-    }
-
-    list_init(&usbmod->usb_card_conf_list);
-    usbmod->adev = (struct audio_device*)adev;
-    usbmod->sidetone_gain = usb_sidetone_gain;
-    usbmod->is_capture_supported = false;
-exit:
-    return;
-}
-
-void audio_extn_usb_deinit(void)
-{
-    if (NULL != usbmod){
-        free(usbmod);
-        usbmod = NULL;
-    }
-}
-#endif /*USB_HEADSET_ENABLED end*/
diff --git a/hal/audio_hw.c b/hal/audio_hw.c
index 4af1e9c..b90fda0 100644
--- a/hal/audio_hw.c
+++ b/hal/audio_hw.c
@@ -44,6 +44,7 @@
 #include <hardware/audio_effect.h>
 #include <hardware/audio_alsaops.h>
 #include <system/thread_defs.h>
+#include <tinyalsa/asoundlib.h>
 #include <audio_effects/effect_aec.h>
 #include <audio_effects/effect_ns.h>
 #include "audio_hw.h"
@@ -85,7 +86,9 @@
 
 
 #define MMAP_PERIOD_SIZE (DEFAULT_OUTPUT_SAMPLING_RATE/1000)
-#define MMAP_PERIOD_COUNT 512
+#define MMAP_PERIOD_COUNT_MIN 32
+#define MMAP_PERIOD_COUNT_MAX 512
+#define MMAP_PERIOD_COUNT_DEFAULT (MMAP_PERIOD_COUNT_MAX)
 
 
 /* This constant enables extended precision handling.
@@ -144,7 +147,7 @@
     .channels = DEFAULT_CHANNEL_COUNT,
     .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
     .period_size = MMAP_PERIOD_SIZE,
-    .period_count = MMAP_PERIOD_COUNT,
+    .period_count = MMAP_PERIOD_COUNT_DEFAULT,
     .format = PCM_FORMAT_S16_LE,
     .start_threshold = MMAP_PERIOD_SIZE*8,
     .stop_threshold = INT32_MAX,
@@ -178,7 +181,7 @@
     .channels = DEFAULT_CHANNEL_COUNT,
     .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
     .period_size = MMAP_PERIOD_SIZE,
-    .period_count = MMAP_PERIOD_COUNT,
+    .period_count = MMAP_PERIOD_COUNT_DEFAULT,
     .format = PCM_FORMAT_S16_LE,
     .start_threshold = 0,
     .stop_threshold = INT_MAX,
@@ -855,8 +858,6 @@
     bool switch_device[AUDIO_USECASE_MAX];
     int i, num_uc_to_switch = 0;
 
-    platform_check_and_set_playback_backend_cfg(adev, uc_info, snd_device);
-
     /*
      * 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
@@ -1201,8 +1202,7 @@
 
     /* Enable new sound devices */
     if (out_snd_device != SND_DEVICE_NONE) {
-        if ((usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) ||
-            (usecase->devices & AUDIO_DEVICE_OUT_USB_DEVICE))
+        if (usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND)
             check_and_route_playback_usecases(adev, usecase, out_snd_device);
         enable_snd_device(adev, out_snd_device);
     }
@@ -1313,14 +1313,10 @@
     select_devices(adev, in->usecase);
 
     if (in->usecase == USECASE_AUDIO_RECORD_MMAP) {
-        if (!pcm_is_ready(in->pcm)) {
+        if (in->pcm == NULL || !pcm_is_ready(in->pcm)) {
             ALOGE("%s: pcm stream not ready", __func__);
             goto error_open;
         }
-        ret = pcm_prepare(in->pcm);
-        if (ret < 0) {
-            ALOGE("%s: MMAP pcm_prepare failed ret %d", __func__, ret);
-            goto error_open;        }
         ret = pcm_start(in->pcm);
         if (ret < 0) {
             ALOGE("%s: MMAP pcm_start failed ret %d", __func__, ret);
@@ -1738,14 +1734,10 @@
         if (adev->offload_effects_start_output != NULL)
             adev->offload_effects_start_output(out->handle, out->pcm_device_id);
     } else if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
-        if (!pcm_is_ready(out->pcm)) {
+        if (out->pcm == NULL || !pcm_is_ready(out->pcm)) {
             ALOGE("%s: pcm stream not ready", __func__);
             goto error_open;
         }
-        ret = pcm_prepare(out->pcm);
-        if (ret < 0) {
-            ALOGE("%s: MMAP pcm_prepare failed ret %d", __func__, ret);
-            goto error_open;        }
         ret = pcm_start(out->pcm);
         if (ret < 0) {
             ALOGE("%s: MMAP pcm_start failed ret %d", __func__, ret);
@@ -1921,6 +1913,7 @@
 {
     struct stream_out *out = (struct stream_out *)stream;
     struct audio_device *adev = out->dev;
+    bool do_stop = true;
 
     ALOGV("%s: enter: usecase(%d: %s)", __func__,
           out->usecase, use_case_table[out->usecase]);
@@ -1937,6 +1930,7 @@
                 out->pcm = NULL;
             }
             if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
+                do_stop = out->playback_started;
                 out->playback_started = false;
             }
         } else {
@@ -1948,7 +1942,9 @@
                 out->compr = NULL;
             }
         }
-        stop_output_stream(out);
+        if (do_stop) {
+            stop_output_stream(out);
+        }
         pthread_mutex_unlock(&adev->lock);
     }
     pthread_mutex_unlock(&out->lock);
@@ -2575,9 +2571,7 @@
             out->playback_started && out->pcm != NULL) {
         pcm_stop(out->pcm);
         ret = stop_output_stream(out);
-        if (ret == 0) {
-            out->playback_started = false;
-        }
+        out->playback_started = false;
     }
     pthread_mutex_unlock(&adev->lock);
     return ret;
@@ -2602,6 +2596,26 @@
     return ret;
 }
 
+/*
+ * Modify config->period_count based on min_size_frames
+ */
+static void adjust_mmap_period_count(struct pcm_config *config, int32_t min_size_frames)
+{
+    int periodCountRequested = (min_size_frames + config->period_size - 1)
+                               / config->period_size;
+    int periodCount = MMAP_PERIOD_COUNT_MIN;
+
+    ALOGV("%s original config.period_size = %d config.period_count = %d",
+          __func__, config->period_size, config->period_count);
+
+    while (periodCount < periodCountRequested && (periodCount * 2) < MMAP_PERIOD_COUNT_MAX) {
+        periodCount *= 2;
+    }
+    config->period_count = periodCount;
+
+    ALOGV("%s requested config.period_count = %d", __func__, config->period_count);
+}
+
 static int out_create_mmap_buffer(const struct audio_stream_out *stream,
                                   int32_t min_size_frames,
                                   struct audio_mmap_buffer_info *info)
@@ -2617,10 +2631,12 @@
     pthread_mutex_lock(&adev->lock);
 
     if (info == NULL || min_size_frames == 0) {
+        ALOGE("%s: info = %p, min_size_frames = %d", __func__, info, min_size_frames);
         ret = -EINVAL;
         goto exit;
     }
     if (out->usecase != USECASE_AUDIO_PLAYBACK_MMAP || !out->standby) {
+        ALOGE("%s: usecase = %d, standby = %d", __func__, out->usecase, out->standby);
         ret = -ENOSYS;
         goto exit;
     }
@@ -2631,6 +2647,9 @@
         ret = -EINVAL;
         goto exit;
     }
+
+    adjust_mmap_period_count(&out->config, min_size_frames);
+
     ALOGV("%s: Opening PCM device card_id(%d) device_id(%d), channels %d",
           __func__, adev->snd_card, out->pcm_device_id, out->config.channels);
     out->pcm = pcm_open(adev->snd_card, out->pcm_device_id,
@@ -2657,6 +2676,8 @@
         step = "commit";
         goto exit;
     }
+
+    out->standby = false;
     ret = 0;
 
     ALOGV("%s: got mmap buffer address %p info->buffer_size_frames %d",
@@ -2664,8 +2685,10 @@
 
 exit:
     if (ret != 0) {
-        ALOGE("%s: %s %s", __func__, step, pcm_get_error(out->pcm));
-        if (out->pcm != NULL) {
+        if (out->pcm == NULL) {
+            ALOGE("%s: %s - %d", __func__, step, ret);
+        } else {
+            ALOGE("%s: %s %s", __func__, step, pcm_get_error(out->pcm));
             pcm_close(out->pcm);
             out->pcm = NULL;
         }
@@ -2744,6 +2767,8 @@
     struct stream_in *in = (struct stream_in *)stream;
     struct audio_device *adev = in->dev;
     int status = 0;
+    bool do_stop = true;
+
     ALOGV("%s: enter", __func__);
 
     lock_input_stream(in);
@@ -2761,6 +2786,7 @@
         pthread_mutex_lock(&adev->lock);
         in->standby = true;
         if (in->usecase == USECASE_AUDIO_RECORD_MMAP) {
+            do_stop = in->capture_started;
             in->capture_started = false;
         }
         if (in->pcm) {
@@ -2769,7 +2795,9 @@
         }
         adev->enable_voicerx = false;
         platform_set_echo_reference(adev, false, AUDIO_DEVICE_NONE );
-        status = stop_input_stream(in);
+        if (do_stop) {
+            status = stop_input_stream(in);
+        }
         pthread_mutex_unlock(&adev->lock);
     }
     pthread_mutex_unlock(&in->lock);
@@ -3074,9 +3102,7 @@
             in->capture_started && in->pcm != NULL) {
         pcm_stop(in->pcm);
         ret = stop_input_stream(in);
-        if (ret == 0) {
-            in->capture_started = false;
-        }
+        in->capture_started = false;
     }
     pthread_mutex_unlock(&adev->lock);
     return ret;
@@ -3116,12 +3142,14 @@
 
     pthread_mutex_lock(&adev->lock);
     ALOGV("%s in %p", __func__, in);
+
     if (info == NULL || min_size_frames == 0) {
-        ALOGV("%s invalid argument info %p min_size_frames %d", __func__, info, min_size_frames);
+        ALOGE("%s invalid argument info %p min_size_frames %d", __func__, info, min_size_frames);
         ret = -EINVAL;
         goto exit;
     }
     if (in->usecase != USECASE_AUDIO_RECORD_MMAP || !in->standby) {
+        ALOGE("%s: usecase = %d, standby = %d", __func__, in->usecase, in->standby);
         ALOGV("%s in %p", __func__, in);
         ret = -ENOSYS;
         goto exit;
@@ -3133,6 +3161,9 @@
         ret = -EINVAL;
         goto exit;
     }
+
+    adjust_mmap_period_count(&in->config, min_size_frames);
+
     ALOGV("%s: Opening PCM device card_id(%d) device_id(%d), channels %d",
           __func__, adev->snd_card, in->pcm_device_id, in->config.channels);
     in->pcm = pcm_open(adev->snd_card, in->pcm_device_id,
@@ -3161,14 +3192,18 @@
         goto exit;
     }
 
+    in->standby = false;
+    ret = 0;
+
     ALOGV("%s: got mmap buffer address %p info->buffer_size_frames %d",
           __func__, info->shared_memory_address, info->buffer_size_frames);
-    ret = 0;
 
 exit:
     if (ret != 0) {
-        ALOGE("%s: %s %s", __func__, step, pcm_get_error(in->pcm));
-        if (in->pcm != NULL) {
+        if (in->pcm == NULL) {
+            ALOGE("%s: %s - %d", __func__, step, ret);
+        } else {
+            ALOGE("%s: %s %s", __func__, step, pcm_get_error(in->pcm));
             pcm_close(in->pcm);
             in->pcm = NULL;
         }
@@ -3558,43 +3593,6 @@
         adev->bt_wb_speech_enabled = !strcmp(value, AUDIO_PARAMETER_VALUE_ON);
     }
 
-    ret = str_parms_get_str(parms, AUDIO_PARAMETER_DEVICE_CONNECT, value, sizeof(value));
-    if (ret >= 0) {
-        audio_devices_t device = (audio_devices_t)strtoul(value, NULL, 10);
-        if (device == AUDIO_DEVICE_OUT_USB_DEVICE) {
-            ret = str_parms_get_str(parms, "card", value, sizeof(value));
-            if (ret >= 0) {
-                const int card = atoi(value);
-                audio_extn_usb_add_device(AUDIO_DEVICE_OUT_USB_DEVICE, card);
-            }
-        } else if (device == AUDIO_DEVICE_IN_USB_DEVICE) {
-            ret = str_parms_get_str(parms, "card", value, sizeof(value));
-            if (ret >= 0) {
-                const int card = atoi(value);
-                audio_extn_usb_add_device(AUDIO_DEVICE_IN_USB_DEVICE, card);
-            }
-        }
-    }
-
-    ret = str_parms_get_str(parms, AUDIO_PARAMETER_DEVICE_DISCONNECT, value, sizeof(value));
-    if (ret >= 0) {
-        audio_devices_t device = (audio_devices_t)strtoul(value, NULL, 10);
-        if (device == AUDIO_DEVICE_OUT_USB_DEVICE) {
-            ret = str_parms_get_str(parms, "card", value, sizeof(value));
-            if (ret >= 0) {
-                const int card = atoi(value);
-
-                audio_extn_usb_remove_device(AUDIO_DEVICE_OUT_USB_DEVICE, card);
-            }
-        } else if (device == AUDIO_DEVICE_IN_USB_DEVICE) {
-            ret = str_parms_get_str(parms, "card", value, sizeof(value));
-            if (ret >= 0) {
-                const int card = atoi(value);
-                audio_extn_usb_remove_device(AUDIO_DEVICE_IN_USB_DEVICE, card);
-            }
-        }
-    }
-
     audio_extn_hfp_set_parameters(adev, parms);
 done:
     str_parms_destroy(parms);
diff --git a/hal/audio_hw.h b/hal/audio_hw.h
index 35b4bdd..b0a6282 100644
--- a/hal/audio_hw.h
+++ b/hal/audio_hw.h
@@ -49,8 +49,6 @@
 #define ACDB_DEV_TYPE_IN 2
 
 #define MAX_SUPPORTED_CHANNEL_MASKS 2
-#define MAX_SUPPORTED_FORMATS 15
-#define MAX_SUPPORTED_SAMPLE_RATES 7
 #define DEFAULT_HDMI_OUT_CHANNELS   2
 
 #define ERROR_LOG_ENTRIES 16
diff --git a/hal/msm8916/platform.c b/hal/msm8916/platform.c
index 65600ee..f7953cc 100644
--- a/hal/msm8916/platform.c
+++ b/hal/msm8916/platform.c
@@ -1093,13 +1093,6 @@
     return 0;
 }
 
-bool platform_check_and_set_playback_backend_cfg(struct audio_device* adev __unused,
-                                              struct audio_usecase *usecase __unused,
-                                              snd_device_t snd_device __unused)
-{
-    return false;
-}
-
 bool platform_check_and_set_capture_backend_cfg(struct audio_device* adev __unused,
                                               struct audio_usecase *usecase __unused,
                                               snd_device_t snd_device __unused)
diff --git a/hal/msm8960/platform.c b/hal/msm8960/platform.c
index 072a1e4..eafb64a 100644
--- a/hal/msm8960/platform.c
+++ b/hal/msm8960/platform.c
@@ -1104,13 +1104,6 @@
     return 0;
 }
 
-bool platform_check_and_set_playback_backend_cfg(struct audio_device* adev __unused,
-                                              struct audio_usecase *usecase __unused,
-                                              snd_device_t snd_device __unused)
-{
-    return false;
-}
-
 bool platform_check_and_set_capture_backend_cfg(struct audio_device* adev __unused,
                                               struct audio_usecase *usecase __unused)
 {
diff --git a/hal/msm8974/platform.c b/hal/msm8974/platform.c
index 3308940..b0e87be 100644
--- a/hal/msm8974/platform.c
+++ b/hal/msm8974/platform.c
@@ -28,8 +28,8 @@
 #include "audio_extn.h"
 #include <linux/msm_audio.h>
 
-#define MIXER_XML_DEFAULT_PATH "/system/etc/mixer_paths.xml"
-#define MIXER_XML_BASE_STRING "/system/etc/mixer_paths"
+#define MIXER_XML_DEFAULT_PATH "mixer_paths.xml"
+#define MIXER_XML_BASE_STRING "mixer_paths"
 #define TOMTOM_8226_SND_CARD_NAME "msm8226-tomtom-snd-card"
 #define TOMTOM_MIXER_FILE_SUFFIX "wcd9330"
 
@@ -138,7 +138,6 @@
     struct csd_data *csd;
     char ec_ref_mixer_path[64];
 
-    codec_backend_cfg_t current_backend_cfg[MAX_CODEC_BACKENDS];
     char *snd_card_name;
     int max_vol_index;
     int max_mic_count;
@@ -228,9 +227,6 @@
     [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_VOICE_TX] = "voice-tx",
-    [SND_DEVICE_OUT_USB_HEADSET] = "usb-headset",
-    [SND_DEVICE_OUT_USB_HEADPHONES] = "usb-headphones",
-    [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = "speaker-and-usb-headphones",
     [SND_DEVICE_OUT_SPEAKER_PROTECTED] = "speaker-protected",
     [SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED] = "voice-speaker-protected",
     [SND_DEVICE_OUT_VOICE_SPEAKER_HFP] = "voice-speaker-hfp",
@@ -282,7 +278,6 @@
     [SND_DEVICE_IN_VOICE_REC_MIC_AEC_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_VOICE_REC_HEADSET_MIC] = "headset-mic",
 
     [SND_DEVICE_IN_UNPROCESSED_MIC] = "unprocessed-mic",
@@ -329,9 +324,6 @@
     [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = 17,
     [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = 37,
     [SND_DEVICE_OUT_VOICE_TX] = 45,
-    [SND_DEVICE_OUT_USB_HEADSET] = 45,
-    [SND_DEVICE_OUT_USB_HEADPHONES] = 45,
-    [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = 14,
     [SND_DEVICE_OUT_SPEAKER_PROTECTED] = 124,
     [SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED] = 101,
     [SND_DEVICE_OUT_VOICE_SPEAKER_HFP] = ACDB_ID_VOICE_SPEAKER,
@@ -391,7 +383,7 @@
     [SND_DEVICE_IN_UNPROCESSED_QUAD_MIC] = 125,
 
     [SND_DEVICE_IN_VOICE_RX] = 44,
-    [SND_DEVICE_IN_USB_HEADSET_MIC] = 44,
+
     [SND_DEVICE_IN_THREE_MIC] = 46,
     [SND_DEVICE_IN_QUAD_MIC] = 46,
     [SND_DEVICE_IN_CAPTURE_VI_FEEDBACK] = 102,
@@ -401,9 +393,6 @@
     [SND_DEVICE_IN_HANDSET_QMIC_AEC] = 125, /* override this for new target to 140 */
 };
 
-// Platform specific backend bit width table
-static int backend_bit_width_table[SND_DEVICE_MAX] = {0};
-
 struct name_to_index {
     char name[100];
     unsigned int index;
@@ -438,9 +427,6 @@
     {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES)},
     {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES)},
     {TO_NAME_INDEX(SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET)},
-    {TO_NAME_INDEX(SND_DEVICE_OUT_USB_HEADSET)},
-    {TO_NAME_INDEX(SND_DEVICE_OUT_USB_HEADPHONES)},
-    {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET)},
 
     /* in */
     {TO_NAME_INDEX(SND_DEVICE_OUT_SPEAKER_PROTECTED)},
@@ -492,7 +478,6 @@
     {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_DMIC_STEREO)},
     {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE)},
     {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_HEADSET_MIC)},
-    {TO_NAME_INDEX(SND_DEVICE_IN_USB_HEADSET_MIC)},
 
     {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_MIC)},
     {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_HEADSET_MIC)},
@@ -918,10 +903,6 @@
         operator_specific_device_table[dev] = NULL;
     }
 
-    for (dev = 0; dev < SND_DEVICE_MAX; dev++) {
-        backend_bit_width_table[dev] = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
-    }
-
     // To overwrite these go to the audio_platform_info.xml file.
     backend_tag_table[SND_DEVICE_IN_BT_SCO_MIC] = strdup("bt-sco");
     backend_tag_table[SND_DEVICE_IN_BT_SCO_MIC_NREC] = strdup("bt-sco");
@@ -934,11 +915,6 @@
     backend_tag_table[SND_DEVICE_OUT_VOICE_TX] = strdup("afe-proxy");
     backend_tag_table[SND_DEVICE_IN_VOICE_RX] = strdup("afe-proxy");
 
-    backend_tag_table[SND_DEVICE_OUT_USB_HEADSET] = strdup("usb-headset");
-    backend_tag_table[SND_DEVICE_OUT_USB_HEADPHONES] = strdup("usb-headphones");
-    backend_tag_table[SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] =
-        strdup("speaker-and-usb-headphones");
-    backend_tag_table[SND_DEVICE_IN_USB_HEADSET_MIC] = strdup("usb-headset-mic");
     hw_interface_table[SND_DEVICE_OUT_HANDSET] = strdup("SLIMBUS_0_RX");
     hw_interface_table[SND_DEVICE_OUT_SPEAKER] = strdup("SLIMBUS_0_RX");
     hw_interface_table[SND_DEVICE_OUT_SPEAKER_REVERSE] = strdup("SLIMBUS_0_RX");
@@ -962,9 +938,6 @@
     hw_interface_table[SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = strdup("SLIMBUS_0_RX");
     hw_interface_table[SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = strdup("SLIMBUS_0_RX");
     hw_interface_table[SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = strdup("SLIMBUS_0_RX");
-    hw_interface_table[SND_DEVICE_OUT_USB_HEADSET] = strdup("USB_AUDIO_RX");
-    hw_interface_table[SND_DEVICE_OUT_USB_HEADPHONES] = strdup("USB_AUDIO_RX");
-    hw_interface_table[SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = strdup("SLIMBUS_0_RX-and-USB_AUDIO_RX");
     hw_interface_table[SND_DEVICE_OUT_VOICE_TX] = strdup("AFE_PCM_RX");
     hw_interface_table[SND_DEVICE_OUT_SPEAKER_PROTECTED] = strdup("SLIMBUS_0_RX");
     hw_interface_table[SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED] = strdup("SLIMBUS_0_RX");
@@ -1032,55 +1005,26 @@
     return 0;
 }
 
-static void
-platform_backend_config_init(struct platform_data *pdata)
-{
-    int i;
+// Treblized config files will be located in /odm/etc or /vendor/etc.
+static const char *kConfigLocationList[] =
+        {"/odm/etc", "/vendor/etc", "/system/etc"};
+static const int kConfigLocationListSize =
+        (sizeof(kConfigLocationList) / sizeof(kConfigLocationList[0]));
 
-    /* initialize backend config */
-    for (i = 0; i < MAX_CODEC_BACKENDS; i++) {
-        pdata->current_backend_cfg[i].sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
-        pdata->current_backend_cfg[i].bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
-        pdata->current_backend_cfg[i].channels = CODEC_BACKEND_DEFAULT_CHANNELS;
-
-        if (i > MAX_RX_CODEC_BACKENDS)
-            pdata->current_backend_cfg[i].channels = CODEC_BACKEND_DEFAULT_TX_CHANNELS;
-
-        pdata->current_backend_cfg[i].bitwidth_mixer_ctl = NULL;
-        pdata->current_backend_cfg[i].samplerate_mixer_ctl = NULL;
-        pdata->current_backend_cfg[i].channels_mixer_ctl = NULL;
+bool resolveConfigFile(char file_name[MIXER_PATH_MAX_LENGTH]) {
+    char full_config_path[MIXER_PATH_MAX_LENGTH];
+    for (int i = 0; i < kConfigLocationListSize; i++) {
+        snprintf(full_config_path,
+                 MIXER_PATH_MAX_LENGTH,
+                 "%s/%s",
+                 kConfigLocationList[i],
+                 file_name);
+        if (F_OK == access(full_config_path, 0)) {
+            strcpy(file_name, full_config_path);
+            return true;
+        }
     }
-
-    pdata->current_backend_cfg[DEFAULT_CODEC_BACKEND].bitwidth_mixer_ctl =
-            strdup("SLIM_0_RX Format");
-    pdata->current_backend_cfg[DEFAULT_CODEC_BACKEND].samplerate_mixer_ctl =
-            strdup("SLIM_0_RX SampleRate");
-
-    pdata->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].bitwidth_mixer_ctl =
-            strdup("SLIM_0_TX Format");
-    pdata->current_backend_cfg[DEFAULT_CODEC_TX_BACKEND].samplerate_mixer_ctl =
-            strdup("SLIM_0_TX SampleRate");
-
-    pdata->current_backend_cfg[USB_AUDIO_TX_BACKEND].bitwidth_mixer_ctl =
-            strdup("USB_AUDIO_TX Format");
-    pdata->current_backend_cfg[USB_AUDIO_TX_BACKEND].samplerate_mixer_ctl =
-            strdup("USB_AUDIO_TX SampleRate");
-    pdata->current_backend_cfg[USB_AUDIO_TX_BACKEND].channels_mixer_ctl =
-            strdup("USB_AUDIO_TX Channels");
-
-    pdata->current_backend_cfg[HEADPHONE_BACKEND].bitwidth_mixer_ctl =
-            strdup("SLIM_6_RX Format");
-    pdata->current_backend_cfg[HEADPHONE_BACKEND].samplerate_mixer_ctl =
-            strdup("SLIM_6_RX SampleRate");
-
-    pdata->current_backend_cfg[USB_AUDIO_RX_BACKEND].bitwidth_mixer_ctl =
-            strdup("USB_AUDIO_RX Format");
-    pdata->current_backend_cfg[USB_AUDIO_RX_BACKEND].samplerate_mixer_ctl =
-            strdup("USB_AUDIO_RX SampleRate");
-
-    pdata->current_backend_cfg[USB_AUDIO_RX_BACKEND].channels = 1;
-    pdata->current_backend_cfg[USB_AUDIO_RX_BACKEND].channels_mixer_ctl =
-            strdup("USB_AUDIO_RX Channels");
+    return false;
 }
 
 void *platform_init(struct audio_device *adev)
@@ -1166,15 +1110,15 @@
             snprintf(mixer_xml_file, sizeof(mixer_xml_file), "%s_%s_%s.xml",
                              MIXER_XML_BASE_STRING, snd_split_handle->snd_card,
                              snd_split_handle->form_factor);
-
-            if (F_OK != access(mixer_xml_file, 0)) {
+            if (!resolveConfigFile(mixer_xml_file)) {
                 memset(mixer_xml_file, 0, sizeof(mixer_xml_file));
                 snprintf(mixer_xml_file, sizeof(mixer_xml_file), "%s_%s.xml",
                              MIXER_XML_BASE_STRING, snd_split_handle->snd_card);
 
-                if (F_OK != access(mixer_xml_file, 0)) {
+                if (!resolveConfigFile(mixer_xml_file)) {
                     memset(mixer_xml_file, 0, sizeof(mixer_xml_file));
                     strlcpy(mixer_xml_file, MIXER_XML_DEFAULT_PATH, MIXER_PATH_MAX_LENGTH);
+                    resolveConfigFile(mixer_xml_file);
                 }
             }
 
@@ -1182,14 +1126,15 @@
                              PLATFORM_INFO_XML_BASE_STRING, snd_split_handle->snd_card,
                              snd_split_handle->form_factor);
 
-            if (F_OK != access(platform_info_file, 0)) {
+            if (!resolveConfigFile(platform_info_file)) {
                 memset(platform_info_file, 0, sizeof(platform_info_file));
                 snprintf(platform_info_file, sizeof(platform_info_file), "%s_%s.xml",
                              PLATFORM_INFO_XML_BASE_STRING, snd_split_handle->snd_card);
 
-                if (F_OK != access(platform_info_file, 0)) {
+                if (!resolveConfigFile(platform_info_file)) {
                     memset(platform_info_file, 0, sizeof(platform_info_file));
                     strlcpy(platform_info_file, PLATFORM_INFO_XML_PATH, MIXER_PATH_MAX_LENGTH);
+                    resolveConfigFile(platform_info_file);
                 }
             }
         }
@@ -1381,9 +1326,6 @@
         platform_acdb_init(my_data);
     }
 
-    /* init usb */
-    audio_extn_usb_init(adev);
-
     audio_extn_spkr_prot_init(adev);
 
     audio_extn_hwdep_cal_send(adev->snd_card, my_data->acdb_handle);
@@ -1391,8 +1333,6 @@
     /* load csd client */
     platform_csd_init(my_data);
 
-    platform_backend_config_init(my_data);
-
     return my_data;
 
 init_failed:
@@ -1444,9 +1384,6 @@
     }
 
     free(platform);
-
-    /* deinit usb */
-    audio_extn_usb_deinit();
 }
 
 const char *platform_get_snd_device_name(snd_device_t snd_device)
@@ -1647,38 +1584,6 @@
         return acdb_device_table[snd_device];
 }
 
-static int platform_get_backend_index(snd_device_t snd_device)
-{
-    int32_t port = DEFAULT_CODEC_BACKEND;
-
-    if (snd_device >= SND_DEVICE_OUT_BEGIN && snd_device < SND_DEVICE_OUT_END) {
-        if (backend_tag_table[snd_device] != NULL) {
-                if (strncmp(backend_tag_table[snd_device], "headphones",
-                            sizeof("headphones")) == 0)
-                        port = HEADPHONE_BACKEND;
-                else if (strcmp(backend_tag_table[snd_device], "hdmi") == 0)
-                        port = HDMI_RX_BACKEND;
-                else if ((strcmp(backend_tag_table[snd_device], "usb-headphones") == 0) ||
-                           (strcmp(backend_tag_table[snd_device], "usb-headset") == 0))
-                        port = USB_AUDIO_RX_BACKEND;
-        }
-    } else if (snd_device >= SND_DEVICE_IN_BEGIN && snd_device < SND_DEVICE_IN_END) {
-        port = DEFAULT_CODEC_TX_BACKEND;
-        if (backend_tag_table[snd_device] != NULL) {
-                if (strcmp(backend_tag_table[snd_device], "usb-headset-mic") == 0)
-                        port = USB_AUDIO_TX_BACKEND;
-                else if (strstr(backend_tag_table[snd_device], "bt-sco") != NULL)
-                        port = BT_SCO_TX_BACKEND;
-        }
-    } else {
-        ALOGW("%s:napb: Invalid device - %d ", __func__, snd_device);
-    }
-
-    ALOGV("%s:napb: backend port - %d device - %d ", __func__, port, snd_device);
-
-    return port;
-}
-
 int platform_send_audio_calibration(void *platform, snd_device_t snd_device)
 {
     struct platform_data *my_data = (struct platform_data *)platform;
@@ -2042,12 +1947,6 @@
         new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER_SAFE;
         new_snd_devices[1] = SND_DEVICE_OUT_LINE;
         ret = 0;
-    } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET &&
-               !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_USB_HEADSET)) {
-        *num_devices = 2;
-        new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
-        new_snd_devices[1] = SND_DEVICE_OUT_USB_HEADSET;
-        ret = 0;
     }
     return ret;
 }
@@ -2086,9 +1985,6 @@
         } 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_USB_DEVICE |
-                               AUDIO_DEVICE_OUT_SPEAKER)) {
-            snd_device = SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET;
         } else {
             ALOGE("%s: Invalid combo device(%#x)", __func__, devices);
             goto exit;
@@ -2169,12 +2065,7 @@
         }
     } else if (devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
         snd_device = SND_DEVICE_OUT_HDMI ;
-    } else if (devices & AUDIO_DEVICE_OUT_USB_DEVICE) {
-        if (audio_extn_usb_is_capture_supported())
-            snd_device = SND_DEVICE_OUT_USB_HEADSET;
-        else
-            snd_device = SND_DEVICE_OUT_USB_HEADPHONES;
-    }else if (devices & AUDIO_DEVICE_OUT_EARPIECE) {
+    } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) {
         /*HAC support for voice-ish audio (eg visual voicemail)*/
         if(adev->voice.hac)
             snd_device = SND_DEVICE_OUT_VOICE_HAC_HANDSET;
@@ -2473,8 +2364,6 @@
             }
         } else if (in_device & AUDIO_DEVICE_IN_AUX_DIGITAL) {
             snd_device = SND_DEVICE_IN_HDMI_MIC;
-        } else if (in_device & AUDIO_DEVICE_IN_USB_DEVICE ) {
-            snd_device = SND_DEVICE_IN_USB_HEADSET_MIC;
         } else {
             ALOGE("%s: Unknown input device(s) %#x", __func__, in_device);
             ALOGW("%s: Using default handset-mic", __func__);
@@ -2515,11 +2404,6 @@
             }
         } else if (out_device & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
             snd_device = SND_DEVICE_IN_HDMI_MIC;
-        } else if (out_device & AUDIO_DEVICE_OUT_USB_DEVICE) {
-            if (audio_extn_usb_is_capture_supported())
-              snd_device = SND_DEVICE_IN_USB_HEADSET_MIC;
-            else
-              snd_device = SND_DEVICE_IN_SPEAKER_MIC;
         } else {
             ALOGE("%s: Unknown output device(s) %#x", __func__, out_device);
             ALOGW("%s: Using default handset-mic", __func__);
@@ -2780,6 +2664,27 @@
     }
 }
 
+bool platform_check_and_set_capture_backend_cfg(struct audio_device* adev,
+         struct audio_usecase *usecase __unused,
+         snd_device_t snd_device __unused)
+{
+    enum pcm_format  in_pcm_format = PCM_FORMAT_S16_LE;
+
+    if (adev && adev->active_input)
+        in_pcm_format = adev->active_input->config.format;
+
+    // allow 24 bit recording only if voice call is not active
+    if (!voice_is_in_call(adev) &&
+        adev->mode != AUDIO_MODE_IN_COMMUNICATION &&
+        in_pcm_format == PCM_FORMAT_S24_LE) {
+        audio_route_apply_and_update_path(adev->audio_route, "set-capture-format-24le");
+    } else {
+        audio_route_apply_and_update_path(adev->audio_route, "set-capture-format-default");
+    }
+
+    return true;
+}
+
 int platform_set_snd_device_backend(snd_device_t device, const char *backend_tag,
                                     const char * hw_interface)
 {
@@ -3002,464 +2907,3 @@
     }
     return 0;
 }
-
-/*
- * configures afe with bit width and Sample Rate
- */
-static int platform_set_backend_cfg(const struct audio_device* adev,
-                                          snd_device_t snd_device,
-                                          const struct audio_backend_cfg *backend_cfg)
-{
-
-    int ret = 0;
-    const int backend_idx = platform_get_backend_index(snd_device);
-    struct platform_data *my_data = (struct platform_data *)adev->platform;
-    const unsigned int bit_width = backend_cfg->bit_width;
-    const unsigned int sample_rate = backend_cfg->sample_rate;
-    const unsigned int channels = backend_cfg->channels;
-    const audio_format_t format = backend_cfg->format;
-    const bool passthrough_enabled = backend_cfg->passthrough_enabled;
-
-
-    ALOGV("%s:becf: afe: bitwidth %d, samplerate %d channels %d"
-          ", backend_idx %d device (%s)", __func__,  bit_width,
-          sample_rate, channels, backend_idx,
-          platform_get_snd_device_name(snd_device));
-
-    if ((my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl) &&
-        (bit_width != my_data->current_backend_cfg[backend_idx].bit_width)) {
-
-        struct  mixer_ctl *ctl = NULL;
-        ctl = mixer_get_ctl_by_name(adev->mixer,
-                                    my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl);
-        if (!ctl) {
-            ALOGE("%s:becf: afe: Could not get ctl for mixer command - %s",
-                  __func__,
-                  my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl);
-            return -EINVAL;
-        }
-
-        if (bit_width == 24) {
-            if (format == AUDIO_FORMAT_PCM_24_BIT_PACKED)
-                ret = mixer_ctl_set_enum_by_string(ctl, "S24_3LE");
-            else
-                ret = mixer_ctl_set_enum_by_string(ctl, "S24_LE");
-        } else if (bit_width == 32) {
-            ret = mixer_ctl_set_enum_by_string(ctl, "S32_LE");
-        } else {
-            ret = mixer_ctl_set_enum_by_string(ctl, "S16_LE");
-        }
-        if ( ret < 0) {
-            ALOGE("%s:becf: afe: fail for %s mixer set to %d bit for %x format", __func__,
-                  my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl, bit_width, format);
-        } else {
-            my_data->current_backend_cfg[backend_idx].bit_width = bit_width;
-            ALOGD("%s:becf: afe: %s mixer set to %d bit for %x format", __func__,
-                  my_data->current_backend_cfg[backend_idx].bitwidth_mixer_ctl, bit_width, format);
-        }
-        /* set the ret as 0 and not pass back to upper layer */
-        ret = 0;
-    }
-
-    if (passthrough_enabled || ((my_data->current_backend_cfg[backend_idx].samplerate_mixer_ctl) &&
-                                (sample_rate != my_data->current_backend_cfg[backend_idx].sample_rate))) {
-        char *rate_str = NULL;
-        struct  mixer_ctl *ctl = NULL;
-
-        switch (sample_rate) {
-            case 32000:
-                if (passthrough_enabled) {
-                    rate_str = "KHZ_32";
-                    break;
-                }
-            case 8000:
-            case 11025:
-            case 16000:
-            case 22050:
-            case 48000:
-                rate_str = "KHZ_48";
-                break;
-            case 44100:
-                rate_str = "KHZ_44P1";
-                break;
-            case 64000:
-            case 96000:
-                rate_str = "KHZ_96";
-                break;
-            case 88200:
-                rate_str = "KHZ_88P2";
-                break;
-            case 176400:
-                rate_str = "KHZ_176P4";
-                break;
-            case 192000:
-                rate_str = "KHZ_192";
-                break;
-            case 352800:
-                rate_str = "KHZ_352P8";
-                break;
-            case 384000:
-                rate_str = "KHZ_384";
-                break;
-            case 144000:
-                if (passthrough_enabled) {
-                    rate_str = "KHZ_144";
-                    break;
-                }
-            default:
-                rate_str = "KHZ_48";
-                break;
-        }
-
-        ctl = mixer_get_ctl_by_name(adev->mixer,
-                                    my_data->current_backend_cfg[backend_idx].samplerate_mixer_ctl);
-        if(!ctl) {
-            ALOGE("%s:becf: afe: Could not get ctl for mixer command - %s",
-                  __func__,
-                  my_data->current_backend_cfg[backend_idx].samplerate_mixer_ctl);
-            return -EINVAL;
-        }
-
-        ALOGD("%s:becf: afe: %s set to %s", __func__,
-              my_data->current_backend_cfg[backend_idx].samplerate_mixer_ctl, rate_str);
-        mixer_ctl_set_enum_by_string(ctl, rate_str);
-        my_data->current_backend_cfg[backend_idx].sample_rate = sample_rate;
-    }
-    if ((my_data->current_backend_cfg[backend_idx].channels_mixer_ctl) &&
-        (channels != my_data->current_backend_cfg[backend_idx].channels)) {
-        struct  mixer_ctl *ctl = NULL;
-        char *channel_cnt_str = NULL;
-
-        switch (channels) {
-            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;
-            case 1:
-                channel_cnt_str = "One"; break;
-            case 2:
-            default:
-                channel_cnt_str = "Two"; break;
-        }
-
-        ctl = mixer_get_ctl_by_name(adev->mixer,
-                                    my_data->current_backend_cfg[backend_idx].channels_mixer_ctl);
-        if (!ctl) {
-            ALOGE("%s:becf: afe: Could not get ctl for mixer command - %s",
-                  __func__,
-                  my_data->current_backend_cfg[backend_idx].channels_mixer_ctl);
-            return -EINVAL;
-        }
-        mixer_ctl_set_enum_by_string(ctl, channel_cnt_str);
-        my_data->current_backend_cfg[backend_idx].channels = channels;
-
-        // skip EDID configuration for HDMI backend
-
-        ALOGD("%s:becf: afe: %s set to %s", __func__,
-              my_data->current_backend_cfg[backend_idx].channels_mixer_ctl,
-              channel_cnt_str);
-    }
-
-    // skip set ext_display format mixer control
-    return ret;
-}
-
-static int platform_get_snd_device_bit_width(snd_device_t snd_device)
-{
-    if ((snd_device < SND_DEVICE_MIN) || (snd_device >= SND_DEVICE_MAX)) {
-        ALOGE("%s: Invalid snd_device = %d", __func__, snd_device);
-        return CODEC_BACKEND_DEFAULT_BIT_WIDTH;
-    }
-
-    return backend_bit_width_table[snd_device];
-}
-
-/*
- * return backend_idx on which voice call is active
- */
-static int platform_get_voice_call_backend(struct audio_device* adev)
-{
-    struct audio_usecase *uc = NULL;
-    struct listnode *node;
-    snd_device_t out_snd_device = SND_DEVICE_NONE;
-
-    int backend_idx = -1;
-
-    if (voice_is_in_call(adev) || adev->mode == AUDIO_MODE_IN_COMMUNICATION) {
-        list_for_each(node, &adev->usecase_list) {
-            uc =  node_to_item(node, struct audio_usecase, list);
-            if (uc && uc->type == VOICE_CALL && uc->stream.out) {
-                out_snd_device = platform_get_output_snd_device(adev->platform,
-                                                        uc->stream.out->devices);
-                backend_idx = platform_get_backend_index(out_snd_device);
-                break;
-            }
-        }
-    }
-    return backend_idx;
-}
-
-/*
- * goes through all the current usecases and picks the highest
- * bitwidth & samplerate
- */
-static bool platform_check_capture_backend_cfg(struct audio_device* adev,
-                                   int backend_idx,
-                                   struct audio_backend_cfg *backend_cfg)
-{
-    bool backend_change = false;
-    unsigned int bit_width;
-    unsigned int sample_rate;
-    unsigned int channels;
-    struct platform_data *my_data = (struct platform_data *)adev->platform;
-
-    bit_width = backend_cfg->bit_width;
-    sample_rate = backend_cfg->sample_rate;
-    channels = backend_cfg->channels;
-
-    ALOGV("%s:txbecf: afe: Codec selected backend: %d current bit width: %d and "
-          "sample rate: %d, channels %d",__func__,backend_idx, bit_width,
-          sample_rate, channels);
-
-    // For voice calls use default configuration i.e. 16b/48K, only applicable to
-    // default backend
-    // force routing is not required here, caller will do it anyway
-    if (voice_is_in_call(adev) || adev->mode == AUDIO_MODE_IN_COMMUNICATION) {
-        ALOGW("%s:txbecf: afe: Use default bw and sr for voice/voip calls and "
-              "for unprocessed/camera source", __func__);
-        bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
-        sample_rate =  CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
-    }
-
-    if (backend_idx == USB_AUDIO_TX_BACKEND) {
-        audio_extn_usb_is_config_supported(&bit_width, &sample_rate, &channels, false);
-        ALOGV("%s:txbecf: afe: USB BE configured as bit_width(%d)sample_rate(%d)channels(%d)",
-              __func__, bit_width, sample_rate, channels);
-    }
-
-    ALOGV("%s:txbecf: afe: Codec selected backend: %d updated bit width: %d and "
-          "sample rate: %d", __func__, backend_idx, bit_width, sample_rate);
-
-    // Force routing if the expected bitwdith or samplerate
-    // is not same as current backend comfiguration
-    if ((bit_width != my_data->current_backend_cfg[backend_idx].bit_width) ||
-        (sample_rate != my_data->current_backend_cfg[backend_idx].sample_rate) ||
-        (channels != my_data->current_backend_cfg[backend_idx].channels)) {
-        backend_cfg->bit_width = bit_width;
-        backend_cfg->sample_rate= sample_rate;
-        backend_cfg->channels = channels;
-        backend_change = true;
-        ALOGI("%s:txbecf: afe: Codec backend needs to be updated. new bit width: %d "
-              "new sample rate: %d new channel: %d",
-              __func__, backend_cfg->bit_width,
-              backend_cfg->sample_rate, backend_cfg->channels);
-    }
-
-    return backend_change;
-}
-
-static bool platform_check_playback_backend_cfg(struct audio_device* adev,
-                                             struct audio_usecase* usecase,
-                                             snd_device_t snd_device,
-                                             struct audio_backend_cfg *backend_cfg)
-{
-    bool backend_change = false;
-    struct listnode *node;
-    unsigned int bit_width;
-    unsigned int sample_rate;
-    unsigned int channels;
-    bool passthrough_enabled = false;
-    int backend_idx = DEFAULT_CODEC_BACKEND;
-    struct platform_data *my_data = (struct platform_data *)adev->platform;
-    bool channels_updated = false;
-
-    if (snd_device == SND_DEVICE_OUT_BT_SCO ||
-        snd_device == SND_DEVICE_OUT_BT_SCO_WB) {
-        backend_change = false;
-        return backend_change;
-    }
-
-    backend_idx = platform_get_backend_index(snd_device);
-    bit_width = backend_cfg->bit_width;
-    sample_rate = backend_cfg->sample_rate;
-    channels = backend_cfg->channels;
-
-    ALOGV("%s:becf: afe: bitwidth %d, samplerate %d channels %d"
-          ", backend_idx %d usecase = %d device (%s)", __func__, bit_width,
-          sample_rate, channels, backend_idx, usecase->id,
-          platform_get_snd_device_name(snd_device));
-
-    if (backend_idx == platform_get_voice_call_backend(adev)) {
-        ALOGW("%s:becf: afe:Use default bw and sr for voice/voip calls ",
-              __func__);
-        bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
-        sample_rate =  CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
-        channels = CODEC_BACKEND_DEFAULT_CHANNELS;
-    } else {
-        /*
-         * The backend should be configured at highest bit width and/or
-         * sample rate amongst all playback usecases.
-         * If the selected sample rate and/or bit width differ with
-         * current backend sample rate and/or bit width, then, we set the
-         * backend re-configuration flag.
-         *
-         * Exception: 16 bit playbacks is allowed through 16 bit/48/44.1 khz backend only
-         */
-
-        int i =0;
-        list_for_each(node, &adev->usecase_list) {
-            struct audio_usecase *uc;
-            uc = node_to_item(node, struct audio_usecase, list);
-            struct stream_out *out = (struct stream_out*) uc->stream.out;
-            if (uc->type == PCM_PLAYBACK && out && usecase != uc) {
-                unsigned int out_channels = audio_channel_count_from_out_mask(out->channel_mask);
-
-                ALOGD("%s:napb: (%d) - (%s)id (%d) sr %d bw "
-                      "(%d) ch (%d) device %s", __func__, i++, use_case_table[uc->id],
-                      uc->id, out->sample_rate,
-                      pcm_format_to_bits(out->config.format), out_channels,
-                      platform_get_snd_device_name(uc->out_snd_device));
-
-                if (platform_check_backends_match(snd_device, uc->out_snd_device)) {
-                    if (bit_width < pcm_format_to_bits(out->config.format))
-                        bit_width = pcm_format_to_bits(out->config.format);
-                    if (sample_rate < out->sample_rate)
-                        sample_rate = out->sample_rate;
-                    if (out->sample_rate < OUTPUT_SAMPLING_RATE_44100)
-                        sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
-                    if (channels < out_channels)
-                        channels = out_channels;
-                }
-            }
-        }
-    }
-
-    /*
-     * Check if the device is speaker or handset,assumption handset shares
-     * backend with speaker, and these devices are restricited to 48kHz.
-     */
-    if (platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, snd_device)) {
-
-        if (bit_width >= 24) {
-            bit_width = platform_get_snd_device_bit_width(SND_DEVICE_OUT_SPEAKER);
-            ALOGD("%s:becf: afe: reset bitwidth to %d (based on supported"
-                  " value for this platform)", __func__, bit_width);
-        }
-        sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
-        ALOGD("%s:becf: afe: playback on codec device not supporting native playback set "
-              "default Sample Rate(48k)", __func__);
-    }
-
-    if (backend_idx == USB_AUDIO_RX_BACKEND) {
-        audio_extn_usb_is_config_supported(&bit_width, &sample_rate, &channels, true);
-        ALOGV("%s: USB BE configured as bit_width(%d)sample_rate(%d)channels(%d)",
-              __func__, bit_width, sample_rate, channels);
-        if (channels != my_data->current_backend_cfg[backend_idx].channels)
-            channels_updated = true;
-    }
-
-    ALOGV("%s:becf: afe: Codec selected backend: %d updated bit width: %d and sample rate: %d",
-          __func__, backend_idx , bit_width, sample_rate);
-
-    // Force routing if the expected bitwdith or samplerate
-    // is not same as current backend comfiguration
-    if ((bit_width != my_data->current_backend_cfg[backend_idx].bit_width) ||
-        (sample_rate != my_data->current_backend_cfg[backend_idx].sample_rate) ||
-        passthrough_enabled || channels_updated) {
-        backend_cfg->bit_width = bit_width;
-        backend_cfg->sample_rate = sample_rate;
-        backend_cfg->channels = channels;
-        backend_cfg->passthrough_enabled = passthrough_enabled;
-        backend_change = true;
-        ALOGV("%s:becf: afe: Codec backend needs to be updated. new bit width: %d"
-              "new sample rate: %d new channels: %d",
-              __func__, backend_cfg->bit_width, backend_cfg->sample_rate, backend_cfg->channels);
-    }
-
-    return backend_change;
-}
-
-bool platform_check_and_set_playback_backend_cfg(struct audio_device* adev,
-    struct audio_usecase *usecase, snd_device_t snd_device)
-{
-    int backend_idx = DEFAULT_CODEC_BACKEND;
-    int new_snd_devices[SND_DEVICE_OUT_END];
-    int i, num_devices = 1;
-    bool ret = false;
-    struct platform_data *my_data = (struct platform_data *)adev->platform;
-    struct audio_backend_cfg backend_cfg;
-
-    backend_idx = platform_get_backend_index(snd_device);
-
-    backend_cfg.bit_width = pcm_format_to_bits(usecase->stream.out->config.format);
-    backend_cfg.sample_rate = usecase->stream.out->sample_rate;
-    backend_cfg.format = usecase->stream.out->format;
-    backend_cfg.channels = audio_channel_count_from_out_mask(usecase->stream.out->channel_mask);
-    /*this is populated by check_codec_backend_cfg hence set default value to false*/
-    backend_cfg.passthrough_enabled = false;
-
-    ALOGV("%s:becf: afe: bitwidth %d, samplerate %d channels %d"
-          ", backend_idx %d usecase = %d device (%s)", __func__, backend_cfg.bit_width,
-          backend_cfg.sample_rate, backend_cfg.channels, backend_idx, usecase->id,
-          platform_get_snd_device_name(snd_device));
-
-    if (platform_can_split_snd_device(snd_device, &num_devices, new_snd_devices) < 0)
-        new_snd_devices[0] = snd_device;
-
-    for (i = 0; i < num_devices; i++) {
-        ALOGV("%s: new_snd_devices[%d] is %d", __func__, i, new_snd_devices[i]);
-        if ((platform_check_playback_backend_cfg(adev, usecase, new_snd_devices[i],
-                                                 &backend_cfg))) {
-            platform_set_backend_cfg(adev, new_snd_devices[i],
-                                     &backend_cfg);
-            ret = true;
-        }
-    }
-    return ret;
-}
-
-bool platform_check_and_set_capture_backend_cfg(struct audio_device* adev,
-    struct audio_usecase *usecase, snd_device_t snd_device)
-{
-    int backend_idx = platform_get_backend_index(snd_device);
-    int ret = 0;
-    struct audio_backend_cfg backend_cfg;
-
-    backend_cfg.passthrough_enabled = false;
-
-    if(usecase->type == PCM_CAPTURE) {
-        backend_cfg.format= usecase->stream.in->format;
-        backend_cfg.channels = audio_channel_count_from_in_mask(usecase->stream.in->channel_mask);
-    } else {
-        backend_cfg.bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
-        backend_cfg.sample_rate =  CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
-        backend_cfg.format = AUDIO_FORMAT_PCM_16_BIT;
-        backend_cfg.channels = 1;
-    }
-
-    ALOGV("%s:txbecf: afe: bitwidth %d, samplerate %d, channel %d"
-          ", backend_idx %d usecase = %d device (%s)", __func__,
-          backend_cfg.bit_width,
-          backend_cfg.sample_rate,
-          backend_cfg.channels,
-          backend_idx, usecase->id,
-          platform_get_snd_device_name(snd_device));
-
-    if (platform_check_capture_backend_cfg(adev, backend_idx, &backend_cfg)) {
-        ret = platform_set_backend_cfg(adev, snd_device,
-                                       &backend_cfg);
-        if(!ret)
-            return true;
-    }
-
-    return false;
-}
-
diff --git a/hal/msm8974/platform.h b/hal/msm8974/platform.h
index cc75384..fb6e24d 100644
--- a/hal/msm8974/platform.h
+++ b/hal/msm8974/platform.h
@@ -41,15 +41,6 @@
      AUDIO_DEVICE_OUT_WIRED_HEADSET | AUDIO_DEVICE_OUT_WIRED_HEADPHONE | \
      AUDIO_DEVICE_OUT_LINE)
 
-/*
- * Below are the input devices for which back end is same, SLIMBUS_0_TX.
- * All these devices are handled by the internal HW codec. We can
- * enable any one of these devices at any time
- */
-#define AUDIO_DEVICE_IN_ALL_CODEC_BACKEND \
-    (AUDIO_DEVICE_IN_BUILTIN_MIC | AUDIO_DEVICE_IN_BACK_MIC | \
-     AUDIO_DEVICE_IN_WIRED_HEADSET | AUDIO_DEVICE_IN_VOICE_CALL) & ~AUDIO_DEVICE_BIT_IN
-
 /* Sound devices specific to the platform
  * The DEVICE_OUT_* and DEVICE_IN_* should be mapped to these sound
  * devices to enable corresponding mixer paths
@@ -87,9 +78,6 @@
     SND_DEVICE_OUT_SPEAKER_PROTECTED,
     SND_DEVICE_OUT_VOICE_SPEAKER_PROTECTED,
     SND_DEVICE_OUT_VOICE_SPEAKER_HFP,
-    SND_DEVICE_OUT_USB_HEADSET,
-    SND_DEVICE_OUT_USB_HEADPHONES,
-    SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET,
     SND_DEVICE_OUT_END,
 
     /*
@@ -154,7 +142,6 @@
 
     SND_DEVICE_IN_VOICE_RX,
 
-    SND_DEVICE_IN_USB_HEADSET_MIC,
     SND_DEVICE_IN_THREE_MIC,
     SND_DEVICE_IN_QUAD_MIC,
     SND_DEVICE_IN_CAPTURE_VI_FEEDBACK,
@@ -168,24 +155,6 @@
     SND_DEVICE_MAX = SND_DEVICE_IN_END,
 
 };
-#define DEFAULT_OUTPUT_SAMPLING_RATE    48000
-#define OUTPUT_SAMPLING_RATE_44100      44100
-enum {
-    DEFAULT_CODEC_BACKEND,
-    SLIMBUS_0_RX = DEFAULT_CODEC_BACKEND,
-    HEADPHONE_BACKEND,
-    SLIMBUS_6_RX = HEADPHONE_BACKEND,
-    HDMI_RX_BACKEND,
-    USB_AUDIO_RX_BACKEND,
-    MAX_RX_CODEC_BACKENDS = USB_AUDIO_RX_BACKEND,
-    /* TX BE follows RX BE */
-    SLIMBUS_0_TX,
-    DEFAULT_CODEC_TX_BACKEND = SLIMBUS_0_TX,
-    USB_AUDIO_TX_BACKEND,
-    BT_SCO_TX_BACKEND,
-    MAX_CODEC_BACKENDS
-};
-
 
 #define DEVICE_NAME_MAX_SIZE   128
 #define HW_INFO_ARRAY_MAX_SIZE 32
@@ -347,23 +316,6 @@
     get_sample_rate_t get_sample_rate;
 };
 
-struct audio_backend_cfg {
-    unsigned int   sample_rate;
-    unsigned int   channels;
-    unsigned int   bit_width;
-    bool           passthrough_enabled;
-    audio_format_t format;
-};
-
-typedef struct codec_backend_cfg {
-    uint32_t sample_rate;
-    uint32_t bit_width;
-    uint32_t channels;
-    char     *bitwidth_mixer_ctl;
-    char     *samplerate_mixer_ctl;
-    char     *channels_mixer_ctl;
-} codec_backend_cfg_t;
-
-#define PLATFORM_INFO_XML_PATH          "/system/etc/audio_platform_info.xml"
-#define PLATFORM_INFO_XML_BASE_STRING   "/system/etc/audio_platform_info"
+#define PLATFORM_INFO_XML_PATH          "audio_platform_info.xml"
+#define PLATFORM_INFO_XML_BASE_STRING   "audio_platform_info"
 #endif // QCOM_AUDIO_PLATFORM_H
diff --git a/hal/platform_api.h b/hal/platform_api.h
index 59ad4b1..83554b0 100644
--- a/hal/platform_api.h
+++ b/hal/platform_api.h
@@ -20,12 +20,6 @@
 #include "voice.h"
 #define MAX_VOLUME_CAL_STEPS 15
 #define CODEC_BACKEND_DEFAULT_SAMPLE_RATE 48000
-#define CODEC_BACKEND_DEFAULT_BIT_WIDTH 16
-#define CODEC_BACKEND_DEFAULT_CHANNELS 2
-#define CODEC_BACKEND_DEFAULT_TX_CHANNELS 1
-#define SAMPLE_RATE_8000 8000
-#define SAMPLE_RATE_11025 11025
-#define sample_rate_multiple(sr, base) ((sr % base)== 0?true:false)
 
 struct amp_db_and_gain_table {
     float amp;
@@ -118,9 +112,6 @@
 
 int platform_set_parameters(void *platform, struct str_parms *parms);
 
-bool platform_check_and_set_playback_backend_cfg(struct audio_device* adev,
-                   struct audio_usecase *usecase, snd_device_t snd_device);
-
 bool platform_check_and_set_capture_backend_cfg(struct audio_device* adev,
                    struct audio_usecase *usecase, snd_device_t snd_device);