avsys-audio-path.c

   1 /*
   2  * avsystem
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <unistd.h>
  28 #include <errno.h>
  29 #include <stdlib.h>
  30 #include <linux/input.h>
  31 #include <iniparser.h>
  32
  33 #include "avsys-audio-shm.h"
  34 #include "avsys-audio-sync.h"
  35 #include "avsys-audio-path.h"
  36 #include "avsys-audio-shm.h"
  37 #include "avsys-debug.h"
  38 #include "avsys-common.h"
  39 #include "avsys-audio-handle.h"
  40 #include "avsys-audio-logical-volume.h"
  41
  42 #ifndef MURPHY_SUPPORT
  43 #include "avsys-audio-alsa.h"
  44 #include "avsys-audio-ascenario.h"
  45 #endif
  46
  47 #define EXPORT_API __attribute__((__visibility__("default")))
  48
  49 #define RET_IO_CTL_ERR_IF_FAIL(SECTION) { if(AVSYS_FAIL(SECTION)) { \
  50                                               avsys_error_r(AVAUDIO,"%s %d\n",__func__,__LINE__);         \
  51                                               return AVSYS_STATE_ERR_IO_CONTROL;                          \
  52                                         } }
  53
  54 static int g_playback_path_select_data[AVSYS_AUDIO_PLAYBACK_GAIN_MAX][AVSYS_AUDIO_PATH_EX_OUTMAX] = {
  55                 { /* AVSYS_AUDIO_PLAYBACK_GAIN_AP */
  56                         /* NONE SPK RECV HEADSET BTHEADSET A2DP HANDSFREE HDMI DOCK USBAUDIO */
  57                                 0,      1,      0,      1,      0,      0,      0,      1,  1,  0
  58                 },
  59                 { /* AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO */
  60                         /* NONE SPK RECV HEADSET BTHEADSET A2DP HANDSFREE HDMI */
  61                                 1,      1,      0,      1,      0,      1,      0,      0,  0,  0
  62                 },
  63                 { /* AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL */
  64                         /* NONE SPK RECV HEADSET BTHEADSET A2DP HANDSFREE HDMI */
  65                                 1,      1,      1,      1,      1,      0,      0,      0,  0,  0
  66                 },
  67                 { /* AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL */
  68                         /* NONE SPK RECV HEADSET BTHEADSET A2DP HANDSFREE HDMI */
  69                                 1,      1,      1,      1,      1,      0,      0,      0,  0,  0
  70                 },
  71                 { /* AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT */
  72                         /* NONE SPK RECV HEADSET BTHEADSET A2DP HANDSFREE HDMI */
  73                                 0,      1,      1,      1,      1,      0,      0,      0,  0,  0
  74                 }
  75 };
  76
  77 static int g_capture_path_select_data[AVSYS_AUDIO_CAPTURE_GAIN_MAX][AVSYS_AUDIO_PATH_EX_INMAX] = {
  78                 { /* AVSYS_AUDIO_CAPTURE_GAIN_AP */
  79                         /* NONE MIC HMIC BMIC FMIN HFREE */
  80                                 1,      1,      1,      1,      0,      0
  81                 },
  82                 { /* AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO */
  83                         /* NONE MIC HMIC BMIC FMIN HFREE */
  84                                 1,      0,      0,      0,      1,      0
  85                 },
  86                 { /* AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL */
  87                         /* NONE MIC HMIC BMIC FMIN HFREE */
  88                                 1,      1,      1,      1,      0,      0
  89                 },
  90                 { /* AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL */
  91                         /* NONE MIC HMIC BMIC FMIN HFREE */
  92                                 1,      1,      1,      1,      0,      0
  93                 },
  94 };
  95
  96 static int g_playback_gain_select_data[AVSYS_AUDIO_PLAYBACK_GAIN_MAX][AVSYS_AUDIO_PLAYBACK_GAIN_MAX] = {
  97                 {       /* AVSYS_AUDIO_PLAYBACK_GAIN_AP */
  98                                 AVSYS_AUDIO_PLAYBACK_GAIN_AP,                   /* AVSYS_AUDIO_PLAYBACK_GAIN_AP */
  99                                 AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO,              /* AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO */
 100                                 AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL,            /* AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL */
 101                                 AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL,            /* AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL */
 102                                 AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT,            /* AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT */
 103                 },
 104                 {       /* AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO */
 105                                 AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO,              /* AVSYS_AUDIO_PLAYBACK_GAIN_AP */
 106                                 AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO,              /* AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO */
 107                                 AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL,            /* AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL */
 108                                 AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL,            /* AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL */
 109                                 AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO,              /* AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT */
 110                 },
 111                 {       /* AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL */
 112                                 AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL,            /* AVSYS_AUDIO_PLAYBACK_GAIN_AP */
 113                                 AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL,            /* AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO */
 114                                 AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL,            /* AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL */
 115                                 AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL,            /* AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL */
 116                                 AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT,            /* AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT */
 117                 },
 118                 {       /* AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL */
 119                                 AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL,            /* AVSYS_AUDIO_PLAYBACK_GAIN_AP */
 120                                 AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL,            /* AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO */
 121                                 AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL,            /* AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL */
 122                                 AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL,            /* AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL */
 123                                 AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT,            /* AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT */
 124                 },
 125                 {       /* AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT */
 126                                 AVSYS_AUDIO_PLAYBACK_GAIN_AP,                   /* AVSYS_AUDIO_PLAYBACK_GAIN_AP */
 127                                 AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO,              /* AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO */
 128                                 AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL,            /* AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL */
 129                                 AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL,            /* AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL */
 130                                 AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT,            /* AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT */
 131                 },
 132 };
 133
 134 static int g_capture_gain_select_data[AVSYS_AUDIO_CAPTURE_GAIN_MAX][AVSYS_AUDIO_CAPTURE_GAIN_MAX] = {
 135                 {       /* AVSYS_AUDIO_CAPTURE_GAIN_AP */
 136                                 AVSYS_AUDIO_CAPTURE_GAIN_AP,                    /* AVSYS_AUDIO_CAPTURE_GAIN_AP */
 137                                 AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO,               /* AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO */
 138                                 AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL,             /* AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL */
 139                                 AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL,             /* AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL */
 140                 },
 141                 {       /* AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO */
 142                                 AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO,               /* AVSYS_AUDIO_CAPTURE_GAIN_AP */
 143                                 AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO,               /* AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO */
 144                                 AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL,             /* AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL */
 145                                 AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL,             /* AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL */
 146                 },
 147                 {       /* AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL */
 148                                 AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL,             /* AVSYS_AUDIO_CAPTURE_GAIN_AP */
 149                                 AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL,             /* AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO */
 150                                 AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL,             /* AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL */
 151                                 AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL,             /* AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL */
 152                 },
 153                 {       /* AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL */
 154                                 AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL,             /* AVSYS_AUDIO_CAPTURE_GAIN_AP */
 155                                 AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL,             /* AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO */
 156                                 AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL,             /* AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL */
 157                                 AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL,             /* AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL */
 158                 },
 159 };
 160
 161 typedef struct {
 162         char headset_detection;
 163         char headset_node_number;
 164 } AudioSystemConf;
 165
 166
 167 #ifndef MURPHY_SUPPORT
 168
 169 static int __avsys_audio_path_set_ascn_ap_playback(avsys_audio_path_ex_info_t *control);
 170 static int __avsys_audio_path_set_ascn_voicecall(avsys_audio_path_ex_info_t *control);
 171 static int __avsys_audio_path_set_ascn_videocall(avsys_audio_path_ex_info_t *control);
 172 static int __avsys_audio_path_set_ascn_fmradio(avsys_audio_path_ex_info_t *control);
 173 static int __avsys_audio_path_set_ascn_ap_capture(avsys_audio_path_ex_info_t *control);
 174 static int __avsys_audio_path_set_hw_controls(avsys_audio_path_ex_info_t *control);
 175 static int __avsys_audio_path_get_earjack_type(void);
 176
 177 #define AUDIOSYSTEM_CONF        "/opt/etc/audio_system.conf"
 178 #define CONF_ITEM_COUNT 2
 179 #define INPUT_DEV_MAX 20
 180
 181 #define EARJACK_EVENT_PATH      "/dev/input/event"
 182
 183 #define AVSYS_AUDIO_INI_DEFAULT_PATH "/usr/etc/mmfw_avsystem.ini"
 184 #define AVSYS_AUDIO_DEFAULT_CONTROL_AIF_BEFORE_PATH_SET         0
 185 #define AVSYS_AUDIO_DEFAULT_GAIN_DEBUG_MODE                                     0
 186
 187 #define CP_STATUS "/sys/class/audio/caps/cp_caps"
 188 #define CP_WB_STRING "wb"
 189
 190 static char *conf_string[] = {
 191         "headset_detection",
 192         "headset_node",
 193 };
 194
 195 typedef struct {
 196         char headset_detection;
 197         char headset_node_number;
 198         bool control_aif_before_path_set;
 199         bool gain_debug_mode;
 200 } avsys_audio_conf;
 201
 202 static int __load_conf(avsys_audio_conf *data)
 203 {
 204         dictionary *dict = NULL;
 205
 206 #if defined(_MMFW_I386_ALL_SIMULATOR)
 207         if (data == NULL)
 208                 return AVSYS_STATE_ERR_NULL_POINTER;
 209
 210         data->headset_detection = 1;
 211         data->headset_node_number = 4;
 212 #else
 213         FILE *fp = NULL;
 214         int i = 0;
 215         char buffer[64] = { 0, };
 216         char conf_data[CONF_ITEM_COUNT] = { 1, 0 };
 217
 218         if (data == NULL)
 219                 return AVSYS_STATE_ERR_NULL_POINTER;
 220
 221         fp = fopen(AUDIOSYSTEM_CONF, "r");
 222         if (fp == NULL) {
 223                 char filename[128] = { 0, };
 224                 char readBuffer[32] = { 0, };
 225                 char headset_find = 0;
 226                 int num = 0, headset_num = -1;
 227
 228                 for (num = 0; num < INPUT_DEV_MAX; num++) {
 229                         FILE *sfp = NULL;
 230                         memset(filename, '\0', sizeof(filename));
 231                         snprintf(filename, sizeof(filename), "/sys/class/input/input%01d/name", num);
 232                         if (NULL == (sfp = fopen(filename, "r")))
 233                                 continue;
 234                         memset(readBuffer, '\0', sizeof(readBuffer));
 235                         if (NULL == fgets(readBuffer, sizeof(readBuffer) - 1, sfp)) {
 236                                 fclose(sfp);
 237                                 continue;
 238                         }
 239                         if (strstr(readBuffer, "Headset")) {
 240                                 headset_find = 1;
 241                                 headset_num = num;
 242                         }
 243
 244                         fclose(sfp);
 245                         if (headset_num != -1) {
 246                                 break;
 247                         }
 248                 }
 249                 if (headset_num == -1)
 250                         return AVSYS_STATE_ERR_INTERNAL;
 251
 252                 if (NULL == (fp = fopen(AUDIOSYSTEM_CONF, "w"))) {
 253                         return AVSYS_STATE_ERR_INTERNAL;
 254                 }
 255
 256                 fprintf(fp, "%s:1\n", conf_string[0]);
 257                 fprintf(fp, "%s:%d\n", conf_string[1], headset_num);
 258                 fflush(fp);
 259                 fclose(fp);
 260                 fp = NULL;
 261                 sync();
 262                 data->headset_detection = 1;
 263                 data->headset_node_number = headset_num;
 264                 return AVSYS_STATE_SUCCESS;
 265         }
 266
 267         while (fgets(buffer, sizeof(buffer) - 1, fp) != NULL) {
 268                 if ((strlen(buffer) < 3) || (buffer[0] == '#') || (buffer[0] == '!'))
 269                         continue;
 270                 if (buffer[strlen(buffer) - 1] == '\n')
 271                         buffer[strlen(buffer) - 1] = '\0';
 272                 for (i = 0; i < CONF_ITEM_COUNT; i++) {
 273                         if (0 == strncmp(buffer, conf_string[i], strlen(conf_string[i]))) {
 274                                 char *ptr = NULL;
 275                                 if (NULL == (ptr = strstr(buffer, ":")))
 276                                         break;
 277                                 conf_data[i] = atoi(ptr + 1);
 278                                 avsys_warning(AVAUDIO, "%s[%d]\n", buffer, conf_data[i]);
 279                         }
 280                 }
 281         }
 282         fclose(fp);
 283         data->headset_detection = conf_data[0];
 284         data->headset_node_number = conf_data[1];
 285 #endif
 286
 287         /* first, try to load existing ini file */
 288         dict = iniparser_load(AVSYS_AUDIO_INI_DEFAULT_PATH);
 289         if (dict) { /* if dict is available */
 290                 data->control_aif_before_path_set = iniparser_getboolean(dict, "aif:control aif before path set", AVSYS_AUDIO_DEFAULT_CONTROL_AIF_BEFORE_PATH_SET);
 291                 data->gain_debug_mode = iniparser_getboolean(dict, "debug:gain debug mode", AVSYS_AUDIO_DEFAULT_GAIN_DEBUG_MODE);
 292
 293                 /* free dict as we got our own structure */
 294                 iniparser_freedict (dict);
 295         } else { /* if no file exists. create one with set of default values */
 296                 data->control_aif_before_path_set = AVSYS_AUDIO_DEFAULT_CONTROL_AIF_BEFORE_PATH_SET;
 297                 data->gain_debug_mode = AVSYS_AUDIO_DEFAULT_GAIN_DEBUG_MODE;
 298         }
 299
 300         return AVSYS_STATE_SUCCESS;
 301 }
 302
 303 static bool __is_cp_wb ()
 304 {
 305         bool ret = false;
 306         char str[10] = { 0, };
 307         FILE* fp = NULL;
 308
 309         avsys_info(AVAUDIO, "Checking [%s] for WB capability...\n", CP_STATUS);
 310         fp = fopen (CP_STATUS, "r");
 311         if (fp) {
 312                 if (fgets (str, sizeof(str)-1, fp)) {
 313                         if (strstr (str, CP_WB_STRING)) {
 314                                 ret = true;
 315                         }
 316                 }
 317                 fclose(fp);
 318         } else {
 319                 avsys_warning (AVAUDIO, "failed to open [%s]...errno=[%d]\n", CP_STATUS, errno);
 320         }
 321
 322         avsys_info(AVAUDIO, "Result [%d] : [%s] capability!!!\n", ret, (ret)? "WB" : "NB");
 323         return ret;
 324 }
 325 #endif  /* MURPHY_SUPPORT */
 326
 327 EXPORT_API
 328 int avsys_audio_path_ex_init(void)
 329 {
 330         avsys_audio_path_ex_info_t *control = NULL;
 331         avsys_audio_path_ex_info_t **temp = NULL;
 332         gain_info_t default_gain = { AVSYS_AUDIO_PLAYBACK_GAIN_AP, AVSYS_AUDIO_CAPTURE_GAIN_AP };
 333         path_info_t default_path = { AVSYS_AUDIO_PATH_EX_SPK, AVSYS_AUDIO_PATH_EX_MIC };
 334         option_info_t default_option = { AVSYS_AUDIO_PATH_OPTION_NONE, AVSYS_AUDIO_PATH_OPTION_NONE };
 335         int index = 0;
 336         int err = AVSYS_STATE_SUCCESS;
 337         avsys_audio_conf conf = { 0, };
 338
 339         /* Check root user */
 340         err = avsys_check_root_privilege();
 341         if (AVSYS_FAIL(err)) {
 342                 return err;
 343         }
 344
 345         temp = &control;
 346         avsys_assert(AVSYS_SUCCESS(avsys_audio_create_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
 347         avsys_assert(AVSYS_SUCCESS(avsys_audio_create_shm(AVSYS_AUDIO_SHM_IDEN_PATH)));
 348
 349         avsys_assert(AVSYS_SUCCESS(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp)));
 350         if (control == NULL)
 351                 return AVSYS_STATE_ERR_NULL_POINTER;
 352
 353         /* init values */
 354         control->pregain = default_gain;
 355         control->gain = default_gain;
 356         control->reqgain = default_gain;
 357         control->path = default_path;
 358         control->backup_gain = default_gain;
 359         control->backup_path = default_path;
 360         control->option = default_option;
 361
 362         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
 363         control->inserted = AVSYS_AUDIO_INSERTED_NONE;
 364
 365 #ifdef MURPHY_SUPPORT
 366     control->gain_debug_mode = 0;
 367 #else  /* MURPHY_SUPPORT */
 368
 369         if (AVSYS_FAIL(__load_conf(&conf)))
 370                 avsys_error_r(AVAUDIO, "Can not load audio system configuration file\n");
 371
 372         if (conf.headset_detection) {
 373                 control->inserted = __avsys_audio_path_get_earjack_type();
 374                 if (control->inserted == AVSYS_AUDIO_INSERTED_NONE)
 375                         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
 376                 else
 377                         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
 378         } else {
 379                 avsys_warning(AVAUDIO, "Ignore headset detection. Use speaker device\n");
 380                 control->inserted = AVSYS_AUDIO_INSERTED_NONE;
 381                 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
 382         }
 383
 384         avsys_error_r(AVAUDIO, "Earjack init value is %d\n", control->inserted);
 385
 386         control->control_aif_before_path_set = conf.control_aif_before_path_set;
 387         control->wb_enabled = __is_cp_wb();
 388         control->gain_debug_mode = conf.gain_debug_mode;
 389
 390 #endif  /* MURPHY_SUPPORT */
 391
 392         control->mute = AVSYS_AUDIO_UNMUTE;
 393         control->path_fixed = PATH_FIXED_NONE;
 394
 395         index = 0;
 396         do {
 397                 control->pathlock_pid[index] = -1;
 398                 index++;
 399         } while (index < AVSYS_AUDIO_LOCK_SLOT_MAX);
 400
 401         index = 0;
 402         do {
 403                 control->path_fixed_pid[index] = -1;
 404                 index++;
 405         } while (index < PATH_FIXED_TYPE_MAX);
 406
 407
 408 #ifdef MURPHY_SUPPORT
 409     err = AVSYS_STATE_SUCCESS;
 410 #else
 411         /* call path control */
 412         err = __avsys_audio_path_set_ascn_ap_playback(control);
 413         if (AVSYS_SUCCESS(err))
 414                 err = __avsys_audio_path_set_hw_controls(control);
 415
 416         if (AVSYS_SUCCESS(err))
 417                 err = __avsys_audio_path_set_ascn_ap_capture(control);
 418 #endif
 419
 420         return err;
 421 }
 422
 423 EXPORT_API
 424 int avsys_audio_path_ex_fini(void)
 425 {
 426         if (AVSYS_FAIL(avsys_audio_remove_shm(AVSYS_AUDIO_SHM_IDEN_PATH))) {
 427                 avsys_error_r(AVAUDIO, "avsys_audio_remove_shm() failed in %s\n", __func__);
 428                 return AVSYS_STATE_ERR_INTERNAL;
 429         }
 430         if (AVSYS_FAIL(avsys_audio_remove_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
 431                 avsys_error_r(AVAUDIO, "avsys_audio_remove_sync() failed in %s\n", __func__);
 432                 return AVSYS_STATE_ERR_INTERNAL;
 433         }
 434         return AVSYS_STATE_SUCCESS;
 435 }
 436
 437 EXPORT_API
 438 int avsys_audio_path_ex_reset(int forced)
 439 {
 440 #ifdef MURPHY_SUPPORT
 441         (void)forced;
 442         return AVSYS_STATE_SUCCESS;
 443 #else
 444         avsys_audio_path_ex_info_t *control = NULL;
 445         avsys_audio_path_ex_info_t **temp = NULL;
 446         gain_info_t default_gain = { AVSYS_AUDIO_PLAYBACK_GAIN_AP, AVSYS_AUDIO_CAPTURE_GAIN_AP };
 447         path_info_t default_path = { AVSYS_AUDIO_PATH_EX_SPK, AVSYS_AUDIO_PATH_EX_MIC };
 448         option_info_t default_option = { AVSYS_AUDIO_PATH_OPTION_NONE, AVSYS_AUDIO_PATH_OPTION_NONE };
 449         int index = 0;
 450         int err = AVSYS_STATE_SUCCESS;
 451         int backup_debug = 0;
 452         avsys_audio_conf conf = { 0, };
 453
 454         /* Check root user */
 455         err = avsys_check_root_privilege();
 456         if (AVSYS_FAIL(err)) {
 457                 return err;
 458         }
 459
 460         temp = &control;
 461         if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
 462                 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
 463                 return AVSYS_STATE_ERR_INTERNAL;
 464         }
 465         if (control == NULL)
 466                 return AVSYS_STATE_ERR_NULL_POINTER;
 467
 468         if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
 469                 avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
 470                 return AVSYS_STATE_ERR_INTERNAL;
 471         }
 472
 473         /* init values */
 474         control->pregain = default_gain;
 475         control->gain = default_gain;
 476         control->reqgain = default_gain;
 477         control->path = default_path;
 478         control->backup_gain = default_gain;
 479         control->backup_path = default_path;
 480         control->option = default_option;
 481
 482         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
 483         control->inserted = AVSYS_AUDIO_INSERTED_NONE;
 484
 485         if (AVSYS_FAIL(__load_conf(&conf)))
 486                 avsys_error_r(AVAUDIO, "Can not load audio system configuration file\n");
 487
 488         if (conf.headset_detection) {
 489                 control->inserted = __avsys_audio_path_get_earjack_type();
 490                 if (control->inserted == AVSYS_AUDIO_INSERTED_NONE)
 491                         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
 492                 else {
 493                         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
 494                         control->path.playback = AVSYS_AUDIO_PATH_EX_HEADSET;
 495
 496                         if (control->inserted == AVSYS_AUDIO_INSERTED_4)
 497                                 control->path.capture = AVSYS_AUDIO_PATH_EX_HEADSETMIC;
 498                 }
 499         } else {
 500                 avsys_warning(AVAUDIO, "Ignore headset detection. Use speaker device\n");
 501                 control->inserted = AVSYS_AUDIO_INSERTED_NONE;
 502                 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
 503         }
 504
 505         avsys_error_r(AVAUDIO, "Earjack init value is %d\n", control->inserted);
 506
 507         control->control_aif_before_path_set = conf.control_aif_before_path_set;
 508         control->gain_debug_mode = conf.gain_debug_mode;
 509
 510         control->mute = AVSYS_AUDIO_UNMUTE;
 511         control->path_fixed = PATH_FIXED_NONE;
 512
 513         index = 0;
 514         do {
 515                 control->pathlock_pid[index] = -1;
 516                 index++;
 517         } while (index < AVSYS_AUDIO_LOCK_SLOT_MAX);
 518
 519         index = 0;
 520         do {
 521                 control->path_fixed_pid[index] = -1;
 522                 index++;
 523         } while (index < PATH_FIXED_TYPE_MAX);
 524
 525         if (forced) {
 526                 backup_debug = control->gain_debug_mode;
 527                 control->gain_debug_mode = 1;
 528         }
 529         /* call path control */
 530         err = __avsys_audio_path_set_ascn_ap_playback(control);
 531         if (AVSYS_SUCCESS(err))
 532                 err = __avsys_audio_path_set_hw_controls(control);
 533
 534         if (AVSYS_SUCCESS(err))
 535                 err = __avsys_audio_path_set_ascn_ap_capture(control);
 536
 537         if (forced) {
 538                 control->gain_debug_mode = backup_debug;
 539         }
 540
 541         if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
 542                 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
 543                 return AVSYS_STATE_ERR_INTERNAL;
 544         }
 545
 546         return err;
 547 #endif  /* MURPHY_SUPPORT */
 548 }
 549
 550 EXPORT_API
 551 int avsys_audio_path_ex_dump(void)
 552 {
 553         avsys_audio_path_ex_info_t *control = NULL;
 554         avsys_audio_path_ex_info_t **temp = NULL;
 555         const static char *str_earType[] = { "None", "EarOnly", "EarMic", "TVout" };
 556         const static char *str_yn[] = { "NO", "YES" };
 557         const static char *str_ear[] = { "MANUAL", "AUTO_MUTE", "AUTO_NOMUTE" };
 558         const static char *str_out[AVSYS_AUDIO_PATH_EX_OUTMAX] = {
 559                 "NONE", "SPK", "RECV", "HEADSET", "BTHEADSET", "A2DP", "HANSFREE", "HDMI", "DOCK", "USBAUDIO"
 560         };
 561         const static char *str_in[AVSYS_AUDIO_PATH_EX_INMAX] = {
 562                 "NONE", "MIC", "HEADMIC", "BTMIC", "FMINPUT", "HANSFREEMIC"
 563         };
 564         const static char *str_route[AVSYS_AUDIO_ROUTE_POLICY_MAX] = {
 565                 "DEFAULT", "IGN_A2DP", "HANDSET"
 566         };
 567         /*
 568         const static char *str_gain[AVSYS_AUDIO_GAIN_EX_MAX] = {
 569                 "KEYTONE", "RINGTONE", "ALARMTONE", "CALLTONE", "AUDIOPLAYER", "VIDEOPLAYER",
 570                 "VOICECALL", "VIDEOCALL", "FMRADIO", "VOICEREC", "CAMCORDER", "CAMERA", "GAME"};
 571         */
 572         const static char *str_playback_gain[AVSYS_AUDIO_PLAYBACK_GAIN_MAX] = {
 573                 "AP", "FMRADIO", "VOICECALL", "VIDEOCALL", "CALLALERT",
 574         };
 575         const static char *str_capture_gain[AVSYS_AUDIO_CAPTURE_GAIN_MAX] = {
 576                 "AP", "FMRADIO", "VOICECALL", "VIDEOCALL",
 577         };
 578
 579         int index = 0;
 580
 581         temp = &control;
 582
 583         if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
 584                 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
 585                 return AVSYS_STATE_ERR_INTERNAL;
 586         }
 587         if (control == NULL)
 588                 return AVSYS_STATE_ERR_NULL_POINTER;
 589
 590         fprintf(stdout, "======================================================================\n");
 591         fprintf(stdout, "               Avsystem Audio Path Control Information                \n");
 592         fprintf(stdout, "======================================================================\n");
 593 #if defined(_MMFW_I386_ALL_SIMULATOR)
 594         fprintf(stdout, " In simulator, follow informations don`t have means.\n");
 595 #elif defined(MURPHY_SUPPORT)
 596         fprintf(stdout, " Murphy support is enabled. module-murphy-ivi is routing in pulseaudio.\n"
 597                         " The information below does not make much sense ...\n");
 598 #endif
 599
 600         fprintf(stdout, " GAIN                          : P (%-s / %-s) - R (%-s / %-s) - C (%-s / %-s)\n",
 601                         str_playback_gain[control->pregain.playback], str_capture_gain[control->pregain.capture],
 602                         str_playback_gain[control->reqgain.playback], str_capture_gain[control->reqgain.capture],
 603                         str_playback_gain[control->gain.playback], str_capture_gain[control->gain.capture]);
 604         fprintf(stdout, " Current Out / In              : %-s / %-s\n", str_out[control->path.playback], str_in[control->path.capture] );
 605         fprintf(stdout, " Gain debug mode               : 0x%-x\n", control->gain_debug_mode);
 606         fprintf(stdout, " Auto EarJack Control          : %-s\n", str_ear[control->ear_auto]);
 607         fprintf(stdout, " Physical Earjack? [type]      : %-s [%-s]\n", str_yn[control->inserted != AVSYS_AUDIO_INSERTED_NONE], str_earType[control->inserted]);
 608         fprintf(stdout, " Path Fixed State              : 0x%-x\n", control->path_fixed);
 609         fprintf(stdout, " Mute status                   : %d\n", control->mute);
 610         if (control->path_fixed_pid[PATH_FIXED_TYPE_FMRADIO] != -1)
 611                 fprintf(stdout, " FM Radio path pid             : %d\n", control->path_fixed_pid[PATH_FIXED_TYPE_FMRADIO]);
 612         if (control->path_fixed_pid[PATH_FIXED_TYPE_CALL] != -1)
 613                 fprintf(stdout, " Call  path pid                : %d\n", control->path_fixed_pid[PATH_FIXED_TYPE_CALL]);
 614
 615         index = 0;
 616         do {
 617                 if (control->pathlock_pid[index] != -1)
 618                         fprintf(stdout, " Path sync lock required PIDs   : %d\n", control->pathlock_pid[index]);
 619                 index++;
 620         } while (index < AVSYS_AUDIO_LOCK_SLOT_MAX);
 621         fprintf(stdout, " Option Dual out               : %-s\n", str_yn[(control->option.playback & AVSYS_AUDIO_PATH_OPTION_DUAL_OUT) ? 1 : 0]);
 622         fprintf(stdout, " Option Forced                 : %-s\n", str_yn[(control->option.playback & AVSYS_AUDIO_PATH_OPTION_FORCED) ? 1 : 0]);
 623
 624         return AVSYS_STATE_SUCCESS;
 625 }
 626
 627 #ifndef MURPHY_SUPPORT
 628 static int __avsys_audio_path_get_earjack_type (void)
 629 {
 630         int fd = 0;
 631         char readval = AVSYS_AUDIO_INSERTED_NONE;
 632         fd = open("/sys/devices/platform/jack/earjack_online", O_RDONLY);
 633
 634         if (fd == -1) {
 635                 avsys_error_r(AVAUDIO, "Can not get initial jack type\n");
 636                 return AVSYS_AUDIO_INSERTED_NONE;
 637         }
 638         read(fd, &readval, sizeof(readval));
 639         switch (readval) {
 640         case '0':
 641                 readval = AVSYS_AUDIO_INSERTED_NONE;
 642                 break;
 643         case '1':
 644                 readval = AVSYS_AUDIO_INSERTED_3;
 645                 break;
 646         case '3':
 647                 readval = AVSYS_AUDIO_INSERTED_4;
 648                 break;
 649         case '8':
 650                 readval = AVSYS_AUDIO_INSERTED_AV;
 651                 break;
 652         case '2':
 653                 if (1 == read(fd, &readval, sizeof(readval))) {
 654                         if (readval == '0') {
 655                                 readval = AVSYS_AUDIO_INSERTED_AV;
 656                         } else {
 657                                 avsys_error(AVAUDIO, "Unknown jack type value...2%d\n", readval);
 658                                 readval = AVSYS_AUDIO_INSERTED_NONE;
 659                         }
 660                 } else {
 661                         avsys_error(AVAUDIO, "jack type read error...\n");
 662                         readval = AVSYS_AUDIO_INSERTED_NONE;
 663                 }
 664                 break;
 665         default:
 666                 avsys_error(AVAUDIO, "jack type unknown value...%c\n", readval);
 667                 readval = AVSYS_AUDIO_INSERTED_NONE;
 668                 break;
 669         }
 670
 671         close(fd);
 672         return readval;
 673 }
 674 #endif  /* MURPHY_SUPPORT */
 675
 676 int avsys_audio_path_earjack_init(int *init_type, int *outfd)
 677 {
 678 #if !defined(_MMFW_I386_ALL_SIMULATOR) && !defined(MURPHY_SUPPORT)
 679         char eventnode_filename[32] = { 0, };
 680         int fd = 0;
 681         avsys_audio_conf conf = { 0, };
 682
 683         if (outfd == NULL || init_type == NULL) {
 684                 avsys_error(AVAUDIO, "input parameter is null\n");
 685                 return AVSYS_STATE_ERR_NULL_POINTER;
 686         }
 687
 688         if (AVSYS_FAIL(__load_conf(&conf))) {
 689                 avsys_error_r(AVAUDIO, "Can not load audio system configuration file\n");
 690         }
 691
 692         if (!conf.headset_detection) {
 693                 avsys_error(AVAUDIO, "Earjack control daemon will be closed by user option...\n");
 694                 return AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT;
 695         }
 696
 697         snprintf(eventnode_filename, sizeof(eventnode_filename), "%s%01d", EARJACK_EVENT_PATH, conf.headset_node_number);
 698
 699         fd = open(eventnode_filename, O_RDONLY);
 700         if (fd == -1) {
 701                 avsys_error_r(AVAUDIO, "Device file open error\n");
 702                 return AVSYS_STATE_ERR_INTERNAL;
 703         } else {
 704                 avsys_audio_path_ex_info_t *control = NULL;
 705                 avsys_audio_path_ex_info_t **temp = NULL;
 706                 void *vol_data = NULL;
 707                 void *handle_data = NULL;
 708                 temp = &control;
 709
 710                 if(AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_LVOLUME, &vol_data))) {
 711                         avsys_error(AVAUDIO,"attach logical volume shared memory failed\n");
 712                         close(fd);
 713                         return AVSYS_STATE_ERR_ALLOCATION;
 714                 }
 715                 if(AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE, &handle_data))) {
 716                         avsys_error(AVAUDIO,"attach handle shared memory failed\n");
 717                         close(fd);
 718                         return AVSYS_STATE_ERR_ALLOCATION;
 719                 }
 720                 if(AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void**)temp))) {
 721                         avsys_error_r(AVAUDIO,"avsys_audio_get_shm() failed in %s\n", __func__);
 722                         close(fd);
 723                         return AVSYS_STATE_ERR_INTERNAL;
 724                 }
 725
 726                 *init_type = control->inserted;
 727                 *outfd = fd;
 728                 return AVSYS_STATE_SUCCESS;
 729         }
 730 #else
 731         return AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT;
 732 #endif
 733 }
 734
 735 int avsys_audio_path_earjack_wait(int fd, int *current_type, int *new_type, int *is_auto_mute)
 736 {
 737 #if !defined(_MMFW_I386_ALL_SIMULATOR) && !defined(MURPHY_SUPPORT)
 738         fd_set set;
 739         int readtemp;
 740         int select_ret = 0;
 741         struct input_event jevent;
 742         int res = AVSYS_STATE_SUCCESS;
 743         int cur_type = -1;
 744
 745         if (new_type == NULL || is_auto_mute == NULL)
 746                 return AVSYS_STATE_ERR_NULL_POINTER;
 747
 748         FD_ZERO(&set);
 749         FD_SET(fd, &set);
 750
 751         cur_type = *current_type;
 752
 753         select_ret = select(fd + 1, &set, NULL, NULL, NULL);
 754         avsys_info(AVAUDIO, "SELECT returns......\n");
 755
 756         if (select_ret != 1) {
 757                 if (select_ret == 0) {
 758                         avsys_error_r(AVAUDIO, "Earjack timeout in autocontrol\n");
 759                 } else if (select_ret == -1) {
 760                         avsys_error_r(AVAUDIO, "Earjack detect unknown error: %d\n", errno);
 761                 }
 762                 return AVSYS_STATE_WAR_INVALID_VALUE;
 763         }
 764 #ifdef EARJACK_LOCK             /* currently this is disabled to avoid semapore value increase */
 765         if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
 766                 avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
 767                 return AVSYS_STATE_ERR_INTERNAL;
 768         }
 769 #endif
 770         if (read(fd, &jevent, sizeof(jevent)) < 0) {
 771                 avsys_error(AVAUDIO, "read fd failed with 0x%x\n", errno);
 772                 return AVSYS_STATE_WAR_INVALID_MODE;
 773         }
 774         avsys_info(AVAUDIO, "*** JEVENT : code=%d, value=%d\n", jevent.code, jevent.value);
 775         if (jevent.type != TYPE_EVENT_SWITCH) {
 776                 avsys_info(AVAUDIO, "Not a switch event\n");
 777                 return AVSYS_STATE_WAR_INVALID_MODE;
 778         }
 779
 780         switch (jevent.code) {
 781         case CODE_HEADPHONE_INSERT:
 782         case CODE_LINEOUT_INSERT:
 783         case CODE_JACK_PHYSICAL_INSERT:
 784                 if (jevent.value == 1) {
 785                         readtemp = __avsys_audio_path_get_earjack_type();
 786                 } else {
 787                         readtemp = 0;
 788                 }
 789                 break;
 790         default:
 791                 readtemp = cur_type; /* same value */
 792                 break;
 793         }
 794
 795         *new_type = readtemp;
 796
 797         avsys_audio_path_ex_info_t *control = NULL;
 798         avsys_audio_path_ex_info_t **temp = NULL;
 799         temp = &control;
 800
 801         if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
 802                 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
 803                 return AVSYS_STATE_ERR_INTERNAL;
 804         }
 805
 806         avsys_info(AVAUDIO, "control->ear_auto = %d\n", control->ear_auto);
 807         if (control->ear_auto == AVSYS_AUDIO_EAR_SWITCH_AUTO_WITH_MUTE) {
 808                 *current_type = control->inserted;
 809                 *is_auto_mute = 1;
 810                 res = AVSYS_STATE_SUCCESS;
 811         } else if (control->ear_auto == AVSYS_AUDIO_EAR_SWITCH_AUTO_WITHOUT_MUTE) {
 812                 *current_type = control->inserted;
 813                 *is_auto_mute = 0;
 814                 res = AVSYS_STATE_SUCCESS;
 815         }
 816
 817         return res;
 818
 819 #else
 820         return AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT;
 821 #endif
 822 }
 823
 824 int avsys_audio_path_earjack_process(int new_type)
 825 {
 826 #if !defined(_MMFW_I386_ALL_SIMULATOR) && !defined(MURPHY_SUPPORT)
 827         avsys_audio_path_ex_info_t *control = NULL;
 828         avsys_audio_path_ex_info_t **temp = NULL;
 829         int err = AVSYS_STATE_SUCCESS;
 830         temp = &control;
 831
 832         avsys_info(AVAUDIO, "new_type = %d\n", new_type);
 833         if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
 834                 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
 835                 return AVSYS_STATE_ERR_INTERNAL;
 836         }
 837
 838         control->inserted = new_type;
 839
 840         return err;
 841 #else
 842         return AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT;
 843 #endif
 844 }
 845
 846 int avsys_audio_path_earjack_deinit(int fd)
 847 {
 848 #if !defined(_MMFW_I386_ALL_SIMULATOR) && !defined(MURPHY_SUPPORT)
 849         close(fd);
 850         return AVSYS_STATE_SUCCESS;
 851 #else
 852         return AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT;
 853 #endif
 854 }
 855
 856 int avsys_audio_path_earjack_unlock()
 857 {
 858 #if defined(EARJACK_LOCK) && !defined(MURPHY_SUPPORT)  /* currently EARJACK_LOCK is disabled to avoid semapore value increase */
 859         if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
 860                 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
 861                 return AVSYS_STATE_ERR_INTERNAL;
 862         }
 863 #endif
 864         return AVSYS_STATE_SUCCESS;
 865 };
 866
 867 #define DO_IF_VALID(c, p) { if(c > -1) p; }
 868 #define DO_IF_INVALID(c, p) { if(c == -1) p; }
 869 #define CHECK_VALID(c) (c>-1 ? 1 : 0)
 870
 871 enum {
 872         CMD_DEVICE_NONE = 0,
 873         CMD_DEVICE_OPEN,
 874         CMD_DEVICE_CLOSE,       /* Not used */
 875         CMD_DEVICE_MAX
 876 };
 877
 878 #ifndef MURPHY_SUPPORT
 879 avsys_audio_alsa_aif_handle_t *g_hAIF[AIF_DEVICE_MAX] = { NULL, NULL, NULL, NULL, NULL };
 880 char *strAIF[AIF_DEVICE_MAX] = { "AIF CP Capture", "AIF CP Playback", "AIF BT Capture", "AIF BT Playback", "AIF RADIO Playback" };
 881
 882 #define SET_AIF(index) do {     AIF_control[index] = CMD_DEVICE_OPEN; } while (0)
 883
 884 static int __is_cp_aif (int type)
 885 {
 886         return ((type == AIF_CP_PLAYBACK || type == AIF_CP_CAPTURE));
 887 }
 888
 889 static int __avsys_open_aif(char AIF_control[], bool wb_enabled)
 890 {
 891         int iAIF = 0;
 892         int err = AVSYS_STATE_SUCCESS;
 893         bool bt_enabled = 0;
 894         aif_rate_t rate = 0;
 895
 896         /* Check If BT is enabled */
 897         for (iAIF = 0; iAIF < AIF_DEVICE_MAX; iAIF++) {
 898                 if (AIF_control[iAIF] == CMD_DEVICE_OPEN && (iAIF == AIF_BT_PLAYBACK || iAIF== AIF_BT_CAPTURE)) {
 899                         bt_enabled = true;
 900                         break;
 901                 }
 902         }
 903
 904         /* Iterate control command */
 905         avsys_info(AVAUDIO, "================== Close if reopen is needed (bt[%d] wb[%d]) ================== \n", bt_enabled, wb_enabled);
 906         for (iAIF = 0; iAIF < AIF_DEVICE_MAX; iAIF++) {
 907                 /* check command */
 908                 if (AIF_control[iAIF] != CMD_DEVICE_OPEN)
 909                         continue;
 910
 911                 avsys_info(AVAUDIO, "%d. [%s]\n", iAIF, strAIF[iAIF]);
 912
 913                 /* check handle exists */
 914                 if (g_hAIF[iAIF]) {
 915                         /* Handle is already opened.
 916                          * Check if WB is supported and CP handle case */
 917                         if (wb_enabled && __is_cp_aif(g_hAIF[iAIF]->type)) {
 918                                 /* CP Handle is already opened with WB enabled .
 919                                  * Determine whether re-open is needed */
 920                                 if ((bt_enabled &&  g_hAIF[iAIF]->rate != AIF_NB_RATE) ||
 921                                         (!bt_enabled &&  g_hAIF[iAIF]->rate == AIF_NB_RATE)) {
 922                                         /* CP handle exists and BT enabled with not NB opened => close for reopen
 923                                            CP handle exists and BT disabled with NB opened => close for reopen */
 924                                         avsys_info(AVAUDIO, "=> Close device for reopen :: %s\n", strAIF[iAIF]);
 925                                         if (AVSYS_FAIL(avsys_audio_alsa_close_AIF_device(g_hAIF[iAIF]))) {
 926                                                 avsys_error_r(AVAUDIO, "close %s device failed\n", strAIF[iAIF]);
 927                                         }
 928                                         free(g_hAIF[iAIF]);
 929                                         g_hAIF[iAIF] = NULL;
 930                                 } else {
 931                                         /* CP handle exists and BT enabled with NB opened ||
 932                                            CP handle exists and BT disabled with not NB opened */
 933                                         avsys_info(AVAUDIO, "=> Skip device :: %s\n", strAIF[iAIF]);
 934                                         continue;
 935                                 }
 936
 937                         } else {
 938                                 /* Not CP case or WB is disabled. No need to reopen */
 939                                 avsys_info(AVAUDIO, "=> Skip device :: %s\n", strAIF[iAIF]);
 940                                 continue;
 941                         }
 942                 }
 943         }
 944
 945         avsys_info(AVAUDIO, "================== Open & Set Param ================== \n");
 946         /* Iterate control command */
 947         for (iAIF = 0; iAIF < AIF_DEVICE_MAX; iAIF++) {
 948                 /* check command */
 949                 if (AIF_control[iAIF] != CMD_DEVICE_OPEN)
 950                         continue;
 951
 952                 avsys_info(AVAUDIO, "%d. [%s]\n", iAIF, strAIF[iAIF]);
 953
 954                 /* check handle exists */
 955                 if (g_hAIF[iAIF]) {
 956                         /* Not CP case or WB is disabled. No need to reopen */
 957                         avsys_info(AVAUDIO, "=> Skip device Already opened!!! :: %s\n", strAIF[iAIF]);
 958                         continue;
 959                 }
 960
 961                 /* memory allocation for handle */
 962                 avsys_warning(AVAUDIO, "=> [%s] handle alloc", strAIF[iAIF]);
 963                 g_hAIF[iAIF] = calloc(sizeof(avsys_audio_handle_t), 1);
 964                 if (!g_hAIF[iAIF]) {
 965                         avsys_error_r(AVAUDIO, "=> Can not alloc memory for [%s] device handle", strAIF[iAIF]);
 966                         err = AVSYS_STATE_ERR_ALLOCATION;
 967                         continue;
 968                 }
 969
 970                 if (AVSYS_FAIL(avsys_audio_alsa_open_AIF_device(iAIF, g_hAIF[iAIF]))) {
 971                         avsys_error_r(AVAUDIO, "=> open [%s] device failed\n", strAIF[iAIF]);
 972                         err = AVSYS_STATE_ERR_INVALID_HANDLE;
 973                 } else {
 974                         avsys_warning(AVAUDIO, "=> open [%s] device success\n", strAIF[iAIF]);
 975
 976                         /* Select RATE */
 977                         if (__is_cp_aif(g_hAIF[iAIF]->type)) {
 978                                 rate = (wb_enabled && !bt_enabled)? AIF_WB_RATE : AIF_NB_RATE;
 979                         } else {
 980                                 rate = AIF_CONF_RATE;
 981                         }
 982
 983                         if (AVSYS_FAIL(avsys_audio_alsa_set_AIF_params(g_hAIF[iAIF],rate))) {
 984                                 avsys_error_r(AVAUDIO, "=> [%s] device set parameter failed\n", strAIF[iAIF]);
 985                                 err = AVSYS_STATE_ERR_INVALID_PARAMETER;
 986                         } else {
 987                                 avsys_warning(AVAUDIO, "=> [%s] device set parameter success\n", strAIF[iAIF]);
 988                         }
 989                 }
 990         }
 991         return err;
 992 }
 993
 994 static void __avsys_close_aif ()
 995 {
 996         int iAIF = 0;
 997
 998         for (iAIF = 0; iAIF < AIF_DEVICE_MAX; iAIF++) {
 999                 if (g_hAIF[iAIF]) {
1000                         avsys_info(AVAUDIO, "close device :: %s\n", strAIF[iAIF]);
1001                         if (AVSYS_FAIL(avsys_audio_alsa_close_AIF_device(g_hAIF[iAIF]))) {
1002                                 avsys_error_r(AVAUDIO, "close %s device failed\n", strAIF[iAIF]);
1003                         }
1004                         free(g_hAIF[iAIF]);
1005                         g_hAIF[iAIF] = NULL;
1006                         avsys_warning(AVAUDIO, "%s device handle free\n", strAIF[iAIF]);
1007                 } else {
1008                         avsys_info(AVAUDIO, "skip closing device :: %s\n", strAIF[iAIF]);
1009                 }
1010         }
1011 }
1012
1013 #endif  /* MURPHY_SUPPORT */
1014
1015
1016 static int __avsys_audio_release_path (gain_info_t local_gain, avsys_audio_path_ex_info_t *control)
1017 {
1018         int err = AVSYS_STATE_SUCCESS;
1019         int iAIF = 0;
1020         bool close_aif_later = false;
1021
1022         avsys_warning(AVAUDIO, "Release path for %d %d\n", local_gain.playback, local_gain.capture);
1023
1024         switch (local_gain.playback) {
1025         case AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL:
1026         case AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL:
1027                 if (getpid() == control->path_fixed_pid[PATH_FIXED_TYPE_CALL]) {
1028 #ifndef MURPHY_SUPPORT
1029                         if (!control->control_aif_before_path_set) {
1030                                 __avsys_close_aif();
1031                         } else {
1032                                 close_aif_later = true;
1033                         }
1034
1035                         if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_CODEC_DISABLE_ON_SUSPEND))) {
1036                                 avsys_error_r(AVAUDIO, "[%s] failed to set codec_disable_on_suspend\n", __func__);
1037                         }
1038 #endif  /* MURPHY_SUPPORT */
1039                 } else {
1040                         if (control->path_fixed_pid[PATH_FIXED_TYPE_CALL] < 0) {
1041                                 avsys_warning(AVAUDIO, "Sound path for call released already\n");
1042                         } else {
1043                                 avsys_warning(AVAUDIO, "Try to close call path from other process.. original pid[%d]\n", control->path_fixed_pid[PATH_FIXED_TYPE_CALL]);
1044                                 avsys_warning(AVAUDIO, "Just mark handle as off\n");
1045                         }
1046                 }
1047
1048                 if ((control->path_fixed & PATH_FIXED_WITH_CALL) == 0) {
1049                         avsys_error(AVAUDIO, "Call path release without call path request\n");
1050                 }
1051                 control->path_fixed &= ~PATH_FIXED_WITH_CALL;
1052                 control->path_fixed_pid[PATH_FIXED_TYPE_CALL] = -1;
1053
1054                 break;
1055
1056         case AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO:
1057                 /* TODO: Reset & Codec disable on suspend script */
1058 #ifdef MURPHY_SUPPORT
1059         control->p_path_status.playback = PS_PATH_NONE;
1060 #else
1061                 if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_CODEC_DISABLE_ON_SUSPEND))) {
1062                         avsys_error_r(AVAUDIO, "[%s] failed to set codec_disable_on_suspend\n", __func__);
1063                 }
1064
1065                 if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_STR_RESET_CAPTURE))) {
1066                         avsys_error_r(AVAUDIO, "[%s] failed to set reset\n", __func__);
1067                 }
1068 #endif
1069
1070                 break;
1071
1072         default:
1073                 avsys_warning(AVAUDIO, "unexpected path release\n");
1074                 break;
1075         }
1076
1077         if (control->path_fixed != PATH_FIXED_NONE) {
1078                 avsys_error(AVAUDIO, "Still remain another path_fixed request : 0x%08X\n", control->path_fixed);
1079                 avsys_error(AVAUDIO, "This is not expected condition\n");
1080         } else {
1081                 avsys_warning(AVAUDIO, "Path Release to default condition....\n");
1082                 control->gain.playback = AVSYS_AUDIO_PLAYBACK_GAIN_AP;
1083                 control->gain.capture = AVSYS_AUDIO_CAPTURE_GAIN_AP;
1084                 control->path.playback = AVSYS_AUDIO_PATH_EX_SPK;
1085                 control->path.capture = AVSYS_AUDIO_PATH_EX_MIC;
1086                 if (control->inserted != AVSYS_AUDIO_INSERTED_NONE) {
1087                         control->path.playback = AVSYS_AUDIO_PATH_EX_HEADSET;
1088                         if (control->inserted == AVSYS_AUDIO_INSERTED_4)
1089                                 control->path.capture = AVSYS_AUDIO_PATH_EX_HEADSETMIC;
1090                 }
1091
1092 #ifndef MURPHY_SUPPORT
1093                 /* Playback */
1094                 err = __avsys_audio_path_set_ascn_ap_playback(control);
1095                 if (AVSYS_SUCCESS(err)) {
1096                         err = __avsys_audio_path_set_hw_controls(control);
1097                         if (AVSYS_FAIL(err)) {
1098                                 avsys_error(AVAUDIO, "Update logical volume failure\n");
1099                         }
1100                 } else {
1101                         avsys_error(AVAUDIO, "Set ap playback failure\n");
1102                 }
1103
1104                 /* Capture */
1105                 err = __avsys_audio_path_set_ascn_ap_capture(control);
1106                 if (AVSYS_FAIL(err)) {
1107                         avsys_error(AVAUDIO, "Set ap capture failure\n");
1108                 }
1109 #endif
1110         }
1111
1112 #ifndef MURPHY_SUPPORT
1113         if (close_aif_later == true) {
1114                 __avsys_close_aif();
1115 #endif
1116
1117         return err;
1118 }
1119
1120 int avsys_audio_path_earjack_get_type()
1121 {
1122         avsys_audio_path_ex_info_t *control = NULL;
1123         avsys_audio_path_ex_info_t **temp = NULL;
1124         int err = AVSYS_STATE_SUCCESS;
1125         int ret = 0;
1126
1127         temp = &control;
1128         if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
1129                 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
1130                 return AVSYS_STATE_ERR_INTERNAL;
1131         }
1132         if (control == NULL)
1133                 return AVSYS_STATE_ERR_NULL_POINTER;
1134
1135         if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1136                 avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
1137                 return AVSYS_STATE_ERR_INTERNAL;
1138         }
1139
1140         ret = control->inserted;
1141
1142         if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1143                 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
1144                 return AVSYS_STATE_ERR_INTERNAL;
1145         }
1146
1147         return ret;
1148 }
1149
1150 int avsys_audio_path_ex_set_path(int gain, int out, int in, int option)
1151 {
1152         avsys_audio_path_ex_info_t *control = NULL;
1153         avsys_audio_path_ex_info_t **temp = NULL;
1154         gain_info_t local_gain = { -1, -1 };
1155         gain_info_t req_gain = { -1, -1 };
1156         pid_t current_pid;
1157         int err = AVSYS_STATE_SUCCESS;
1158         char req_release_path = 0;
1159 #ifndef MURPHY_SUPPORT
1160         char AIF_control[AIF_DEVICE_MAX] = { CMD_DEVICE_NONE, CMD_DEVICE_NONE, CMD_DEVICE_NONE, CMD_DEVICE_NONE, CMD_DEVICE_NONE };
1161         int iAIF = 0;
1162 #endif
1163
1164         avsys_warning(AVAUDIO, "=================== [Input Param] gain %d, out %d, in %d, opt 0x%x ====================\n", gain, out, in, option);
1165
1166         /* Determine REQUESTs */
1167         switch (gain) {
1168         case AVSYS_AUDIO_GAIN_EX_KEYTONE:
1169         case AVSYS_AUDIO_GAIN_EX_ALARMTONE:
1170         case AVSYS_AUDIO_GAIN_EX_AUDIOPLAYER:
1171         case AVSYS_AUDIO_GAIN_EX_VIDEOPLAYER:
1172         case AVSYS_AUDIO_GAIN_EX_CAMERA:
1173         case AVSYS_AUDIO_GAIN_EX_GAME:
1174                 req_gain.playback = AVSYS_AUDIO_PLAYBACK_GAIN_AP;
1175                 req_gain.capture = AVSYS_AUDIO_CAPTURE_GAIN_AP;
1176                 break;
1177
1178         case AVSYS_AUDIO_GAIN_EX_RINGTONE:
1179         case AVSYS_AUDIO_GAIN_EX_CALLTONE:
1180                 req_gain.playback = AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT;
1181                 break;
1182
1183         case AVSYS_AUDIO_GAIN_EX_VOICEREC:
1184         case AVSYS_AUDIO_GAIN_EX_CAMCORDER:
1185                 req_gain.capture = AVSYS_AUDIO_CAPTURE_GAIN_AP;
1186                 break;
1187
1188         case AVSYS_AUDIO_GAIN_EX_VOICECALL:
1189                 req_gain.playback = AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL;
1190                 req_gain.capture = AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL;
1191                 if (out == AVSYS_AUDIO_PATH_EX_NONE && in == AVSYS_AUDIO_PATH_EX_NONE)
1192                         req_release_path = 1;
1193                 break;
1194
1195         case AVSYS_AUDIO_GAIN_EX_VIDEOCALL:
1196                 req_gain.playback = AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL;
1197                 req_gain.capture = AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL;
1198                 if (out == AVSYS_AUDIO_PATH_EX_NONE && in == AVSYS_AUDIO_PATH_EX_NONE)
1199                         req_release_path = 1;
1200                 break;
1201
1202         case AVSYS_AUDIO_GAIN_EX_FMRADIO:
1203                 req_gain.playback = AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO;
1204                 req_gain.capture = AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO;
1205                 if (out == AVSYS_AUDIO_PATH_EX_NONE && in == AVSYS_AUDIO_PATH_EX_NONE)
1206                         req_release_path = 1;
1207                 break;
1208         }
1209
1210         /* Get avsys shared memeory */
1211         temp = &control;
1212         if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
1213                 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
1214                 return AVSYS_STATE_ERR_INTERNAL;
1215         }
1216         /* LOCK */
1217         if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1218                 avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
1219                 return AVSYS_STATE_ERR_INTERNAL;
1220         }
1221
1222         current_pid = getpid(); /* moved from below */
1223
1224         /* Check FORCED option */
1225         if (option & AVSYS_AUDIO_PATH_OPTION_FORCED) {
1226                 DO_IF_VALID(req_gain.playback, local_gain.playback = req_gain.playback)
1227                 DO_IF_VALID(req_gain.capture, local_gain.capture = req_gain.capture)
1228         } else {
1229                 DO_IF_VALID(req_gain.playback, local_gain.playback = g_playback_gain_select_data[control->gain.playback][req_gain.playback])
1230                 DO_IF_VALID(req_gain.capture, local_gain.capture = g_capture_gain_select_data[control->gain.capture][req_gain.capture])
1231         }
1232
1233         avsys_info(AVAUDIO, "Gain : req(%d,%d)  local(%d,%d)\n", req_gain.playback, req_gain.capture, local_gain.playback, local_gain.capture);
1234
1235         /* Check path fixed process alive. */
1236         if (control->path_fixed & PATH_FIXED_WITH_CALL) {
1237                 if (AVSYS_FAIL(avsys_check_process(control->path_fixed_pid[PATH_FIXED_TYPE_CALL]))) {
1238                         control->path_fixed &= ~PATH_FIXED_WITH_CALL;
1239                 }
1240         }
1241         if (control->path_fixed == PATH_FIXED_NONE) {
1242                 /* forced gain setting when path fixed by dead process */
1243                 if (req_gain.playback != local_gain.playback) {
1244                         local_gain.playback = req_gain.playback;
1245                 }
1246                 if (req_gain.capture != local_gain.capture) {
1247                         local_gain.capture = req_gain.capture;
1248                 }
1249         }
1250
1251         if (CHECK_VALID(local_gain.playback)) {
1252                 if (g_playback_path_select_data[local_gain.playback][out] == 0) {
1253                         avsys_error(AVAUDIO, "[PLAYBACK] Does not support request sound path : conv gain %d, out path %d\n", local_gain.playback, out);
1254                         if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1255                                 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
1256                                 return AVSYS_STATE_ERR_INTERNAL;
1257                         }
1258                         return AVSYS_STATE_ERR_INVALID_STATE;
1259                 }
1260         }
1261         if (CHECK_VALID(local_gain.capture)) {
1262                 if (g_capture_path_select_data[local_gain.capture][in] == 0) {
1263                         avsys_error(AVAUDIO, "[CAPTURE] Does not support request sound path : conv gain %d, in path %d\n", local_gain.capture, in);
1264                         if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1265                                 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
1266                                 return AVSYS_STATE_ERR_INTERNAL;
1267                         }
1268                         return AVSYS_STATE_ERR_INVALID_STATE;
1269                 }
1270         }
1271         /* overwrite local_gain with current gain if it is simplex sound path */
1272         DO_IF_INVALID(local_gain.playback, local_gain.playback = control->gain.playback)
1273         DO_IF_INVALID(local_gain.capture, local_gain.capture = control->gain.capture)
1274         control->pregain = control->gain;
1275         control->gain = local_gain;
1276
1277         DO_IF_VALID(req_gain.playback, control->reqgain.playback = req_gain.playback)
1278         DO_IF_VALID(req_gain.capture, control->reqgain.capture = req_gain.capture)
1279         DO_IF_VALID(local_gain.playback, control->option.playback = option)
1280         DO_IF_VALID(local_gain.capture, control->option.capture = option)
1281
1282         /* Check for Release PATH */
1283         if (req_release_path && (req_gain.playback == local_gain.playback) && (req_gain.capture == local_gain.capture)) {
1284                 avsys_warning(AVAUDIO,"Release path for %d %d\n", local_gain.playback, local_gain.capture);
1285
1286 #ifdef MURPHY_SUPPORT
1287                 err = AVSYS_STATE_SUCCESS;
1288 #else
1289                 err = __avsys_audio_release_path(local_gain, control);
1290 #endif
1291                 goto FINISHED;
1292         }
1293         if (CHECK_VALID(req_gain.playback)) {
1294                 if(req_gain.playback != local_gain.playback) {
1295                         avsys_warning(AVAUDIO, "Sound Path is protected. use current configuration (playback_gain %d, out %d, opt 0x%x)\n",
1296                                         local_gain.playback, control->path.playback, control->option.playback);
1297                         if (req_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_AP) {
1298                                 control->backup_gain.playback = control->reqgain.playback;
1299                                 control->backup_path.playback = out;
1300                         }
1301                 } else {
1302                         control->path.playback = out;
1303                         control->backup_gain.playback = local_gain.playback;
1304                         control->backup_path.playback = out;
1305
1306                         switch (local_gain.playback) {
1307                         case AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT:
1308 #ifndef MURPHY_SUPPORT
1309                                 if (control->path.playback == AVSYS_AUDIO_PATH_EX_BTHEADSET) {
1310                                         SET_AIF(AIF_BT_PLAYBACK);
1311                                         SET_AIF(AIF_BT_CAPTURE);
1312                                 }
1313 #endif
1314                                 break;
1315
1316                         case AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL:
1317                         case AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL:
1318 #ifndef MURPHY_SUPPORT
1319                                 /* Set CP only for voicecall */
1320                                 if (local_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL) {
1321                                         SET_AIF(AIF_CP_PLAYBACK);
1322                                 }
1323                                 control->path_fixed_pid[PATH_FIXED_TYPE_CALL] = current_pid;
1324                                 SET_AIF(AIF2_PLAYBACK);
1325
1326                                 /* Voicecall / Videocall Common setting */
1327                                 control->path_fixed_pid[PATH_FIXED_TYPE_CALL] = current_pid;
1328                                 if (control->path.playback == AVSYS_AUDIO_PATH_EX_BTHEADSET) {
1329                                         SET_AIF(AIF_BT_PLAYBACK);
1330                                 }
1331 #endif
1332                                 break;
1333
1334                         case AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO:
1335                                 control->path_fixed_pid[PATH_FIXED_TYPE_FMRADIO] = current_pid;
1336                                 SET_AIF(AIF_RADIO_PLAYBACK);
1337                                 break;
1338                         }
1339                 }
1340         }
1341
1342         if (CHECK_VALID(req_gain.capture)) {
1343                 if (req_gain.capture != local_gain.capture) {
1344                         avsys_warning(AVAUDIO, "Sound Path is protected. use current configuration (capture_gain %d, in %d, opt 0x%x)\n",
1345                                         local_gain.capture, control->path.capture, control->option.capture);
1346                         if (req_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_AP) {
1347                                 control->backup_gain.capture = control->reqgain.capture;
1348                                 control->backup_path.capture = in;
1349                         }
1350                 } else {
1351                         control->path.capture = in;
1352                         control->backup_gain.capture = local_gain.capture;
1353                         control->backup_path.capture = in;
1354
1355                         switch (local_gain.capture) {
1356                         case AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL:
1357                         case AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL:
1358                                 /* Voicecall / Videocall Common setting */
1359                                 control->path_fixed_pid[PATH_FIXED_TYPE_CALL] = current_pid;
1360 #ifndef MURPHY_SUPPORT
1361                                 /* Set CP only for voicecall */
1362                                 if (local_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL) {
1363                                         SET_AIF(AIF_CP_CAPTURE);
1364                                 }
1365                                 control->path_fixed_pid[PATH_FIXED_TYPE_CALL] = current_pid;
1366                                 if (control->path.capture == AVSYS_AUDIO_PATH_EX_BTMIC) {
1367                                         SET_AIF(AIF3_CAPTURE);
1368                                 }
1369
1370                                 SET_AIF(AIF2_CAPTURE);
1371
1372                                 if (control->path.capture == AVSYS_AUDIO_PATH_EX_BTMIC) {
1373                                         SET_AIF(AIF_BT_CAPTURE);
1374                                 }
1375 #endif
1376                                 break;
1377
1378                         case AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO:
1379                                 control->path_fixed_pid[PATH_FIXED_TYPE_FMRADIO] = current_pid;
1380                                 break;
1381                         }
1382                 }
1383         }
1384
1385         /* Open AIFs */
1386         if (control->control_aif_before_path_set) {
1387 #if !defined(MURPHY_SUPPORT)
1388                 err = __avsys_open_aif(AIF_control, control->wb_enabled);
1389 #else
1390         err = AVSYS_STATE_SUCCESS;
1391 #endif
1392         }
1393
1394         /* Do ALSA scenario control based on gain */
1395         /* Playback */
1396         if (local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_AP) {
1397                 avsys_warning(AVAUDIO, "playback gain : ap\n");
1398 #ifndef MURPHY_SUPPORT
1399                 err = __avsys_audio_path_set_ascn_ap_playback(control);
1400                 if (AVSYS_SUCCESS(err)) {
1401                         err = __avsys_audio_path_set_hw_controls(control);
1402                 }
1403 #endif
1404         } else if(local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT) {
1405                 avsys_warning(AVAUDIO,"playback gain : callalert\n");
1406 #ifndef MURPHY_SUPPORT
1407                 err = __avsys_audio_path_set_ascn_ap_playback(control);
1408                 if (AVSYS_SUCCESS(err)) {
1409                         err = __avsys_audio_path_set_hw_controls(control);
1410                 }
1411 #endif
1412         } else if (local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO &&
1413                            local_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO) {
1414                 avsys_warning(AVAUDIO, "fmradio gain\n");
1415 #ifndef MURPHY_SUPPORT
1416                 err = __avsys_audio_path_set_ascn_fmradio(control);
1417 #endif
1418         } else if (local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL &&
1419                            local_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL) {
1420                 avsys_warning(AVAUDIO, "voicecall gain\n");
1421 #ifndef MURPHY_SUPPORT
1422                 err = __avsys_audio_path_set_ascn_voicecall(control);
1423 #endif
1424         } else if (local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL &&
1425                            local_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL) {
1426                 avsys_warning(AVAUDIO, "videocall gain\n");
1427 #ifndef MURPHY_SUPPORT
1428                 err = __avsys_audio_path_set_ascn_videocall(control);
1429 #endif
1430         }
1431         /* Capture */
1432         if (local_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_AP) {
1433                 avsys_warning(AVAUDIO, "capture gain : ap\n");
1434 #ifndef MURPHY_SUPPORT
1435                 err = __avsys_audio_path_set_ascn_ap_capture(control);
1436 #endif
1437         }
1438
1439         if (!control->control_aif_before_path_set) {
1440 #if !defined(MURPHY_SUPPORT)
1441                 err = __avsys_open_aif(AIF_control, control->wb_enabled);
1442 #else
1443         err = AVSYS_STATE_SUCCESS;
1444 #endif
1445         }
1446
1447 FINISHED:
1448         /* UnLOCK */
1449         if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1450                 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
1451                 return AVSYS_STATE_ERR_INTERNAL;
1452         }
1453         avsys_info(AVAUDIO, "------------------------------------------------\n");
1454         return err;
1455 }
1456
1457 int avsys_audio_path_ex_get_path(int *gain, int *out, int *in, int *option)
1458 {
1459         avsys_audio_path_ex_info_t *control = NULL;
1460         avsys_audio_path_ex_info_t ** temp = NULL;
1461
1462         if(gain == NULL || out == NULL || in == NULL || option == NULL) {
1463                 avsys_error(AVAUDIO,"Invalid parameter\n");
1464                 return AVSYS_STATE_ERR_NULL_POINTER;
1465         }
1466
1467         temp = &control;
1468
1469         if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
1470                 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
1471                 return AVSYS_STATE_ERR_INTERNAL;
1472         }
1473         if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1474                 avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
1475                 return AVSYS_STATE_ERR_INTERNAL;
1476         }
1477
1478         switch (control->gain.playback) {
1479         case AVSYS_AUDIO_PLAYBACK_GAIN_AP:
1480                 *gain = AVSYS_AUDIO_GAIN_EX_KEYTONE;
1481                 *out = control->path.playback;
1482                 *in = AVSYS_AUDIO_PATH_EX_NONE;
1483                 *option = control->option.playback;
1484                 break;
1485         case AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT:
1486                 *gain = AVSYS_AUDIO_GAIN_EX_RINGTONE;
1487                 *out = control->path.playback;
1488                 *in = AVSYS_AUDIO_PATH_EX_NONE;
1489                 *option = control->option.playback;
1490                 break;
1491         case AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL:
1492                 *gain = AVSYS_AUDIO_GAIN_EX_VOICECALL;
1493                 *out = control->path.playback;
1494                 *in = control->path.capture;
1495                 *option = control->option.playback;
1496                 break;
1497         case AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL:
1498                 *gain = AVSYS_AUDIO_GAIN_EX_VIDEOCALL;
1499                 *out = control->path.playback;
1500                 *in = control->path.capture;
1501                 *option = control->option.playback;
1502                 break;
1503         case AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO:
1504                 *gain = AVSYS_AUDIO_GAIN_EX_FMRADIO;
1505                 *out = control->path.playback;
1506                 *in = control->path.capture;
1507                 *option = control->option.playback;
1508                 break;
1509         }
1510
1511         if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1512                 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
1513                 return AVSYS_STATE_ERR_INTERNAL;
1514         }
1515
1516         return AVSYS_STATE_SUCCESS;
1517 }
1518
1519 int avsys_audio_path_ex_set_amp(const int onoff)
1520 {
1521         //not yet implemented.
1522         return AVSYS_STATE_SUCCESS;
1523 }
1524
1525 int avsys_audio_path_ex_set_mute(const int mute)
1526 {
1527         avsys_audio_path_ex_info_t *control = NULL;
1528         avsys_audio_path_ex_info_t **temp = NULL;
1529
1530         temp = &control;
1531
1532         if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
1533                 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
1534                 return AVSYS_STATE_ERR_INTERNAL;
1535         }
1536
1537         if (control == NULL) {
1538                 return AVSYS_STATE_ERR_NULL_POINTER;
1539         }
1540
1541         if (mute == AVSYS_AUDIO_UNMUTE || mute == AVSYS_AUDIO_MUTE) {
1542                 if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1543                         avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
1544                         return AVSYS_STATE_ERR_INTERNAL;
1545                 }
1546
1547                 if (control->mute == mute) {
1548                         avsys_info(AVAUDIO, "[Path Mute] skip mute ctrl op: %d\n", mute);
1549                         if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1550                                 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() 2 failed in %s\n", __func__);
1551                                 return AVSYS_STATE_ERR_INTERNAL;
1552                         }
1553                         return AVSYS_STATE_SUCCESS;
1554                 } else {
1555                         control->mute = mute;
1556                         avsys_warning(AVAUDIO, "[Path Mute] run mute ctrl op: %d\n", mute);
1557                 }
1558
1559 #ifndef MURPHY_SUPPORT
1560                 if (control->mute) {
1561                         if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_STR_PLAYBACK_MUTE))) {
1562                                 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1563                                         avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() 1 failed in %s\n", __func__);
1564                                         return AVSYS_STATE_ERR_INTERNAL;
1565                                 }
1566                                 avsys_error(AVAUDIO, "Mute fail %s\n", __func__);
1567                                 return AVSYS_STATE_ERR_IO_CONTROL;
1568                         }
1569                 } else {
1570                         if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_STR_PLAYBACK_UNMUTE))) {
1571                                 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1572                                         avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() 1 failed in %s\n", __func__);
1573                                         return AVSYS_STATE_ERR_INTERNAL;
1574                                 }
1575                                 avsys_error(AVAUDIO, "Unmute fail %s\n", __func__);
1576                                 return AVSYS_STATE_ERR_IO_CONTROL;
1577                         }
1578                 }
1579 #endif
1580
1581                 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1582                         avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() 2 failed in %s\n", __func__);
1583                         return AVSYS_STATE_ERR_INTERNAL;
1584                 }
1585         } else {
1586                 int mute_nolock;
1587                 if (mute == AVSYS_AUDIO_UNMUTE_NOLOCK)  /* set nomalize */
1588                         mute_nolock = AVSYS_AUDIO_UNMUTE;
1589                 else
1590                         mute_nolock = AVSYS_AUDIO_MUTE;
1591
1592                 if (control->mute == mute_nolock) {
1593                         avsys_info(AVAUDIO, "[Path Mute] skip mute ctrl op: %d\n", mute);
1594                         return AVSYS_STATE_SUCCESS;
1595                 } else {
1596                         control->mute = mute_nolock;
1597                         avsys_warning(AVAUDIO, "[Path Mute] run mute ctrl op: %d\n", mute);
1598                 }
1599
1600 #ifndef MURPHY_SUPPORT
1601                 if (control->mute) {
1602                         if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_STR_PLAYBACK_MUTE))) {
1603                                 avsys_error(AVAUDIO, "Mute fail %s\n", __func__);
1604                                 return AVSYS_STATE_ERR_IO_CONTROL;
1605                         }
1606                 } else {
1607                         if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_STR_PLAYBACK_UNMUTE))) {
1608                                 avsys_error(AVAUDIO, "Unmute fail %s\n", __func__);
1609                                 return AVSYS_STATE_ERR_IO_CONTROL;
1610                         }
1611                 }
1612 #endif
1613         }
1614
1615         if (mute == AVSYS_AUDIO_UNMUTE || mute == AVSYS_AUDIO_UNMUTE_NOLOCK)
1616                 avsys_info_r(AVAUDIO, "Global Mute Disabled\n");
1617         else if (mute == AVSYS_AUDIO_MUTE || mute == AVSYS_AUDIO_MUTE_NOLOCK)
1618                 avsys_info_r(AVAUDIO, "Global Mute Enabled\n");
1619         return AVSYS_STATE_SUCCESS;
1620 }
1621
1622 int avsys_audio_path_ex_get_mute(int *mute)
1623 {
1624         avsys_audio_path_ex_info_t *control = NULL;
1625         avsys_audio_path_ex_info_t **temp = NULL;
1626
1627         temp = &control;
1628
1629         if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
1630                 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
1631                 return AVSYS_STATE_ERR_INTERNAL;
1632         }
1633
1634         if (control == NULL) {
1635                 return AVSYS_STATE_ERR_NULL_POINTER;
1636         }
1637
1638         if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1639                 avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
1640                 return AVSYS_STATE_ERR_INTERNAL;
1641         }
1642
1643         *mute = control->mute;
1644
1645         if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1646                 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
1647                 return AVSYS_STATE_ERR_INTERNAL;
1648         }
1649
1650         return AVSYS_STATE_SUCCESS;
1651 }
1652
1653 #ifndef MURPHY_SUPPORT
1654 static int __avsys_audio_path_set_ascn_ap_playback(avsys_audio_path_ex_info_t *control)
1655 {
1656         int cmd_gain[2] = { 0, 0 };
1657         int cmd_path[3] = { 0, 0, 0 };
1658         char callalert_mode = 0;
1659
1660         avsys_info(AVAUDIO, "<< path.playback = %d, option = %x, gain.playback = %d, inserted = %d\n",
1661                                 control->path.playback, control->option.playback, control->gain.playback, control->inserted);
1662
1663         callalert_mode = (control->gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT) ? 1 : 0;
1664         control->path_fixed = PATH_FIXED_NONE;
1665
1666         switch (control->path.playback) {
1667         case AVSYS_AUDIO_PATH_EX_SPK:
1668                 if (control->option.playback & AVSYS_AUDIO_PATH_OPTION_DUAL_OUT) {
1669                         if (callalert_mode) {
1670                                 cmd_gain[0] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_CALLALERT;
1671                                 cmd_gain[1] = INPUT_AP | OUTPUT_HEADSET | GAIN_CALLALERT;
1672                         } else {
1673                                 cmd_gain[0] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_MODE;
1674                                 cmd_gain[1] = INPUT_AP | OUTPUT_HEADSET | GAIN_MODE;
1675                         }
1676
1677                         cmd_path[0] = INPUT_AP | OUTPUT_STEREO_SPK;
1678                         cmd_path[1] = INPUT_AP | OUTPUT_HEADSET;
1679
1680                         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1681                 } else {
1682                         if (callalert_mode) {
1683                                 cmd_gain[0] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_CALLALERT;
1684                         } else {
1685                                 cmd_gain[0] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_MODE;
1686                         }
1687                         control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_AUTO_WITHOUT_MUTE;
1688                         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1689
1690                         cmd_path[0] = INPUT_AP | OUTPUT_STEREO_SPK;
1691                 }
1692                 break;
1693
1694         case AVSYS_AUDIO_PATH_EX_RECV:
1695                 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1696                 cmd_gain[0] = INPUT_AP | OUTPUT_RECV | GAIN_MODE;
1697                 cmd_path[0] = INPUT_AP | OUTPUT_RECV;
1698                 break;
1699
1700         case AVSYS_AUDIO_PATH_EX_HEADSET:
1701                 if (callalert_mode) {
1702                         cmd_gain[0] = INPUT_AP | OUTPUT_HEADSET | GAIN_CALLALERT;
1703                 } else {
1704                         cmd_gain[0] = INPUT_AP | OUTPUT_HEADSET | GAIN_MODE;
1705                 }
1706                 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
1707                 cmd_path[0] = INPUT_AP | OUTPUT_HEADSET;
1708                 break;
1709
1710         case AVSYS_AUDIO_PATH_EX_HDMI:
1711                 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1712                 cmd_gain[0] = INPUT_AP | OUTPUT_HDMI | GAIN_MODE;
1713                 cmd_path[0] = INPUT_AP | OUTPUT_HDMI;
1714                 break;
1715
1716         case AVSYS_AUDIO_PATH_EX_DOCK:
1717                 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1718                 cmd_gain[0] = INPUT_AP | OUTPUT_DOCK | GAIN_MODE;
1719                 cmd_path[0] = INPUT_AP | OUTPUT_DOCK;
1720                 break;
1721
1722         case AVSYS_AUDIO_PATH_EX_BTHEADSET:
1723                 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET;
1724                 cmd_gain[0] = INPUT_AP | OUTPUT_BT_HEADSET | GAIN_MODE;
1725                 cmd_path[0] = INPUT_AP | OUTPUT_BT_HEADSET;
1726                 break;
1727         case AVSYS_AUDIO_PATH_EX_HANDSFREE:
1728         default:                /* DEFAULT PATH CONTROL TO NONE */
1729                 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1730                 break;
1731         }
1732
1733         avsys_warning(AVAUDIO, "Run Alsa Scenario Script\n");
1734         RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_gain, 2, ASCN_RESET_PLAYBACK))
1735         RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_path, 2, ASCN_RESET_NONE))
1736
1737         avsys_info(AVAUDIO, ">> leave");
1738         return AVSYS_STATE_SUCCESS;
1739 }
1740
1741 static int __avsys_audio_path_set_ascn_voicecall(avsys_audio_path_ex_info_t *control)
1742 {
1743         int cmd_gain[6] = { 0, 0, 0, 0, 0, 0 };
1744         int cmd_path[6] = { 0, 0, 0, 0, 0, 0 };
1745         int gain_idx = 0;
1746         int path_idx = 0;
1747         control->path_fixed = PATH_FIXED_WITH_CALL;
1748
1749         avsys_info(AVAUDIO, "<< path.playback = %d, option = %x, gain.playback = %d, inserted = %d\n",
1750                                 control->path.playback, control->option.playback, control->gain.playback, control->inserted);
1751
1752         /* PLAYBACK */
1753         switch (control->path.playback) {
1754         case AVSYS_AUDIO_PATH_EX_NONE:
1755                 avsys_warning(AVAUDIO, "[SZ] playback AVSYS_AUDIO_PATH_EX_NONE\n");
1756                 break;
1757
1758         case AVSYS_AUDIO_PATH_EX_SPK:
1759                 if (control->reqgain.playback == control->gain.playback) {
1760                         cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_MODE;
1761                         cmd_path[path_idx++] = INPUT_AP | OUTPUT_STEREO_SPK;
1762                         cmd_gain[gain_idx++] = INPUT_CP | OUTPUT_STEREO_SPK | GAIN_VOICE_CALL;
1763                         cmd_path[path_idx++] = INPUT_CP | OUTPUT_STEREO_SPK;
1764                 } else {
1765                         avsys_warning(AVAUDIO, "Ignore another path setting request during voicecall\n");
1766                 }
1767                 break;
1768
1769         case AVSYS_AUDIO_PATH_EX_RECV:
1770                 if (control->gain.playback == control->reqgain.playback) {
1771                         cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_RECV | GAIN_MODE;
1772                         cmd_path[path_idx++] = INPUT_AP | OUTPUT_RECV;
1773                         cmd_gain[gain_idx++] = INPUT_CP | OUTPUT_RECV | GAIN_VOICE_CALL;
1774                         cmd_path[path_idx++] = INPUT_CP | OUTPUT_RECV;
1775                 } else {
1776                         avsys_warning(AVAUDIO, "Ignore another path setting request during voicecall\n");
1777                 }
1778                 break;
1779
1780         case AVSYS_AUDIO_PATH_EX_HEADSET:
1781                 if (control->reqgain.playback == control->gain.playback) {
1782                         cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_HEADSET | GAIN_MODE;
1783                         cmd_path[path_idx++] = INPUT_AP | OUTPUT_HEADSET;
1784                         cmd_gain[gain_idx++] = INPUT_CP | OUTPUT_HEADSET | GAIN_VOICE_CALL;
1785                         cmd_path[path_idx++] = INPUT_CP | OUTPUT_HEADSET;
1786                 } else {
1787                         avsys_warning(AVAUDIO, "Ignore another path setting request during voicecall\n");
1788                 }
1789                 break;
1790
1791         case AVSYS_AUDIO_PATH_EX_BTHEADSET:
1792
1793                 if (control->reqgain.playback == control->gain.playback) {
1794                         control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_AUTO_WITH_MUTE;
1795                         cmd_gain[gain_idx++] = INPUT_CP | OUTPUT_BT_HEADSET | GAIN_MODE;
1796                         cmd_path[path_idx++] = INPUT_AP | OUTPUT_BT_HEADSET;
1797                         cmd_path[path_idx++] = INPUT_CP | OUTPUT_BT_HEADSET;
1798                 } else {
1799                         avsys_warning(AVAUDIO, "Ignore another path setting request during voicecall\n");
1800                 }
1801                 break;
1802
1803         case AVSYS_AUDIO_PATH_EX_HANDSFREE:
1804         default:
1805                 if (control->reqgain.playback == control->gain.playback) {
1806                         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1807                 }
1808                 break;
1809         }
1810
1811
1812         /* Add sound path CP to AP (Rx recording) */
1813         if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC) {
1814                 avsys_warning(AVAUDIO, "[SZ] capture AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC\n");
1815                 //cmd_path[path_idx++] = INPUT_CP | OUTPUT_AP;
1816         }
1817
1818
1819         /* CAPTURE */
1820         switch (control->path.capture) {
1821         case AVSYS_AUDIO_PATH_EX_NONE:
1822                 avsys_warning(AVAUDIO, "[SZ] capture AVSYS_AUDIO_PATH_EX_NONE\n");
1823                 break;
1824
1825         case AVSYS_AUDIO_PATH_EX_MIC:
1826                 if (control->reqgain.capture == control->gain.capture) {
1827                         if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_USE_SUBMIC) {
1828                                 cmd_gain[gain_idx++] = INPUT_SUB_MIC | OUTPUT_CP | GAIN_MODE;
1829                                 cmd_path[path_idx++] = INPUT_SUB_MIC | OUTPUT_CP;
1830                                 if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC) {
1831                                         avsys_warning(AVAUDIO, "[SZ] capture AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC\n");
1832                                         //cmd_path[path_idx++] = INPUT_SUB_MIC | OUTPUT_AP;
1833                                 }
1834                         } else {
1835                                 cmd_gain[gain_idx++] = INPUT_MAIN_MIC | OUTPUT_CP | GAIN_MODE;
1836                                 cmd_path[path_idx++] = INPUT_MAIN_MIC | OUTPUT_CP;
1837                                 if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC) {
1838                                         avsys_warning(AVAUDIO, "[SZ] capture AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC\n");
1839                                         //cmd_path[path_idx++] = INPUT_MAIN_MIC | OUTPUT_AP;
1840                                 }
1841                         }
1842                 }
1843                 break;
1844
1845         case AVSYS_AUDIO_PATH_EX_HEADSETMIC:
1846                 if (control->reqgain.capture == control->gain.capture) {
1847                         cmd_gain[gain_idx++] = INPUT_EAR_MIC | OUTPUT_CP | GAIN_MODE;
1848                         cmd_path[path_idx++] = INPUT_EAR_MIC | OUTPUT_CP;
1849                         if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC) {
1850                                 avsys_warning(AVAUDIO, "[SZ] capture AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC\n");
1851                                 //cmd_path[path_idx++] = INPUT_EAR_MIC | OUTPUT_AP;
1852                         }
1853                 }
1854                 break;
1855
1856         case AVSYS_AUDIO_PATH_EX_BTMIC:
1857                 if (control->reqgain.capture == control->gain.capture) {
1858                         cmd_gain[gain_idx++] = INPUT_BT_MIC | OUTPUT_CP | GAIN_MODE;
1859                         cmd_path[path_idx++] = INPUT_BT_MIC | OUTPUT_CP;
1860                         if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC) {
1861                                 avsys_warning(AVAUDIO, "[SZ] capture AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC\n");
1862                                 //avsys_error(AVAUDIO, "BT Call recording is not supported");
1863                         }
1864                 }
1865                 break;
1866         case AVSYS_AUDIO_PATH_EX_HANDSFREE:
1867         default:
1868                 break;
1869         }
1870
1871         RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_single_set(ASCN_STR_RESET));
1872         RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_gain, 6, ASCN_RESET_NONE));
1873         RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_path, 6, ASCN_RESET_NONE));
1874
1875         avsys_info(AVAUDIO, ">> leave");
1876         return AVSYS_STATE_SUCCESS;
1877 }
1878
1879 static int __avsys_audio_path_set_ascn_videocall(avsys_audio_path_ex_info_t *control)
1880 {
1881         int cmd_gain[2] = { 0, 0 };
1882         int cmd_path[3] = { 0, 0, 0 };
1883         int gain_idx = 0;
1884         int path_idx = 0;
1885
1886         control->path_fixed = PATH_FIXED_WITH_CALL;
1887         switch (control->path.playback) {
1888         case AVSYS_AUDIO_PATH_EX_NONE:
1889                 avsys_warning(AVAUDIO, "[SZ] playback AVSYS_AUDIO_PATH_EX_NONE\n");
1890                 break;
1891
1892         case AVSYS_AUDIO_PATH_EX_SPK:
1893                 if (control->reqgain.playback == control->gain.playback) {
1894                         cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_MODE;
1895                         cmd_path[path_idx++] = INPUT_AP | OUTPUT_STEREO_SPK;
1896                         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1897                 } else {
1898                         avsys_warning(AVAUDIO, "Sound Path request during VT call ignored.");
1899                 }
1900                 break;
1901
1902         case AVSYS_AUDIO_PATH_EX_RECV:
1903                 if (control->gain.playback == control->reqgain.playback) {
1904                         cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_RECV | GAIN_MODE;
1905                         cmd_path[path_idx++] = INPUT_AP | OUTPUT_RECV;
1906                         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1907                 } else {
1908                         avsys_warning(AVAUDIO, "Sound Path request during VT call ignored.");
1909                 }
1910                 break;
1911
1912         case AVSYS_AUDIO_PATH_EX_HEADSET:
1913                 if (control->reqgain.playback == control->gain.playback) {
1914                         cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_HEADSET | GAIN_MODE;
1915                         cmd_path[path_idx++] = INPUT_AP | OUTPUT_HEADSET;
1916                         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
1917                 } else {
1918                         avsys_warning(AVAUDIO, "Sound Path request during VT call ignored.");
1919                 }
1920                 break;
1921
1922         case AVSYS_AUDIO_PATH_EX_BTHEADSET:
1923                 if (control->reqgain.playback == control->gain.playback) {
1924                         cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_BT_HEADSET | GAIN_MODE;
1925                         cmd_path[path_idx++] = INPUT_AP | OUTPUT_BT_HEADSET;
1926                         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET;
1927                 } else {
1928                         avsys_warning(AVAUDIO, "Sound Path request during VT call ignored.");
1929                 }
1930                 break;
1931
1932         case AVSYS_AUDIO_PATH_EX_HANDSFREE:
1933         default:
1934                 if (control->reqgain.playback == control->gain.playback) {
1935                         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1936                 }
1937                 break;
1938         }
1939
1940         switch (control->path.capture) {
1941         case AVSYS_AUDIO_PATH_EX_NONE:
1942                 avsys_warning(AVAUDIO, "[SZ] capture AVSYS_AUDIO_PATH_EX_NONE\n");
1943                 break;
1944
1945         case AVSYS_AUDIO_PATH_EX_MIC:
1946                 if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_USE_SUBMIC) {
1947                         cmd_gain[gain_idx++] = INPUT_SUB_MIC | OUTPUT_AP | GAIN_MODE;
1948                         cmd_path[path_idx++] = INPUT_SUB_MIC | OUTPUT_AP;
1949                 } else {
1950                         cmd_gain[gain_idx++] = INPUT_MAIN_MIC | OUTPUT_AP | GAIN_MODE;
1951                         cmd_path[path_idx++] = INPUT_MAIN_MIC | OUTPUT_AP;
1952                 }
1953                 break;
1954
1955         case AVSYS_AUDIO_PATH_EX_HEADSETMIC:
1956                 cmd_gain[gain_idx++] = INPUT_EAR_MIC | OUTPUT_AP | GAIN_MODE;
1957                 cmd_path[path_idx++] = INPUT_EAR_MIC | OUTPUT_AP;
1958                 break;
1959
1960         case AVSYS_AUDIO_PATH_EX_BTMIC:
1961                 cmd_gain[gain_idx++] = INPUT_BT_MIC | OUTPUT_AP | GAIN_MODE;
1962                 cmd_path[path_idx++] = INPUT_BT_MIC | OUTPUT_AP;
1963
1964                 break;
1965         case AVSYS_AUDIO_PATH_EX_HANDSFREE:
1966         default:
1967                 break;
1968         }
1969
1970         RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_single_set(ASCN_STR_RESET));
1971         RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_gain, 2, ASCN_RESET_NONE));
1972         RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_path, 2, ASCN_RESET_NONE));
1973
1974         return AVSYS_STATE_SUCCESS;
1975 }
1976
1977
1978 static int __avsys_audio_path_set_ascn_fmradio(avsys_audio_path_ex_info_t *control)
1979 {
1980         int cmd_gain[2] = { 0, 0 };
1981         int cmd_path[3] = { 0, 0, 0 };
1982         int skip_clear = 0;
1983         int skip_clear_record = 0;
1984         int gain_idx = 0;
1985         int path_idx = 0;
1986
1987         avsys_warning(AVAUDIO, "req gain playback [%x], control gain playback [%x]\n",
1988                         control->reqgain.playback, control->gain.playback);
1989         avsys_warning(AVAUDIO, "req gain capture [%x], control gain capture [%x]\n",
1990                                 control->reqgain.capture, control->gain.capture);
1991
1992         switch (control->path.playback) {
1993         case AVSYS_AUDIO_PATH_EX_NONE:
1994                 avsys_warning(AVAUDIO, "[SZ] playback AVSYS_AUDIO_PATH_EX_NONE\n");
1995                 break;
1996
1997         case AVSYS_AUDIO_PATH_EX_SPK:
1998                 if (control->reqgain.playback == control->gain.playback) {
1999                         avsys_warning(AVAUDIO, "req gain playback == control gain playback\n");
2000                         cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_MODE;
2001                         cmd_path[path_idx++] = INPUT_AP | OUTPUT_STEREO_SPK;
2002                 } else {
2003                         avsys_warning(AVAUDIO, "req gain playback != control gain playback\n");
2004                         /* append ap playback sound path */
2005                         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
2006                         cmd_path[path_idx++] = INPUT_AP | OUTPUT_STEREO_SPK;
2007                         skip_clear = 1;
2008                 }
2009                 break;
2010
2011         case AVSYS_AUDIO_PATH_EX_HEADSET:
2012                 if (control->reqgain.playback == control->gain.playback) {
2013                         avsys_warning(AVAUDIO, "req gain playback  == control gain playback\n");
2014                         cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_HEADSET | GAIN_MODE;
2015                         cmd_path[path_idx++] = INPUT_AP | OUTPUT_HEADSET;
2016                 } else {
2017                         //append ap playback
2018                         avsys_warning(AVAUDIO, "req gain playback != control gain playback\n");
2019                         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
2020                         cmd_path[path_idx++] = INPUT_AP | OUTPUT_HEADSET;
2021                         skip_clear = 1;
2022                 }
2023                 break;
2024
2025         case AVSYS_AUDIO_PATH_EX_A2DP:
2026                 if (control->reqgain.playback == control->gain.playback) {
2027                         avsys_warning(AVAUDIO, "req gain playback == control gain playback\n");
2028                         //control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_MANUAL;
2029                 } else {
2030                         avsys_warning(AVAUDIO, "req gain playback != control gain playback\n");
2031                         control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET;
2032                         skip_clear = 1;
2033                 }
2034                 break;
2035
2036         default:
2037                 break;
2038         }
2039
2040         switch (control->path.capture) {
2041         case AVSYS_AUDIO_PATH_EX_FMINPUT:
2042                 if (control->reqgain.capture == control->gain.capture) {
2043                         avsys_warning(AVAUDIO, "req gain capture == control gain capture\n");
2044                         cmd_path[path_idx++] = INPUT_FMRADIO | OUTPUT_AP | GAIN_MODE;
2045                         cmd_path[path_idx++] = INPUT_FMRADIO | OUTPUT_AP;
2046                         if (control->reqgain.capture == control->pregain.capture) {
2047                                 avsys_warning(AVAUDIO, "req gain capture == control pregain capture\n");
2048                                 skip_clear_record = 1;
2049                         }
2050                 }
2051                 break;
2052         default:
2053                 break;
2054         }
2055
2056         if (skip_clear_record) {
2057                 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_single_set(ASCN_STR_RESET_PLAYBACK))
2058         } else if (!skip_clear) {
2059                 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_single_set(ASCN_STR_RESET))
2060         }
2061         RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_gain, gain_idx, ASCN_RESET_NONE))
2062         RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_path, path_idx, ASCN_RESET_NONE))
2063
2064         return AVSYS_STATE_SUCCESS;
2065 }
2066
2067 static int __avsys_audio_path_set_ascn_ap_capture(avsys_audio_path_ex_info_t *control)
2068 {
2069         int cmd_gain[2] = { 0, 0 };
2070         int cmd_path[3] = { 0, 0, 0 };
2071
2072         avsys_info(AVAUDIO, "<< path.capture = %d, option = %x, gain.capture = %d, inserted = %d\n",
2073                                 control->path.capture, control->option.capture, control->gain.capture, control->inserted);
2074         switch(control->path.capture) {
2075         case AVSYS_AUDIO_PATH_EX_MIC:
2076                 control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_AUTO_WITHOUT_MUTE;
2077                 if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_USE_SUBMIC) {
2078                         cmd_gain[0] = INPUT_SUB_MIC | OUTPUT_AP | GAIN_MODE;
2079                         cmd_path[0] = INPUT_SUB_MIC | OUTPUT_AP;
2080                 } else if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_USE_STEREOMIC) {
2081                         cmd_gain[0] = INPUT_STEREO_MIC | OUTPUT_AP | GAIN_MODE;
2082                         cmd_path[0] = INPUT_STEREO_MIC | OUTPUT_AP;
2083                 } else {
2084                         cmd_gain[0] = INPUT_MAIN_MIC | OUTPUT_AP | GAIN_MODE;
2085                         cmd_path[0] = INPUT_MAIN_MIC | OUTPUT_AP;
2086                 }
2087                 break;
2088
2089         case AVSYS_AUDIO_PATH_EX_HEADSETMIC:
2090                 cmd_gain[0] = INPUT_EAR_MIC | OUTPUT_AP | GAIN_MODE;
2091                 cmd_path[0] = INPUT_EAR_MIC | OUTPUT_AP;
2092                 break;
2093
2094         default:
2095                 break;
2096         }
2097
2098         RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_gain, 2, ASCN_RESET_CAPTURE))
2099         RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_path, 2, ASCN_RESET_NONE))
2100
2101         avsys_info (AVAUDIO, ">> leave");
2102
2103         return AVSYS_STATE_SUCCESS;
2104 }
2105
2106
2107 static int __avsys_audio_path_set_hw_controls(avsys_audio_path_ex_info_t *control)
2108 {
2109         avsys_audio_handle_info_t *handle_control = NULL;
2110         avsys_audio_handle_info_t **temp = NULL;
2111         int ret = AVSYS_STATE_SUCCESS;
2112         avsys_info(AVAUDIO, "global mute %d\n", control->mute);
2113         avsys_info(AVAUDIO, "path_fixed mute %d\n", control->path_fixed);
2114
2115         /* update logical volume table - about output device - information for open handles */
2116         avsys_info(AVAUDIO, "Control handle informations\n");
2117         {
2118                 avsys_audio_handle_t *ptr = NULL;
2119                 int handle = -1;
2120                 int out_device = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
2121
2122                 temp = &handle_control;
2123                 if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE, (void**)temp))) {
2124                         avsys_error(AVAUDIO, "avsys_audio_get_shm() failed in %s\n",__func__);
2125                         return AVSYS_STATE_ERR_INTERNAL;
2126                 }
2127
2128                 if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
2129                         avsys_error(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n",__func__);
2130                         return AVSYS_STATE_ERR_INTERNAL;
2131                 }
2132
2133                 while (++handle < AVSYS_AUDIO_HANDLE_MAX) {
2134                         long long int flag = 0x01;
2135                         flag <<= handle;
2136
2137                         if (handle_control->allocated & flag)
2138                         {
2139                                 ptr = &(handle_control->handles[handle]);
2140
2141                                 if (ptr->mode != AVSYS_AUDIO_MODE_OUTPUT && ptr->mode != AVSYS_AUDIO_MODE_OUTPUT_CLOCK
2142                                                         && ptr->mode != AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY && ptr->mode != AVSYS_AUDIO_MODE_OUTPUT_AP_CALL) {
2143                                         continue;
2144                                 }
2145                                 ptr->path_off = 0;
2146                                 out_device = control->lvol_dev_type;
2147                                 avsys_audio_logical_volume_update_table(out_device, &ptr->gain_setting);
2148                                 avsys_audio_logical_volume_convert(&ptr->setting_vol, &ptr->working_vol, &ptr->gain_setting);
2149                         }
2150                 }
2151
2152                 if(AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
2153                         avsys_error(AVAUDIO,"avsys_audio_unlock_sync() failed in %s\n",__func__);
2154                         return AVSYS_STATE_ERR_INTERNAL;
2155                 }
2156         }
2157         return AVSYS_STATE_SUCCESS;
2158 }
2159
2160 #endif  /* MURPHY_SUPPORT */
2161
2162 static bool __avsys_audio_path_check_cp_audio(int gain)
2163 {
2164         /*If video call uses CP audio, add AVSYS_AUDIO_GAIN_EX_VIDEOCALL to following code. */
2165         if (gain == AVSYS_AUDIO_GAIN_EX_VOICECALL)
2166                 return true;
2167         else
2168                 return false;
2169 }
2170
2171 int avsys_audio_path_set_volume(int handle)
2172 {
2173         avsys_audio_path_ex_info_t *control = NULL;
2174         avsys_audio_path_ex_info_t **temp = NULL;
2175         avsys_audio_handle_t *ptr = NULL;
2176         int err;
2177         int vol_conf, vol_conf_type;
2178         int out_device = AVSYS_AUDIO_DEVICE_TYPE_SPK;
2179
2180         err = avsys_audio_handle_get_ptr(handle, &ptr, HANDLE_PTR_MODE_NORMAL);
2181         if (AVSYS_FAIL(err)) {
2182                 avsys_error(AVAUDIO, "Handle is not allocated\n");
2183                 avsys_audio_handle_release_ptr(handle, HANDLE_PTR_MODE_NORMAL);
2184                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
2185         }
2186
2187         temp = &control;
2188         avsys_assert(AVSYS_SUCCESS(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp)));
2189         avsys_assert(control != NULL);
2190         avsys_assert(AVSYS_SUCCESS(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
2191
2192         if (__avsys_audio_path_check_cp_audio(control->gain.playback))
2193                 ptr->during_cp_audio = 1;
2194         else
2195                 ptr->during_cp_audio = 0;
2196
2197         vol_conf = ptr->gain_setting.volume_config;
2198         vol_conf_type = AVSYS_AUDIO_VOLUME_CONFIG_TYPE(vol_conf);
2199         out_device = control->lvol_dev_type;
2200         avsys_assert(AVSYS_SUCCESS(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
2201         avsys_warning(AVAUDIO, "set path volume  : gain(%d), out_dev(%d)\n", vol_conf_type, out_device);
2202         err = avsys_audio_logical_volume_set_table(vol_conf, out_device, &ptr->gain_setting);
2203         avsys_audio_handle_release_ptr(handle, HANDLE_PTR_MODE_NORMAL);
2204         return err;
2205 }
2206
2207 int avsys_audio_path_set_route_policy(avsys_audio_route_policy_t route)
2208 {
2209         /* Deprecated */
2210         return 0;
2211 }
2212
2213 int avsys_audio_path_get_route_policy(avsys_audio_route_policy_t *route)
2214 {
2215         /* Deprecated */
2216         return 0;
2217 }
2218
2219 int avsys_audio_path_check_cp_audio(bool *cpaudio, bool *btpath)
2220 {
2221         avsys_audio_path_ex_info_t *control = NULL;
2222         avsys_audio_path_ex_info_t **temp = NULL;
2223
2224         if (!cpaudio || !btpath)
2225                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
2226
2227         temp = &control;
2228         avsys_assert(AVSYS_SUCCESS(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp)));
2229         avsys_assert(control != NULL);
2230         avsys_assert(AVSYS_SUCCESS(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
2231
2232         if (__avsys_audio_path_check_cp_audio(control->gain.playback))
2233                 *cpaudio = true;
2234         else
2235                 *cpaudio = false;
2236
2237         if (control->path.playback == AVSYS_AUDIO_PATH_EX_BTHEADSET)
2238                 *btpath = true;
2239         else
2240                 *btpath = false;
2241
2242         avsys_assert(AVSYS_SUCCESS(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
2243         return AVSYS_STATE_SUCCESS;
2244 }
2245
2246 int avsys_audio_path_set_single_ascn(char *str)
2247 {
2248         if (!str)
2249                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
2250
2251 #ifndef MURPHY_SUPPORT
2252         RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_single_set(str))
2253 #endif
2254
2255         return AVSYS_STATE_SUCCESS;
2256 }