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