/*
 * Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *   * Neither the name of The Linux Foundation nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#define LOG_TAG "alsa_ucm"
//#define LOG_NDDEBUG 0

#ifdef ANDROID
/* definitions for Android logging */
#include <utils/Log.h>
#include <cutils/properties.h>
#else /* ANDROID */
#include <math.h>
#define strlcat g_strlcat
#define strlcpy g_strlcpy
#define ALOGI(...)      fprintf(stdout, __VA_ARGS__)
#define ALOGE(...)      fprintf(stderr, __VA_ARGS__)
#define ALOGV(...)      fprintf(stderr, __VA_ARGS__)
#define ALOGD(...)      fprintf(stderr, __VA_ARGS__)
#endif /* ANDROID */

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
#include <ctype.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/time.h>
#include <sys/poll.h>
#include <stdint.h>
#include <dlfcn.h>

#include <linux/ioctl.h>
#include "msm8960_use_cases.h"
#if defined(QC_PROP)
    static void (*acdb_send_audio_cal)(int,int);
    static void (*acdb_send_voice_cal)(int,int);
#endif
#define PARSE_DEBUG 0

/**
 * Create an identifier
 * fmt - sprintf like format,
 * ... - Optional arguments
 * returns - string allocated or NULL on error
 */
char *snd_use_case_identifier(const char *fmt, ...)
{
    ALOGE("API not implemented for now, to be updated if required");
    return NULL;
}

/**
 * Free a list
 * list - list to free
 * items -  Count of strings
 * Return Zero on success, otherwise a negative error code
 */
int snd_use_case_free_list(const char *list[], int items)
{
    /* list points to UCM internal static tables,
     * hence there is no need to do a free call
     * just set the list to NULL and return */
    list = NULL;
    return 0;
}

/**
 * Obtain a list of entries
 * uc_mgr - UCM structure pointer or  NULL for card list
 * identifier - NULL for card list
 * list - Returns allocated list
 * returns Number of list entries on success, otherwise a negative error code
 */
int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr,
                          const char *identifier,
                          const char **list[])
{
    use_case_verb_t *verb_list;
    int verb_index, list_size, index = 0;

    if (identifier == NULL) {
        *list = card_list;
        return ((int)MAX_NUM_CARDS);
    }

    pthread_mutex_lock(&uc_mgr->card_ctxt_ptr->card_lock);
    if ((uc_mgr->snd_card_index >= (int)MAX_NUM_CARDS) ||
        (uc_mgr->snd_card_index < 0) || (uc_mgr->card_ctxt_ptr == NULL)) {
        ALOGE("snd_use_case_get_list(): failed, invalid arguments");
        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
        return -EINVAL;
    }

    if (!strncmp(identifier, "_verbs", 6)) {
        while(strncmp(uc_mgr->card_ctxt_ptr->verb_list[index],
            SND_UCM_END_OF_LIST, strlen(SND_UCM_END_OF_LIST))) {
            ALOGV("Index:%d Verb:%s", index,
                 uc_mgr->card_ctxt_ptr->verb_list[index]);
            index++;
        }
        *list = (char ***)uc_mgr->card_ctxt_ptr->verb_list;
        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
        return index;
    } else  if (!strncmp(identifier, "_devices", 8)) {
        if (!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
            SND_USE_CASE_VERB_INACTIVE, strlen(SND_USE_CASE_VERB_INACTIVE))) {
            ALOGE("Use case verb name not set, invalid current verb");
            pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
            return -EINVAL;
        }
        verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
        while(strncmp(uc_mgr->card_ctxt_ptr->current_verb,
            verb_list[index].use_case_name,
            (strlen(verb_list[index].use_case_name)+1))) {
            index++;
        }
        verb_index = index;
        index = 0;
        while(strncmp(verb_list[verb_index].device_list[index],
            SND_UCM_END_OF_LIST, strlen(SND_UCM_END_OF_LIST))) {
            ALOGV("Index:%d Device:%s", index,
                 verb_list[verb_index].device_list[index]);
            index++;
        }
        *list = verb_list[verb_index].device_list;
        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
        return index;
    } else  if (!strncmp(identifier, "_modifiers", 10)) {
        if (!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
                    SND_USE_CASE_VERB_INACTIVE, MAX_STR_LEN)) {
            ALOGE("Use case verb name not set, invalid current verb");
            pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
            return -EINVAL;
        }
        verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
        while(strncmp(uc_mgr->card_ctxt_ptr->current_verb,
            verb_list[index].use_case_name,
            (strlen(verb_list[index].use_case_name)+1))) {
            index++;
        }
        verb_index = index;
        index = 0;
        while(strncmp(verb_list[verb_index].modifier_list[index],
                    SND_UCM_END_OF_LIST, strlen(SND_UCM_END_OF_LIST))) {
            ALOGV("Index:%d Modifier:%s", index,
                 verb_list[verb_index].modifier_list[index]);
            index++;
        }
        *list = verb_list[verb_index].modifier_list;
        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
        return index;
    } else  if (!strncmp(identifier, "_enadevs", 8)) {
        if (uc_mgr->device_list_count) {
            for (index = 0; index < uc_mgr->device_list_count; index++) {
                free(uc_mgr->current_device_list[index]);
                uc_mgr->current_device_list[index] = NULL;
            }
            free(uc_mgr->current_device_list);
            uc_mgr->current_device_list = NULL;
            uc_mgr->device_list_count = 0;
        }
        list_size =
            snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
        uc_mgr->device_list_count = list_size;
    if (list_size > 0) {
            uc_mgr->current_device_list =
                (char **)malloc(sizeof(char *)*list_size);
            if (uc_mgr->current_device_list == NULL) {
                *list = NULL;
                pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
                return -ENOMEM;
            }
            for (index = 0; index < list_size; index++) {
                uc_mgr->current_device_list[index] =
                snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
                index);
            }
        }
        *list = (const char **)uc_mgr->current_device_list;
        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
        return (list_size);
    } else  if (!strncmp(identifier, "_enamods", 8)) {
        if (uc_mgr->modifier_list_count) {
            for (index = 0; index < uc_mgr->modifier_list_count; index++) {
                free(uc_mgr->current_modifier_list[index]);
                uc_mgr->current_modifier_list[index] = NULL;
            }
            free(uc_mgr->current_modifier_list);
            uc_mgr->current_modifier_list = NULL;
            uc_mgr->modifier_list_count = 0;
        }
        list_size =
            snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->mod_list_head);
        uc_mgr->modifier_list_count = list_size;
    if (list_size > 0) {
            uc_mgr->current_modifier_list =
                (char **)malloc(sizeof(char *) * list_size);
            if (uc_mgr->current_modifier_list == NULL) {
                *list = NULL;
                pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
                return -ENOMEM;
            }
            for (index = 0; index < list_size; index++) {
                uc_mgr->current_modifier_list[index] =
                snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->mod_list_head,
                index);
            }
        }
        *list = (const char **)uc_mgr->current_modifier_list;
        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
        return (list_size);
    } else {
        ALOGE("Invalid identifier: %s", identifier);
        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
        return -EINVAL;
    }
}


/**
 * Get current value of the identifier
 * identifier - NULL for current card
 *        _verb
 *        <Name>/<_device/_modifier>
 *    Name -    PlaybackPCM
 *        CapturePCM
 *        PlaybackCTL
 *        CaptureCTL
 * value - Value pointer
 * returns Zero if success, otherwise a negative error code
 */
int snd_use_case_get(snd_use_case_mgr_t *uc_mgr,
                     const char *identifier,
                     const char **value)
{
    card_mctrl_t *ctrl_list;
    use_case_verb_t *verb_list;
    char ident[MAX_STR_LEN], *ident1, *ident2, *temp_ptr;
    int index, verb_index = 0, ret = 0;

    pthread_mutex_lock(&uc_mgr->card_ctxt_ptr->card_lock);
    if ((uc_mgr->snd_card_index >= (int)MAX_NUM_CARDS) ||
        (uc_mgr->snd_card_index < 0) || (uc_mgr->card_ctxt_ptr == NULL)) {
        ALOGE("snd_use_case_get(): failed, invalid arguments");
        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
        return -EINVAL;
    }

    if (identifier == NULL) {
        if (uc_mgr->card_ctxt_ptr->card_name != NULL) {
            *value = strdup(uc_mgr->card_ctxt_ptr->card_name);
        } else {
            *value = NULL;
        }
        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
        return 0;
    }

    if (!strncmp(identifier, "_verb", 5)) {
        if (uc_mgr->card_ctxt_ptr->current_verb != NULL) {
            *value = strdup(uc_mgr->card_ctxt_ptr->current_verb);
        } else {
            *value = NULL;
        }
        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
        return 0;
    }

    strlcpy(ident, identifier, sizeof(ident));
    if(!(ident1 = strtok_r(ident, "/", &temp_ptr))) {
        ALOGE("No valid identifier found: %s", ident);
        ret = -EINVAL;
    } else {
        if ((!strncmp(ident1, "PlaybackPCM", 11)) ||
            (!strncmp(ident1, "CapturePCM", 10))) {
            ident2 = strtok_r(NULL, "/", &temp_ptr);
            index = 0;
            if (ident2 != NULL) {
                verb_index = uc_mgr->card_ctxt_ptr->current_verb_index;
                verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
                if((get_usecase_type(uc_mgr, ident2)) == CTRL_LIST_VERB) {
                    ctrl_list = verb_list[verb_index].verb_ctrls;
                } else {
                    ctrl_list = verb_list[verb_index].mod_ctrls;
                }
                if((verb_index < 0) ||
                    (!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
                    SND_UCM_END_OF_LIST, 3)) || (ctrl_list == NULL)) {
                    ALOGE("Invalid current verb value: %s - %d",
                         uc_mgr->card_ctxt_ptr->current_verb, verb_index);
                    pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
                    return -EINVAL;
                }
                while(strncmp(ctrl_list[index].case_name, ident2,
                    (strlen(ident2)+1))) {
                    if (!strncmp(ctrl_list[index].case_name,
                        SND_UCM_END_OF_LIST, strlen(SND_UCM_END_OF_LIST))){
                        *value = NULL;
                        ret = -EINVAL;
                        break;
                    } else {
                        index++;
                    }
                }
            } else {
                ret = -EINVAL;
            }
            if (ret < 0) {
                ALOGE("No valid device/modifier found with given identifier: %s",
                     ident2);
            } else {
                if(!strncmp(ident1, "PlaybackPCM", 11)) {
                    if (ctrl_list[index].playback_dev_name) {
                        *value = strdup(ctrl_list[index].playback_dev_name);
                    } else {
                        *value = NULL;
                        ret = -ENODEV;
                    }
                } else if(!strncmp(ident1, "CapturePCM", 10)) {
                    if (ctrl_list[index].capture_dev_name) {
                        *value = strdup(ctrl_list[index].capture_dev_name);
                    } else {
                        *value = NULL;
                        ret = -ENODEV;
                    }
                } else {
                    ALOGE("No valid device name exists for given identifier: %s",
                         ident2);
                    *value = NULL;
                    ret = -ENODEV;
                }
            }
        } else if ((!strncmp(ident1, "PlaybackCTL", 11)) ||
                   (!strncmp(ident1, "CaptureCTL", 10))) {
            if(uc_mgr->card_ctxt_ptr->control_device != NULL) {
                *value = strdup(uc_mgr->card_ctxt_ptr->control_device);
            } else {
                ALOGE("No valid control device found");
                *value = NULL;
                ret = -ENODEV;
            }
        } else if (!strncmp(ident1, "ACDBID", 11)) {
            ident2 = strtok_r(NULL, "/", &temp_ptr);
            index = 0; verb_index = 0;
            verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
            if((verb_index < 0) ||
               (!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
                SND_UCM_END_OF_LIST, 3)) ||
                (verb_list[verb_index].verb_ctrls == NULL)) {
                ALOGE("Invalid current verb value: %s - %d",
                     uc_mgr->card_ctxt_ptr->current_verb, verb_index);
                pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
                return -EINVAL;
            }
            ctrl_list = verb_list[verb_index].device_ctrls;
            if (ident2 != NULL) {
                while(strncmp(ctrl_list[index].case_name, ident2,
                    MAX_LEN(ctrl_list[index].case_name,ident2))) {
                    if (!strncmp(ctrl_list[index].case_name, SND_UCM_END_OF_LIST,
                        strlen(SND_UCM_END_OF_LIST))){
                        ret = -EINVAL;
                        break;
                    } else {
                        index++;
                    }
                }
            }
            if (ret < 0) {
                ALOGE("No valid device/modifier found with given identifier: %s",
                      ident2);
            } else {
                if (verb_list[verb_index].device_ctrls[index].acdb_id) {
                    ret = verb_list[verb_index].device_ctrls[index].acdb_id;
                } else {
                    ret = -ENODEV;
                }
            }
        } else if (!strncmp(ident1, "EffectsMixerCTL", 11)) {
            ident2 = strtok_r(NULL, "/", &temp_ptr);
            index = 0; verb_index = 0;
            verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
            if((verb_index < 0) ||
               (!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
                SND_UCM_END_OF_LIST, 3)) ||
                (verb_list[verb_index].verb_ctrls == NULL)) {
                ALOGE("Invalid current verb value: %s - %d",
                     uc_mgr->card_ctxt_ptr->current_verb, verb_index);
                pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
                return -EINVAL;
            }
            ctrl_list = verb_list[verb_index].device_ctrls;
            if (ident2 != NULL) {
                while(strncmp(ctrl_list[index].case_name, ident2, strlen(ident2)+1)) {
                    if (!strncmp(ctrl_list[index].case_name, SND_UCM_END_OF_LIST,
                        strlen(SND_UCM_END_OF_LIST))){
                        ret = -EINVAL;
                        break;
                    } else {
                        index++;
                    }
                }
            }
            if (ret < 0) {
                ALOGE("No valid device/modifier found with given identifier: %s",
                      ident2);
            } else {
                if (verb_list[verb_index].device_ctrls[index].effects_mixer_ctl) {
                    *value = strdup(verb_list[verb_index].device_ctrls[index].effects_mixer_ctl);
                } else {
                    *value = NULL;
                    ret = -ENODEV;
                }
            }
        } else {
            ALOGE("Unsupported identifier value: %s", ident1);
            *value = NULL;
            ret = -EINVAL;
        }
    }
    pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
    return ret;
}

/**
 * Get current status
 * uc_mgr - UCM structure
 * identifier - _devstatus/<device>,
        _modstatus/<modifier>
 * value - result
 * returns 0 on success, otherwise a negative error code
 */
int snd_use_case_geti(snd_use_case_mgr_t *uc_mgr,
              const char *identifier,
              long *value)
{
    char ident[MAX_STR_LEN], *ident1, *ident2, *ident_value, *temp_ptr;
    int index, list_size, ret = -EINVAL;

    pthread_mutex_lock(&uc_mgr->card_ctxt_ptr->card_lock);
    if ((uc_mgr->snd_card_index >= (int)MAX_NUM_CARDS) ||
        (uc_mgr->snd_card_index < 0) || (uc_mgr->card_ctxt_ptr == NULL)) {
        ALOGE("snd_use_case_geti(): failed, invalid arguments");
        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
        return -EINVAL;
    }

    *value = 0;
    strlcpy(ident, identifier, sizeof(ident));
    if(!(ident1 = strtok_r(ident, "/", &temp_ptr))) {
        ALOGE("No valid identifier found: %s", ident);
        ret = -EINVAL;
    } else {
        if (!strncmp(ident1, "_devstatus", 10)) {
            ident2 = strtok_r(NULL, "/", &temp_ptr);
            if (ident2 != NULL) {
                list_size =
                snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
                for (index = 0; index < list_size; index++) {
                if ((ident_value =
                snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
                index))) {
                        if (!strncmp(ident2, ident_value,
                            (strlen(ident_value)+1))) {
                            *value = 1;
                            free(ident_value);
                            ident_value = NULL;
                            break;
                        } else {
                            free(ident_value);
                            ident_value = NULL;
                        }
                    }
                }
                ret = 0;
            }
        } else if (!strncmp(ident1, "_modstatus", 10)) {
            ident2 = strtok_r(NULL, "/", &temp_ptr);
            if (ident2 != NULL) {
                list_size =
                snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->mod_list_head);
                for (index = 0; index < list_size; index++) {
                if((ident_value =
                snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->mod_list_head,
                index))) {
                        if (!strncmp(ident2, ident_value,
                            (strlen(ident_value)+1))) {
                            *value = 1;
                            free(ident_value);
                            ident_value = NULL;
                            break;
                        } else {
                            free(ident_value);
                            ident_value = NULL;
                        }
                    }
                }
                ret = 0;
            }
        } else {
            ALOGE("Unknown identifier: %s", ident1);
        }
    }
    pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
    return ret;
}

static int check_devices_for_voice_call(snd_use_case_mgr_t *uc_mgr,
const char *use_case)
{
    struct snd_ucm_ident_node *dev_node = NULL;
    int index = 0, list_size = 0, rx_dev_status = 0, tx_dev_status = 0;

    if ((!strncmp(use_case, SND_USE_CASE_VERB_VOICECALL,
        strlen(SND_USE_CASE_VERB_VOICECALL))) ||
        (!strncmp(use_case, SND_USE_CASE_VERB_IP_VOICECALL,
        strlen(SND_USE_CASE_VERB_IP_VOICECALL))) ||
        (!strncmp(use_case, SND_USE_CASE_MOD_PLAY_VOICE,
        strlen(SND_USE_CASE_MOD_PLAY_VOICE))) ||
        (!strncmp(use_case, SND_USE_CASE_MOD_PLAY_VOIP,
        strlen(SND_USE_CASE_MOD_PLAY_VOIP)))) {
        ALOGV("check_devices_for_voice_call(): voice cap detected\n");
        list_size =
        snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
        for (index = 0; index < list_size; index++) {
            if ((dev_node =
                snd_ucm_get_device_node(uc_mgr->card_ctxt_ptr->dev_list_head,
                index))) {
                if (dev_node->capability == CAP_RX && dev_node->active == 1) {
                    rx_dev_status = 1;
                } else if (dev_node->capability == CAP_TX && dev_node->active == 1) {
                    tx_dev_status = 1;
                }
            }
        }
        if (rx_dev_status == 1 && tx_dev_status == 1) {
            ALOGV("check_devices_for_voice_call(): Rx and Tx devices enabled\n");
            return 0;
        } else {
            ALOGV("check_devices_for_voice_call(): Rx/Tx dev not enabled: \
                  %d,%d\n", rx_dev_status, tx_dev_status);
            return 1;
        }
    }
    return 0;
}

static int snd_use_case_apply_voice_acdb(snd_use_case_mgr_t *uc_mgr,
int use_case_index)
{
    card_mctrl_t *ctrl_list;
    int list_size, index, verb_index, ret = 0, voice_acdb = 0, rx_id, tx_id;
    char *ident_value = NULL;

    /* Check if voice call use case/modifier exists */
    if ((!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
        SND_USE_CASE_VERB_VOICECALL, strlen(SND_USE_CASE_VERB_VOICECALL))) ||
        (!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
        SND_USE_CASE_VERB_IP_VOICECALL,
        strlen(SND_USE_CASE_VERB_IP_VOICECALL)))) {
        voice_acdb = 1;
    }
    if (voice_acdb != 1) {
        list_size =
        snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->mod_list_head);
        for (index = 0; index < list_size; index++) {
            if ((ident_value =
                snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->mod_list_head,
                index))) {
                if ((!strncmp(ident_value, SND_USE_CASE_MOD_PLAY_VOICE,
                    strlen(SND_USE_CASE_MOD_PLAY_VOICE))) ||
                    (!strncmp(ident_value, SND_USE_CASE_MOD_PLAY_VOIP,
                    strlen(SND_USE_CASE_MOD_PLAY_VOIP)))) {
                    voice_acdb = 1;
                    free(ident_value);
                    ident_value = NULL;
                    break;
                }
                free(ident_value);
                ident_value = NULL;
            }
        }
    }

    verb_index = uc_mgr->card_ctxt_ptr->current_verb_index;
    if((verb_index < 0) ||
        (!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
        SND_UCM_END_OF_LIST, 3))) {
        ALOGE("Invalid current verb value: %s - %d",
            uc_mgr->card_ctxt_ptr->current_verb, verb_index);
        return -EINVAL;
    }
    if (voice_acdb == 1) {
        ctrl_list =
        uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].device_ctrls;
        list_size =
        snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
        for (index = 0; index < list_size; index++) {
            if ((ident_value =
                snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
                index))) {
                if (strncmp(ident_value, ctrl_list[use_case_index].case_name,
                    (strlen(ctrl_list[use_case_index].case_name)+1))) {
                    break;
                }
                free(ident_value);
                ident_value = NULL;
            }
        }
        index = 0;
        if (ident_value != NULL) {
            while(strncmp(ctrl_list[index].case_name, ident_value,
                  (strlen(ident_value)+1))) {
                if (!strncmp(ctrl_list[index].case_name, SND_UCM_END_OF_LIST,
                    strlen(SND_UCM_END_OF_LIST))) {
                    ret = -EINVAL;
                    break;
                }
                index++;
            }
            if (ret < 0) {
                ALOGE("No valid device found: %s",ident_value);
            } else {
                if (ctrl_list[use_case_index].capability == CAP_RX) {
                    rx_id = ctrl_list[use_case_index].acdb_id;
                    tx_id = ctrl_list[index].acdb_id;
                } else {
                    rx_id = ctrl_list[index].acdb_id;
                    tx_id = ctrl_list[use_case_index].acdb_id;
                }
                if(((rx_id == DEVICE_SPEAKER_MONO_RX_ACDB_ID)||(rx_id == DEVICE_SPEAKER_STEREO_RX_ACDB_ID))
                    && tx_id == DEVICE_HANDSET_TX_ACDB_ID) {
                    tx_id = DEVICE_SPEAKER_TX_ACDB_ID;
                } else if (((rx_id == DEVICE_SPEAKER_MONO_RX_ACDB_ID )||(rx_id == DEVICE_SPEAKER_STEREO_RX_ACDB_ID))
                    && tx_id == DEVICE_HANDSET_TX_FV5_ACDB_ID) {
                    tx_id = DEVICE_SPEAKER_TX_FV5_ACDB_ID;
                }

                if ((rx_id != uc_mgr->current_rx_device) ||
                    (tx_id != uc_mgr->current_tx_device)) {
                    uc_mgr->current_rx_device = rx_id;
                    uc_mgr->current_tx_device = tx_id;
                    ALOGD("Voice acdb: rx id %d tx id %d",
                          uc_mgr->current_rx_device,
                          uc_mgr->current_tx_device);
                    if (uc_mgr->acdb_handle && !uc_mgr->isFusion3Platform) {
                        acdb_send_voice_cal = dlsym(uc_mgr->acdb_handle,"acdb_loader_send_voice_cal");
                        if (acdb_send_voice_cal == NULL) {
                            ALOGE("ucm: dlsym: Error:%s Loading acdb_loader_send_voice_cal", dlerror());
                        }else {
                            acdb_send_voice_cal(uc_mgr->current_rx_device,
                                       uc_mgr->current_tx_device);
                        }
                   }
                } else {
                    ALOGV("Voice acdb: Required acdb already pushed \
                         rx id %d tx id %d", uc_mgr->current_rx_device,
                         uc_mgr->current_tx_device);
                }
            }
            free(ident_value);
            ident_value = NULL;
        }
    } else {
        ALOGV("No voice use case found");
        uc_mgr->current_rx_device = -1; uc_mgr->current_tx_device = -1;
        ret = -ENODEV;
    }
    return ret;
}

int get_use_case_index(snd_use_case_mgr_t *uc_mgr, const char *use_case,
int ctrl_list_type)
{
    use_case_verb_t *verb_list;
    card_mctrl_t *ctrl_list;
    int ret = 0, index = 0, verb_index;

    verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
    verb_index = uc_mgr->card_ctxt_ptr->current_verb_index;
    if (ctrl_list_type == CTRL_LIST_VERB) {
        ctrl_list =
            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].verb_ctrls;
    } else if (ctrl_list_type == CTRL_LIST_DEVICE) {
        ctrl_list =
            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].device_ctrls;
    } else if (ctrl_list_type == CTRL_LIST_MODIFIER) {
        ctrl_list =
            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].mod_ctrls;
    } else {
        ctrl_list = NULL;
    }
    if((verb_index < 0) ||
      (!strncmp(uc_mgr->card_ctxt_ptr->current_verb, SND_UCM_END_OF_LIST, 3)) ||
      (ctrl_list == NULL) || (ctrl_list[index].case_name == NULL)) {
        ALOGE("Invalid current verb value: %s - %d",
                uc_mgr->card_ctxt_ptr->current_verb, verb_index);
        return -EINVAL;
    }
    while(strncmp(ctrl_list[index].case_name, use_case, (strlen(use_case)+1))) {
        if (!strncmp(ctrl_list[index].case_name, SND_UCM_END_OF_LIST,
            strlen(SND_UCM_END_OF_LIST))) {
            ret = -EINVAL;
            break;
        }
        index++;
        if (ctrl_list[index].case_name == NULL) {
            ALOGE("Invalid case_name at index %d", index);
            ret = -EINVAL;
            break;
        }
    }
    if (ret < 0) {
        return ret;
    } else {
        return index;
    }
}

/* Apply the required mixer controls for specific use case
 * uc_mgr - UCM structure pointer
 * use_case - use case name
 * return 0 on sucess, otherwise a negative error code
 */
int snd_use_case_apply_mixer_controls(snd_use_case_mgr_t *uc_mgr,
const char *use_case, int enable, int ctrl_list_type, int uc_index)
{
    card_mctrl_t *ctrl_list;
    mixer_control_t *mixer_list;
    struct mixer_ctl *ctl;
    int i, ret = 0, index = 0, verb_index, mixer_count;

    verb_index = uc_mgr->card_ctxt_ptr->current_verb_index;
    if (ctrl_list_type == CTRL_LIST_VERB) {
        ctrl_list =
            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].verb_ctrls;
    } else if (ctrl_list_type == CTRL_LIST_DEVICE) {
        ctrl_list =
            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].device_ctrls;
    } else if (ctrl_list_type == CTRL_LIST_MODIFIER) {
        ctrl_list =
            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].mod_ctrls;
    } else {
        ctrl_list = NULL;
    }
    if((verb_index < 0) ||
      (!strncmp(uc_mgr->card_ctxt_ptr->current_verb, SND_UCM_END_OF_LIST, 3)) ||
      (ctrl_list == NULL)) {
        ALOGE("Invalid current verb value: %s - %d",
            uc_mgr->card_ctxt_ptr->current_verb, verb_index);
        return -EINVAL;
    }
    if (uc_index < 0) {
        ALOGE("No valid use case found with the use case: %s", use_case);
        ret = -ENODEV;
    } else {
        if (!uc_mgr->card_ctxt_ptr->mixer_handle) {
            ALOGE("Control device not initialized");
            ret = -ENODEV;
        } else {
            if (enable &&
                (check_devices_for_voice_call(uc_mgr, use_case) != NULL))
                return ret;
            ALOGD("Set mixer controls for %s enable %d", use_case, enable);
            if (ctrl_list[uc_index].acdb_id && ctrl_list[uc_index].capability) {
                if (enable) {
                    if (snd_use_case_apply_voice_acdb(uc_mgr, uc_index)) {
                        ALOGV("acdb_id %d cap %d enable %d",
                            ctrl_list[uc_index].acdb_id,
                            ctrl_list[uc_index].capability, enable);
                        if (uc_mgr->acdb_handle) {
                            acdb_send_audio_cal = dlsym(uc_mgr->acdb_handle,"acdb_loader_send_audio_cal");
                            if (acdb_send_audio_cal == NULL) {
                                ALOGE("ucm:dlsym:Error:%s Loading acdb_loader_send_audio_cal", dlerror());
                            } else {
                                acdb_send_audio_cal(ctrl_list[uc_index].acdb_id,
                                                     ctrl_list[uc_index].capability);
                            }
                        }
                    }
                }
            }
            if (enable) {
                mixer_list = ctrl_list[uc_index].ena_mixer_list;
                mixer_count = ctrl_list[uc_index].ena_mixer_count;
            } else {
                mixer_list = ctrl_list[uc_index].dis_mixer_list;
                mixer_count = ctrl_list[uc_index].dis_mixer_count;
            }
            for(index = 0; index < mixer_count; index++) {
                if (mixer_list == NULL) {
                    ALOGE("No valid controls exist for this case: %s", use_case);
                    break;
                }
                ctl = mixer_get_control(uc_mgr->card_ctxt_ptr->mixer_handle,
                          mixer_list[index].control_name, 0);
                if (ctl) {
                    if (mixer_list[index].type == TYPE_INT) {
                        ALOGV("Setting mixer control: %s, value: %d",
                             mixer_list[index].control_name,
                             mixer_list[index].value);
                        ret = mixer_ctl_set(ctl, mixer_list[index].value);
                    } else if (mixer_list[index].type == TYPE_MULTI_VAL) {
                        ALOGD("Setting multi value: %s",
                            mixer_list[index].control_name);
                        ret = mixer_ctl_set_value(ctl, mixer_list[index].value,
                                mixer_list[index].mulval);
                        if (ret < 0)
                            ALOGE("Failed to set multi value control %s\n",
                                mixer_list[index].control_name);
                    } else {
                        ALOGV("Setting mixer control: %s, value: %s",
                            mixer_list[index].control_name,
                            mixer_list[index].string);
                        ret = mixer_ctl_select(ctl, mixer_list[index].string);
                    }
                    if ((ret != 0) && enable) {
                       /* Disable all the mixer controls which are
                        * already enabled before failure */
                       mixer_list = ctrl_list[uc_index].dis_mixer_list;
                       mixer_count = ctrl_list[uc_index].dis_mixer_count;
                       for(i = 0; i < mixer_count; i++) {
                           ctl = mixer_get_control(
                                     uc_mgr->card_ctxt_ptr->mixer_handle,
                                     mixer_list[i].control_name, 0);
                           if (ctl) {
                               if (mixer_list[i].type == TYPE_INT) {
                                   ret = mixer_ctl_set(ctl,
                                             mixer_list[i].value);
                               } else {
                                   ret = mixer_ctl_select(ctl,
                                             mixer_list[i].string);
                               }
                           }
                       }
                       ALOGE("Failed to enable the mixer controls for %s",
                            use_case);
                       break;
                    }
                }
            }
        }
    }
    return ret;
}

int getUseCaseType(const char *useCase)
{
    ALOGV("getUseCaseType: use case is %s\n", useCase);
    if (!strncmp(useCase, SND_USE_CASE_VERB_HIFI,
           MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI)) ||
        !strncmp(useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC,
           MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC)) ||
        !strncmp(useCase, SND_USE_CASE_VERB_HIFI_LOW_POWER,
           MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_LOW_POWER)) ||
        !strncmp(useCase, SND_USE_CASE_VERB_HIFI_TUNNEL,
            MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_TUNNEL)) ||
        !strncmp(useCase, SND_USE_CASE_VERB_HIFI2,
            MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI2)) ||
        !strncmp(useCase, SND_USE_CASE_VERB_DIGITAL_RADIO,
            MAX_LEN(useCase,SND_USE_CASE_VERB_DIGITAL_RADIO)) ||
        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_MUSIC,
            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_MUSIC)) ||
        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_LOWLATENCY_MUSIC,
            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_LOWLATENCY_MUSIC)) ||
        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_MUSIC2,
            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_MUSIC2)) ||
        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_LPA,
            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_LPA)) ||
        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_TUNNEL,
            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_TUNNEL)) ||
        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_FM,
            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_FM))) {
        return CAP_RX;
    } else if (!strncmp(useCase, SND_USE_CASE_VERB_HIFI_REC,
            MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_REC)) ||
        !strncmp(useCase, SND_USE_CASE_VERB_FM_REC,
            MAX_LEN(useCase,SND_USE_CASE_VERB_FM_REC)) ||
        !strncmp(useCase, SND_USE_CASE_VERB_FM_A2DP_REC,
            MAX_LEN(useCase,SND_USE_CASE_VERB_FM_A2DP_REC)) ||
        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_MUSIC,
            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_MUSIC)) ||
        !strncmp(useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_REC,
            MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_LOWLATENCY_REC)) ||
        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_LOWLATENCY_MUSIC,
            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_LOWLATENCY_MUSIC)) ||
        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_FM,
            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_FM)) ||
        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_A2DP_FM,
            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_A2DP_FM))) {
        return CAP_TX;
    } else if (!strncmp(useCase, SND_USE_CASE_VERB_VOICECALL,
            MAX_LEN(useCase,SND_USE_CASE_VERB_VOICECALL)) ||
        !strncmp(useCase, SND_USE_CASE_VERB_IP_VOICECALL,
            MAX_LEN(useCase,SND_USE_CASE_VERB_IP_VOICECALL)) ||
        !strncmp(useCase, SND_USE_CASE_VERB_DL_REC,
            MAX_LEN(useCase,SND_USE_CASE_VERB_DL_REC)) ||
        !strncmp(useCase, SND_USE_CASE_VERB_UL_DL_REC,
            MAX_LEN(useCase,SND_USE_CASE_VERB_UL_DL_REC)) ||
        !strncmp(useCase, SND_USE_CASE_VERB_INCALL_REC,
            MAX_LEN(useCase,SND_USE_CASE_VERB_INCALL_REC)) ||
        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_VOICE,
            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_VOICE)) ||
        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_VOIP,
            MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_VOIP)) ||
        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_VOICE_DL,
            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_VOICE_DL)) ||
        !strncmp(useCase, SND_USE_CASE_MOD_CAPTURE_VOICE_UL_DL,
            MAX_LEN(useCase,SND_USE_CASE_MOD_CAPTURE_VOICE_UL_DL)) ||
        !strncmp(useCase, SND_USE_CASE_VERB_VOLTE,
            MAX_LEN(useCase,SND_USE_CASE_VERB_VOLTE)) ||
        !strncmp(useCase, SND_USE_CASE_MOD_PLAY_VOLTE,
            MAX_LEN(useCase, SND_USE_CASE_MOD_PLAY_VOLTE))) {
        return CAP_VOICE;
    } else {
        ALOGE("unknown use case %s, returning voice capablity", useCase);
        return CAP_VOICE;
    }
}

/* Set/Reset mixer controls of specific use case for all current devices
 * uc_mgr - UCM structure pointer
 * ident  - use case name (verb or modifier)
 * enable - 1 for enable and 0 for disable
 * return 0 on sucess, otherwise a negative error code
 */
static int set_controls_of_usecase_for_all_devices(snd_use_case_mgr_t *uc_mgr,
const char *ident, int enable, int ctrl_list_type)
{
    card_mctrl_t *dev_list, *uc_list;
    char *current_device, use_case[MAX_UC_LEN];
    int list_size, index, uc_index, ret = 0, intdev_flag = 0;
    int verb_index, capability = 0, ident_cap = 0, dev_cap =0;

    ALOGV("set_use_case_ident_for_all_devices(): %s", ident);
    if ((verb_index = uc_mgr->card_ctxt_ptr->current_verb_index) < 0)
        verb_index = 0;
    dev_list =
        uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].device_ctrls;
    if (ctrl_list_type == CTRL_LIST_VERB) {
        uc_list =
            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].verb_ctrls;
    } else if (ctrl_list_type == CTRL_LIST_MODIFIER) {
        uc_list =
            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].mod_ctrls;
    } else {
        uc_list = NULL;
    }
    ident_cap = getUseCaseType(ident);
    list_size = snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
    for (index = 0; index < list_size; index++) {
        current_device =
        snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->dev_list_head, index);
        if (current_device != NULL) {
            uc_index = get_use_case_index(uc_mgr, current_device,
                       CTRL_LIST_DEVICE);
            dev_cap = dev_list[uc_index].capability;
            if (!capability) {
                capability = dev_list[uc_index].capability;
            } else if (capability != dev_list[uc_index].capability) {
                capability = CAP_VOICE;
            }
            if (ident_cap == CAP_VOICE  || ident_cap == dev_cap) {
                if (enable) {
                    if (!snd_ucm_get_status_at_index(
                        uc_mgr->card_ctxt_ptr->dev_list_head, current_device)) {
                        if (uc_index >= 0) {
                            ALOGV("Applying mixer controls for device: %s",
                                  current_device);
                            ret = snd_use_case_apply_mixer_controls(uc_mgr,
                                  current_device, enable, CTRL_LIST_DEVICE, uc_index);
                            if (!ret)
                                snd_ucm_set_status_at_index(
                                  uc_mgr->card_ctxt_ptr->dev_list_head,
                                  current_device, enable, dev_cap);
                        }
                     } else if (ident_cap == CAP_VOICE) {
                        snd_use_case_apply_voice_acdb(uc_mgr, uc_index);
                     }
                 }
                 strlcpy(use_case, ident, sizeof(use_case));
                 strlcat(use_case, current_device, sizeof(use_case));
                 ALOGV("Applying mixer controls for use case: %s", use_case);
                 if ((uc_index =
                      get_use_case_index(uc_mgr, use_case, ctrl_list_type)) < 0) {
                      ALOGV("No valid use case found: %s", use_case);
                      intdev_flag++;
                 } else {
                      if (capability == CAP_VOICE || ident_cap == CAP_VOICE ||
                          capability == ident_cap) {
                          ret = snd_use_case_apply_mixer_controls(uc_mgr, use_case,
                                enable, ctrl_list_type, uc_index);
                      }
                 }
                 use_case[0] = 0;
                 free(current_device);
             }
        }
    }
    if (intdev_flag) {
        if ((uc_index = get_use_case_index(uc_mgr, ident, ctrl_list_type)) < 0) {
            ALOGE("use case %s not valid without device combination", ident);
        } else {
            if (capability == CAP_VOICE || capability == ident_cap ||
                ident_cap == CAP_VOICE) {
                snd_use_case_apply_mixer_controls(uc_mgr, ident, enable,
                ctrl_list_type, uc_index);
            }
        }
    }
    return ret;
}

/* Set/Reset mixer controls of specific use case for a specific device
 * uc_mgr - UCM structure pointer
 * ident  - use case name (verb or modifier)
 * device - device for which use case needs to be set/reset
 * enable - 1 for enable and 0 for disable
 * return 0 on sucess, otherwise a negative error code
 */
static int set_controls_of_usecase_for_device(snd_use_case_mgr_t *uc_mgr,
const char *ident, const char *device, int enable, int ctrl_list_type)
{
    card_mctrl_t *dev_list;
    char use_case[MAX_UC_LEN];
    int list_size, index, dev_index, uc_index, ret = 0;
    int verb_index, capability = 0;

    ALOGV("set_use_case_ident_for_device(): use case %s device %s", ident,
        device);
    if ((verb_index = uc_mgr->card_ctxt_ptr->current_verb_index) < 0)
        verb_index = 0;
    dev_list =
        uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].device_ctrls;
    if (device != NULL) {
        if (enable) {
            dev_index = get_use_case_index(uc_mgr, device, CTRL_LIST_DEVICE);
            capability = dev_list[dev_index].capability;
            if (!snd_ucm_get_status_at_index(
                uc_mgr->card_ctxt_ptr->dev_list_head, device)) {
                ret = snd_use_case_apply_mixer_controls(uc_mgr, device,
                         enable, CTRL_LIST_DEVICE, dev_index);
                if (!ret)
                    snd_ucm_set_status_at_index(
                    uc_mgr->card_ctxt_ptr->dev_list_head, device, enable,
                    capability);
            }
        }
        strlcpy(use_case, ident, sizeof(use_case));
        strlcat(use_case, device, sizeof(use_case));
    ALOGV("Applying mixer controls for use case: %s", use_case);
        if ((uc_index = get_use_case_index(uc_mgr, use_case, ctrl_list_type)) < 0) {
            ALOGV("No valid use case found: %s", use_case );
            uc_index = get_use_case_index(uc_mgr, ident, ctrl_list_type);
            if (snd_use_case_apply_mixer_controls(uc_mgr, ident, enable,
                ctrl_list_type, uc_index) < 0) {
                 ALOGV("use case %s not valid without device combination also",
                     ident);
            }
        } else {
            ret = snd_use_case_apply_mixer_controls(uc_mgr, use_case, enable,
                      ctrl_list_type, uc_index);
        }
    } else {
        uc_index = get_use_case_index(uc_mgr, ident, ctrl_list_type);
        if (snd_use_case_apply_mixer_controls(uc_mgr, ident, enable,
            ctrl_list_type, uc_index) < 0) {
             ALOGV("use case %s not valid without device combination also",
                 ident);
        }
    }
    return ret;
}

/* Set/Reset mixer controls of specific device for all use cases
 * uc_mgr - UCM structure pointer
 * device - device name
 * enable - 1 for enable and 0 for disable
 * return 0 on sucess, otherwise a negative error code
 */
static int set_controls_of_device_for_all_usecases(snd_use_case_mgr_t *uc_mgr,
const char *device, int enable)
{
    card_mctrl_t *dev_list, *uc_list;
    char *ident_value, use_case[MAX_UC_LEN];
    int verb_index, uc_index, dev_index, capability = 0;
    int list_size, index = 0, ret = -ENODEV, flag = 0, intdev_flag = 0;

    ALOGV("set_controls_of_device_for_all_usecases: %s", device);
    if ((verb_index = uc_mgr->card_ctxt_ptr->current_verb_index) < 0)
        verb_index = 0;
    dev_list =
         uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].device_ctrls;
    dev_index = get_use_case_index(uc_mgr, device, CTRL_LIST_DEVICE);
    if (dev_index >= 0)
        capability = dev_list[dev_index].capability;
    if (strncmp(uc_mgr->card_ctxt_ptr->current_verb, SND_USE_CASE_VERB_INACTIVE,
        strlen(SND_USE_CASE_VERB_INACTIVE))) {
        uc_list =
            uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].verb_ctrls;
        if (capability == CAP_VOICE ||
            capability == getUseCaseType(uc_mgr->card_ctxt_ptr->current_verb) ||
            getUseCaseType(uc_mgr->card_ctxt_ptr->current_verb) == CAP_VOICE) {
            strlcpy(use_case, uc_mgr->card_ctxt_ptr->current_verb,
                sizeof(use_case));
            strlcat(use_case, device, sizeof(use_case));
            if ((uc_index =
                get_use_case_index(uc_mgr, use_case, CTRL_LIST_VERB)) < 0) {
                ALOGV("No valid use case found: %s", use_case);
                intdev_flag = 1;
            } else {
                if (enable) {
                    if (!snd_ucm_get_status_at_index(
                        uc_mgr->card_ctxt_ptr->dev_list_head, device)) {
                        ret = snd_use_case_apply_mixer_controls(uc_mgr, device,
                                  enable, CTRL_LIST_DEVICE, dev_index);
                        if (!ret)
                            snd_ucm_set_status_at_index(
                            uc_mgr->card_ctxt_ptr->dev_list_head, device,
                            enable, capability);
                            flag = 1;
                    }
                }
                ALOGV("set %d for use case value: %s", enable, use_case);
                ret = snd_use_case_apply_mixer_controls(uc_mgr, use_case,
                          enable, CTRL_LIST_VERB, uc_index);
                if (ret != 0)
                     ALOGE("No valid controls exists for usecase %s and device \
                          %s, enable: %d", use_case, device, enable);
            }
        }
        if (intdev_flag) {
            if (enable && !flag) {
                if (!snd_ucm_get_status_at_index(
                    uc_mgr->card_ctxt_ptr->dev_list_head, device)) {
                    ret = snd_use_case_apply_mixer_controls(uc_mgr,
                              device, enable, CTRL_LIST_DEVICE, dev_index);
                    if (!ret)
                        snd_ucm_set_status_at_index(
                        uc_mgr->card_ctxt_ptr->dev_list_head, device, enable,
                        capability);
                    flag = 1;
                }
            }
            use_case[0] = 0;
            strlcpy(use_case, uc_mgr->card_ctxt_ptr->current_verb,
                sizeof(use_case));
            uc_index = get_use_case_index(uc_mgr, use_case, CTRL_LIST_VERB);
            if (capability == CAP_VOICE ||
                capability ==
                getUseCaseType(uc_mgr->card_ctxt_ptr->current_verb) ||
                getUseCaseType(uc_mgr->card_ctxt_ptr->current_verb) ==
                CAP_VOICE) {
                ALOGV("set %d for use case value: %s", enable, use_case);
                ret = snd_use_case_apply_mixer_controls(uc_mgr, use_case,
                          enable, CTRL_LIST_VERB, uc_index);
                if (ret != 0)
                      ALOGE("No valid controls exists for usecase %s and \
                           device %s, enable: %d", use_case, device, enable);
            }
            intdev_flag = 0;
        }
        use_case[0] = 0;
    }
    snd_ucm_print_list(uc_mgr->card_ctxt_ptr->mod_list_head);
    uc_list =
        uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].mod_ctrls;
    list_size = snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->mod_list_head);
    for (index = 0; index < list_size; index++) {
        if ((ident_value =
            snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->mod_list_head,
            index))) {
            if (capability == CAP_VOICE ||
                getUseCaseType(ident_value) == CAP_VOICE ||
                capability == getUseCaseType(ident_value)) {
                strlcpy(use_case, ident_value, sizeof(use_case));
                strlcat(use_case, device, sizeof(use_case));
                if ((uc_index = get_use_case_index(uc_mgr, use_case,
                    CTRL_LIST_MODIFIER)) < 0) {
                    ALOGV("No valid use case found: %s", use_case);
                    intdev_flag = 1;
                } else {
                    if (enable && !flag) {
                        if (!snd_ucm_get_status_at_index(
                            uc_mgr->card_ctxt_ptr->dev_list_head, device)) {
                            ret = snd_use_case_apply_mixer_controls(uc_mgr,
                                      device, enable, CTRL_LIST_DEVICE,
                                      dev_index);
                            if (!ret)
                                snd_ucm_set_status_at_index(
                                    uc_mgr->card_ctxt_ptr->dev_list_head,
                                    device, enable, capability);
                            flag = 1;
                        }
                    }
                    ALOGV("set %d for use case value: %s", enable, use_case);
                    ret = snd_use_case_apply_mixer_controls(uc_mgr,
                          use_case, enable, CTRL_LIST_MODIFIER, uc_index);
                    if (ret != 0)
                        ALOGE("No valid controls exists for usecase %s and \
                            device %s, enable: %d", use_case, device, enable);
                }
            }
            if (intdev_flag) {
                if (enable && !flag) {
                    if (!snd_ucm_get_status_at_index(
                         uc_mgr->card_ctxt_ptr->dev_list_head, device)) {
                        ret = snd_use_case_apply_mixer_controls(uc_mgr,
                                  device, enable, CTRL_LIST_DEVICE, dev_index);
                        if (!ret)
                            snd_ucm_set_status_at_index(
                            uc_mgr->card_ctxt_ptr->dev_list_head, device,
                            enable, capability);
                        flag = 1;
                    }
                }
                use_case[0] = 0;
                strlcpy(use_case, ident_value, sizeof(use_case));
                uc_index =
                    get_use_case_index(uc_mgr, ident_value, CTRL_LIST_MODIFIER);
                if (capability == CAP_VOICE ||
                    capability == getUseCaseType(ident_value) ||
                    getUseCaseType(ident_value) == CAP_VOICE) {
                    ALOGV("set %d for use case value: %s", enable, use_case);
                    ret = snd_use_case_apply_mixer_controls(uc_mgr, use_case,
                          enable, CTRL_LIST_MODIFIER, uc_index);
                    if (ret != 0)
                         ALOGE("No valid controls exists for usecase %s and \
                              device %s, enable: %d", use_case, device, enable);
                }
                intdev_flag = 0;
            }
            use_case[0] = 0;
            free(ident_value);
        }
    }
    if (!enable) {
        ret = snd_use_case_apply_mixer_controls(uc_mgr, device, enable,
                  CTRL_LIST_DEVICE, dev_index);
        if (!ret)
            snd_ucm_set_status_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
                device, enable, capability);
    }
    return ret;
}

/* Returns usecase type i.e. either verb or modifier
 * uc_mgr - UCM structure pointer
 * usecase - usecase name either verb or modifier
 * return CTRL_LIST_VERB or CTRL_LIST_MODIFIER for verb/modifier respectively
 */
static int get_usecase_type(snd_use_case_mgr_t *uc_mgr, const char *usecase)
{
    int ret = -EINVAL, index = 0;

    while (strncmp(uc_mgr->card_ctxt_ptr->verb_list[index],
        SND_UCM_END_OF_LIST, strlen(SND_UCM_END_OF_LIST))) {
        if (!strncmp(uc_mgr->card_ctxt_ptr->verb_list[index], usecase,
            (strlen(usecase)+1))) {
            ret = 0;
            break;
        }
        index++;
    }
    if (ret == 0)
        return CTRL_LIST_VERB;
    else
        return CTRL_LIST_MODIFIER;
}

/* Set/Reset mixer controls of specific device and specific use cases
 * uc_mgr - UCM structure pointer
 * device - device name
 * usecase - use case for which device needs to be enabled
 * enable - 1 for enable and 0 for disable
 * return 0 on sucess, otherwise a negative error code
 */
static int set_controls_of_device_for_usecase(snd_use_case_mgr_t *uc_mgr,
    const char *device, const char *usecase, int enable)
{
    card_mctrl_t *dev_list;
    char use_case[MAX_UC_LEN];
    int ret = -ENODEV, uc_index, dev_index;
    int verb_index, capability = 0;

    ALOGV("set_device_for_ident(): %s %s", device, usecase);
    if ((verb_index = uc_mgr->card_ctxt_ptr->current_verb_index) < 0)
        verb_index = 0;
    dev_list =
         uc_mgr->card_ctxt_ptr->use_case_verb_list[verb_index].device_ctrls;
    dev_index = get_use_case_index(uc_mgr, device, CTRL_LIST_DEVICE);
    capability = dev_list[dev_index].capability;
    if (usecase != NULL) {
        strlcpy(use_case, usecase, sizeof(use_case));
        strlcat(use_case, device, sizeof(use_case));
        if ((uc_index = get_use_case_index(uc_mgr, use_case,
            get_usecase_type(uc_mgr, usecase))) < 0) {
            ALOGV("No valid use case found: %s", use_case);
        } else {
            if (enable) {
                if (!snd_ucm_get_status_at_index(
                    uc_mgr->card_ctxt_ptr->dev_list_head, device)) {
                    ret = snd_use_case_apply_mixer_controls(uc_mgr, device,
                          enable, CTRL_LIST_DEVICE, dev_index);
                    if (!ret)
                        snd_ucm_set_status_at_index
                        (uc_mgr->card_ctxt_ptr->dev_list_head, device, enable,
                        capability);
                }
            }
            ALOGV("set %d for use case value: %s", enable, use_case);
            ret = snd_use_case_apply_mixer_controls(uc_mgr, use_case, enable,
                      get_usecase_type(uc_mgr, usecase), uc_index);
            if (ret != 0)
                ALOGE("No valid controls exists for usecase %s and device %s, \
                     enable: %d", use_case, device, enable);
        }
        use_case[0] = 0;
    } else {
        if (enable) {
            if (!snd_ucm_get_status_at_index(
                 uc_mgr->card_ctxt_ptr->dev_list_head, device)) {
                ret = snd_use_case_apply_mixer_controls(uc_mgr, device, enable,
                          CTRL_LIST_DEVICE, dev_index);
                if (!ret)
                    snd_ucm_set_status_at_index(
                        uc_mgr->card_ctxt_ptr->dev_list_head, device, enable,
                        capability);
            }
        }
    }
    if (!enable) {
        ret = snd_use_case_apply_mixer_controls(uc_mgr, device, enable,
                  CTRL_LIST_DEVICE, dev_index);
        if (!ret)
            snd_ucm_set_status_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
                device, enable, capability);
    }
    return ret;
}

/**
 * Set new value for an identifier
 * uc_mgr - UCM structure
 * identifier - _verb, _enadev, _disdev, _enamod, _dismod
 *        _swdev, _swmod
 * value - Value to be set
 * returns 0 on success, otherwise a negative error code
 */
int snd_use_case_set(snd_use_case_mgr_t *uc_mgr,
                     const char *identifier,
                     const char *value)
{
    use_case_verb_t *verb_list;
    char ident[MAX_STR_LEN], *ident1, *ident2, *temp_ptr;
    int verb_index, list_size, index = 0, ret = -EINVAL;

    pthread_mutex_lock(&uc_mgr->card_ctxt_ptr->card_lock);
    if ((uc_mgr->snd_card_index >= (int)MAX_NUM_CARDS) || (value == NULL) ||
        (uc_mgr->snd_card_index < 0) || (uc_mgr->card_ctxt_ptr == NULL) ||
        (identifier == NULL)) {
        ALOGE("snd_use_case_set(): failed, invalid arguments");
        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
        return -EINVAL;
    }

    ALOGD("snd_use_case_set(): uc_mgr %p identifier %s value %s", uc_mgr,
         identifier, value);
    strlcpy(ident, identifier, sizeof(ident));
    if(!(ident1 = strtok_r(ident, "/", &temp_ptr))) {
        ALOGV("No multiple identifiers found in identifier value");
        ident[0] = 0;
    } else {
        if (!strncmp(ident1, "_swdev", 6)) {
            if(!(ident2 = strtok_r(NULL, "/", &temp_ptr))) {
                ALOGD("Invalid disable device value: %s, but enabling new \
                     device", ident2);
            } else {
                ret = snd_ucm_del_ident_from_list(
                          &uc_mgr->card_ctxt_ptr->dev_list_head, ident2);
                if (ret < 0) {
                    ALOGV("Ignore device %s disable, device not part of \
                         enabled list", ident2);
                } else {
                    ALOGV("swdev: device value to be disabled: %s", ident2);
                    /* Disable mixer controls for
                     * corresponding use cases and device */
                    ret = set_controls_of_device_for_all_usecases(uc_mgr,
                              ident2, 0);
                    if (ret < 0) {
                        ALOGV("Device %s not disabled, no valid use case \
                              found: %d", ident2, errno);
                    }
                }
            }
            pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
            ret = snd_use_case_set(uc_mgr, "_enadev", value);
            if (ret < 0) {
                ALOGV("Device %s not enabled, no valid use case found: %d",
                    value, errno);
            }
            return ret;
        } else if (!strncmp(ident1, "_swmod", 6)) {
            pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
            if(!(ident2 = strtok_r(NULL, "/", &temp_ptr))) {
                ALOGD("Invalid modifier value: %s, but enabling new modifier",
                    ident2);
            } else {
                ret = snd_use_case_set(uc_mgr, "_dismod", ident2);
                if (ret < 0) {
                    ALOGV("Modifier %s not disabled, no valid use case \
                         found: %d", ident2, errno);
                }
            }
            ret = snd_use_case_set(uc_mgr, "_enamod", value);
            if (ret < 0) {
                ALOGV("Modifier %s not enabled, no valid use case found: %d",
                    value, errno);
            }
            return ret;
        } else {
            ALOGV("No switch device/modifier option found: %s", ident1);
        }
        ident[0] = 0;
    }

    if (!strncmp(identifier, "_verb", 5)) {
        /* Check if value is valid verb */
        while (strncmp(uc_mgr->card_ctxt_ptr->verb_list[index],
               SND_UCM_END_OF_LIST, strlen(SND_UCM_END_OF_LIST))) {
            if (!strncmp(uc_mgr->card_ctxt_ptr->verb_list[index], value,
                (strlen(value)+1))) {
                ret = 0;
                break;
            }
            index++;
        }
        if ((ret < 0) && (strncmp(value, SND_USE_CASE_VERB_INACTIVE,
            strlen(SND_USE_CASE_VERB_INACTIVE)))) {
            ALOGE("Invalid verb identifier value");
        } else {
            ALOGV("Index:%d Verb:%s", index,
                uc_mgr->card_ctxt_ptr->verb_list[index]);
            /* Disable the mixer controls for current use case
             * for all the enabled devices */
            if (strncmp(uc_mgr->card_ctxt_ptr->current_verb,
                SND_USE_CASE_VERB_INACTIVE,
                strlen(SND_USE_CASE_VERB_INACTIVE))) {
                ret = set_controls_of_usecase_for_all_devices(uc_mgr,
                      uc_mgr->card_ctxt_ptr->current_verb, 0, CTRL_LIST_VERB);
                if (ret != 0)
                    ALOGE("Failed to disable controls for use case: %s",
                        uc_mgr->card_ctxt_ptr->current_verb);
            }
            strlcpy(uc_mgr->card_ctxt_ptr->current_verb, value, MAX_STR_LEN);
            /* Enable the mixer controls for the new use case
             * for all the enabled devices */
            if (strncmp(uc_mgr->card_ctxt_ptr->current_verb,
               SND_USE_CASE_VERB_INACTIVE,
               strlen(SND_USE_CASE_VERB_INACTIVE))) {
               uc_mgr->card_ctxt_ptr->current_verb_index = index;
               ret = set_controls_of_usecase_for_all_devices(uc_mgr,
                     uc_mgr->card_ctxt_ptr->current_verb, 1, CTRL_LIST_VERB);
            }
        }
    } else if (!strncmp(identifier, "_enadev", 7)) {
        index = 0; ret = 0;
        list_size =
            snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
        for (index = 0; index < list_size; index++) {
            if ((ident1 =
                snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
                index))) {
                if (!strncmp(ident1, value, (strlen(value)+1))) {
                    ALOGV("Ignore enable as %s device is already part of \
                         enabled list", value);
                    free(ident1);
                    break;
                }
                free(ident1);
            }
        }
        if (index == list_size) {
            ALOGV("enadev: device value to be enabled: %s", value);
            snd_ucm_add_ident_to_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
                value);
        }
        snd_ucm_print_list(uc_mgr->card_ctxt_ptr->dev_list_head);
        /* Apply Mixer controls of all verb and modifiers for this device*/
        ret = set_controls_of_device_for_all_usecases(uc_mgr, value, 1);
    } else if (!strncmp(identifier, "_disdev", 7)) {
        ret = snd_ucm_get_status_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
                  value);
        if (ret < 0) {
            ALOGD("disdev: device %s not enabled, no need to disable", value);
        } else if (ret == 0) {
            ALOGV("disdev: device %s not active, remove from the list", value);
            ret =
            snd_ucm_del_ident_from_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
            value);
            if (ret < 0) {
                ALOGE("Invalid device: Device not part of enabled device list");
            }
        } else {
            ret =
            snd_ucm_del_ident_from_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
            value);
            if (ret < 0) {
                ALOGE("Invalid device: Device not part of enabled device list");
            } else {
                ALOGV("disdev: device value to be disabled: %s", value);
                index = get_use_case_index(uc_mgr, value, CTRL_LIST_DEVICE);
                /* Apply Mixer controls for corresponding device and modifier */
                ret = snd_use_case_apply_mixer_controls(uc_mgr, value, 0,
                          CTRL_LIST_DEVICE, index);
            }
        }
    } else if (!strncmp(identifier, "_enamod", 7)) {
        index = 0; ret = 0;
        verb_index = uc_mgr->card_ctxt_ptr->current_verb_index;
        if (verb_index < 0) {
            ALOGE("Invalid verb identifier value");
        } else {
            ALOGV("Index:%d Verb:%s", verb_index,
                 uc_mgr->card_ctxt_ptr->verb_list[verb_index]);
            verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
            while(strncmp(verb_list[verb_index].modifier_list[index], value,
                  (strlen(value)+1))) {
                if (!strncmp(verb_list[verb_index].modifier_list[index],
                    SND_UCM_END_OF_LIST, strlen(SND_UCM_END_OF_LIST))){
                    ret = -EINVAL;
                    break;
                }
                index++;
            }
            if (ret < 0) {
                ALOGE("Invalid modifier identifier value");
            } else {
                snd_ucm_add_ident_to_list(&uc_mgr->card_ctxt_ptr->mod_list_head,
                    value);
                /* Enable the mixer controls for the new use case
                 * for all the enabled devices */
                ret = set_controls_of_usecase_for_all_devices(uc_mgr, value, 1,
                          CTRL_LIST_MODIFIER);
            }
        }
    } else if (!strncmp(identifier, "_dismod", 7)) {
        ret = snd_ucm_del_ident_from_list(&uc_mgr->card_ctxt_ptr->mod_list_head,
                  value);
        if (ret < 0) {
            ALOGE("Modifier not enabled currently, invalid modifier");
        } else {
            ALOGV("dismod: modifier value to be disabled: %s", value);
            /* Enable the mixer controls for the new use case
             * for all the enabled devices */
            ret = set_controls_of_usecase_for_all_devices(uc_mgr, value, 0,
                      CTRL_LIST_MODIFIER);
        }
    } else {
        ALOGE("Unknown identifier value: %s", identifier);
    }
    pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
    return ret;
}

/**
 * Set new value for an identifier based on use case
 * uc_mgr - UCM structure
 * identifier - _verb, _enadev, _disdev, _enamod, _dismod
 *        _swdev, _swmod
 * value - Value to be set
 * usecase - usecase/device for which this command needs to be executed
 * returns 0 on success, otherwise a negative error code
 */
int snd_use_case_set_case(snd_use_case_mgr_t *uc_mgr,
                     const char *identifier,
                     const char *value, const char *usecase)
{
    use_case_verb_t *verb_list;
    char ident[MAX_STR_LEN], *ident1, *ident2, *temp_ptr;
    int verb_index, list_size, index = 0, ret = -EINVAL;

    pthread_mutex_lock(&uc_mgr->card_ctxt_ptr->card_lock);
    if ((uc_mgr->snd_card_index >= (int)MAX_NUM_CARDS) || (value == NULL) ||
        (uc_mgr->snd_card_index < 0) || (uc_mgr->card_ctxt_ptr == NULL) ||
        (identifier == NULL)) {
        ALOGE("snd_use_case_set_case(): failed, invalid arguments");
        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
        return -EINVAL;
    }

    ALOGD("snd_use_case_set_case(): uc_mgr %p identifier %s value %s",
        uc_mgr, identifier, value);
    strlcpy(ident, identifier, sizeof(ident));
    if(!(ident1 = strtok_r(ident, "/", &temp_ptr))) {
        ALOGV("No multiple identifiers found in identifier value");
        ident[0] = 0;
    } else {
        if (!strncmp(ident1, "_swdev", 6)) {
            if(!(ident2 = strtok_r(NULL, "/", &temp_ptr))) {
                ALOGD("Invalid disable device value: %s, but enabling new \
                     device", ident2);
            } else {
                ret = snd_ucm_del_ident_from_list(
                          &uc_mgr->card_ctxt_ptr->dev_list_head, ident2);
                if (ret < 0) {
                    ALOGV("Ignore device %s disable, device not part of \
                         enabled list", ident2);
                } else {
                    ALOGV("swdev: device value to be disabled: %s", ident2);
                    /* Disable mixer controls for
                     * corresponding use cases and device */
                    ret = set_controls_of_device_for_usecase(uc_mgr, ident2,
                              usecase, 0);
                    if (ret < 0) {
                        ALOGV("Device %s not disabled, no valid use case \
                             found: %d", ident2, errno);
                    }
                }
            }
            pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
            ret = snd_use_case_set_case(uc_mgr, "_enadev", value, usecase);
            if (ret < 0) {
                ALOGV("Device %s not enabled, no valid use case found: %d",
                    value, errno);
            }
            return ret;
        } else if (!strncmp(ident1, "_swmod", 6)) {
            pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
            if(!(ident2 = strtok_r(NULL, "/", &temp_ptr))) {
                ALOGD("Invalid modifier value: %s, but enabling new modifier",
                    ident2);
            } else {
                ret = snd_use_case_set_case(uc_mgr, "_dismod", ident2, usecase);
                if (ret < 0) {
                    ALOGV("Modifier %s not disabled, no valid use case \
                         found: %d", ident2, errno);
                }
            }
            ret = snd_use_case_set_case(uc_mgr, "_enamod", value, usecase);
            if (ret < 0) {
                ALOGV("Modifier %s not enabled, no valid use case found: %d",
                    value, errno);
            }
            return ret;
        } else {
            ALOGV("No switch device/modifier option found: %s", ident1);
        }
        ident[0] = 0;
    }

    if (!strncmp(identifier, "_verb", 5)) {
        /* Check if value is valid verb */
        while (strncmp(uc_mgr->card_ctxt_ptr->verb_list[index],
               SND_UCM_END_OF_LIST, MAX_STR_LEN)) {
            if (!strncmp(uc_mgr->card_ctxt_ptr->verb_list[index],
                value, MAX_STR_LEN)) {
                ret = 0;
                break;
            }
            index++;
        }
        if ((ret < 0) && (strncmp(value, SND_USE_CASE_VERB_INACTIVE,
            MAX_STR_LEN))) {
            ALOGE("Invalid verb identifier value");
        } else {
            ALOGV("Index:%d Verb:%s", index,
                 uc_mgr->card_ctxt_ptr->verb_list[index]);
            /* Disable the mixer controls for current use case
             * for specified device */
            if (strncmp(uc_mgr->card_ctxt_ptr->current_verb,
                SND_USE_CASE_VERB_INACTIVE, MAX_STR_LEN)) {
                ret = set_controls_of_usecase_for_device(uc_mgr,
                          uc_mgr->card_ctxt_ptr->current_verb, usecase,
                          0, CTRL_LIST_VERB);
                if (ret != 0)
                    ALOGE("Failed to disable controls for use case: %s",
                        uc_mgr->card_ctxt_ptr->current_verb);
            }
            strlcpy(uc_mgr->card_ctxt_ptr->current_verb, value, MAX_STR_LEN);
            /* Enable the mixer controls for the new use case
             * for specified device */
            if (strncmp(uc_mgr->card_ctxt_ptr->current_verb,
                SND_USE_CASE_VERB_INACTIVE, MAX_STR_LEN)) {
               uc_mgr->card_ctxt_ptr->current_verb_index = index;
               index = 0;
               list_size =
               snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
               for (index = 0; index < list_size; index++) {
                   if ((ident1 = snd_ucm_get_value_at_index(
                       uc_mgr->card_ctxt_ptr->dev_list_head, index))) {
                       if (!strncmp(ident1, usecase, MAX_STR_LEN)) {
                           ALOGV("Device already part of enabled list: %s",
                               usecase);
                           free(ident1);
                           break;
                       }
                       free(ident1);
                   }
               }
               if (index == list_size) {
                   ALOGV("enadev: device value to be enabled: %s", usecase);
                   snd_ucm_add_ident_to_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
                        usecase);
               }
               ret = set_controls_of_usecase_for_device(uc_mgr,
                         uc_mgr->card_ctxt_ptr->current_verb, usecase,
                         1, CTRL_LIST_VERB);
            }
        }
    } else if (!strncmp(identifier, "_enadev", 7)) {
        index = 0; ret = 0;
        list_size =
            snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
        for (index = 0; index < list_size; index++) {
            if ((ident1 =
                snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
                index))) {
                if (!strncmp(ident1, value, MAX_STR_LEN)) {
                    ALOGV("Device already part of enabled list: %s", value);
                    free(ident1);
                    break;
                }
                free(ident1);
            }
        }
        if (index == list_size) {
            ALOGV("enadev: device value to be enabled: %s", value);
            snd_ucm_add_ident_to_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
                value);
        }
        snd_ucm_print_list(uc_mgr->card_ctxt_ptr->dev_list_head);
        /* Apply Mixer controls of usecase for this device*/
        ret = set_controls_of_device_for_usecase(uc_mgr, value, usecase, 1);
    } else if (!strncmp(identifier, "_disdev", 7)) {
        ret = snd_ucm_get_status_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
                  value);
        if (ret < 0) {
            ALOGD("disdev: device %s not enabled, no need to disable", value);
        } else if (ret == 0) {
            ALOGV("disdev: device %s not active, remove from the list", value);
            ret =
            snd_ucm_del_ident_from_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
            value);
            if (ret < 0) {
                ALOGE("Invalid device: Device not part of enabled device list");
            }
        } else {
            ret =
            snd_ucm_del_ident_from_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
            value);
            if (ret < 0) {
                ALOGE("Invalid device: Device not part of enabled device list");
            } else {
                ALOGV("disdev: device value to be disabled: %s", value);
                /* Apply Mixer controls of usecase for this device*/
                ret = set_controls_of_device_for_usecase(uc_mgr, value,
                          usecase, 0);
            }
        }
    } else if (!strncmp(identifier, "_enamod", 7)) {
        if (!strncmp(uc_mgr->card_ctxt_ptr->current_verb,
            SND_USE_CASE_VERB_INACTIVE, MAX_STR_LEN)) {
            ALOGE("Invalid use case verb value");
            ret = -EINVAL;
        } else {
            ret = 0;
            while(strncmp(uc_mgr->card_ctxt_ptr->verb_list[index],
                  uc_mgr->card_ctxt_ptr->current_verb, MAX_STR_LEN)) {
                if (!strncmp(uc_mgr->card_ctxt_ptr->verb_list[index],
                    SND_UCM_END_OF_LIST, MAX_STR_LEN)){
                    ret = -EINVAL;
                    break;
                }
                index++;
            }
        }
        if (ret < 0) {
            ALOGE("Invalid verb identifier value");
        } else {
            verb_index = index; index = 0; ret = 0;
            verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
            ALOGV("Index:%d Verb:%s", verb_index,
                 uc_mgr->card_ctxt_ptr->verb_list[verb_index]);
            while(strncmp(verb_list[verb_index].modifier_list[index],
                value, MAX_STR_LEN)) {
                if (!strncmp(verb_list[verb_index].modifier_list[index],
                    SND_UCM_END_OF_LIST, MAX_STR_LEN)){
                    ret = -EINVAL;
                    break;
                }
                index++;
            }
            if (ret < 0) {
                ALOGE("Invalid modifier identifier value");
            } else {
                index = 0;
                list_size =
                snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
                for (index = 0; index < list_size; index++) {
                    if ((ident1 = snd_ucm_get_value_at_index(
                        uc_mgr->card_ctxt_ptr->dev_list_head, index))) {
                        if (!strncmp(ident1, usecase, MAX_STR_LEN)) {
                            ALOGV("Device already part of enabled list: %s",
                                usecase);
                            free(ident1);
                            break;
                        }
                        free(ident1);
                    }
                }
                if (index == list_size) {
                    ALOGV("enadev: device value to be enabled: %s", usecase);
                    snd_ucm_add_ident_to_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
                         usecase);
                }
                snd_ucm_add_ident_to_list(&uc_mgr->card_ctxt_ptr->mod_list_head,
                    value);
                /* Enable the mixer controls for the new use case
                 * for all the enabled devices */
                ret = set_controls_of_usecase_for_device(uc_mgr, value,
                      usecase, 1, CTRL_LIST_MODIFIER);
            }
        }
    } else if (!strncmp(identifier, "_dismod", 7)) {
        ret = snd_ucm_del_ident_from_list(&uc_mgr->card_ctxt_ptr->mod_list_head,
              value);
        if (ret < 0) {
            ALOGE("Modifier not enabled currently, invalid modifier");
        } else {
            ALOGV("dismod: modifier value to be disabled: %s", value);
            /* Enable the mixer controls for the new use case
             * for all the enabled devices */
            ret = set_controls_of_usecase_for_device(uc_mgr, value, usecase,
                      0, CTRL_LIST_MODIFIER);
        }
    } else {
        ALOGE("Unknown identifier value: %s", identifier);
    }
    pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
    return ret;
}

/**
 * Open and initialise use case core for sound card
 * uc_mgr - Returned use case manager pointer
 * card_name - Sound card name.
 * returns 0 on success, otherwise a negative error code
 */
int snd_use_case_mgr_open(snd_use_case_mgr_t **uc_mgr, const char *card_name)
{
    snd_use_case_mgr_t *uc_mgr_ptr = NULL;
    int index, ret = -EINVAL;
    char tmp[2];

    ALOGV("snd_use_case_open(): card_name %s", card_name);

    if (card_name == NULL) {
        ALOGE("snd_use_case_mgr_open: failed, invalid arguments");
        return ret;
    }

    for (index = 0; index < (int)MAX_NUM_CARDS; index++) {
        if(!strncmp(card_name, card_mapping_list[index].card_name,
           (strlen(card_mapping_list[index].card_name)+1))) {
            ret = 0;
            break;
        }
    }

    if (ret < 0) {
        ALOGE("Card %s not found", card_name);
    } else {
        uc_mgr_ptr = (snd_use_case_mgr_t *)calloc(1,
                         sizeof(snd_use_case_mgr_t));
        if (uc_mgr_ptr == NULL) {
            ALOGE("Failed to allocate memory for instance");
            return -ENOMEM;
        }
        uc_mgr_ptr->snd_card_index = index;
        uc_mgr_ptr->card_ctxt_ptr = (card_ctxt_t *)calloc(1,
                                        sizeof(card_ctxt_t));
        if (uc_mgr_ptr->card_ctxt_ptr == NULL) {
            ALOGE("Failed to allocate memory for card context");
            free(uc_mgr_ptr);
            uc_mgr_ptr = NULL;
            return -ENOMEM;
        }
        uc_mgr_ptr->card_ctxt_ptr->card_number =
            card_mapping_list[index].card_number;
        uc_mgr_ptr->card_ctxt_ptr->card_name =
            (char *)malloc((strlen(card_name)+1)*sizeof(char));
        if (uc_mgr_ptr->card_ctxt_ptr->card_name == NULL) {
            ALOGE("Failed to allocate memory for card name");
            free(uc_mgr_ptr->card_ctxt_ptr);
            free(uc_mgr_ptr);
            uc_mgr_ptr = NULL;
            return -ENOMEM;
        }
        strlcpy(uc_mgr_ptr->card_ctxt_ptr->card_name, card_name,
            ((strlen(card_name)+1)*sizeof(char)));
        uc_mgr_ptr->card_ctxt_ptr->control_device =
            (char *)malloc((strlen("/dev/snd/controlC")+2)*sizeof(char));
        if (uc_mgr_ptr->card_ctxt_ptr->control_device == NULL) {
            ALOGE("Failed to allocate memory for control device string");
            free(uc_mgr_ptr->card_ctxt_ptr->card_name);
            free(uc_mgr_ptr->card_ctxt_ptr);
            free(uc_mgr_ptr);
            uc_mgr_ptr = NULL;
            return -ENOMEM;
        }
        strlcpy(uc_mgr_ptr->card_ctxt_ptr->control_device,
            "/dev/snd/controlC", 18);
        snprintf(tmp, sizeof(tmp), "%d",
            uc_mgr_ptr->card_ctxt_ptr->card_number);
        strlcat(uc_mgr_ptr->card_ctxt_ptr->control_device, tmp,
            (strlen("/dev/snd/controlC")+2)*sizeof(char));
        uc_mgr_ptr->device_list_count = 0;
        uc_mgr_ptr->modifier_list_count = 0;
        uc_mgr_ptr->current_device_list = NULL;
        uc_mgr_ptr->current_modifier_list = NULL;
        uc_mgr_ptr->current_tx_device = -1;
        uc_mgr_ptr->current_rx_device = -1;
        pthread_mutexattr_init(&uc_mgr_ptr->card_ctxt_ptr->card_lock_attr);
        pthread_mutex_init(&uc_mgr_ptr->card_ctxt_ptr->card_lock,
            &uc_mgr_ptr->card_ctxt_ptr->card_lock_attr);
        strlcpy(uc_mgr_ptr->card_ctxt_ptr->current_verb,
                SND_USE_CASE_VERB_INACTIVE, MAX_STR_LEN);
        /* Reset all mixer controls if any applied
         * previously for the same card */
    snd_use_case_mgr_reset(uc_mgr_ptr);
        uc_mgr_ptr->card_ctxt_ptr->current_verb_index = -1;
        /* Parse config files and update mixer controls */
        ret = snd_ucm_parse(&uc_mgr_ptr);
        if(ret < 0) {
            ALOGE("Failed to parse config files: %d", ret);
            snd_ucm_free_mixer_list(&uc_mgr_ptr);
        }
        ALOGV("Open mixer device: %s",
            uc_mgr_ptr->card_ctxt_ptr->control_device);
        uc_mgr_ptr->card_ctxt_ptr->mixer_handle =
            mixer_open(uc_mgr_ptr->card_ctxt_ptr->control_device);
        ALOGV("Mixer handle %p", uc_mgr_ptr->card_ctxt_ptr->mixer_handle);
        *uc_mgr = uc_mgr_ptr;
    }
    ALOGV("snd_use_case_open(): returning instance %p", uc_mgr_ptr);
    return ret;
}


/**
 * \brief Reload and re-parse use case configuration files for sound card.
 * \param uc_mgr Use case manager
 * \return zero if success, otherwise a negative error code
 */
int snd_use_case_mgr_reload(snd_use_case_mgr_t *uc_mgr) {
    ALOGE("Reload is not implemented for now as there is no use case currently");
    return 0;
}

/**
 * \brief Close use case manager
 * \param uc_mgr Use case manager
 * \return zero if success, otherwise a negative error code
 */
int snd_use_case_mgr_close(snd_use_case_mgr_t *uc_mgr)
{
    int ret = 0;

    if ((uc_mgr->snd_card_index >= (int)MAX_NUM_CARDS) ||
        (uc_mgr->snd_card_index < 0) || (uc_mgr->card_ctxt_ptr == NULL)) {
        ALOGE("snd_use_case_mgr_close(): failed, invalid arguments");
        return -EINVAL;
    }

    ALOGV("snd_use_case_close(): instance %p", uc_mgr);
    ret = snd_use_case_mgr_reset(uc_mgr);
    if (ret < 0)
        ALOGE("Failed to reset ucm session");
    snd_ucm_free_mixer_list(&uc_mgr);
    pthread_mutexattr_destroy(&uc_mgr->card_ctxt_ptr->card_lock_attr);
    pthread_mutex_destroy(&uc_mgr->card_ctxt_ptr->card_lock);
    if (uc_mgr->card_ctxt_ptr->mixer_handle) {
        mixer_close(uc_mgr->card_ctxt_ptr->mixer_handle);
        uc_mgr->card_ctxt_ptr->mixer_handle = NULL;
    }
    uc_mgr->snd_card_index = -1;
    uc_mgr->current_tx_device = -1;
    uc_mgr->current_rx_device = -1;
    free(uc_mgr->card_ctxt_ptr->control_device);
    free(uc_mgr->card_ctxt_ptr->card_name);
    free(uc_mgr->card_ctxt_ptr);
    uc_mgr->card_ctxt_ptr = NULL;
    free(uc_mgr);
    uc_mgr = NULL;
    ALOGV("snd_use_case_mgr_close(): card instace closed successfully");
    return ret;
}

/**
 * \brief Reset use case manager verb, device, modifier to deafult settings.
 * \param uc_mgr Use case manager
 * \return zero if success, otherwise a negative error code
 */
int snd_use_case_mgr_reset(snd_use_case_mgr_t *uc_mgr)
{
    char *ident_value;
    int index, list_size, ret = 0;

    ALOGV("snd_use_case_reset(): instance %p", uc_mgr);
    pthread_mutex_lock(&uc_mgr->card_ctxt_ptr->card_lock);
    if ((uc_mgr->snd_card_index >= (int)MAX_NUM_CARDS) ||
        (uc_mgr->snd_card_index < 0) || (uc_mgr->card_ctxt_ptr == NULL)) {
        ALOGE("snd_use_case_mgr_reset(): failed, invalid arguments");
        pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
        return -EINVAL;
    }

    /* Disable mixer controls of all the enabled modifiers */
    list_size = snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->mod_list_head);
    for (index = (list_size-1); index >= 0; index--) {
        if ((ident_value =
            snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->mod_list_head,
                index))) {
            snd_ucm_del_ident_from_list(&uc_mgr->card_ctxt_ptr->mod_list_head,
                ident_value);
            ret = set_controls_of_usecase_for_all_devices(uc_mgr,
                      ident_value, 0, CTRL_LIST_MODIFIER);
        if (ret != 0)
                ALOGE("Failed to disable mixer controls for %s", ident_value);
            free(ident_value);
        }
    }
    /* Clear the enabled modifiers list */
    if (uc_mgr->modifier_list_count) {
        for (index = 0; index < uc_mgr->modifier_list_count; index++) {
            free(uc_mgr->current_modifier_list[index]);
            uc_mgr->current_modifier_list[index] = NULL;
        }
        free(uc_mgr->current_modifier_list);
        uc_mgr->current_modifier_list = NULL;
        uc_mgr->modifier_list_count = 0;
    }
    /* Disable mixer controls of current use case verb */
    if(strncmp(uc_mgr->card_ctxt_ptr->current_verb, SND_USE_CASE_VERB_INACTIVE,
       strlen(SND_USE_CASE_VERB_INACTIVE))) {
        ret = set_controls_of_usecase_for_all_devices(uc_mgr,
                  uc_mgr->card_ctxt_ptr->current_verb, 0, CTRL_LIST_VERB);
        if (ret != 0)
            ALOGE("Failed to disable mixer controls for %s",
                uc_mgr->card_ctxt_ptr->current_verb);
        strlcpy(uc_mgr->card_ctxt_ptr->current_verb, SND_USE_CASE_VERB_INACTIVE,
            MAX_STR_LEN);
    }
    /* Disable mixer controls of all the enabled devices */
    list_size = snd_ucm_get_size_of_list(uc_mgr->card_ctxt_ptr->dev_list_head);
    for (index = (list_size-1); index >= 0; index--) {
        if ((ident_value =
            snd_ucm_get_value_at_index(uc_mgr->card_ctxt_ptr->dev_list_head,
                index))) {
            snd_ucm_del_ident_from_list(&uc_mgr->card_ctxt_ptr->dev_list_head,
                ident_value);
            ret = set_controls_of_device_for_all_usecases(uc_mgr,
                      ident_value, 0);
        if (ret != 0)
                ALOGE("Failed to disable or no mixer controls set for %s",
                    ident_value);
        free(ident_value);
        }
    }
    /* Clear the enabled devices list */
    if (uc_mgr->device_list_count) {
        for (index = 0; index < uc_mgr->device_list_count; index++) {
            free(uc_mgr->current_device_list[index]);
            uc_mgr->current_device_list[index] = NULL;
        }
        free(uc_mgr->current_device_list);
        uc_mgr->current_device_list = NULL;
        uc_mgr->device_list_count = 0;
    }
    uc_mgr->current_tx_device = -1;
    uc_mgr->current_rx_device = -1;
    pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
    return ret;
}

/* 2nd stage parsing done in seperate thread */
void *second_stage_parsing_thread(void *uc_mgr_ptr)
{
    use_case_verb_t *verb_list;
    char path[200];
    struct stat st;
    int fd, index = 0, ret = 0, rc = 0;
    char *read_buf = NULL, *next_str = NULL, *current_str = NULL, *buf = NULL;
    char *p = NULL, *verb_name = NULL, *file_name = NULL, *temp_ptr = NULL;
    snd_use_case_mgr_t **uc_mgr = (snd_use_case_mgr_t **)&uc_mgr_ptr;

    strlcpy(path, CONFIG_DIR, (strlen(CONFIG_DIR)+1));
    strlcat(path, (*uc_mgr)->card_ctxt_ptr->card_name, sizeof(path));
    ALOGV("master config file path:%s", path);
    fd = open(path, O_RDONLY);
    if (fd < 0) {
        ALOGE("failed to open config file %s error %d\n", path, errno);
        return NULL;
    }
    if (fstat(fd, &st) < 0) {
        ALOGE("failed to stat %s error %d\n", path, errno);
        close(fd);
        return NULL;
    }
    read_buf = (char *) mmap(0, st.st_size, PROT_READ | PROT_WRITE,
               MAP_PRIVATE, fd, 0);
    if (read_buf == MAP_FAILED) {
        ALOGE("failed to mmap file error %d\n", errno);
        close(fd);
        return NULL;
    }
    current_str = read_buf;
    verb_name = NULL;
    while (*current_str != (char)EOF)  {
        next_str = strchr(current_str, '\n');
        if (!next_str)
            break;
        *next_str++ = '\0';
        if (verb_name == NULL) {
            buf = strstr(current_str, "SectionUseCase");
            if (buf == NULL) {
                if((current_str = next_str) == NULL)
                    break;
                else
                    continue;
            }
            /* Ignore parsing first use case (HiFi) as it is already parsed
             * in 1st stage of parsing */
            if (index == 0) {
                index++;
                if((current_str = next_str) == NULL)
                    break;
                else
                    continue;
            }
            p = strtok_r(buf, ".", &temp_ptr);
            while (p != NULL) {
                p = strtok_r(NULL, "\"", &temp_ptr);
                if (p == NULL)
                    break;
                verb_name = (char *)malloc((strlen(p)+1)*sizeof(char));
                if(verb_name == NULL) {
                    ret = -ENOMEM;
                    break;
                }
                strlcpy(verb_name, p, (strlen(p)+1)*sizeof(char));
                break;
            }
        } else {
            buf = strstr(current_str, "File");
            if (buf == NULL) {
                if((current_str = next_str) == NULL)
                    break;
                else
                    continue;
            }
            p = strtok_r(buf, "\"", &temp_ptr);
            while (p != NULL) {
                p = strtok_r(NULL, "\"", &temp_ptr);
                if (p == NULL)
                    break;
                file_name = (char *)malloc((strlen(p)+1)*sizeof(char));
                if(file_name == NULL) {
                    ret = -ENOMEM;
                    break;
                }
                strlcpy(file_name, p, (strlen(p)+1)*sizeof(char));
                break;
            }
            verb_list = (*uc_mgr)->card_ctxt_ptr->use_case_verb_list;
            if (file_name != NULL) {
                ret = snd_ucm_parse_verb(uc_mgr, file_name, index);
                verb_list[index].use_case_name =
                    (char *)malloc((strlen(verb_name)+1)*sizeof(char));
                strlcpy(verb_list[index].use_case_name, verb_name,
                    ((strlen(verb_name)+1)*sizeof(char)));
                /* Verb list might have been appended with END OF LIST in
                 * 1st stage parsing. Delete this entry so that new verbs
                 * are appended from here and END OF LIST will be added
                 * again at the end of 2nd stage parsing
                 */
                if((*uc_mgr)->card_ctxt_ptr->verb_list[index]) {
                    free((*uc_mgr)->card_ctxt_ptr->verb_list[index]);
                    (*uc_mgr)->card_ctxt_ptr->verb_list[index] = NULL;
                }
                (*uc_mgr)->card_ctxt_ptr->verb_list[index] =
                    (char *)malloc((strlen(verb_name)+1)*sizeof(char));
                strlcpy((*uc_mgr)->card_ctxt_ptr->verb_list[index], verb_name,
                    ((strlen(verb_name)+1)*sizeof(char)));
                free(verb_name);
                verb_name = NULL;
                free(file_name);
                file_name = NULL;
            }
            index++;
            (*uc_mgr)->card_ctxt_ptr->verb_list[index] =
                (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
            strlcpy((*uc_mgr)->card_ctxt_ptr->verb_list[index],
                 SND_UCM_END_OF_LIST,
                 ((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)));
        }
        if((current_str = next_str) == NULL)
            break;
    }
    if (verb_name != NULL) {
        free(verb_name);
        verb_name = NULL;
    }
    if (file_name != NULL) {
        free(file_name);
        file_name = NULL;
    }
    munmap(read_buf, st.st_size);
    close(fd);
#if PARSE_DEBUG
        /* Prints use cases and mixer controls parsed from config files */
        snd_ucm_print((*uc_mgr));
#endif
    if(ret < 0)
        ALOGE("Failed to parse config files: %d", ret);
    ALOGE("Exiting parsing thread uc_mgr %p\n", uc_mgr);
    return NULL;
}

/* Function can be used by UCM clients to wait until parsing completes
 * uc_mgr - use case manager structure
 * Returns 0 on success, error number otherwise
*/
int snd_use_case_mgr_wait_for_parsing(snd_use_case_mgr_t *uc_mgr)
{
    int ret;

    ret = pthread_join(uc_mgr->thr, NULL);
    return ret;
}

/* Parse config files and update mixer controls for the use cases
 * 1st stage parsing done to parse HiFi config file
 * uc_mgr - use case manager structure
 * Returns 0 on sucess, negative error code otherwise
 */
static int snd_ucm_parse(snd_use_case_mgr_t **uc_mgr)
{
    use_case_verb_t *verb_list;
    struct stat st;
    int fd, verb_count, index = 0, ret = 0, rc;
    char *read_buf, *next_str, *current_str, *buf, *p, *verb_name;
    char *file_name = NULL, *temp_ptr;
    char path[200];

    strlcpy(path, CONFIG_DIR, (strlen(CONFIG_DIR)+1));
    strlcat(path, (*uc_mgr)->card_ctxt_ptr->card_name, sizeof(path));
    ALOGV("master config file path:%s", path);
    fd = open(path, O_RDONLY);
    if (fd < 0) {
        ALOGE("failed to open config file %s error %d\n", path, errno);
        return -EINVAL;
    }
    if (fstat(fd, &st) < 0) {
        ALOGE("failed to stat %s error %d\n", path, errno);
        close(fd);
        return -EINVAL;
    }
    read_buf = (char *) mmap(0, st.st_size, PROT_READ | PROT_WRITE,
               MAP_PRIVATE, fd, 0);
    if (read_buf == MAP_FAILED) {
        ALOGE("failed to mmap file error %d\n", errno);
        close(fd);
        return -EINVAL;
    }
    current_str = read_buf;
    verb_count = get_verb_count(current_str);
    (*uc_mgr)->card_ctxt_ptr->use_case_verb_list =
        (use_case_verb_t *)malloc((verb_count+1)*(sizeof(use_case_verb_t)));
    if ((*uc_mgr)->card_ctxt_ptr->use_case_verb_list == NULL) {
        ALOGE("failed to allocate memory for use case verb list\n");
        munmap(read_buf, st.st_size);
        close(fd);
        return -ENOMEM;
    }
    if (((*uc_mgr)->card_ctxt_ptr->verb_list =
        (char **)malloc((verb_count+2)*(sizeof(char *)))) == NULL) {
        ALOGE("failed to allocate memory for verb list\n");
        munmap(read_buf, st.st_size);
        close(fd);
        return -ENOMEM;
    }
    verb_name = NULL;
    if ((ret = is_single_config_format(current_str))) {
        ALOGD("Single config file format detected\n");
        ret = parse_single_config_format(uc_mgr, current_str, verb_count);
        munmap(read_buf, st.st_size);
        close(fd);
        return ret;
    }
    while (*current_str != (char)EOF)  {
        next_str = strchr(current_str, '\n');
        if (!next_str)
            break;
        *next_str++ = '\0';
        if (verb_name == NULL) {
            buf = strstr(current_str, "SectionUseCase");
            if (buf == NULL) {
                if((current_str = next_str) == NULL)
                    break;
                else
                    continue;
            }
            verb_list = (*uc_mgr)->card_ctxt_ptr->use_case_verb_list;
            p = strtok_r(buf, ".", &temp_ptr);
            while (p != NULL) {
                p = strtok_r(NULL, "\"", &temp_ptr);
                if (p == NULL)
                    break;
                verb_name = (char *)malloc((strlen(p)+1)*sizeof(char));
                if(verb_name == NULL) {
                    ret = -ENOMEM;
                    break;
                }
                strlcpy(verb_name, p, (strlen(p)+1)*sizeof(char));
                if ((verb_list[index].use_case_name =
                    (char *)malloc((strlen(verb_name)+1)*sizeof(char)))) {
                    strlcpy(verb_list[index].use_case_name,
                        verb_name, ((strlen(verb_name)+1)*sizeof(char)));
                } else {
                    ret = -ENOMEM;
                    break;
                }
                if (((*uc_mgr)->card_ctxt_ptr->verb_list[index] =
                    (char *)malloc((strlen(verb_name)+1)*sizeof(char)))) {
                    strlcpy((*uc_mgr)->card_ctxt_ptr->verb_list[index],
                        verb_name, ((strlen(verb_name)+1)*sizeof(char)));
                } else {
                    ret = -ENOMEM;
                    break;
                }
                break;
            }
        } else {
            buf = strstr(current_str, "File");
            if (buf == NULL) {
                if((current_str = next_str) == NULL)
                    break;
                else
                    continue;
            }
            p = strtok_r(buf, "\"", &temp_ptr);
            while (p != NULL) {
                p = strtok_r(NULL, "\"", &temp_ptr);
                if (p == NULL)
                    break;
                file_name = (char *)malloc((strlen(p)+1)*sizeof(char));
                if(file_name == NULL) {
                    ret = -ENOMEM;
                    break;
                }
                strlcpy(file_name, p, (strlen(p)+1)*sizeof(char));
                break;
            }
            if (file_name != NULL) {
                ret = snd_ucm_parse_verb(uc_mgr, file_name, index);
                if (ret < 0)
                    ALOGE("Failed to parse config file %s\n", file_name);
                free(verb_name);
                verb_name = NULL;
                free(file_name);
                file_name = NULL;
            }
            index++;
            /* Break here so that only one first use case config file (HiFi)
             * from master config file is parsed initially and all other
             * config files are parsed in seperate thread created below so
             * that audio HAL can initialize faster during boot-up
             */
            break;
        }
        if((current_str = next_str) == NULL)
            break;
    }
    munmap(read_buf, st.st_size);
    close(fd);
    if (((*uc_mgr)->card_ctxt_ptr->verb_list[index] =
        (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)))) {
        strlcpy((*uc_mgr)->card_ctxt_ptr->verb_list[index], SND_UCM_END_OF_LIST,
                ((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)));
    } else {
        ALOGE("Failed to allocate memory\n");
        ret = -ENOMEM;
    }
    if (!ret) {
        ALOGD("Creating Parsing thread uc_mgr %p\n", uc_mgr);
        rc = pthread_create(&(*uc_mgr)->thr, 0, second_stage_parsing_thread,
                 (void*)(*uc_mgr));
        if(rc < 0) {
            ALOGE("Failed to create parsing thread rc %d errno %d\n", rc, errno);
        } else {
            ALOGV("Prasing thread created successfully\n");
        }
    }
    if (verb_name)
        free(verb_name);
    if (file_name)
        free(file_name);
    return ret;
}

/* Parse a single config file format
 * uc_mgr - use case manager structure
 * buf - config file buffer to be parsed
 * Returns 0 on sucess, negative error code otherwise
 */
static int parse_single_config_format(snd_use_case_mgr_t **uc_mgr,
char *current_str, int num_verbs)
{
    struct stat st;
    card_mctrl_t *list;
    use_case_verb_t *verb_list;
    int verb_count = 0, device_count = 0, mod_count = 0, index = -1, ret = 0;
    char *next_str, *buf, *p, *verb_ptr, *temp_ptr;

    verb_list = (*uc_mgr)->card_ctxt_ptr->use_case_verb_list;
    while (*current_str != (char)EOF)  {
        next_str = strchr(current_str, '\n');
        if (!next_str)
            break;
        *next_str++ = '\0';
        if ((buf = strcasestr(current_str, "SectionUseCase")) != NULL) {
            if (index != -1) {
                list = (verb_list[index].verb_ctrls +
                            verb_list[index].verb_count);
                list->case_name = (char *)
                    malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
                if(list->case_name == NULL) {
                    free(verb_list[index].verb_ctrls);
                    return -ENOMEM;
                }
                strlcpy(list->case_name, SND_UCM_END_OF_LIST,
                   (strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
                list->ena_mixer_list = NULL;
                list->dis_mixer_list = NULL;
                list->ena_mixer_count = 0;
                list->dis_mixer_count = 0;
                list->playback_dev_name = NULL;
                list->capture_dev_name = NULL;
                list->acdb_id = 0;
                list->capability = 0;
            }
            index++;
            p = strtok_r(buf, ".", &temp_ptr);
            while (p != NULL) {
                p = strtok_r(NULL, "\"", &temp_ptr);
                if (p == NULL)
                    break;
                if ((verb_list[index].use_case_name =
                    (char *)malloc((strlen(p)+1)*sizeof(char)))) {
                    strlcpy(verb_list[index].use_case_name,
                        p, ((strlen(p)+1)*sizeof(char)));
                } else {
                    ret = -ENOMEM;
                    break;
                }
                if (((*uc_mgr)->card_ctxt_ptr->verb_list[index] =
                    (char *)malloc((strlen(p)+1)*sizeof(char)))) {
                    strlcpy((*uc_mgr)->card_ctxt_ptr->verb_list[index],
                       p, ((strlen(p)+1)*sizeof(char)));
                } else {
                    ret = -ENOMEM;
                    break;
                }
                break;
            }
            verb_list[index].verb_count = 0;
            verb_list[index].device_count = 0;
            verb_list[index].mod_count = 0;
            verb_list[index].device_list = NULL;
            verb_list[index].modifier_list = NULL;
            verb_list[index].verb_ctrls = NULL;
            verb_list[index].device_ctrls = NULL;
            verb_list[index].mod_ctrls = NULL;
            verb_count = get_num_verbs_config_format(next_str);
            verb_list[index].verb_ctrls = (card_mctrl_t *)
                malloc((verb_count+1)*sizeof(card_mctrl_t));
            if (verb_list[index].verb_ctrls == NULL) {
               ret = -ENOMEM;
               break;
            }
            verb_list[index].verb_count = 0;
        } else if (!strncasecmp(current_str, "SectionVerb", 11)) {
            ret = snd_ucm_parse_section(uc_mgr, &current_str,
                    &next_str, index, CTRL_LIST_VERB);
            if (ret < 0)
                break;
        } else if (!strncasecmp(current_str, "SectionDevice", 13)) {
            if (device_count == 0) {
                device_count = get_num_device_config_format(next_str);
                verb_list[0].device_ctrls = (card_mctrl_t *)
                    malloc((device_count+1)*sizeof(card_mctrl_t));
                if (verb_list[0].device_ctrls == NULL) {
                    ret = -ENOMEM;
                    break;
                }
                verb_list[0].device_list =
                    (char **)malloc((device_count+1)*sizeof(char *));
                if (verb_list[0].device_list == NULL)
                    return -ENOMEM;
                verb_list[0].device_count = 0;
            }
            ret = snd_ucm_parse_section(uc_mgr, &current_str,
                      &next_str, 0, CTRL_LIST_DEVICE);
            if (ret < 0) {
                break;
            } else {
                list = (verb_list[0].device_ctrls +
                           (verb_list[0].device_count - 1));
                verb_ptr = (char *)
                    malloc((strlen(list->case_name)+1)*sizeof(char));
                    if (verb_ptr == NULL) {
                        ret = -ENOMEM;
                        break;
                    }
                    strlcpy(verb_ptr, list->case_name,
                        ((strlen(list->case_name)+1)*sizeof(char)));
                    verb_list[0].device_list[(verb_list[0].device_count-1)]
                        = verb_ptr;
            }
        } else if (!strncasecmp(current_str, "SectionModifier", 15)) {
            if (mod_count == 0) {
                mod_count = get_num_mod_config_format(next_str);
                verb_list[0].mod_ctrls = (card_mctrl_t *)
                    malloc((mod_count+1)*sizeof(card_mctrl_t));
                if (verb_list[0].mod_ctrls == NULL) {
                    ret = -ENOMEM;
                    break;
                }
                verb_list[0].modifier_list =
                    (char **)malloc((mod_count+1)*sizeof(char *));
                if (verb_list[0].modifier_list == NULL)
                    return -ENOMEM;
                verb_list[0].mod_count = 0;
            }
            ret = snd_ucm_parse_section(uc_mgr, &current_str,
                     &next_str, 0, CTRL_LIST_MODIFIER);
            if (ret < 0) {
                break;
            } else {
                list = (verb_list[0].mod_ctrls +
                        (verb_list[0].mod_count - 1));
                verb_ptr = (char *)
                    malloc((strlen(list->case_name)+1)*sizeof(char));
                if (verb_ptr == NULL) {
                    ret = -ENOMEM;
                    break;
                }
                strlcpy(verb_ptr, list->case_name,
                   ((strlen(list->case_name)+1)*sizeof(char)));
                verb_list[0].modifier_list[(verb_list[0].mod_count - 1)]
                    = verb_ptr;
            }
        }
        if((current_str = next_str) == NULL)
            break;
    }
    list = (verb_list[index].verb_ctrls +
            verb_list[index].verb_count);
    list->case_name =
        (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
    if(list->case_name == NULL) {
        free(verb_list[index].verb_ctrls);
        return -ENOMEM;
    }
    strlcpy(list->case_name, SND_UCM_END_OF_LIST,
        (strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
    list->ena_mixer_list = NULL;
    list->dis_mixer_list = NULL;
    list->ena_mixer_count = 0;
    list->dis_mixer_count = 0;
    list->playback_dev_name = NULL;
    list->capture_dev_name = NULL;
    list->acdb_id = 0;
    list->capability = 0;
    index++;
    if (index != -1) {
        if (((*uc_mgr)->card_ctxt_ptr->verb_list[index] =
            (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)))) {
            strlcpy((*uc_mgr)->card_ctxt_ptr->verb_list[index],
                SND_UCM_END_OF_LIST,
                ((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)));
        } else {
            ALOGE("Failed to allocate memory\n");
            ret = -ENOMEM;
        }
    }
    /* Add end of list to device list */
    verb_ptr =
       (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
    if (verb_ptr == NULL)
        return -ENOMEM;
    strlcpy(verb_ptr, SND_UCM_END_OF_LIST,
        ((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)));
    verb_list[0].device_list[verb_list[0].device_count] = verb_ptr;
    /* Add end of list to modifier list */
    verb_ptr =
    (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
        if (verb_ptr == NULL)
            return -ENOMEM;
    strlcpy(verb_ptr, SND_UCM_END_OF_LIST,
        ((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)));
    verb_list[0].modifier_list[verb_list[0].mod_count] = verb_ptr;
    /* Add end of list to device controls list */
    list = (verb_list[0].device_ctrls +
               verb_list[0].device_count);
    list->case_name =
        (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
    if(list->case_name == NULL) {
        free(verb_list[0].device_ctrls);
        return -ENOMEM;
    }
    strlcpy(list->case_name, SND_UCM_END_OF_LIST,
        (strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
    list->ena_mixer_list = NULL;
    list->dis_mixer_list = NULL;
    list->ena_mixer_count = 0;
    list->dis_mixer_count = 0;
    list->playback_dev_name = NULL;
    list->capture_dev_name = NULL;
    list->acdb_id = 0;
    list->capability = 0;
    /* Add end of list to modifier controls list */
    list = (verb_list[0].mod_ctrls +
        verb_list[0].mod_count);
    list->case_name =
        (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
    if(list->case_name == NULL) {
        free(verb_list[0].mod_ctrls);
        return -ENOMEM;
    }
    strlcpy(list->case_name, SND_UCM_END_OF_LIST,
        (strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
    list->ena_mixer_list = NULL;
    list->dis_mixer_list = NULL;
    list->ena_mixer_count = 0;
    list->dis_mixer_count = 0;
    list->playback_dev_name = NULL;
    list->capture_dev_name = NULL;
    list->acdb_id = 0;
    list->capability = 0;
    for (index = 1; index < num_verbs; index++) {
        verb_list[index].device_ctrls = verb_list[0].device_ctrls;
        verb_list[index].device_list = verb_list[0].device_list;
        verb_list[index].device_count = verb_list[0].device_count;
        verb_list[index].mod_ctrls = verb_list[0].mod_ctrls;
        verb_list[index].modifier_list = verb_list[0].modifier_list;
        verb_list[index].mod_count = verb_list[0].mod_count;
    }
    if (ret < 0) {
        ALOGE("Failed to parse config file ret %d errno %d\n", ret, errno);
    } else {
        ALOGV("Prasing done successfully\n");
#if PARSE_DEBUG
        /* Prints use cases and mixer controls parsed from config files */
        snd_ucm_print((*uc_mgr));
#endif
    }
    return ret;
}

/* Returns number of verb sections for specific use case verb*/
static int get_num_verbs_config_format(const char *nxt_str)
{
    char *current_str, *next_str, *str_addr, *buf;
    int count = 0;

    next_str = (char *)malloc((strlen(nxt_str)+1)*sizeof(char));
    if (next_str == NULL) {
        ALOGE("Failed to allocate memory");
        return -ENOMEM;
    }
    strlcpy(next_str, nxt_str, ((strlen(nxt_str)+1)*sizeof(char)));
    str_addr = next_str;
    current_str = next_str;
    while(1) {
        next_str = strchr(current_str, '\n');
        if (!next_str)
            break;
        *next_str++ = '\0';
        buf = strcasestr(current_str, "SectionUseCase");
        if (buf != NULL)
            break;
        buf = strcasestr(current_str, "SectionVerb");
        if (buf != NULL)
            count++;
        if (*next_str == (char)EOF)
            break;
        if((current_str = next_str) == NULL)
            break;
    }
    free(str_addr);
    return count;
}

/* Returns number of common device sections for all use case verbs*/
static int get_num_device_config_format(const char *nxt_str)
{
    char *current_str, *next_str, *str_addr, *buf;
    int count = 1;

    next_str = (char *)malloc((strlen(nxt_str)+1)*sizeof(char));
    if (next_str == NULL) {
        ALOGE("Failed to allocate memory");
        return -ENOMEM;
    }
    strlcpy(next_str, nxt_str, ((strlen(nxt_str)+1)*sizeof(char)));
    str_addr = next_str;
    current_str = next_str;
    while(1) {
        next_str = strchr(current_str, '\n');
        if (!next_str)
            break;
        *next_str++ = '\0';
        buf = strcasestr(current_str, "SectionDevice");
        if (buf != NULL)
            count++;
        if (*next_str == (char)EOF)
            break;
        if((current_str = next_str) == NULL)
            break;
    }
    free(str_addr);
    return count;
}

/* Returns number of common modifier sections for all use case verbs*/
static int get_num_mod_config_format(const char *nxt_str)
{
    char *current_str, *next_str, *str_addr, *buf;
    int count = 1;

    next_str = (char *)malloc((strlen(nxt_str)+1)*sizeof(char));
    if (next_str == NULL) {
        ALOGE("Failed to allocate memory");
        return -ENOMEM;
    }
    strlcpy(next_str, nxt_str, ((strlen(nxt_str)+1)*sizeof(char)));
    str_addr = next_str;
    current_str = next_str;
    while(1) {
        next_str = strchr(current_str, '\n');
        if (!next_str)
            break;
        *next_str++ = '\0';
        buf = strcasestr(current_str, "SectionModifier");
        if (buf != NULL)
            count++;
        if (*next_str == (char)EOF)
            break;
        if((current_str = next_str) == NULL)
            break;
    }
    free(str_addr);
    return count;
}

/* Gets the number of use case verbs defined by master config file */
static int get_verb_count(const char *nxt_str)
{
    char *current_str, *next_str, *str_addr, *buf, *p;
    int count = 0;

    next_str = (char *)malloc((strlen(nxt_str)+1)*sizeof(char));
    if (next_str == NULL) {
        ALOGE("Failed to allocate memory");
        return -ENOMEM;
    }
    strlcpy(next_str, nxt_str, ((strlen(nxt_str)+1)*sizeof(char)));
    str_addr = next_str;
    current_str = next_str;
    while(1) {
        next_str = strchr(current_str, '\n');
        if (!next_str)
            break;
        *next_str++ = '\0';
        buf = strstr(current_str, "SectionUseCase");
        if (buf != NULL)
            count++;
        if (*next_str == (char)EOF)
            break;
        if((current_str = next_str) == NULL)
            break;
    }
    free(str_addr);
    return count;
}

/* Returns one if single config file per sound card format is being used */
static int is_single_config_format(const char *nxt_str)
{
    char *current_str, *next_str, *str_addr, *buf;
    int ret = 1, count = 0;

    next_str = (char *)malloc((strlen(nxt_str)+1)*sizeof(char));
    if (next_str == NULL) {
        ALOGE("Failed to allocate memory");
        return -ENOMEM;
    }
    strlcpy(next_str, nxt_str, ((strlen(nxt_str)+1)*sizeof(char)));
    str_addr = next_str;
    current_str = next_str;
    while(1) {
        next_str = strchr(current_str, '\n');
        if (!next_str)
            break;
        *next_str++ = '\0';
        buf = strstr(current_str, "SectionUseCase");
        if (buf != NULL)
            count++;
        buf = strstr(current_str, "File");
        if (buf != NULL)
            ret = 0;
        if ((*next_str == (char)EOF) || (count == 2))
            break;
        if((current_str = next_str) == NULL)
            break;
    }
    free(str_addr);
    return ret;
}

/* Parse a use case verb config files and update mixer controls for the verb
 * uc_mgr - use case manager structure
 * file_name - use case verb config file name
 * index - index of the verb in the list
 * Returns 0 on sucess, negative error code otherwise
 */
static int snd_ucm_parse_verb(snd_use_case_mgr_t **uc_mgr,
const char *file_name, int index)
{
    struct stat st;
    card_mctrl_t *list;
    int device_count, modifier_count;
    int fd, ret = 0, parse_count = 0;
    char *read_buf, *next_str, *current_str, *verb_ptr;
    char path[200];
    use_case_verb_t *verb_list;

    strlcpy(path, CONFIG_DIR, (strlen(CONFIG_DIR)+1));
    strlcat(path, file_name, sizeof(path));
    ALOGV("path:%s", path);
    verb_list = (*uc_mgr)->card_ctxt_ptr->use_case_verb_list;
    while(1) {
        device_count = 0; modifier_count = 0;
        if (parse_count == 0) {
            verb_list[index].verb_count = 0;
            verb_list[index].device_count = 0;
            verb_list[index].mod_count = 0;
            verb_list[index].device_list = NULL;
            verb_list[index].modifier_list = NULL;
            verb_list[index].verb_ctrls = NULL;
            verb_list[index].device_ctrls = NULL;
            verb_list[index].mod_ctrls = NULL;
        }
        fd = open(path, O_RDONLY);
        if (fd < 0) {
             ALOGE("failed to open config file %s error %d\n", path, errno);
             return -EINVAL;
        }
        if (fstat(fd, &st) < 0) {
            ALOGE("failed to stat %s error %d\n", path, errno);
            close(fd);
            return -EINVAL;
        }
        read_buf = (char *) mmap(0, st.st_size, PROT_READ | PROT_WRITE,
                   MAP_PRIVATE, fd, 0);
        if (read_buf == MAP_FAILED) {
            ALOGE("failed to mmap file error %d\n", errno);
            close(fd);
            return -EINVAL;
        }
        current_str = read_buf;
        while (*current_str != (char)EOF)  {
            next_str = strchr(current_str, '\n');
            if (!next_str)
                break;
            *next_str++ = '\0';
            if (!strncasecmp(current_str, "SectionVerb", 11)) {
                if (parse_count == 0) {
                    verb_list[index].verb_count++;
                } else {
                    ret = snd_ucm_parse_section(uc_mgr, &current_str,
                              &next_str, index, CTRL_LIST_VERB);
                    if (ret < 0)
                        break;
                }
            } else if (!strncasecmp(current_str, "SectionDevice", 13)) {
                if (parse_count == 0) {
                    verb_list[index].device_count++;
                    device_count++;
                } else {
                    ret = snd_ucm_parse_section(uc_mgr, &current_str,
                              &next_str, index, CTRL_LIST_DEVICE);
                    if (ret < 0) {
                        break;
                    } else {
                        list = (verb_list[index].device_ctrls +
                                   (verb_list[index].device_count - 1));
                        verb_ptr = (char *)
                            malloc((strlen(list->case_name)+1)*sizeof(char));
                        if (verb_ptr == NULL) {
                            ret = -ENOMEM;
                            break;
                        }
                        strlcpy(verb_ptr, list->case_name,
                            ((strlen(list->case_name)+1)*sizeof(char)));
                        verb_list[index].device_list[device_count] = verb_ptr;
                        device_count++;
                    }
                }
            } else if (!strncasecmp(current_str, "SectionModifier", 15)) {
                if (parse_count == 0) {
                    verb_list[index].mod_count++;
                    modifier_count++;
                } else {
                    ret = snd_ucm_parse_section(uc_mgr, &current_str,
                              &next_str, index, CTRL_LIST_MODIFIER);
                    if (ret < 0) {
                        break;
                    } else {
                        list = (verb_list[index].mod_ctrls +
                               (verb_list[index].mod_count - 1));
                        verb_ptr = (char *)
                            malloc((strlen(list->case_name)+1)*sizeof(char));
                        if (verb_ptr == NULL) {
                            ret = -ENOMEM;
                            break;
                        }
                        strlcpy(verb_ptr, list->case_name,
                            ((strlen(list->case_name)+1)*sizeof(char)));
                        verb_list[index].modifier_list[modifier_count]
                            = verb_ptr;
                        modifier_count++;
                    }
                }
            }
            if((current_str = next_str) == NULL)
                break;
        }
        munmap(read_buf, st.st_size);
        close(fd);
        if(ret < 0)
            return ret;
        if (parse_count == 0) {
            verb_list[index].device_list =
                (char **)malloc((device_count+1)*sizeof(char *));
            if (verb_list[index].device_list == NULL)
                return -ENOMEM;
            verb_list[index].modifier_list =
                (char **)malloc((modifier_count+1)*sizeof(char *));
            if (verb_list[index].modifier_list == NULL)
                return -ENOMEM;
            parse_count += verb_list[index].verb_count;
            verb_list[index].verb_ctrls = (card_mctrl_t *)
                malloc((verb_list[index].verb_count+1)*sizeof(card_mctrl_t));
            if (verb_list[index].verb_ctrls == NULL) {
               ret = -ENOMEM;
               break;
            }
            verb_list[index].verb_count = 0;
            parse_count += verb_list[index].device_count;
            verb_list[index].device_ctrls = (card_mctrl_t *)
                malloc((verb_list[index].device_count+1)*sizeof(card_mctrl_t));
            if (verb_list[index].device_ctrls == NULL) {
               ret = -ENOMEM;
               break;
            }
            verb_list[index].device_count = 0;
            parse_count += verb_list[index].mod_count;
            verb_list[index].mod_ctrls = (card_mctrl_t *)
                malloc((verb_list[index].mod_count+1)*sizeof(card_mctrl_t));
            if (verb_list[index].mod_ctrls == NULL) {
               ret = -ENOMEM;
               break;
            }
            verb_list[index].mod_count = 0;
            continue;
        } else {
            verb_ptr =
            (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
            if (verb_ptr == NULL)
                return -ENOMEM;
            strlcpy(verb_ptr, SND_UCM_END_OF_LIST,
                ((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)));
            verb_list[index].device_list[device_count] = verb_ptr;
            verb_ptr =
            (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
            if (verb_ptr == NULL)
                return -ENOMEM;
            strlcpy(verb_ptr, SND_UCM_END_OF_LIST,
                ((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char)));
            verb_list[index].modifier_list[modifier_count] = verb_ptr;
            list = (verb_list[index].verb_ctrls +
                       verb_list[index].verb_count);
            list->case_name =
                 (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
            if(list->case_name == NULL) {
                free(verb_list[index].verb_ctrls);
                return -ENOMEM;
            }
            strlcpy(list->case_name, SND_UCM_END_OF_LIST,
               (strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
            list->ena_mixer_list = NULL;
            list->dis_mixer_list = NULL;
            list->ena_mixer_count = 0;
            list->dis_mixer_count = 0;
            list->playback_dev_name = NULL;
            list->capture_dev_name = NULL;
            list->acdb_id = 0;
            list->capability = 0;
            list = (verb_list[index].device_ctrls +
                       verb_list[index].device_count);
            list->case_name =
                 (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
            if(list->case_name == NULL) {
                free(verb_list[index].device_ctrls);
                return -ENOMEM;
            }
            strlcpy(list->case_name, SND_UCM_END_OF_LIST,
               (strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
            list->ena_mixer_list = NULL;
            list->dis_mixer_list = NULL;
            list->ena_mixer_count = 0;
            list->dis_mixer_count = 0;
            list->playback_dev_name = NULL;
            list->capture_dev_name = NULL;
            list->acdb_id = 0;
            list->capability = 0;
            list = (verb_list[index].mod_ctrls +
                       verb_list[index].mod_count);
            list->case_name =
                 (char *)malloc((strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
            if(list->case_name == NULL) {
                free(verb_list[index].mod_ctrls);
                return -ENOMEM;
            }
            strlcpy(list->case_name, SND_UCM_END_OF_LIST,
               (strlen(SND_UCM_END_OF_LIST)+1)*sizeof(char));
            list->ena_mixer_list = NULL;
            list->dis_mixer_list = NULL;
            list->ena_mixer_count = 0;
            list->dis_mixer_count = 0;
            list->playback_dev_name = NULL;
            list->capture_dev_name = NULL;
            list->acdb_id = 0;
            list->capability = 0;
            parse_count = 0;
            break;
        }
    }
    return ret;
}

/* Print mixer controls in a specific list
 * list - list to be printed
 * verb_index - verb index
 * count - number of elements in the list
 * Returns 0 on sucess, negative error code otherwise
 */
static int print_list(card_mctrl_t *list, int verb_index, int count)
{
    int i, j;

    for(i=0; i < count; i++) {
        ALOGD("\tcase name: %s\n", list[i].case_name);
        ALOGD("\tEnable sequence: %d\n", list[i].ena_mixer_count);
        for(j=0; j<list[i].ena_mixer_count; j++) {
            ALOGD("\t\t%s : %d : %d: %s\n",
                list[i].ena_mixer_list[j].control_name,
                list[i].ena_mixer_list[j].type,
                list[i].ena_mixer_list[j].value,
                list[i].ena_mixer_list[j].string);
        }
        ALOGD("\tDisable sequence: %d\n", list[i].dis_mixer_count);
        for(j=0; j<list[i].dis_mixer_count; j++) {
            ALOGD("\t\t%s : %d : %d : %s\n",
                list[i].dis_mixer_list[j].control_name,
                list[i].dis_mixer_list[j].type,
                list[i].dis_mixer_list[j].value,
                list[i].dis_mixer_list[j].string);
        }
    }
    return 0;
}

/* Print mixer controls extracted from config files
 * uc_mgr - use case manager structure
 * Returns 0 on sucess, negative error code otherwise
 */
static int snd_ucm_print(snd_use_case_mgr_t *uc_mgr)
{
    card_mctrl_t *list;
    int i, j, verb_index = 0;
    use_case_verb_t *verb_list;

    pthread_mutex_lock(&uc_mgr->card_ctxt_ptr->card_lock);
    verb_list = uc_mgr->card_ctxt_ptr->use_case_verb_list;
    while(strncmp(uc_mgr->card_ctxt_ptr->verb_list[verb_index],
         SND_UCM_END_OF_LIST, 3)) {
        ALOGD("\nuse case verb: %s\n",
            uc_mgr->card_ctxt_ptr->verb_list[verb_index]);
        if(verb_list[verb_index].device_list) {
            ALOGD("\tValid device list:");
            i = 0;
            while(strncmp(verb_list[verb_index].device_list[i],
                  SND_UCM_END_OF_LIST, 3)) {
                ALOGD("\t\t%s", verb_list[verb_index].device_list[i]);
                i++;
            }
        }
        if(verb_list[verb_index].modifier_list) {
            ALOGD("\tValid modifier list:");
            i = 0;
            while(strncmp(verb_list[verb_index].modifier_list[i],
                  SND_UCM_END_OF_LIST, 3)) {
                ALOGD("\t\t%s", verb_list[verb_index].modifier_list[i]);
                i++;
            }
        }
        ALOGD("Verbs:\n");
        list = verb_list[verb_index].verb_ctrls;
        print_list(list, verb_index, verb_list[verb_index].verb_count);
        ALOGD("Devices:\n");
        list = verb_list[verb_index].device_ctrls;
        print_list(list, verb_index, verb_list[verb_index].device_count);
        ALOGD("Modifier:\n");
        list = verb_list[verb_index].mod_ctrls;
        print_list(list, verb_index, verb_list[verb_index].mod_count);
        verb_index++;
    }
    pthread_mutex_unlock(&uc_mgr->card_ctxt_ptr->card_lock);
    return 0;
}

/* Gets the number of controls for specific sequence of a use cae */
static int get_controls_count(const char *nxt_str)
{
    char *current_str, *next_str, *str_addr;
    int count = 0;

    next_str = (char *)malloc((strlen(nxt_str)+1)*sizeof(char));
    if (next_str == NULL) {
        ALOGE("Failed to allocate memory");
        return -ENOMEM;
    }
    strlcpy(next_str, nxt_str, ((strlen(nxt_str)+1)*sizeof(char)));
    str_addr = next_str;
    while(1) {
        current_str = next_str;
        next_str = strchr(current_str, '\n');
        if ((!next_str) || (!strncasecmp(current_str, "EndSection", 10)))
            break;
        *next_str++ = '\0';
        if (strcasestr(current_str, "EndSequence") != NULL) {
            break;
        } else {
            count++;
        }
        if (*next_str == (char)EOF)
            break;
        if(!strncasecmp(current_str, "EndSection", 10))
            break;
    }
    free(str_addr);
    return count;
}

/* Parse a section of config files
 * uc_mgr - use case manager structure
 * Returns 0 on sucess, negative error code otherwise
 */
static int snd_ucm_parse_section(snd_use_case_mgr_t **uc_mgr, char **cur_str,
char **nxt_str, int verb_index, int ctrl_list_type)
{
    use_case_verb_t *verb_list;
    card_mctrl_t *list;
    int enable_seq = 0, disable_seq = 0, controls_count = 0, ret = 0;
    char *p, *current_str, *next_str, *name;

    verb_list = (*uc_mgr)->card_ctxt_ptr->use_case_verb_list;
    if (ctrl_list_type == CTRL_LIST_VERB) {
        list = (verb_list[verb_index].verb_ctrls +
            verb_list[verb_index].verb_count);
    } else if (ctrl_list_type == CTRL_LIST_DEVICE) {
        list = (verb_list[verb_index].device_ctrls +
            verb_list[verb_index].device_count);
    } else if (ctrl_list_type == CTRL_LIST_MODIFIER) {
        list = (verb_list[verb_index].mod_ctrls +
            verb_list[verb_index].mod_count);
    } else {
        ALOGE("Invalid list type: %d\n", ctrl_list_type);
        return -EINVAL;
    }
    list->case_name = NULL;
    list->ena_mixer_list = NULL;
    list->dis_mixer_list = NULL;
    list->ena_mixer_count = 0;
    list->dis_mixer_count = 0;
    list->playback_dev_name = NULL;
    list->capture_dev_name = NULL;
    list->acdb_id = 0;
    list->capability = 0;
    list->effects_mixer_ctl = NULL;
    current_str = *cur_str; next_str = *nxt_str;
    while(strncasecmp(current_str, "EndSection", 10)) {
        current_str = next_str;
        next_str = strchr(current_str, '\n');
        if ((!next_str) || (!strncasecmp(current_str, "EndSection", 10)))
            break;
        *next_str++ = '\0';
        if (strcasestr(current_str, "EndSequence") != NULL) {
            if (enable_seq == 1)
                enable_seq = 0;
            else if (disable_seq == 1)
                disable_seq = 0;
            else
                ALOGE("Error: improper config file\n");
        }
        if (enable_seq == 1) {
            ret = snd_ucm_extract_controls(current_str, &list->ena_mixer_list,
                  list->ena_mixer_count);
            if (ret < 0)
                break;
            list->ena_mixer_count++;
        } else if (disable_seq == 1) {
            ret = snd_ucm_extract_controls(current_str, &list->dis_mixer_list,
                  list->dis_mixer_count);
            if (ret < 0)
                break;
            list->dis_mixer_count++;
        } else if (strcasestr(current_str, "Name") != NULL) {
            ret = snd_ucm_extract_name(current_str, &list->case_name);
            if (ret < 0)
                break;
            ALOGV("Name of section is %s\n", list->case_name);
        } else if (strcasestr(current_str, "PlaybackPCM") != NULL) {
            ret = snd_ucm_extract_dev_name(current_str,
                      &list->playback_dev_name);
            if (ret < 0)
                break;
            ALOGV("Device name of playback is %s\n",
                list->playback_dev_name);
        } else if (strcasestr(current_str, "CapturePCM") != NULL) {
            ret = snd_ucm_extract_dev_name(current_str,
                      &list->capture_dev_name);
            if (ret < 0)
                break;
            ALOGV("Device name of capture is %s\n", list->capture_dev_name);
        } else if (strcasestr(current_str, "ACDBID") != NULL) {
            ret = snd_ucm_extract_acdb(current_str, &list->acdb_id,
                      &list->capability);
            if (ret < 0)
                break;
            ALOGV("ACDB ID: %d CAPABILITY: %d\n", list->acdb_id,
                list->capability);
        } else if (strcasestr(current_str, "EffectsMixerCTL") != NULL) {
            ret = snd_ucm_extract_effects_mixer_ctl(current_str,
                      &list->effects_mixer_ctl);
            if (ret < 0)
                break;
            ALOGV("Effects mixer ctl: %s: %d\n", list->effects_mixer_ctl);
        }
        if (strcasestr(current_str, "EnableSequence") != NULL) {
            controls_count = get_controls_count(next_str);
            if (controls_count < 0) {
                ret = -ENOMEM;
                break;
            }
            list->ena_mixer_list =
            (mixer_control_t *)malloc((controls_count*sizeof(mixer_control_t)));
            if (list->ena_mixer_list == NULL) {
                ret = -ENOMEM;
                break;
            }
            enable_seq = 1;
        } else if (strcasestr(current_str, "DisableSequence") != NULL) {
            controls_count = get_controls_count(next_str);
            if (controls_count < 0) {
                ret = -ENOMEM;
                break;
            }
            list->dis_mixer_list =
            (mixer_control_t *)malloc((controls_count*sizeof(mixer_control_t)));
            if (list->dis_mixer_list == NULL) {
                ret = -ENOMEM;
                break;
            }
            disable_seq = 1;
        }
        if (*next_str == (char)EOF)
             break;
    }
    if(ret == 0) {
        *cur_str = current_str; *nxt_str = next_str;
        if (ctrl_list_type == CTRL_LIST_VERB) {
            verb_list[verb_index].verb_count++;
        } else if (ctrl_list_type == CTRL_LIST_DEVICE) {
            verb_list[verb_index].device_count++;
        } else if (ctrl_list_type == CTRL_LIST_MODIFIER) {
            verb_list[verb_index].mod_count++;
        }
    }
    return ret;
}

/* Extract a mixer control name from config file
 * Returns 0 on sucess, negative error code otherwise
 */
static int snd_ucm_extract_name(char *buf, char **case_name)
{
    int ret = 0;
    char *p, *name = *case_name, *temp_ptr;

    p = strtok_r(buf, "\"", &temp_ptr);
    while (p != NULL) {
        p = strtok_r(NULL, "\"", &temp_ptr);
        if (p == NULL)
            break;
        name = (char *)malloc((strlen(p)+1)*sizeof(char));
        if(name == NULL) {
            ret = -ENOMEM;
            break;
        }
        strlcpy(name, p, (strlen(p)+1)*sizeof(char));
        *case_name = name;
        break;
    }
    return ret;
}

/* Extract a ACDB ID and capability of use case from config file
 * Returns 0 on sucess, negative error code otherwise
 */
static int snd_ucm_extract_acdb(char *buf, int *id, int *cap)
{
    char *p, key[] = "0123456789", *temp_ptr;

    p = strpbrk(buf, key);
    if (p == NULL) {
        *id = 0;
        *cap = 0;
    } else {
        p = strtok_r(p, ":", &temp_ptr);
        while (p != NULL) {
            *id = atoi(p);
            p = strtok_r(NULL, "\0", &temp_ptr);
            if (p == NULL)
                break;
            *cap = atoi(p);
            break;
        }
    }
    return 0;
}

/* Extract Effects Mixer ID of device from config file
 * Returns 0 on sucess, negative error code otherwise
 */
static int snd_ucm_extract_effects_mixer_ctl(char *buf, char **mixer_name)
{
    int ret = 0;
    char *p, *name = *mixer_name, *temp_ptr;

    p = strtok_r(buf, "\"", &temp_ptr);
    while (p != NULL) {
        p = strtok_r(NULL, "\"", &temp_ptr);
        if (p == NULL)
            break;
        name = (char *)malloc((strlen(p)+1)*sizeof(char));
        if(name == NULL) {
            ret = -ENOMEM;
            break;
        }
        strlcpy(name, p, (strlen(p)+1)*sizeof(char));
        *mixer_name = name;
        break;
    }
    return ret;
}

/* Extract a playback and capture device name of use case from config file
 * Returns 0 on sucess, negative error code otherwise
 */
static int snd_ucm_extract_dev_name(char *buf, char **dev_name)
{
    char key[] = "0123456789";
    char *p, *name = *dev_name;
    char dev_pre[] = "hw:0,";
    char *temp_ptr;

    p = strpbrk(buf, key);
    if (p == NULL) {
        *dev_name = NULL;
    } else {
        p = strtok_r(p, "\r\n", &temp_ptr);
        if (p == NULL) {
            *dev_name = NULL;
        } else {
            name = (char *)malloc((strlen(p)+strlen(dev_pre)+1)*sizeof(char));
            if(name == NULL)
                 return -ENOMEM;
            strlcpy(name, dev_pre, (strlen(p)+strlen(dev_pre)+1)*sizeof(char));
            strlcat(name, p, (strlen(p)+strlen(dev_pre)+1)*sizeof(char));
            *dev_name = name;
        }
    }
    return 0;
}

static int get_num_values(const char *buf)
{
    char *buf_addr, *p;
    int count = 0;
    char *temp_ptr;

    buf_addr = (char *)malloc((strlen(buf)+1)*sizeof(char));
    if (buf_addr == NULL) {
        ALOGE("Failed to allocate memory");
        return -ENOMEM;
    }
    strlcpy(buf_addr, buf, ((strlen(buf)+1)*sizeof(char)));
    p = strtok_r(buf_addr, " ", &temp_ptr);
    while (p != NULL) {
        count++;
        p = strtok_r(NULL, " ", &temp_ptr);
        if (p == NULL)
            break;
    }
    free(buf_addr);
    return count;
}

/* Extract a mixer control from config file
 * Returns 0 on sucess, negative error code otherwise
 */
static int snd_ucm_extract_controls(char *buf, mixer_control_t **mixer_list,
int size)
{
    unsigned long temp;
    int ret = -EINVAL, i, index = 0, count = 0;
    char *p, *ps, *pmv, temp_coeff[20];
    mixer_control_t *list;
    static const char *const seps = "\r\n";
    char *temp_ptr, *temp_vol_ptr;

    p = strtok_r(buf, "'", &temp_ptr);
    while (p != NULL) {
        p = strtok_r(NULL, "'", &temp_ptr);
        if (p == NULL)
            break;
        list = ((*mixer_list)+size);
        list->control_name = (char *)malloc((strlen(p)+1)*sizeof(char));
        if(list->control_name == NULL) {
            ret = -ENOMEM;
            free((*mixer_list));
            break;
        }
        strlcpy(list->control_name, p, (strlen(p)+1)*sizeof(char));
        p = strtok_r(NULL, ":", &temp_ptr);
        if (p == NULL)
            break;
        if(!strncmp(p, "0", 1)) {
            list->type = TYPE_STR;
        } else if(!strncmp(p, "1", 1)) {
            list->type = TYPE_INT;
        } else if(!strncmp(p, "2", 1)) {
            list->type = TYPE_MULTI_VAL;
        } else {
            ALOGE("Unknown type: p %s\n", p);
        }
        p = strtok_r(NULL, seps, &temp_ptr);
        if (p == NULL)
            break;
        if(list->type == TYPE_INT) {
            list->value = atoi(p);
            list->string = NULL;
            list->mulval = NULL;
        } else if(list->type == TYPE_STR) {
            list->value = -1;
            list->string = (char *)malloc((strlen(p)+1)*sizeof(char));
            list->mulval = NULL;
            if(list->string == NULL) {
                ret = -ENOMEM;
                free((*mixer_list));
                free(list->control_name);
                break;
            }
            strlcpy(list->string, p, (strlen(p)+1)*sizeof(char));
        } else if(list->type == TYPE_MULTI_VAL) {
            if (p != NULL) {
                count = get_num_values(p);
                list->mulval = (char **)malloc(count*sizeof(char *));
                if (list->mulval == NULL) {
                    ret = -ENOMEM;
                    free((*mixer_list));
                    free(list->control_name);
                    break;
                }
                index = 0;
                /* To support volume values in percentage */
                if ((count == 1) && (strstr(p, "%") != NULL)) {
                    pmv = strtok_r(p, " ", &temp_vol_ptr);
                    while (pmv != NULL) {
                        list->mulval[index] =
                            (char *)malloc((strlen(pmv)+1)*sizeof(char));
                        strlcpy(list->mulval[index], pmv, (strlen(pmv)+1));
                        index++;
                        pmv = strtok_r(NULL, " ", &temp_vol_ptr);
                        if (pmv == NULL)
                            break;
                    }
                } else {
                    pmv = strtok_r(p, " ", &temp_vol_ptr);
                    while (pmv != NULL) {
                        temp = strtoul(pmv, &ps, 16);
                        snprintf(temp_coeff, sizeof(temp_coeff),"%lu", temp);
                        list->mulval[index] =
                            (char *)malloc((strlen(temp_coeff)+1)*sizeof(char));
                        strlcpy(list->mulval[index], temp_coeff,
                            (strlen(temp_coeff)+1));
                        index++;
                        pmv = strtok_r(NULL, " ", &temp_vol_ptr);
                        if (pmv == NULL)
                            break;
                    }
                }
                list->value = count;
                list->string = NULL;
            }
        } else {
            ALOGE("Unknown type: p %s\n", p);
            list->value = -1;
            list->string = NULL;
        }
        ret = 0;
        break;
    }
    return ret;
}

void free_list(card_mctrl_t *list, int verb_index, int count)
{
    int case_index = 0, index = 0, mindex = 0;

    for(case_index = 0; case_index < count; case_index++) {
        for(index = 0; index < list[case_index].ena_mixer_count; index++) {
            if(list[case_index].ena_mixer_list[index].control_name) {
                free(list[case_index].ena_mixer_list[index].control_name);
            }
            if(list[case_index].ena_mixer_list[index].string) {
                free(list[case_index].ena_mixer_list[index].string);
            }
            if(list[case_index].ena_mixer_list[index].mulval) {
                for(mindex = 0;
                    mindex < list[case_index].ena_mixer_list[index].value;
                    mindex++) {
                    free(list[case_index].ena_mixer_list[index].mulval[mindex]);
                }
                if(list[case_index].ena_mixer_list[index].mulval) {
                    free(list[case_index].ena_mixer_list[index].mulval);
                }
            }
        }
        for(index = 0; index < list[case_index].dis_mixer_count; index++) {
            if(list[case_index].dis_mixer_list[index].control_name) {
                free(list[case_index].dis_mixer_list[index].control_name);
            }
            if(list[case_index].dis_mixer_list[index].string) {
                free(list[case_index].dis_mixer_list[index].string);
            }
            if(list[case_index].dis_mixer_list[index].mulval) {
                for(mindex = 0;
                    mindex < list[case_index].dis_mixer_list[index].value;
                    mindex++) {
                    free(list[case_index].dis_mixer_list[index].mulval[mindex]);
                }
                if(list[case_index].dis_mixer_list[index].mulval) {
                    free(list[case_index].dis_mixer_list[index].mulval);
                }
            }
        }
        if(list[case_index].case_name) {
            free(list[case_index].case_name);
        }
        if(list[case_index].ena_mixer_list) {
            free(list[case_index].ena_mixer_list);
        }
        if(list[case_index].dis_mixer_list) {
            free(list[case_index].dis_mixer_list);
        }
        if(list[case_index].playback_dev_name) {
            free(list[case_index].playback_dev_name);
        }
        if(list[case_index].capture_dev_name) {
            free(list[case_index].capture_dev_name);
        }
        if(list[case_index].effects_mixer_ctl) {
            list[case_index].effects_mixer_ctl = NULL;
        }
    }
}

void snd_ucm_free_mixer_list(snd_use_case_mgr_t **uc_mgr)
{
    card_mctrl_t *ctrl_list;
    use_case_verb_t *verb_list;
    int index = 0, verb_index = 0;

    pthread_mutex_lock(&(*uc_mgr)->card_ctxt_ptr->card_lock);
    verb_list = (*uc_mgr)->card_ctxt_ptr->use_case_verb_list;
    while(strncmp((*uc_mgr)->card_ctxt_ptr->verb_list[verb_index],
          SND_UCM_END_OF_LIST, 3)) {
        ctrl_list = verb_list[verb_index].verb_ctrls;
        free_list(ctrl_list, verb_index, verb_list[verb_index].verb_count);
        if(verb_list[verb_index].use_case_name)
            free(verb_list[verb_index].use_case_name);
        if((*uc_mgr)->card_ctxt_ptr->verb_list[verb_index]) {
            free((*uc_mgr)->card_ctxt_ptr->verb_list[verb_index]);
        }
        verb_index++;
    }
    verb_index -= 1;
    ctrl_list = verb_list[verb_index].device_ctrls;
    free_list(ctrl_list, verb_index, verb_list[verb_index].device_count);
    ctrl_list = verb_list[verb_index].mod_ctrls;
    free_list(ctrl_list, verb_index, verb_list[verb_index].mod_count);
    index = 0;
    while(1) {
        if (verb_list[verb_index].device_list[index]) {
            if (!strncmp(verb_list[verb_index].device_list[index],
                SND_UCM_END_OF_LIST, 3)) {
                free(verb_list[verb_index].device_list[index]);
                break;
            } else {
                free(verb_list[verb_index].device_list[index]);
                index++;
            }
        }
    }
    if (verb_list[verb_index].device_list)
        free(verb_list[verb_index].device_list);
    index = 0;
    while(1) {
        if (verb_list[verb_index].modifier_list[index]) {
            if (!strncmp(verb_list[verb_index].modifier_list[index],
                SND_UCM_END_OF_LIST, 3)) {
                free(verb_list[verb_index].modifier_list[index]);
                break;
            } else {
                free(verb_list[verb_index].modifier_list[index]);
                index++;
            }
        }
    }
    if (verb_list[verb_index].modifier_list)
        free(verb_list[verb_index].modifier_list);
    if((*uc_mgr)->card_ctxt_ptr->use_case_verb_list)
        free((*uc_mgr)->card_ctxt_ptr->use_case_verb_list);
    if((*uc_mgr)->card_ctxt_ptr->verb_list)
        free((*uc_mgr)->card_ctxt_ptr->verb_list);
    pthread_mutex_unlock(&(*uc_mgr)->card_ctxt_ptr->card_lock);
}

/* Add an identifier to the respective list
 * head - list head
 * value - node value that needs to be added
 * Returns 0 on sucess, negative error code otherwise
 */
static int snd_ucm_add_ident_to_list(struct snd_ucm_ident_node **head,
const char *value)
{
    struct snd_ucm_ident_node *temp, *node;

    node =
        (struct snd_ucm_ident_node *)malloc(sizeof(struct snd_ucm_ident_node));
    if (node == NULL) {
        ALOGE("Failed to allocate memory for new node");
        return -ENOMEM;
    } else {
        node->next = NULL;
        strlcpy(node->ident, value, MAX_STR_LEN);
        node->active = 0;
        node->capability = 0;
    }
    if (*head == NULL) {
        *head = node;
    } else {
        temp = *head;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = node;
    }
    ALOGV("add_to_list: head %p, value %s", *head, node->ident);
    return 0;
}

/* Get the status of identifier at particulare index of the list
 * head - list head
 * ident - identifier value for which status needs to be get
 * status - status to be set (1 - active, 0 - inactive)
 */
static int snd_ucm_get_status_at_index(struct snd_ucm_ident_node *head,
const char *ident)
{
    while (head != NULL) {
        if(!strncmp(ident, head->ident, (strlen(head->ident)+1))) {
            break;
        }
        head = head->next;
    }
    if (head == NULL) {
        ALOGV("Element not found in the list");
    } else {
        return(head->active);
    }
    return -EINVAL;
}

/* Get the node at particular index
 * head - list head
 * index - index value
 */
struct snd_ucm_ident_node *snd_ucm_get_device_node(struct snd_ucm_ident_node *head,
int index)
{
    if (head == NULL) {
        ALOGV("Empty list");
        return NULL;
    }

    if ((index < 0) || (index >= (snd_ucm_get_size_of_list(head)))) {
        ALOGE("Element with given index %d doesn't exist in the list", index);
        return NULL;
    }

    while (index) {
        head = head->next;
        index--;
    }

    return head;
}

/* Set the status of identifier at particulare index of the list
 * head - list head
 * ident - identifier value for which status needs to be set
 * status - status to be set (1 - active, 0 - inactive)
 */
static void snd_ucm_set_status_at_index(struct snd_ucm_ident_node *head,
const char *ident, int status, int capability)
{
    while (head != NULL) {
        if(!strncmp(ident, head->ident, (strlen(head->ident)+1))) {
            break;
        }
        head = head->next;
    }
    if (head == NULL) {
        ALOGE("Element not found to set the status");
    } else {
        head->active = status;
        head->capability = capability;
    }
}

/* Get the identifier value at particulare index of the list
 * head - list head
 * index - node index value
 * Returns node idetifier value at index on sucess, NULL otherwise
 */
static char *snd_ucm_get_value_at_index(struct snd_ucm_ident_node *head,
int index)
{
    if (head == NULL) {
        ALOGV("Empty list");
        return NULL;
    }

    if ((index < 0) || (index >= (snd_ucm_get_size_of_list(head)))) {
        ALOGE("Element with given index %d doesn't exist in the list", index);
        return NULL;
    }

    while (index) {
        head = head->next;
        index--;
    }

    return (strdup(head->ident));
}

/* Get the size of the list
 * head - list head
 * Returns size of list on sucess, negative error code otherwise
 */
static int snd_ucm_get_size_of_list(struct snd_ucm_ident_node *head)
{
    int index = 0;

    if (head == NULL) {
        ALOGV("Empty list");
        return 0;
    }

    while (head->next != NULL) {
        index++;
        head = head->next;
    }

    return (index+1);
}

static void snd_ucm_print_list(struct snd_ucm_ident_node *head)
{
    int index = 0;

    ALOGV("print_list: head %p", head);
    if (head == NULL) {
        ALOGV("Empty list");
        return;
    }

    while (head->next != NULL) {
        ALOGV("index: %d, value: %s", index, head->ident);
        index++;
        head = head->next;
    }
    ALOGV("index: %d, value: %s", index, head->ident);
}

/* Delete an identifier from respective list
 * head - list head
 * value - node value that needs to be deleted
 * Returns 0 on sucess, negative error code otherwise
 *
 */
static int snd_ucm_del_ident_from_list(struct snd_ucm_ident_node **head,
const char *value)
{
    struct snd_ucm_ident_node *temp1, *temp2;
    int ret = -EINVAL;

    if (*head == NULL) {
        ALOGE("del_from_list: Empty list");
        return -EINVAL;
    } else if (!strncmp((*head)->ident, value, (strlen(value)+1))) {
            temp2 = *head;
            *head = temp2->next;
            ret = 0;
    } else {
        temp1 = *head;
        temp2 = temp1->next;
        while (temp2 != NULL) {
            if (!strncmp(temp2->ident, value, (strlen(value)+1))) {
                temp1->next = temp2->next;
                ret = 0;
                break;
            }
            temp1 = temp1->next;
            temp2 = temp1->next;
        }
    }
    if (ret < 0) {
        ALOGE("Element not found in enabled list");
    } else {
        temp2->next = NULL;
        temp2->ident[0] = 0;
        temp2->active = 0;
        temp2->capability = 0;
        free(temp2);
        temp2 = NULL;
    }
    return ret;
}