4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
24 #include <sys/types.h>
30 #include <linux/input.h>
31 #include <iniparser.h>
33 #include "avsys-audio-shm.h"
34 #include "avsys-audio-sync.h"
35 #include "avsys-audio-path.h"
36 #include "avsys-audio-shm.h"
37 #include "avsys-debug.h"
38 #include "avsys-common.h"
39 #include "avsys-audio-handle.h"
40 #include "avsys-audio-logical-volume.h"
41 #include "avsys-audio-alsa.h"
42 #include "avsys-audio-ascenario.h"
44 #define EXPORT_API __attribute__((__visibility__("default")))
46 #define RET_IO_CTL_ERR_IF_FAIL(SECTION) { if(AVSYS_FAIL(SECTION)) { \
47 avsys_error_r(AVAUDIO,"%s %d\n",__func__,__LINE__); \
48 return AVSYS_STATE_ERR_IO_CONTROL; \
51 static int g_playback_path_select_data[AVSYS_AUDIO_PLAYBACK_GAIN_MAX][AVSYS_AUDIO_PATH_EX_OUTMAX] = {
52 { /* AVSYS_AUDIO_PLAYBACK_GAIN_AP */
53 /* NONE SPK RECV HEADSET BTHEADSET A2DP HANDSFREE HDMI DOCK USBAUDIO */
54 0, 1, 0, 1, 0, 0, 0, 1, 1, 0
56 { /* AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO */
57 /* NONE SPK RECV HEADSET BTHEADSET A2DP HANDSFREE HDMI */
58 1, 1, 0, 1, 0, 1, 0, 0, 0, 0
60 { /* AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL */
61 /* NONE SPK RECV HEADSET BTHEADSET A2DP HANDSFREE HDMI */
62 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
64 { /* AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL */
65 /* NONE SPK RECV HEADSET BTHEADSET A2DP HANDSFREE HDMI */
66 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
68 { /* AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT */
69 /* NONE SPK RECV HEADSET BTHEADSET A2DP HANDSFREE HDMI */
70 0, 1, 1, 1, 1, 0, 0, 0, 0, 0
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 */
79 { /* AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO */
80 /* NONE MIC HMIC BMIC FMIN HFREE */
83 { /* AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL */
84 /* NONE MIC HMIC BMIC FMIN HFREE */
87 { /* AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL */
88 /* NONE MIC HMIC BMIC FMIN HFREE */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
159 static int __avsys_audio_path_set_ascn_ap_playback(avsys_audio_path_ex_info_t *control);
160 static int __avsys_audio_path_set_ascn_voicecall(avsys_audio_path_ex_info_t *control);
161 static int __avsys_audio_path_set_ascn_videocall(avsys_audio_path_ex_info_t *control);
162 static int __avsys_audio_path_set_ascn_fmradio(avsys_audio_path_ex_info_t *control);
163 static int __avsys_audio_path_set_ascn_ap_capture(avsys_audio_path_ex_info_t *control);
164 static int __avsys_audio_path_set_hw_controls(avsys_audio_path_ex_info_t *control);
165 static int __avsys_audio_path_get_earjack_type(void);
167 #define AUDIOSYSTEM_CONF "/opt/etc/audio_system.conf"
168 #define CONF_ITEM_COUNT 2
169 #define INPUT_DEV_MAX 20
171 #define EARJACK_EVENT_PATH "/dev/input/event"
173 #define AVSYS_AUDIO_INI_DEFAULT_PATH "/usr/etc/mmfw_avsystem.ini"
174 #define AVSYS_AUDIO_DEFAULT_CONTROL_AIF_BEFORE_PATH_SET 0
175 #define AVSYS_AUDIO_DEFAULT_GAIN_DEBUG_MODE 0
177 #define CP_STATUS "/sys/class/audio/caps/cp_caps"
178 #define CP_WB_STRING "wb"
180 static char *conf_string[] = {
186 char headset_detection;
187 char headset_node_number;
188 bool control_aif_before_path_set;
189 bool gain_debug_mode;
192 static int __load_conf(avsys_audio_conf *data)
194 dictionary *dict = NULL;
196 #if defined(_MMFW_I386_ALL_SIMULATOR)
198 return AVSYS_STATE_ERR_NULL_POINTER;
200 data->headset_detection = 1;
201 data->headset_node_number = 4;
205 char buffer[64] = { 0, };
206 char conf_data[CONF_ITEM_COUNT] = { 1, 0 };
209 return AVSYS_STATE_ERR_NULL_POINTER;
211 fp = fopen(AUDIOSYSTEM_CONF, "r");
213 char filename[128] = { 0, };
214 char readBuffer[32] = { 0, };
215 char headset_find = 0;
216 int num = 0, headset_num = -1;
218 for (num = 0; num < INPUT_DEV_MAX; num++) {
220 memset(filename, '\0', sizeof(filename));
221 snprintf(filename, sizeof(filename), "/sys/class/input/input%01d/name", num);
222 if (NULL == (sfp = fopen(filename, "r")))
224 memset(readBuffer, '\0', sizeof(readBuffer));
225 if (NULL == fgets(readBuffer, sizeof(readBuffer) - 1, sfp)) {
229 if (strstr(readBuffer, "Headset")) {
235 if (headset_num != -1) {
239 if (headset_num == -1)
240 return AVSYS_STATE_ERR_INTERNAL;
242 if (NULL == (fp = fopen(AUDIOSYSTEM_CONF, "w"))) {
243 return AVSYS_STATE_ERR_INTERNAL;
246 fprintf(fp, "%s:1\n", conf_string[0]);
247 fprintf(fp, "%s:%d\n", conf_string[1], headset_num);
252 data->headset_detection = 1;
253 data->headset_node_number = headset_num;
254 return AVSYS_STATE_SUCCESS;
257 while (fgets(buffer, sizeof(buffer) - 1, fp) != NULL) {
258 if ((strlen(buffer) < 3) || (buffer[0] == '#') || (buffer[0] == '!'))
260 if (buffer[strlen(buffer) - 1] == '\n')
261 buffer[strlen(buffer) - 1] = '\0';
262 for (i = 0; i < CONF_ITEM_COUNT; i++) {
263 if (0 == strncmp(buffer, conf_string[i], strlen(conf_string[i]))) {
265 if (NULL == (ptr = strstr(buffer, ":")))
267 conf_data[i] = atoi(ptr + 1);
268 avsys_warning(AVAUDIO, "%s[%d]\n", buffer, conf_data[i]);
273 data->headset_detection = conf_data[0];
274 data->headset_node_number = conf_data[1];
277 /* first, try to load existing ini file */
278 dict = iniparser_load(AVSYS_AUDIO_INI_DEFAULT_PATH);
279 if (dict) { /* if dict is available */
280 data->control_aif_before_path_set = iniparser_getboolean(dict, "aif:control aif before path set", AVSYS_AUDIO_DEFAULT_CONTROL_AIF_BEFORE_PATH_SET);
281 data->gain_debug_mode = iniparser_getboolean(dict, "debug:gain debug mode", AVSYS_AUDIO_DEFAULT_GAIN_DEBUG_MODE);
283 /* free dict as we got our own structure */
284 iniparser_freedict (dict);
285 } else { /* if no file exists. create one with set of default values */
286 data->control_aif_before_path_set = AVSYS_AUDIO_DEFAULT_CONTROL_AIF_BEFORE_PATH_SET;
287 data->gain_debug_mode = AVSYS_AUDIO_DEFAULT_GAIN_DEBUG_MODE;
290 return AVSYS_STATE_SUCCESS;
293 static bool __is_cp_wb ()
296 char str[10] = { 0, };
299 avsys_info(AVAUDIO, "Checking [%s] for WB capability...\n", CP_STATUS);
300 fp = fopen (CP_STATUS, "r");
302 if (fgets (str, sizeof(str)-1, fp)) {
303 if (strstr (str, CP_WB_STRING)) {
309 avsys_warning (AVAUDIO, "failed to open [%s]...errno=[%d]\n", CP_STATUS, errno);
312 avsys_info(AVAUDIO, "Result [%d] : [%s] capability!!!\n", ret, (ret)? "WB" : "NB");
317 int avsys_audio_path_ex_init(void)
319 avsys_audio_path_ex_info_t *control = NULL;
320 avsys_audio_path_ex_info_t **temp = NULL;
321 gain_info_t default_gain = { AVSYS_AUDIO_PLAYBACK_GAIN_AP, AVSYS_AUDIO_CAPTURE_GAIN_AP };
322 path_info_t default_path = { AVSYS_AUDIO_PATH_EX_SPK, AVSYS_AUDIO_PATH_EX_MIC };
323 option_info_t default_option = { AVSYS_AUDIO_PATH_OPTION_NONE, AVSYS_AUDIO_PATH_OPTION_NONE };
325 int err = AVSYS_STATE_SUCCESS;
326 avsys_audio_conf conf = { 0, };
329 avsys_assert(AVSYS_SUCCESS(avsys_audio_create_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
330 avsys_assert(AVSYS_SUCCESS(avsys_audio_create_shm(AVSYS_AUDIO_SHM_IDEN_PATH)));
332 avsys_assert(AVSYS_SUCCESS(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp)));
334 return AVSYS_STATE_ERR_NULL_POINTER;
337 control->pregain = default_gain;
338 control->gain = default_gain;
339 control->reqgain = default_gain;
340 control->path = default_path;
341 control->backup_gain = default_gain;
342 control->backup_path = default_path;
343 control->option = default_option;
345 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
346 control->inserted = AVSYS_AUDIO_INSERTED_NONE;
348 if (AVSYS_FAIL(__load_conf(&conf)))
349 avsys_error_r(AVAUDIO, "Can not load audio system configuration file\n");
351 if (conf.headset_detection) {
352 control->inserted = __avsys_audio_path_get_earjack_type();
353 if (control->inserted == AVSYS_AUDIO_INSERTED_NONE)
354 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
356 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
358 avsys_warning(AVAUDIO, "Ignore headset detection. Use speaker device\n");
359 control->inserted = AVSYS_AUDIO_INSERTED_NONE;
360 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
363 avsys_error_r(AVAUDIO, "Earjack init value is %d\n", control->inserted);
365 control->control_aif_before_path_set = conf.control_aif_before_path_set;
366 control->wb_enabled = __is_cp_wb();
367 control->gain_debug_mode = conf.gain_debug_mode;
369 control->mute = AVSYS_AUDIO_UNMUTE;
370 control->path_fixed = PATH_FIXED_NONE;
374 control->pathlock_pid[index] = -1;
376 } while (index < AVSYS_AUDIO_LOCK_SLOT_MAX);
380 control->path_fixed_pid[index] = -1;
382 } while (index < PATH_FIXED_TYPE_MAX);
384 /* call path control */
385 err = __avsys_audio_path_set_ascn_ap_playback(control);
386 if (AVSYS_SUCCESS(err))
387 err = __avsys_audio_path_set_hw_controls(control);
389 if (AVSYS_SUCCESS(err))
390 err = __avsys_audio_path_set_ascn_ap_capture(control);
396 int avsys_audio_path_ex_fini(void)
398 if (AVSYS_FAIL(avsys_audio_remove_shm(AVSYS_AUDIO_SHM_IDEN_PATH))) {
399 avsys_error_r(AVAUDIO, "avsys_audio_remove_shm() failed in %s\n", __func__);
400 return AVSYS_STATE_ERR_INTERNAL;
402 if (AVSYS_FAIL(avsys_audio_remove_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
403 avsys_error_r(AVAUDIO, "avsys_audio_remove_sync() failed in %s\n", __func__);
404 return AVSYS_STATE_ERR_INTERNAL;
406 return AVSYS_STATE_SUCCESS;
410 int avsys_audio_path_ex_reset(int forced)
412 avsys_audio_path_ex_info_t *control = NULL;
413 avsys_audio_path_ex_info_t **temp = NULL;
414 gain_info_t default_gain = { AVSYS_AUDIO_PLAYBACK_GAIN_AP, AVSYS_AUDIO_CAPTURE_GAIN_AP };
415 path_info_t default_path = { AVSYS_AUDIO_PATH_EX_SPK, AVSYS_AUDIO_PATH_EX_MIC };
416 option_info_t default_option = { AVSYS_AUDIO_PATH_OPTION_NONE, AVSYS_AUDIO_PATH_OPTION_NONE };
418 int err = AVSYS_STATE_SUCCESS;
419 int backup_debug = 0;
420 avsys_audio_conf conf = { 0, };
423 if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
424 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
425 return AVSYS_STATE_ERR_INTERNAL;
428 return AVSYS_STATE_ERR_NULL_POINTER;
430 if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
431 avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
432 return AVSYS_STATE_ERR_INTERNAL;
436 control->pregain = default_gain;
437 control->gain = default_gain;
438 control->reqgain = default_gain;
439 control->path = default_path;
440 control->backup_gain = default_gain;
441 control->backup_path = default_path;
442 control->option = default_option;
444 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
445 control->inserted = AVSYS_AUDIO_INSERTED_NONE;
447 if (AVSYS_FAIL(__load_conf(&conf)))
448 avsys_error_r(AVAUDIO, "Can not load audio system configuration file\n");
450 if (conf.headset_detection) {
451 control->inserted = __avsys_audio_path_get_earjack_type();
452 if (control->inserted == AVSYS_AUDIO_INSERTED_NONE)
453 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
455 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
456 control->path.playback = AVSYS_AUDIO_PATH_EX_HEADSET;
458 if (control->inserted == AVSYS_AUDIO_INSERTED_4)
459 control->path.capture = AVSYS_AUDIO_PATH_EX_HEADSETMIC;
462 avsys_warning(AVAUDIO, "Ignore headset detection. Use speaker device\n");
463 control->inserted = AVSYS_AUDIO_INSERTED_NONE;
464 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
467 avsys_error_r(AVAUDIO, "Earjack init value is %d\n", control->inserted);
469 control->control_aif_before_path_set = conf.control_aif_before_path_set;
470 control->gain_debug_mode = conf.gain_debug_mode;
472 control->mute = AVSYS_AUDIO_UNMUTE;
473 control->path_fixed = PATH_FIXED_NONE;
477 control->pathlock_pid[index] = -1;
479 } while (index < AVSYS_AUDIO_LOCK_SLOT_MAX);
483 control->path_fixed_pid[index] = -1;
485 } while (index < PATH_FIXED_TYPE_MAX);
488 backup_debug = control->gain_debug_mode;
489 control->gain_debug_mode = 1;
491 /* call path control */
492 err = __avsys_audio_path_set_ascn_ap_playback(control);
493 if (AVSYS_SUCCESS(err))
494 err = __avsys_audio_path_set_hw_controls(control);
496 if (AVSYS_SUCCESS(err))
497 err = __avsys_audio_path_set_ascn_ap_capture(control);
500 control->gain_debug_mode = backup_debug;
503 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
504 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
505 return AVSYS_STATE_ERR_INTERNAL;
512 int avsys_audio_path_ex_dump(void)
514 avsys_audio_path_ex_info_t *control = NULL;
515 avsys_audio_path_ex_info_t **temp = NULL;
516 const static char *str_earType[] = { "None", "EarOnly", "EarMic", "TVout" };
517 const static char *str_yn[] = { "NO", "YES" };
518 const static char *str_ear[] = { "MANUAL", "AUTO_MUTE", "AUTO_NOMUTE" };
519 const static char *str_out[AVSYS_AUDIO_PATH_EX_OUTMAX] = {
520 "NONE", "SPK", "RECV", "HEADSET", "BTHEADSET", "A2DP", "HANSFREE", "HDMI", "DOCK", "USBAUDIO"
522 const static char *str_in[AVSYS_AUDIO_PATH_EX_INMAX] = {
523 "NONE", "MIC", "HEADMIC", "BTMIC", "FMINPUT", "HANSFREEMIC"
525 const static char *str_route[AVSYS_AUDIO_ROUTE_POLICY_MAX] = {
526 "DEFAULT", "IGN_A2DP", "HANDSET"
529 const static char *str_gain[AVSYS_AUDIO_GAIN_EX_MAX] = {
530 "KEYTONE", "RINGTONE", "ALARMTONE", "CALLTONE", "AUDIOPLAYER", "VIDEOPLAYER",
531 "VOICECALL", "VIDEOCALL", "FMRADIO", "VOICEREC", "CAMCORDER", "CAMERA", "GAME"};
533 const static char *str_playback_gain[AVSYS_AUDIO_PLAYBACK_GAIN_MAX] = {
534 "AP", "FMRADIO", "VOICECALL", "VIDEOCALL", "CALLALERT",
536 const static char *str_capture_gain[AVSYS_AUDIO_CAPTURE_GAIN_MAX] = {
537 "AP", "FMRADIO", "VOICECALL", "VIDEOCALL",
544 if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
545 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
546 return AVSYS_STATE_ERR_INTERNAL;
549 return AVSYS_STATE_ERR_NULL_POINTER;
551 fprintf(stdout, "======================================================================\n");
552 fprintf(stdout, " Avsystem Audio Path Control Information \n");
553 fprintf(stdout, "======================================================================\n");
554 #if defined(_MMFW_I386_ALL_SIMULATOR)
555 fprintf(stdout, " In simulator, follow informations don`t have means.\n");
558 fprintf(stdout, " GAIN : P (%-s / %-s) - R (%-s / %-s) - C (%-s / %-s)\n",
559 str_playback_gain[control->pregain.playback], str_capture_gain[control->pregain.capture],
560 str_playback_gain[control->reqgain.playback], str_capture_gain[control->reqgain.capture],
561 str_playback_gain[control->gain.playback], str_capture_gain[control->gain.capture]);
562 fprintf(stdout, " Current Out / In : %-s / %-s\n", str_out[control->path.playback], str_in[control->path.capture] );
563 fprintf(stdout, " Gain debug mode : 0x%-x\n", control->gain_debug_mode);
564 fprintf(stdout, " Auto EarJack Control : %-s\n", str_ear[control->ear_auto]);
565 fprintf(stdout, " Physical Earjack? [type] : %-s [%-s]\n", str_yn[control->inserted != AVSYS_AUDIO_INSERTED_NONE], str_earType[control->inserted]);
566 fprintf(stdout, " Path Fixed State : 0x%-x\n", control->path_fixed);
567 fprintf(stdout, " Mute status : %d\n", control->mute);
568 if (control->path_fixed_pid[PATH_FIXED_TYPE_FMRADIO] != -1)
569 fprintf(stdout, " FM Radio path pid : %d\n", control->path_fixed_pid[PATH_FIXED_TYPE_FMRADIO]);
570 if (control->path_fixed_pid[PATH_FIXED_TYPE_CALL] != -1)
571 fprintf(stdout, " Call path pid : %d\n", control->path_fixed_pid[PATH_FIXED_TYPE_CALL]);
575 if (control->pathlock_pid[index] != -1)
576 fprintf(stdout, " Path sync lock required PIDs : %d\n", control->pathlock_pid[index]);
578 } while (index < AVSYS_AUDIO_LOCK_SLOT_MAX);
579 fprintf(stdout, " Option Dual out : %-s\n", str_yn[(control->option.playback & AVSYS_AUDIO_PATH_OPTION_DUAL_OUT) ? 1 : 0]);
580 fprintf(stdout, " Option Forced : %-s\n", str_yn[(control->option.playback & AVSYS_AUDIO_PATH_OPTION_FORCED) ? 1 : 0]);
582 return AVSYS_STATE_SUCCESS;
585 static int __avsys_audio_path_get_earjack_type (void)
588 char readval = AVSYS_AUDIO_INSERTED_NONE;
589 fd = open("/sys/devices/platform/jack/earjack_online", O_RDONLY);
592 avsys_error_r(AVAUDIO, "Can not get initial jack type\n");
593 return AVSYS_AUDIO_INSERTED_NONE;
595 read(fd, &readval, sizeof(readval));
598 readval = AVSYS_AUDIO_INSERTED_NONE;
601 readval = AVSYS_AUDIO_INSERTED_3;
604 readval = AVSYS_AUDIO_INSERTED_4;
607 readval = AVSYS_AUDIO_INSERTED_AV;
610 if (1 == read(fd, &readval, sizeof(readval))) {
611 if (readval == '0') {
612 readval = AVSYS_AUDIO_INSERTED_AV;
614 avsys_error(AVAUDIO, "Unknown jack type value...2%d\n", readval);
615 readval = AVSYS_AUDIO_INSERTED_NONE;
618 avsys_error(AVAUDIO, "jack type read error...\n");
619 readval = AVSYS_AUDIO_INSERTED_NONE;
623 avsys_error(AVAUDIO, "jack type unknown value...%c\n", readval);
624 readval = AVSYS_AUDIO_INSERTED_NONE;
632 int avsys_audio_path_earjack_init(int *init_type, int *outfd)
634 #if !defined(_MMFW_I386_ALL_SIMULATOR)
635 char eventnode_filename[32] = { 0, };
637 avsys_audio_conf conf = { 0, };
639 if (outfd == NULL || init_type == NULL) {
640 avsys_error(AVAUDIO, "input parameter is null\n");
641 return AVSYS_STATE_ERR_NULL_POINTER;
644 if (AVSYS_FAIL(__load_conf(&conf))) {
645 avsys_error_r(AVAUDIO, "Can not load audio system configuration file\n");
648 if (!conf.headset_detection) {
649 avsys_error(AVAUDIO, "Earjack control daemon will be closed by user option...\n");
650 return AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT;
653 snprintf(eventnode_filename, sizeof(eventnode_filename), "%s%01d", EARJACK_EVENT_PATH, conf.headset_node_number);
655 fd = open(eventnode_filename, O_RDONLY);
657 avsys_error_r(AVAUDIO, "Device file open error\n");
658 return AVSYS_STATE_ERR_INTERNAL;
660 avsys_audio_path_ex_info_t *control = NULL;
661 avsys_audio_path_ex_info_t **temp = NULL;
662 void *vol_data = NULL;
663 void *handle_data = NULL;
666 if(AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_LVOLUME, &vol_data))) {
667 avsys_error(AVAUDIO,"attach logical volume shared memory failed\n");
669 return AVSYS_STATE_ERR_ALLOCATION;
671 if(AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE, &handle_data))) {
672 avsys_error(AVAUDIO,"attach handle shared memory failed\n");
674 return AVSYS_STATE_ERR_ALLOCATION;
676 if(AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void**)temp))) {
677 avsys_error_r(AVAUDIO,"avsys_audio_get_shm() failed in %s\n", __func__);
679 return AVSYS_STATE_ERR_INTERNAL;
682 *init_type = control->inserted;
684 return AVSYS_STATE_SUCCESS;
687 return AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT;
691 int avsys_audio_path_earjack_wait(int fd, int *current_type, int *new_type, int *is_auto_mute)
693 #if !defined(_MMFW_I386_ALL_SIMULATOR)
697 struct input_event jevent;
698 int res = AVSYS_STATE_SUCCESS;
701 if (new_type == NULL || is_auto_mute == NULL)
702 return AVSYS_STATE_ERR_NULL_POINTER;
707 cur_type = *current_type;
709 select_ret = select(fd + 1, &set, NULL, NULL, NULL);
710 avsys_info(AVAUDIO, "SELECT returns......\n");
712 if (select_ret != 1) {
713 if (select_ret == 0) {
714 avsys_error_r(AVAUDIO, "Earjack timeout in autocontrol\n");
715 } else if (select_ret == -1) {
716 avsys_error_r(AVAUDIO, "Earjack detect unknown error: %d\n", errno);
718 return AVSYS_STATE_WAR_INVALID_VALUE;
720 #ifdef EARJACK_LOCK /* currently this is disabled to avoid semapore value increase */
721 if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
722 avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
723 return AVSYS_STATE_ERR_INTERNAL;
726 if (read(fd, &jevent, sizeof(jevent)) < 0) {
727 avsys_error(AVAUDIO, "read fd failed with 0x%x\n", errno);
728 return AVSYS_STATE_WAR_INVALID_MODE;
730 avsys_info(AVAUDIO, "*** JEVENT : code=%d, value=%d\n", jevent.code, jevent.value);
731 if (jevent.type != TYPE_EVENT_SWITCH) {
732 avsys_info(AVAUDIO, "Not a switch event\n");
733 return AVSYS_STATE_WAR_INVALID_MODE;
736 switch (jevent.code) {
737 case CODE_HEADPHONE_INSERT:
738 case CODE_LINEOUT_INSERT:
739 case CODE_JACK_PHYSICAL_INSERT:
740 if (jevent.value == 1) {
741 readtemp = __avsys_audio_path_get_earjack_type();
747 readtemp = cur_type; /* same value */
751 *new_type = readtemp;
753 avsys_audio_path_ex_info_t *control = NULL;
754 avsys_audio_path_ex_info_t **temp = NULL;
757 if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
758 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
759 return AVSYS_STATE_ERR_INTERNAL;
762 avsys_info(AVAUDIO, "control->ear_auto = %d\n", control->ear_auto);
763 if (control->ear_auto == AVSYS_AUDIO_EAR_SWITCH_AUTO_WITH_MUTE) {
764 *current_type = control->inserted;
766 res = AVSYS_STATE_SUCCESS;
767 } else if (control->ear_auto == AVSYS_AUDIO_EAR_SWITCH_AUTO_WITHOUT_MUTE) {
768 *current_type = control->inserted;
770 res = AVSYS_STATE_SUCCESS;
776 return AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT;
780 int avsys_audio_path_earjack_process(int new_type)
782 #if !defined(_MMFW_I386_ALL_SIMULATOR)
783 avsys_audio_path_ex_info_t *control = NULL;
784 avsys_audio_path_ex_info_t **temp = NULL;
785 int err = AVSYS_STATE_SUCCESS;
788 avsys_info(AVAUDIO, "new_type = %d\n", new_type);
789 if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
790 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
791 return AVSYS_STATE_ERR_INTERNAL;
794 control->inserted = new_type;
798 return AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT;
802 int avsys_audio_path_earjack_deinit(int fd)
804 #if !defined(_MMFW_I386_ALL_SIMULATOR)
806 return AVSYS_STATE_SUCCESS;
808 return AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT;
812 int avsys_audio_path_earjack_unlock()
814 #ifdef EARJACK_LOCK /* currently this is disabled to avoid semapore value increase */
815 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
816 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
817 return AVSYS_STATE_ERR_INTERNAL;
820 return AVSYS_STATE_SUCCESS;
823 #define DO_IF_VALID(c, p) { if(c > -1) p; }
824 #define DO_IF_INVALID(c, p) { if(c == -1) p; }
825 #define CHECK_VALID(c) (c>-1 ? 1 : 0)
830 CMD_DEVICE_CLOSE, /* Not used */
834 avsys_audio_alsa_aif_handle_t *g_hAIF[AIF_DEVICE_MAX] = { NULL, NULL, NULL, NULL, NULL };
835 char *strAIF[AIF_DEVICE_MAX] = { "AIF CP Capture", "AIF CP Playback", "AIF BT Capture", "AIF BT Playback", "AIF RADIO Playback" };
837 #define SET_AIF(index) do { AIF_control[index] = CMD_DEVICE_OPEN; } while (0)
839 static int __is_cp_aif (int type)
841 return ((type == AIF_CP_PLAYBACK || type == AIF_CP_CAPTURE));
844 static int __avsys_open_aif(char AIF_control[], bool wb_enabled)
847 int err = AVSYS_STATE_SUCCESS;
851 /* Check If BT is enabled */
852 for (iAIF = 0; iAIF < AIF_DEVICE_MAX; iAIF++) {
853 if (AIF_control[iAIF] == CMD_DEVICE_OPEN && (iAIF == AIF_BT_PLAYBACK || iAIF== AIF_BT_CAPTURE)) {
859 /* Iterate control command */
860 avsys_info(AVAUDIO, "================== Close if reopen is needed (bt[%d] wb[%d]) ================== \n", bt_enabled, wb_enabled);
861 for (iAIF = 0; iAIF < AIF_DEVICE_MAX; iAIF++) {
863 if (AIF_control[iAIF] != CMD_DEVICE_OPEN)
866 avsys_info(AVAUDIO, "%d. [%s]\n", iAIF, strAIF[iAIF]);
868 /* check handle exists */
870 /* Handle is already opened.
871 * Check if WB is supported and CP handle case */
872 if (wb_enabled && __is_cp_aif(g_hAIF[iAIF]->type)) {
873 /* CP Handle is already opened with WB enabled .
874 * Determine whether re-open is needed */
875 if ((bt_enabled && g_hAIF[iAIF]->rate != AIF_NB_RATE) ||
876 (!bt_enabled && g_hAIF[iAIF]->rate == AIF_NB_RATE)) {
877 /* CP handle exists and BT enabled with not NB opened => close for reopen
878 CP handle exists and BT disabled with NB opened => close for reopen */
879 avsys_info(AVAUDIO, "=> Close device for reopen :: %s\n", strAIF[iAIF]);
880 if (AVSYS_FAIL(avsys_audio_alsa_close_AIF_device(g_hAIF[iAIF]))) {
881 avsys_error_r(AVAUDIO, "close %s device failed\n", strAIF[iAIF]);
886 /* CP handle exists and BT enabled with NB opened ||
887 CP handle exists and BT disabled with not NB opened */
888 avsys_info(AVAUDIO, "=> Skip device :: %s\n", strAIF[iAIF]);
893 /* Not CP case or WB is disabled. No need to reopen */
894 avsys_info(AVAUDIO, "=> Skip device :: %s\n", strAIF[iAIF]);
900 avsys_info(AVAUDIO, "================== Open & Set Param ================== \n");
901 /* Iterate control command */
902 for (iAIF = 0; iAIF < AIF_DEVICE_MAX; iAIF++) {
904 if (AIF_control[iAIF] != CMD_DEVICE_OPEN)
907 avsys_info(AVAUDIO, "%d. [%s]\n", iAIF, strAIF[iAIF]);
909 /* check handle exists */
911 /* Not CP case or WB is disabled. No need to reopen */
912 avsys_info(AVAUDIO, "=> Skip device Already opened!!! :: %s\n", strAIF[iAIF]);
916 /* memory allocation for handle */
917 avsys_warning(AVAUDIO, "=> [%s] handle alloc", strAIF[iAIF]);
918 g_hAIF[iAIF] = calloc(sizeof(avsys_audio_handle_t), 1);
920 avsys_error_r(AVAUDIO, "=> Can not alloc memory for [%s] device handle", strAIF[iAIF]);
921 err = AVSYS_STATE_ERR_ALLOCATION;
925 if (AVSYS_FAIL(avsys_audio_alsa_open_AIF_device(iAIF, g_hAIF[iAIF]))) {
926 avsys_error_r(AVAUDIO, "=> open [%s] device failed\n", strAIF[iAIF]);
927 err = AVSYS_STATE_ERR_INVALID_HANDLE;
929 avsys_warning(AVAUDIO, "=> open [%s] device success\n", strAIF[iAIF]);
932 if (__is_cp_aif(g_hAIF[iAIF]->type)) {
933 rate = (wb_enabled && !bt_enabled)? AIF_WB_RATE : AIF_NB_RATE;
935 rate = AIF_CONF_RATE;
938 if (AVSYS_FAIL(avsys_audio_alsa_set_AIF_params(g_hAIF[iAIF],rate))) {
939 avsys_error_r(AVAUDIO, "=> [%s] device set parameter failed\n", strAIF[iAIF]);
940 err = AVSYS_STATE_ERR_INVALID_PARAMETER;
942 avsys_warning(AVAUDIO, "=> [%s] device set parameter success\n", strAIF[iAIF]);
949 static void __avsys_close_aif ()
953 for (iAIF = 0; iAIF < AIF_DEVICE_MAX; iAIF++) {
955 avsys_info(AVAUDIO, "close device :: %s\n", strAIF[iAIF]);
956 if (AVSYS_FAIL(avsys_audio_alsa_close_AIF_device(g_hAIF[iAIF]))) {
957 avsys_error_r(AVAUDIO, "close %s device failed\n", strAIF[iAIF]);
961 avsys_warning(AVAUDIO, "%s device handle free\n", strAIF[iAIF]);
963 avsys_info(AVAUDIO, "skip closing device :: %s\n", strAIF[iAIF]);
968 static int __avsys_audio_release_path (gain_info_t local_gain, avsys_audio_path_ex_info_t *control)
970 int err = AVSYS_STATE_SUCCESS;
972 bool close_aif_later = false;
974 avsys_warning(AVAUDIO, "Release path for %d %d\n", local_gain.playback, local_gain.capture);
976 switch (local_gain.playback) {
977 case AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL:
978 case AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL:
979 if (getpid() == control->path_fixed_pid[PATH_FIXED_TYPE_CALL]) {
980 if (!control->control_aif_before_path_set) {
983 close_aif_later = true;
986 if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_CODEC_DISABLE_ON_SUSPEND))) {
987 avsys_error_r(AVAUDIO, "[%s] failed to set codec_disable_on_suspend\n", __func__);
990 if (control->path_fixed_pid[PATH_FIXED_TYPE_CALL] < 0) {
991 avsys_warning(AVAUDIO, "Sound path for call released already\n");
993 avsys_warning(AVAUDIO, "Try to close call path from other process.. original pid[%d]\n", control->path_fixed_pid[PATH_FIXED_TYPE_CALL]);
994 avsys_warning(AVAUDIO, "Just mark handle as off\n");
998 if ((control->path_fixed & PATH_FIXED_WITH_CALL) == 0) {
999 avsys_error(AVAUDIO, "Call path release without call path request\n");
1001 control->path_fixed &= ~PATH_FIXED_WITH_CALL;
1002 control->path_fixed_pid[PATH_FIXED_TYPE_CALL] = -1;
1006 case AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO:
1007 /* TODO: Reset & Codec disable on suspend script */
1008 if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_CODEC_DISABLE_ON_SUSPEND))) {
1009 avsys_error_r(AVAUDIO, "[%s] failed to set codec_disable_on_suspend\n", __func__);
1012 if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_STR_RESET_CAPTURE))) {
1013 avsys_error_r(AVAUDIO, "[%s] failed to set reset\n", __func__);
1019 avsys_warning(AVAUDIO, "unexpected path release\n");
1023 if (control->path_fixed != PATH_FIXED_NONE) {
1024 avsys_error(AVAUDIO, "Still remain another path_fixed request : 0x%08X\n", control->path_fixed);
1025 avsys_error(AVAUDIO, "This is not expected condition\n");
1027 avsys_warning(AVAUDIO, "Path Release to default condition....\n");
1028 control->gain.playback = AVSYS_AUDIO_PLAYBACK_GAIN_AP;
1029 control->gain.capture = AVSYS_AUDIO_CAPTURE_GAIN_AP;
1030 control->path.playback = AVSYS_AUDIO_PATH_EX_SPK;
1031 control->path.capture = AVSYS_AUDIO_PATH_EX_MIC;
1032 if (control->inserted != AVSYS_AUDIO_INSERTED_NONE) {
1033 control->path.playback = AVSYS_AUDIO_PATH_EX_HEADSET;
1034 if (control->inserted == AVSYS_AUDIO_INSERTED_4)
1035 control->path.capture = AVSYS_AUDIO_PATH_EX_HEADSETMIC;
1039 err = __avsys_audio_path_set_ascn_ap_playback(control);
1040 if (AVSYS_SUCCESS(err)) {
1041 err = __avsys_audio_path_set_hw_controls(control);
1042 if (AVSYS_FAIL(err)) {
1043 avsys_error(AVAUDIO, "Update logical volume failure\n");
1046 avsys_error(AVAUDIO, "Set ap playback failure\n");
1050 err = __avsys_audio_path_set_ascn_ap_capture(control);
1051 if (AVSYS_FAIL(err)) {
1052 avsys_error(AVAUDIO, "Set ap capture failure\n");
1056 if (close_aif_later == true) {
1057 __avsys_close_aif();
1063 int avsys_audio_path_earjack_get_type()
1065 avsys_audio_path_ex_info_t *control = NULL;
1066 avsys_audio_path_ex_info_t **temp = NULL;
1067 int err = AVSYS_STATE_SUCCESS;
1071 if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
1072 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
1073 return AVSYS_STATE_ERR_INTERNAL;
1075 if (control == NULL)
1076 return AVSYS_STATE_ERR_NULL_POINTER;
1078 if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1079 avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
1080 return AVSYS_STATE_ERR_INTERNAL;
1083 ret = control->inserted;
1085 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1086 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
1087 return AVSYS_STATE_ERR_INTERNAL;
1093 int avsys_audio_path_ex_set_path(int gain, int out, int in, int option)
1095 avsys_audio_path_ex_info_t *control = NULL;
1096 avsys_audio_path_ex_info_t **temp = NULL;
1097 gain_info_t local_gain = { -1, -1 };
1098 gain_info_t req_gain = { -1, -1 };
1100 int err = AVSYS_STATE_SUCCESS;
1101 char req_release_path = 0;
1102 char AIF_control[AIF_DEVICE_MAX] = { CMD_DEVICE_NONE, CMD_DEVICE_NONE, CMD_DEVICE_NONE, CMD_DEVICE_NONE, CMD_DEVICE_NONE };
1105 avsys_warning(AVAUDIO, "=================== [Input Param] gain %d, out %d, in %d, opt 0x%x ====================\n", gain, out, in, option);
1107 /* Determine REQUESTs */
1109 case AVSYS_AUDIO_GAIN_EX_KEYTONE:
1110 case AVSYS_AUDIO_GAIN_EX_ALARMTONE:
1111 case AVSYS_AUDIO_GAIN_EX_AUDIOPLAYER:
1112 case AVSYS_AUDIO_GAIN_EX_VIDEOPLAYER:
1113 case AVSYS_AUDIO_GAIN_EX_CAMERA:
1114 case AVSYS_AUDIO_GAIN_EX_GAME:
1115 req_gain.playback = AVSYS_AUDIO_PLAYBACK_GAIN_AP;
1116 req_gain.capture = AVSYS_AUDIO_CAPTURE_GAIN_AP;
1119 case AVSYS_AUDIO_GAIN_EX_RINGTONE:
1120 case AVSYS_AUDIO_GAIN_EX_CALLTONE:
1121 req_gain.playback = AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT;
1124 case AVSYS_AUDIO_GAIN_EX_VOICEREC:
1125 case AVSYS_AUDIO_GAIN_EX_CAMCORDER:
1126 req_gain.capture = AVSYS_AUDIO_CAPTURE_GAIN_AP;
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;
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;
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;
1151 /* Get avsys shared memeory */
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;
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;
1163 current_pid = getpid(); /* moved from below */
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)
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])
1174 avsys_info(AVAUDIO, "Gain : req(%d,%d) local(%d,%d)\n", req_gain.playback, req_gain.capture, local_gain.playback, local_gain.capture);
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;
1182 if (control->path_fixed == PATH_FIXED_NONE) {
1183 /* forced gain setting when path fixed by dead process */
1184 if (req_gain.playback != local_gain.playback) {
1185 local_gain.playback = req_gain.playback;
1187 if (req_gain.capture != local_gain.capture) {
1188 local_gain.capture = req_gain.capture;
1192 if (CHECK_VALID(local_gain.playback)) {
1193 if (g_playback_path_select_data[local_gain.playback][out] == 0) {
1194 avsys_error(AVAUDIO, "[PLAYBACK] Does not support request sound path : conv gain %d, out path %d\n", local_gain.playback, out);
1195 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1196 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
1197 return AVSYS_STATE_ERR_INTERNAL;
1199 return AVSYS_STATE_ERR_INVALID_STATE;
1202 if (CHECK_VALID(local_gain.capture)) {
1203 if (g_capture_path_select_data[local_gain.capture][in] == 0) {
1204 avsys_error(AVAUDIO, "[CAPTURE] Does not support request sound path : conv gain %d, in path %d\n", local_gain.capture, in);
1205 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1206 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
1207 return AVSYS_STATE_ERR_INTERNAL;
1209 return AVSYS_STATE_ERR_INVALID_STATE;
1212 /* overwrite local_gain with current gain if it is simplex sound path */
1213 DO_IF_INVALID(local_gain.playback, local_gain.playback = control->gain.playback)
1214 DO_IF_INVALID(local_gain.capture, local_gain.capture = control->gain.capture)
1215 control->pregain = control->gain;
1216 control->gain = local_gain;
1218 DO_IF_VALID(req_gain.playback, control->reqgain.playback = req_gain.playback)
1219 DO_IF_VALID(req_gain.capture, control->reqgain.capture = req_gain.capture)
1220 DO_IF_VALID(local_gain.playback, control->option.playback = option)
1221 DO_IF_VALID(local_gain.capture, control->option.capture = option)
1223 /* Check for Release PATH */
1224 if (req_release_path && (req_gain.playback == local_gain.playback) && (req_gain.capture == local_gain.capture)) {
1225 avsys_warning(AVAUDIO,"Release path for %d %d\n", local_gain.playback, local_gain.capture);
1227 err = __avsys_audio_release_path(local_gain, control);
1230 if (CHECK_VALID(req_gain.playback)) {
1231 if(req_gain.playback != local_gain.playback) {
1232 avsys_warning(AVAUDIO, "Sound Path is protected. use current configuration (playback_gain %d, out %d, opt 0x%x)\n",
1233 local_gain.playback, control->path.playback, control->option.playback);
1234 if (req_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_AP) {
1235 control->backup_gain.playback = control->reqgain.playback;
1236 control->backup_path.playback = out;
1239 control->path.playback = out;
1240 control->backup_gain.playback = local_gain.playback;
1241 control->backup_path.playback = out;
1243 switch (local_gain.playback) {
1244 case AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT:
1245 if (control->path.playback == AVSYS_AUDIO_PATH_EX_BTHEADSET) {
1246 SET_AIF(AIF_BT_PLAYBACK);
1247 SET_AIF(AIF_BT_CAPTURE);
1251 case AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL:
1252 case AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL:
1253 /* Set CP only for voicecall */
1254 if (local_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL) {
1255 SET_AIF(AIF_CP_PLAYBACK);
1258 /* Voicecall / Videocall Common setting */
1259 control->path_fixed_pid[PATH_FIXED_TYPE_CALL] = current_pid;
1260 if (control->path.playback == AVSYS_AUDIO_PATH_EX_BTHEADSET) {
1261 SET_AIF(AIF_BT_PLAYBACK);
1265 case AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO:
1266 control->path_fixed_pid[PATH_FIXED_TYPE_FMRADIO] = current_pid;
1267 SET_AIF(AIF_RADIO_PLAYBACK);
1273 if (CHECK_VALID(req_gain.capture)) {
1274 if (req_gain.capture != local_gain.capture) {
1275 avsys_warning(AVAUDIO, "Sound Path is protected. use current configuration (capture_gain %d, in %d, opt 0x%x)\n",
1276 local_gain.capture, control->path.capture, control->option.capture);
1277 if (req_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_AP) {
1278 control->backup_gain.capture = control->reqgain.capture;
1279 control->backup_path.capture = in;
1282 control->path.capture = in;
1283 control->backup_gain.capture = local_gain.capture;
1284 control->backup_path.capture = in;
1286 switch (local_gain.capture) {
1287 case AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL:
1288 case AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL:
1289 /* Set CP only for voicecall */
1290 if (local_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL) {
1291 SET_AIF(AIF_CP_CAPTURE);
1294 /* Voicecall / Videocall Common setting */
1295 control->path_fixed_pid[PATH_FIXED_TYPE_CALL] = current_pid;
1296 if (control->path.capture == AVSYS_AUDIO_PATH_EX_BTMIC) {
1297 SET_AIF(AIF_BT_CAPTURE);
1301 case AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO:
1302 control->path_fixed_pid[PATH_FIXED_TYPE_FMRADIO] = current_pid;
1309 if (control->control_aif_before_path_set) {
1310 err = __avsys_open_aif(AIF_control, control->wb_enabled);
1313 /* Do ALSA scenario control based on gain */
1315 if (local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_AP) {
1316 avsys_warning(AVAUDIO, "playback gain : ap\n");
1317 err = __avsys_audio_path_set_ascn_ap_playback(control);
1318 if (AVSYS_SUCCESS(err)) {
1319 err = __avsys_audio_path_set_hw_controls(control);
1321 } else if(local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT) {
1322 avsys_warning(AVAUDIO,"playback gain : callalert\n");
1323 err = __avsys_audio_path_set_ascn_ap_playback(control);
1324 if (AVSYS_SUCCESS(err)) {
1325 err = __avsys_audio_path_set_hw_controls(control);
1327 } else if (local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO &&
1328 local_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO) {
1329 avsys_warning(AVAUDIO, "fmradio gain\n");
1330 err = __avsys_audio_path_set_ascn_fmradio(control);
1331 } else if (local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL &&
1332 local_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL) {
1333 avsys_warning(AVAUDIO, "voicecall gain\n");
1334 err = __avsys_audio_path_set_ascn_voicecall(control);
1335 } else if (local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL &&
1336 local_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL) {
1337 avsys_warning(AVAUDIO, "videocall gain\n");
1338 err = __avsys_audio_path_set_ascn_videocall(control);
1341 if (local_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_AP) {
1342 avsys_warning(AVAUDIO, "capture gain : ap\n");
1343 err = __avsys_audio_path_set_ascn_ap_capture(control);
1346 if (!control->control_aif_before_path_set) {
1347 err = __avsys_open_aif(AIF_control, control->wb_enabled);
1352 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1353 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
1354 return AVSYS_STATE_ERR_INTERNAL;
1356 avsys_info(AVAUDIO, "------------------------------------------------\n");
1360 int avsys_audio_path_ex_get_path(int *gain, int *out, int *in, int *option)
1362 avsys_audio_path_ex_info_t *control = NULL;
1363 avsys_audio_path_ex_info_t ** temp = NULL;
1365 if(gain == NULL || out == NULL || in == NULL || option == NULL) {
1366 avsys_error(AVAUDIO,"Invalid parameter\n");
1367 return AVSYS_STATE_ERR_NULL_POINTER;
1372 if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
1373 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
1374 return AVSYS_STATE_ERR_INTERNAL;
1376 if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1377 avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
1378 return AVSYS_STATE_ERR_INTERNAL;
1381 switch (control->gain.playback) {
1382 case AVSYS_AUDIO_PLAYBACK_GAIN_AP:
1383 *gain = AVSYS_AUDIO_GAIN_EX_KEYTONE;
1384 *out = control->path.playback;
1385 *in = AVSYS_AUDIO_PATH_EX_NONE;
1386 *option = control->option.playback;
1388 case AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT:
1389 *gain = AVSYS_AUDIO_GAIN_EX_RINGTONE;
1390 *out = control->path.playback;
1391 *in = AVSYS_AUDIO_PATH_EX_NONE;
1392 *option = control->option.playback;
1394 case AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL:
1395 *gain = AVSYS_AUDIO_GAIN_EX_VOICECALL;
1396 *out = control->path.playback;
1397 *in = control->path.capture;
1398 *option = control->option.playback;
1400 case AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL:
1401 *gain = AVSYS_AUDIO_GAIN_EX_VIDEOCALL;
1402 *out = control->path.playback;
1403 *in = control->path.capture;
1404 *option = control->option.playback;
1406 case AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO:
1407 *gain = AVSYS_AUDIO_GAIN_EX_FMRADIO;
1408 *out = control->path.playback;
1409 *in = control->path.capture;
1410 *option = control->option.playback;
1414 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1415 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
1416 return AVSYS_STATE_ERR_INTERNAL;
1419 return AVSYS_STATE_SUCCESS;
1422 int avsys_audio_path_ex_set_amp(const int onoff)
1424 //not yet implemented.
1425 return AVSYS_STATE_SUCCESS;
1428 int avsys_audio_path_ex_set_mute(const int mute)
1430 avsys_audio_path_ex_info_t *control = NULL;
1431 avsys_audio_path_ex_info_t **temp = NULL;
1435 if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
1436 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
1437 return AVSYS_STATE_ERR_INTERNAL;
1440 if (control == NULL) {
1441 return AVSYS_STATE_ERR_NULL_POINTER;
1444 if (mute == AVSYS_AUDIO_UNMUTE || mute == AVSYS_AUDIO_MUTE) {
1445 if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1446 avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
1447 return AVSYS_STATE_ERR_INTERNAL;
1450 if (control->mute == mute) {
1451 avsys_info(AVAUDIO, "[Path Mute] skip mute ctrl op: %d\n", mute);
1452 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1453 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() 2 failed in %s\n", __func__);
1454 return AVSYS_STATE_ERR_INTERNAL;
1456 return AVSYS_STATE_SUCCESS;
1458 control->mute = mute;
1459 avsys_warning(AVAUDIO, "[Path Mute] run mute ctrl op: %d\n", mute);
1462 if (control->mute) {
1463 if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_STR_PLAYBACK_MUTE))) {
1464 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1465 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() 1 failed in %s\n", __func__);
1466 return AVSYS_STATE_ERR_INTERNAL;
1468 avsys_error(AVAUDIO, "Mute fail %s\n", __func__);
1469 return AVSYS_STATE_ERR_IO_CONTROL;
1472 if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_STR_PLAYBACK_UNMUTE))) {
1473 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1474 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() 1 failed in %s\n", __func__);
1475 return AVSYS_STATE_ERR_INTERNAL;
1477 avsys_error(AVAUDIO, "Unmute fail %s\n", __func__);
1478 return AVSYS_STATE_ERR_IO_CONTROL;
1482 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1483 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() 2 failed in %s\n", __func__);
1484 return AVSYS_STATE_ERR_INTERNAL;
1488 if (mute == AVSYS_AUDIO_UNMUTE_NOLOCK) /* set nomalize */
1489 mute_nolock = AVSYS_AUDIO_UNMUTE;
1491 mute_nolock = AVSYS_AUDIO_MUTE;
1493 if (control->mute == mute_nolock) {
1494 avsys_info(AVAUDIO, "[Path Mute] skip mute ctrl op: %d\n", mute);
1495 return AVSYS_STATE_SUCCESS;
1497 control->mute = mute_nolock;
1498 avsys_warning(AVAUDIO, "[Path Mute] run mute ctrl op: %d\n", mute);
1501 if (control->mute) {
1502 if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_STR_PLAYBACK_MUTE))) {
1503 avsys_error(AVAUDIO, "Mute fail %s\n", __func__);
1504 return AVSYS_STATE_ERR_IO_CONTROL;
1507 if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_STR_PLAYBACK_UNMUTE))) {
1508 avsys_error(AVAUDIO, "Unmute fail %s\n", __func__);
1509 return AVSYS_STATE_ERR_IO_CONTROL;
1514 if (mute == AVSYS_AUDIO_UNMUTE || mute == AVSYS_AUDIO_UNMUTE_NOLOCK)
1515 avsys_info_r(AVAUDIO, "Global Mute Disabled\n");
1516 else if (mute == AVSYS_AUDIO_MUTE || mute == AVSYS_AUDIO_MUTE_NOLOCK)
1517 avsys_info_r(AVAUDIO, "Global Mute Enabled\n");
1518 return AVSYS_STATE_SUCCESS;
1521 int avsys_audio_path_ex_get_mute(int *mute)
1523 avsys_audio_path_ex_info_t *control = NULL;
1524 avsys_audio_path_ex_info_t **temp = NULL;
1528 if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
1529 avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
1530 return AVSYS_STATE_ERR_INTERNAL;
1533 if (control == NULL) {
1534 return AVSYS_STATE_ERR_NULL_POINTER;
1537 if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1538 avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
1539 return AVSYS_STATE_ERR_INTERNAL;
1542 *mute = control->mute;
1544 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
1545 avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
1546 return AVSYS_STATE_ERR_INTERNAL;
1549 return AVSYS_STATE_SUCCESS;
1552 static int __avsys_audio_path_set_ascn_ap_playback(avsys_audio_path_ex_info_t *control)
1554 int cmd_gain[2] = { 0, 0 };
1555 int cmd_path[3] = { 0, 0, 0 };
1556 char callalert_mode = 0;
1558 avsys_info(AVAUDIO, "<< path.playback = %d, option = %x, gain.playback = %d, inserted = %d\n",
1559 control->path.playback, control->option.playback, control->gain.playback, control->inserted);
1561 callalert_mode = (control->gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT) ? 1 : 0;
1562 control->path_fixed = PATH_FIXED_NONE;
1564 switch (control->path.playback) {
1565 case AVSYS_AUDIO_PATH_EX_SPK:
1566 if (control->option.playback & AVSYS_AUDIO_PATH_OPTION_DUAL_OUT) {
1567 if (callalert_mode) {
1568 cmd_gain[0] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_CALLALERT;
1569 cmd_gain[1] = INPUT_AP | OUTPUT_HEADSET | GAIN_CALLALERT;
1571 cmd_gain[0] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_MODE;
1572 cmd_gain[1] = INPUT_AP | OUTPUT_HEADSET | GAIN_MODE;
1575 cmd_path[0] = INPUT_AP | OUTPUT_STEREO_SPK;
1576 cmd_path[1] = INPUT_AP | OUTPUT_HEADSET;
1578 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1580 if (callalert_mode) {
1581 cmd_gain[0] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_CALLALERT;
1583 cmd_gain[0] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_MODE;
1585 control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_AUTO_WITHOUT_MUTE;
1586 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1588 cmd_path[0] = INPUT_AP | OUTPUT_STEREO_SPK;
1592 case AVSYS_AUDIO_PATH_EX_RECV:
1593 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1594 cmd_gain[0] = INPUT_AP | OUTPUT_RECV | GAIN_MODE;
1595 cmd_path[0] = INPUT_AP | OUTPUT_RECV;
1598 case AVSYS_AUDIO_PATH_EX_HEADSET:
1599 if (callalert_mode) {
1600 cmd_gain[0] = INPUT_AP | OUTPUT_HEADSET | GAIN_CALLALERT;
1602 cmd_gain[0] = INPUT_AP | OUTPUT_HEADSET | GAIN_MODE;
1604 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
1605 cmd_path[0] = INPUT_AP | OUTPUT_HEADSET;
1608 case AVSYS_AUDIO_PATH_EX_HDMI:
1609 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1610 cmd_gain[0] = INPUT_AP | OUTPUT_HDMI | GAIN_MODE;
1611 cmd_path[0] = INPUT_AP | OUTPUT_HDMI;
1614 case AVSYS_AUDIO_PATH_EX_DOCK:
1615 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1616 cmd_gain[0] = INPUT_AP | OUTPUT_DOCK | GAIN_MODE;
1617 cmd_path[0] = INPUT_AP | OUTPUT_DOCK;
1620 case AVSYS_AUDIO_PATH_EX_BTHEADSET:
1621 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET;
1622 cmd_gain[0] = INPUT_AP | OUTPUT_BT_HEADSET | GAIN_MODE;
1623 cmd_path[0] = INPUT_AP | OUTPUT_BT_HEADSET;
1625 case AVSYS_AUDIO_PATH_EX_HANDSFREE:
1626 default: /* DEFAULT PATH CONTROL TO NONE */
1627 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1631 avsys_warning(AVAUDIO, "Run Alsa Scenario Script\n");
1632 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_gain, 2, ASCN_RESET_PLAYBACK))
1633 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_path, 2, ASCN_RESET_NONE))
1635 avsys_info(AVAUDIO, ">> leave");
1636 return AVSYS_STATE_SUCCESS;
1639 static int __avsys_audio_path_set_ascn_voicecall(avsys_audio_path_ex_info_t *control)
1641 int cmd_gain[6] = { 0, 0, 0, 0, 0, 0 };
1642 int cmd_path[6] = { 0, 0, 0, 0, 0, 0 };
1645 control->path_fixed = PATH_FIXED_WITH_CALL;
1647 avsys_info(AVAUDIO, "<< path.playback = %d, option = %x, gain.playback = %d, inserted = %d\n",
1648 control->path.playback, control->option.playback, control->gain.playback, control->inserted);
1651 switch (control->path.playback) {
1652 case AVSYS_AUDIO_PATH_EX_NONE:
1653 avsys_warning(AVAUDIO, "[SZ] playback AVSYS_AUDIO_PATH_EX_NONE\n");
1656 case AVSYS_AUDIO_PATH_EX_SPK:
1657 if (control->reqgain.playback == control->gain.playback) {
1658 cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_MODE;
1659 cmd_path[path_idx++] = INPUT_AP | OUTPUT_STEREO_SPK;
1660 cmd_gain[gain_idx++] = INPUT_CP | OUTPUT_STEREO_SPK | GAIN_VOICE_CALL;
1661 cmd_path[path_idx++] = INPUT_CP | OUTPUT_STEREO_SPK;
1663 avsys_warning(AVAUDIO, "Ignore another path setting request during voicecall\n");
1667 case AVSYS_AUDIO_PATH_EX_RECV:
1668 if (control->gain.playback == control->reqgain.playback) {
1669 cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_RECV | GAIN_MODE;
1670 cmd_path[path_idx++] = INPUT_AP | OUTPUT_RECV;
1671 cmd_gain[gain_idx++] = INPUT_CP | OUTPUT_RECV | GAIN_VOICE_CALL;
1672 cmd_path[path_idx++] = INPUT_CP | OUTPUT_RECV;
1674 avsys_warning(AVAUDIO, "Ignore another path setting request during voicecall\n");
1678 case AVSYS_AUDIO_PATH_EX_HEADSET:
1679 if (control->reqgain.playback == control->gain.playback) {
1680 cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_HEADSET | GAIN_MODE;
1681 cmd_path[path_idx++] = INPUT_AP | OUTPUT_HEADSET;
1682 cmd_gain[gain_idx++] = INPUT_CP | OUTPUT_HEADSET | GAIN_VOICE_CALL;
1683 cmd_path[path_idx++] = INPUT_CP | OUTPUT_HEADSET;
1685 avsys_warning(AVAUDIO, "Ignore another path setting request during voicecall\n");
1689 case AVSYS_AUDIO_PATH_EX_BTHEADSET:
1691 if (control->reqgain.playback == control->gain.playback) {
1692 control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_AUTO_WITH_MUTE;
1693 cmd_gain[gain_idx++] = INPUT_CP | OUTPUT_BT_HEADSET | GAIN_MODE;
1694 cmd_path[path_idx++] = INPUT_AP | OUTPUT_BT_HEADSET;
1695 cmd_path[path_idx++] = INPUT_CP | OUTPUT_BT_HEADSET;
1697 avsys_warning(AVAUDIO, "Ignore another path setting request during voicecall\n");
1701 case AVSYS_AUDIO_PATH_EX_HANDSFREE:
1703 if (control->reqgain.playback == control->gain.playback) {
1704 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1710 /* Add sound path CP to AP (Rx recording) */
1711 if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC) {
1712 avsys_warning(AVAUDIO, "[SZ] capture AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC\n");
1713 //cmd_path[path_idx++] = INPUT_CP | OUTPUT_AP;
1718 switch (control->path.capture) {
1719 case AVSYS_AUDIO_PATH_EX_NONE:
1720 avsys_warning(AVAUDIO, "[SZ] capture AVSYS_AUDIO_PATH_EX_NONE\n");
1723 case AVSYS_AUDIO_PATH_EX_MIC:
1724 if (control->reqgain.capture == control->gain.capture) {
1725 if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_USE_SUBMIC) {
1726 cmd_gain[gain_idx++] = INPUT_SUB_MIC | OUTPUT_CP | GAIN_MODE;
1727 cmd_path[path_idx++] = INPUT_SUB_MIC | OUTPUT_CP;
1728 if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC) {
1729 avsys_warning(AVAUDIO, "[SZ] capture AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC\n");
1730 //cmd_path[path_idx++] = INPUT_SUB_MIC | OUTPUT_AP;
1733 cmd_gain[gain_idx++] = INPUT_MAIN_MIC | OUTPUT_CP | GAIN_MODE;
1734 cmd_path[path_idx++] = INPUT_MAIN_MIC | OUTPUT_CP;
1735 if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC) {
1736 avsys_warning(AVAUDIO, "[SZ] capture AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC\n");
1737 //cmd_path[path_idx++] = INPUT_MAIN_MIC | OUTPUT_AP;
1743 case AVSYS_AUDIO_PATH_EX_HEADSETMIC:
1744 if (control->reqgain.capture == control->gain.capture) {
1745 cmd_gain[gain_idx++] = INPUT_EAR_MIC | OUTPUT_CP | GAIN_MODE;
1746 cmd_path[path_idx++] = INPUT_EAR_MIC | OUTPUT_CP;
1747 if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC) {
1748 avsys_warning(AVAUDIO, "[SZ] capture AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC\n");
1749 //cmd_path[path_idx++] = INPUT_EAR_MIC | OUTPUT_AP;
1754 case AVSYS_AUDIO_PATH_EX_BTMIC:
1755 if (control->reqgain.capture == control->gain.capture) {
1756 cmd_gain[gain_idx++] = INPUT_BT_MIC | OUTPUT_CP | GAIN_MODE;
1757 cmd_path[path_idx++] = INPUT_BT_MIC | OUTPUT_CP;
1758 if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC) {
1759 avsys_warning(AVAUDIO, "[SZ] capture AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC\n");
1760 //avsys_error(AVAUDIO, "BT Call recording is not supported");
1764 case AVSYS_AUDIO_PATH_EX_HANDSFREE:
1769 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_single_set(ASCN_STR_RESET));
1770 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_gain, 6, ASCN_RESET_NONE));
1771 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_path, 6, ASCN_RESET_NONE));
1773 avsys_info(AVAUDIO, ">> leave");
1774 return AVSYS_STATE_SUCCESS;
1777 static int __avsys_audio_path_set_ascn_videocall(avsys_audio_path_ex_info_t *control)
1779 int cmd_gain[2] = { 0, 0 };
1780 int cmd_path[3] = { 0, 0, 0 };
1784 control->path_fixed = PATH_FIXED_WITH_CALL;
1785 switch (control->path.playback) {
1786 case AVSYS_AUDIO_PATH_EX_NONE:
1787 avsys_warning(AVAUDIO, "[SZ] playback AVSYS_AUDIO_PATH_EX_NONE\n");
1790 case AVSYS_AUDIO_PATH_EX_SPK:
1791 if (control->reqgain.playback == control->gain.playback) {
1792 cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_MODE;
1793 cmd_path[path_idx++] = INPUT_AP | OUTPUT_STEREO_SPK;
1794 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1796 avsys_warning(AVAUDIO, "Sound Path request during VT call ignored.");
1800 case AVSYS_AUDIO_PATH_EX_RECV:
1801 if (control->gain.playback == control->reqgain.playback) {
1802 cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_RECV | GAIN_MODE;
1803 cmd_path[path_idx++] = INPUT_AP | OUTPUT_RECV;
1804 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1806 avsys_warning(AVAUDIO, "Sound Path request during VT call ignored.");
1810 case AVSYS_AUDIO_PATH_EX_HEADSET:
1811 if (control->reqgain.playback == control->gain.playback) {
1812 cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_HEADSET | GAIN_MODE;
1813 cmd_path[path_idx++] = INPUT_AP | OUTPUT_HEADSET;
1814 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
1816 avsys_warning(AVAUDIO, "Sound Path request during VT call ignored.");
1820 case AVSYS_AUDIO_PATH_EX_BTHEADSET:
1821 if (control->reqgain.playback == control->gain.playback) {
1822 cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_BT_HEADSET | GAIN_MODE;
1823 cmd_path[path_idx++] = INPUT_AP | OUTPUT_BT_HEADSET;
1824 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET;
1826 avsys_warning(AVAUDIO, "Sound Path request during VT call ignored.");
1830 case AVSYS_AUDIO_PATH_EX_HANDSFREE:
1832 if (control->reqgain.playback == control->gain.playback) {
1833 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1838 switch (control->path.capture) {
1839 case AVSYS_AUDIO_PATH_EX_NONE:
1840 avsys_warning(AVAUDIO, "[SZ] capture AVSYS_AUDIO_PATH_EX_NONE\n");
1843 case AVSYS_AUDIO_PATH_EX_MIC:
1844 if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_USE_SUBMIC) {
1845 cmd_gain[gain_idx++] = INPUT_SUB_MIC | OUTPUT_AP | GAIN_MODE;
1846 cmd_path[path_idx++] = INPUT_SUB_MIC | OUTPUT_AP;
1848 cmd_gain[gain_idx++] = INPUT_MAIN_MIC | OUTPUT_AP | GAIN_MODE;
1849 cmd_path[path_idx++] = INPUT_MAIN_MIC | OUTPUT_AP;
1853 case AVSYS_AUDIO_PATH_EX_HEADSETMIC:
1854 cmd_gain[gain_idx++] = INPUT_EAR_MIC | OUTPUT_AP | GAIN_MODE;
1855 cmd_path[path_idx++] = INPUT_EAR_MIC | OUTPUT_AP;
1858 case AVSYS_AUDIO_PATH_EX_BTMIC:
1859 cmd_gain[gain_idx++] = INPUT_BT_MIC | OUTPUT_AP | GAIN_MODE;
1860 cmd_path[path_idx++] = INPUT_BT_MIC | OUTPUT_AP;
1863 case AVSYS_AUDIO_PATH_EX_HANDSFREE:
1868 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_single_set(ASCN_STR_RESET));
1869 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_gain, 2, ASCN_RESET_NONE));
1870 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_path, 2, ASCN_RESET_NONE));
1872 return AVSYS_STATE_SUCCESS;
1876 static int __avsys_audio_path_set_ascn_fmradio(avsys_audio_path_ex_info_t *control)
1878 int cmd_gain[2] = { 0, 0 };
1879 int cmd_path[3] = { 0, 0, 0 };
1881 int skip_clear_record = 0;
1885 avsys_warning(AVAUDIO, "req gain playback [%x], control gain playback [%x]\n",
1886 control->reqgain.playback, control->gain.playback);
1887 avsys_warning(AVAUDIO, "req gain capture [%x], control gain capture [%x]\n",
1888 control->reqgain.capture, control->gain.capture);
1890 switch (control->path.playback) {
1891 case AVSYS_AUDIO_PATH_EX_NONE:
1892 avsys_warning(AVAUDIO, "[SZ] playback AVSYS_AUDIO_PATH_EX_NONE\n");
1895 case AVSYS_AUDIO_PATH_EX_SPK:
1896 if (control->reqgain.playback == control->gain.playback) {
1897 avsys_warning(AVAUDIO, "req gain playback == control gain playback\n");
1898 cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_MODE;
1899 cmd_path[path_idx++] = INPUT_AP | OUTPUT_STEREO_SPK;
1901 avsys_warning(AVAUDIO, "req gain playback != control gain playback\n");
1902 /* append ap playback sound path */
1903 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
1904 cmd_path[path_idx++] = INPUT_AP | OUTPUT_STEREO_SPK;
1909 case AVSYS_AUDIO_PATH_EX_HEADSET:
1910 if (control->reqgain.playback == control->gain.playback) {
1911 avsys_warning(AVAUDIO, "req gain playback == control gain playback\n");
1912 cmd_gain[gain_idx++] = INPUT_AP | OUTPUT_HEADSET | GAIN_MODE;
1913 cmd_path[path_idx++] = INPUT_AP | OUTPUT_HEADSET;
1915 //append ap playback
1916 avsys_warning(AVAUDIO, "req gain playback != control gain playback\n");
1917 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
1918 cmd_path[path_idx++] = INPUT_AP | OUTPUT_HEADSET;
1923 case AVSYS_AUDIO_PATH_EX_A2DP:
1924 if (control->reqgain.playback == control->gain.playback) {
1925 avsys_warning(AVAUDIO, "req gain playback == control gain playback\n");
1926 //control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_MANUAL;
1928 avsys_warning(AVAUDIO, "req gain playback != control gain playback\n");
1929 control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET;
1938 switch (control->path.capture) {
1939 case AVSYS_AUDIO_PATH_EX_FMINPUT:
1940 if (control->reqgain.capture == control->gain.capture) {
1941 avsys_warning(AVAUDIO, "req gain capture == control gain capture\n");
1942 cmd_path[path_idx++] = INPUT_FMRADIO | OUTPUT_AP | GAIN_MODE;
1943 cmd_path[path_idx++] = INPUT_FMRADIO | OUTPUT_AP;
1944 if (control->reqgain.capture == control->pregain.capture) {
1945 avsys_warning(AVAUDIO, "req gain capture == control pregain capture\n");
1946 skip_clear_record = 1;
1954 if (skip_clear_record) {
1955 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_single_set(ASCN_STR_RESET_PLAYBACK))
1956 } else if (!skip_clear) {
1957 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_single_set(ASCN_STR_RESET))
1959 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_gain, gain_idx, ASCN_RESET_NONE))
1960 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_path, path_idx, ASCN_RESET_NONE))
1962 return AVSYS_STATE_SUCCESS;
1965 static int __avsys_audio_path_set_ascn_ap_capture(avsys_audio_path_ex_info_t *control)
1967 int cmd_gain[2] = { 0, 0 };
1968 int cmd_path[3] = { 0, 0, 0 };
1970 avsys_info(AVAUDIO, "<< path.capture = %d, option = %x, gain.capture = %d, inserted = %d\n",
1971 control->path.capture, control->option.capture, control->gain.capture, control->inserted);
1972 switch(control->path.capture) {
1973 case AVSYS_AUDIO_PATH_EX_MIC:
1974 control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_AUTO_WITHOUT_MUTE;
1975 if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_USE_SUBMIC) {
1976 cmd_gain[0] = INPUT_SUB_MIC | OUTPUT_AP | GAIN_MODE;
1977 cmd_path[0] = INPUT_SUB_MIC | OUTPUT_AP;
1978 } else if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_USE_STEREOMIC) {
1979 cmd_gain[0] = INPUT_STEREO_MIC | OUTPUT_AP | GAIN_MODE;
1980 cmd_path[0] = INPUT_STEREO_MIC | OUTPUT_AP;
1982 cmd_gain[0] = INPUT_MAIN_MIC | OUTPUT_AP | GAIN_MODE;
1983 cmd_path[0] = INPUT_MAIN_MIC | OUTPUT_AP;
1987 case AVSYS_AUDIO_PATH_EX_HEADSETMIC:
1988 cmd_gain[0] = INPUT_EAR_MIC | OUTPUT_AP | GAIN_MODE;
1989 cmd_path[0] = INPUT_EAR_MIC | OUTPUT_AP;
1996 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_gain, 2, ASCN_RESET_CAPTURE))
1997 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_path, 2, ASCN_RESET_NONE))
1999 avsys_info (AVAUDIO, ">> leave");
2001 return AVSYS_STATE_SUCCESS;
2005 static int __avsys_audio_path_set_hw_controls(avsys_audio_path_ex_info_t *control)
2007 avsys_audio_handle_info_t *handle_control = NULL;
2008 avsys_audio_handle_info_t **temp = NULL;
2009 int ret = AVSYS_STATE_SUCCESS;
2010 avsys_info(AVAUDIO, "global mute %d\n", control->mute);
2011 avsys_info(AVAUDIO, "path_fixed mute %d\n", control->path_fixed);
2013 /* update logical volume table - about output device - information for open handles */
2014 avsys_info(AVAUDIO, "Control handle informations\n");
2016 avsys_audio_handle_t *ptr = NULL;
2018 int out_device = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
2020 temp = &handle_control;
2021 if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE, (void**)temp))) {
2022 avsys_error(AVAUDIO, "avsys_audio_get_shm() failed in %s\n",__func__);
2023 return AVSYS_STATE_ERR_INTERNAL;
2026 if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
2027 avsys_error(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n",__func__);
2028 return AVSYS_STATE_ERR_INTERNAL;
2031 while (++handle < AVSYS_AUDIO_HANDLE_MAX) {
2032 long long int flag = 0x01;
2035 if (handle_control->allocated & flag)
2037 ptr = &(handle_control->handles[handle]);
2039 if (ptr->mode != AVSYS_AUDIO_MODE_OUTPUT && ptr->mode != AVSYS_AUDIO_MODE_OUTPUT_CLOCK
2040 && ptr->mode != AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY && ptr->mode != AVSYS_AUDIO_MODE_OUTPUT_AP_CALL) {
2044 out_device = control->lvol_dev_type;
2045 avsys_audio_logical_volume_update_table(out_device, &ptr->gain_setting);
2046 avsys_audio_logical_volume_convert(&ptr->setting_vol, &ptr->working_vol, &ptr->gain_setting);
2050 if(AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
2051 avsys_error(AVAUDIO,"avsys_audio_unlock_sync() failed in %s\n",__func__);
2052 return AVSYS_STATE_ERR_INTERNAL;
2055 return AVSYS_STATE_SUCCESS;
2058 static bool __avsys_audio_path_check_cp_audio(int gain)
2060 /*If video call uses CP audio, add AVSYS_AUDIO_GAIN_EX_VIDEOCALL to following code. */
2061 if (gain == AVSYS_AUDIO_GAIN_EX_VOICECALL)
2067 int avsys_audio_path_set_volume(int handle)
2069 avsys_audio_path_ex_info_t *control = NULL;
2070 avsys_audio_path_ex_info_t **temp = NULL;
2071 avsys_audio_handle_t *ptr = NULL;
2073 int vol_conf, vol_conf_type;
2074 int out_device = AVSYS_AUDIO_DEVICE_TYPE_SPK;
2076 err = avsys_audio_handle_get_ptr(handle, &ptr, HANDLE_PTR_MODE_NORMAL);
2077 if (AVSYS_FAIL(err)) {
2078 avsys_error(AVAUDIO, "Handle is not allocated\n");
2079 avsys_audio_handle_release_ptr(handle, HANDLE_PTR_MODE_NORMAL);
2080 return AVSYS_STATE_ERR_INVALID_PARAMETER;
2084 avsys_assert(AVSYS_SUCCESS(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp)));
2085 avsys_assert(control != NULL);
2086 avsys_assert(AVSYS_SUCCESS(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
2088 if (__avsys_audio_path_check_cp_audio(control->gain.playback))
2089 ptr->during_cp_audio = 1;
2091 ptr->during_cp_audio = 0;
2093 vol_conf = ptr->gain_setting.volume_config;
2094 vol_conf_type = AVSYS_AUDIO_VOLUME_CONFIG_TYPE(vol_conf);
2095 out_device = control->lvol_dev_type;
2096 avsys_assert(AVSYS_SUCCESS(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
2097 avsys_warning(AVAUDIO, "set path volume : gain(%d), out_dev(%d)\n", vol_conf_type, out_device);
2098 err = avsys_audio_logical_volume_set_table(vol_conf, out_device, &ptr->gain_setting);
2099 avsys_audio_handle_release_ptr(handle, HANDLE_PTR_MODE_NORMAL);
2103 int avsys_audio_path_set_route_policy(avsys_audio_route_policy_t route)
2109 int avsys_audio_path_get_route_policy(avsys_audio_route_policy_t *route)
2115 int avsys_audio_path_check_cp_audio(bool *cpaudio, bool *btpath)
2117 avsys_audio_path_ex_info_t *control = NULL;
2118 avsys_audio_path_ex_info_t **temp = NULL;
2120 if (!cpaudio || !btpath)
2121 return AVSYS_STATE_ERR_INVALID_PARAMETER;
2124 avsys_assert(AVSYS_SUCCESS(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp)));
2125 avsys_assert(control != NULL);
2126 avsys_assert(AVSYS_SUCCESS(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
2128 if (__avsys_audio_path_check_cp_audio(control->gain.playback))
2133 if (control->path.playback == AVSYS_AUDIO_PATH_EX_BTHEADSET)
2138 avsys_assert(AVSYS_SUCCESS(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
2139 return AVSYS_STATE_SUCCESS;
2142 int avsys_audio_path_set_single_ascn(char *str)
2145 return AVSYS_STATE_ERR_INVALID_PARAMETER;
2147 RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_single_set(str))
2149 return AVSYS_STATE_SUCCESS;