initial audio HAL implementation for mako
alsa_sound is imported from codeaurora at:
c1217338f349fe746e0933fcf9b1b288b532808d
[remote "quic"]
url = git://git-android.quicinc.com/platform/hardware/alsa_sound.git
review = review-android.quicinc.com
projectname = platform/hardware/alsa_sound
fetch = +refs/heads/*:refs/remotes/quic/*
Change-Id: Ic985cc3a1088c3957b6e2ac5537e2c36caaf7212
Signed-off-by: Iliyan Malchev <malchev@google.com>
diff --git a/libalsa-intf/alsa_ucm.c b/libalsa-intf/alsa_ucm.c
new file mode 100644
index 0000000..e7c8388
--- /dev/null
+++ b/libalsa-intf/alsa_ucm.c
@@ -0,0 +1,3791 @@
+/*
+ * Copyright (c) 2011-2012, Code Aurora Forum. 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 Code Aurora Forum, Inc. 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 ALOG_TAG "alsa_ucm"
+#define ALOG_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 <linux/ioctl.h>
+#include "msm8960_use_cases.h"
+#if defined(QC_PROP)
+ #include "acdb-loader.h"
+#else
+ #define acdb_loader_init_ACDB() (-EPERM)
+ #define acdb_loader_deallocate_ACDB() (-EPERM)
+ #define acdb_loader_send_voice_cal(rxacdb_id, txacdb_id) (-EPERM)
+ #define acdb_loader_send_audio_cal(acdb_id, capability) (-EPERM)
+ #define acdb_loader_send_anc_cal(acdb_id) (-EPERM)
+#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 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_RX_ACDB_ID &&
+ tx_id == DEVICE_HANDSET_TX_ACDB_ID) {
+ tx_id = DEVICE_SPEAKER_TX_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);
+ acdb_loader_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 {
+ 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)) {
+ ALOGD("acdb_id %d cap %d enable %d",
+ ctrl_list[uc_index].acdb_id,
+ ctrl_list[uc_index].capability, enable);
+ acdb_loader_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) {
+ ALOGD("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 {
+ ALOGD("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_LOW_POWER,
+ MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_LOW_POWER)) ||
+ !strncmp(useCase, SND_USE_CASE_VERB_HIFI_TUNNEL,
+ MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI_TUNNEL)) ||
+ !strncmp(useCase, SND_USE_CASE_VERB_HIFI2,
+ MAX_LEN(useCase,SND_USE_CASE_VERB_HIFI2)) ||
+ !strncmp(useCase, SND_USE_CASE_VERB_DIGITAL_RADIO,
+ MAX_LEN(useCase,SND_USE_CASE_VERB_DIGITAL_RADIO)) ||
+ !strncmp(useCase, SND_USE_CASE_MOD_PLAY_MUSIC,
+ MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_MUSIC)) ||
+ !strncmp(useCase, SND_USE_CASE_MOD_PLAY_MUSIC2,
+ MAX_LEN(useCase,SND_USE_CASE_MOD_PLAY_MUSIC2)) ||
+ !strncmp(useCase, SND_USE_CASE_MOD_PLAY_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_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;
+
+ 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);
+ if (!capability) {
+ capability = dev_list[uc_index].capability;
+ } else if (capability != dev_list[uc_index].capability) {
+ capability = CAP_VOICE;
+ }
+ 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);
+ }
+ } 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)
+{
+ char use_case[MAX_UC_LEN];
+ int list_size, index, dev_index, uc_index, ret = 0;
+
+ ALOGV("set_use_case_ident_for_device(): use case %s device %s", ident,
+ device);
+ if (device != NULL) {
+ if (enable) {
+ dev_index = get_use_case_index(uc_mgr, device, CTRL_LIST_DEVICE);
+ 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);
+ }
+ }
+ 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);
+ 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;
+ 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);
+ flag = 1;
+ }
+ }
+ 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);
+ }
+ }
+ 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);
+ 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))) {
+ 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);
+ flag = 1;
+ }
+ }
+ if (capability == CAP_VOICE ||
+ getUseCaseType(ident_value) == CAP_VOICE ||
+ capability == getUseCaseType(ident_value)) {
+ 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);
+ 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);
+ }
+ 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)
+{
+ char use_case[MAX_UC_LEN];
+ int ret = -ENODEV, uc_index, dev_index;
+
+ ALOGV("set_device_for_ident(): %s %s", device, usecase);
+ dev_index = get_use_case_index(uc_mgr, device, CTRL_LIST_DEVICE);
+ 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);
+ }
+ }
+ 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);
+ }
+ }
+ }
+ 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);
+ }
+ 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);
+ if ((acdb_loader_init_ACDB()) < 0) {
+ ALOGE("Failed to initialize ACDB");
+ }
+ *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);
+ acdb_loader_deallocate_ACDB();
+ 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, ¤t_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, ¤t_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, ¤t_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, ¤t_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, ¤t_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, ¤t_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++) {
+ ALOGE("\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++) {
+ ALOGE("\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].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);
+ }
+ }
+}
+
+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);
+ while(strncmp((*uc_mgr)->card_ctxt_ptr->verb_list[verb_index],
+ SND_UCM_END_OF_LIST, 3)) {
+ verb_list = (*uc_mgr)->card_ctxt_ptr->use_case_verb_list;
+ ctrl_list = verb_list[verb_index].verb_ctrls;
+ free_list(ctrl_list, verb_index, verb_list[verb_index].verb_count);
+ 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(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++;
+ }
+ 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;
+ }
+ 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;
+}
+
+/* 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)
+{
+ 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;
+ }
+}
+
+/* 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;
+ free(temp2);
+ temp2 = NULL;
+ }
+ return ret;
+}