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