Name: audio-hal-sc7727
Summary: TIZEN Audio HAL for SC7727
-Version: 0.1.10
+Version: 0.1.11
Release: 0
Group: System/Libraries
License: Apache-2.0
}
#endif
-int _voice_pcm_open(audio_hal_t *ah)
+audio_return_t _fmradio_pcm_open(audio_hal_t *ah)
+{
+ audio_return_t audio_ret = AUDIO_RET_OK;
+ int ret = 0;
+ const char *device_name = NULL;
+ audio_pcm_sample_spec_t sample_spec;
+ uint8_t use_mmap = 0;
+ sample_spec.rate = 44100;
+ sample_spec.channels = 2;
+ sample_spec.format = SND_PCM_FORMAT_S16_LE;
+
+ if ((audio_ret = _ucm_get_device_name(ah, AUDIO_USE_CASE_VERB_FMRADIO, AUDIO_DIRECTION_OUT, &device_name)))
+ goto error_exit;
+
+#ifdef __USE_TINYALSA__
+ AUDIO_LOG_WARN("need implementation for tinyAlsa");
+ return AUDIO_ERR_NOT_IMPLEMENTED;
+#else
+ if (device_name) {
+ if((ret = snd_pcm_open((snd_pcm_t **)&ah->device.fmradio_pcm_out, (char *)device_name, SND_PCM_STREAM_PLAYBACK, 0)) < 0) {
+ AUDIO_LOG_ERROR("[%s] out pcm_open failed", device_name);
+ audio_ret = AUDIO_ERR_IOCTL;
+ goto error_exit;
+ }
+ AUDIO_LOG_INFO("[%s] out pcm_open success:%p", device_name, ah->device.fmradio_pcm_out);
+
+ if ((audio_ret = _pcm_set_hw_params(ah->device.fmradio_pcm_out, &sample_spec, &use_mmap, NULL, NULL)) < 0) {
+ AUDIO_LOG_ERROR("[%s] out __set_pcm_hw_params failed", device_name);
+ if ((audio_ret = _pcm_close(ah->device.pcm_out)))
+ AUDIO_LOG_ERROR("failed to _pcm_close(), ret(0x%x)", audio_ret);
+ ah->device.fmradio_pcm_out = NULL;
+ goto error_exit;
+ }
+ }
+#endif
+
+error_exit:
+ if (device_name)
+ free((void*)device_name);
+
+ return audio_ret;
+}
+
+audio_return_t _fmradio_pcm_close(audio_hal_t *ah)
+{
+ audio_return_t audio_ret = AUDIO_RET_OK;
+
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+
+ AUDIO_LOG_INFO("close fmradio pcm handles");
+
+ if (ah->device.fmradio_pcm_out) {
+ if ((audio_ret = _pcm_close(ah->device.fmradio_pcm_out)))
+ AUDIO_LOG_ERROR("failed to _fmradio_pcm_close() for pcm_out, ret(0x%x)", audio_ret);
+ else {
+ ah->device.fmradio_pcm_out = NULL;
+ AUDIO_LOG_INFO("fmradio pcm_out handle close success");
+ }
+ }
+
+ return audio_ret;
+}
+
+audio_return_t _voice_pcm_open(audio_hal_t *ah)
{
int err, ret = 0;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+#ifdef __USE_TINYALSA__
+ AUDIO_LOG_WARN("need implementation for tinyAlsa");
+ return AUDIO_ERR_NOT_IMPLEMENTED;
+#else
AUDIO_LOG_INFO("open voice pcm handles");
/* Get playback voice-pcm from ucm conf. Open and set-params */
- if ((err = snd_pcm_open((snd_pcm_t **)&ah->device.pcm_out, VOICE_PCM_DEVICE, AUDIO_DIRECTION_OUT, 0)) < 0) {
+ if ((err = snd_pcm_open((snd_pcm_t **)&ah->device.pcm_out, VOICE_PCM_DEVICE, SND_PCM_STREAM_PLAYBACK, 0)) < 0) {
AUDIO_LOG_ERROR("snd_pcm_open for %s failed. %s", VOICE_PCM_DEVICE, snd_strerror(err));
return AUDIO_ERR_IOCTL;
}
AUDIO_LOG_INFO("pcm playback device open success device(%s)", VOICE_PCM_DEVICE);
/* Get capture voice-pcm from ucm conf. Open and set-params */
- if ((err = snd_pcm_open((snd_pcm_t **)&ah->device.pcm_in, VOICE_PCM_DEVICE, AUDIO_DIRECTION_IN, 0)) < 0) {
+ if ((err = snd_pcm_open((snd_pcm_t **)&ah->device.pcm_in, VOICE_PCM_DEVICE, SND_PCM_STREAM_CAPTURE, 0)) < 0) {
AUDIO_LOG_ERROR("snd_pcm_open for %s failed. %s", VOICE_PCM_DEVICE, snd_strerror(err));
return AUDIO_ERR_IOCTL;
}
ret = __voice_pcm_set_params(ah, ah->device.pcm_in);
AUDIO_LOG_INFO("pcm captures device open success device(%s)", VOICE_PCM_DEVICE);
+#endif
- return ret;
+ return (ret == 0 ? AUDIO_RET_OK : AUDIO_ERR_INTERNAL);
}
-int _voice_pcm_close(audio_hal_t *ah, uint32_t direction)
+audio_return_t _voice_pcm_close(audio_hal_t *ah, uint32_t direction)
{
+ audio_return_t audio_ret = AUDIO_RET_OK;
+
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
AUDIO_LOG_INFO("close voice pcm handles");
if (ah->device.pcm_out && (direction == AUDIO_DIRECTION_OUT)) {
- _pcm_close(ah->device.pcm_out);
- ah->device.pcm_out = NULL;
- AUDIO_LOG_INFO("voice pcm_out handle close success");
+ if ((audio_ret = _pcm_close(ah->device.pcm_out)))
+ AUDIO_LOG_ERROR("failed to _pcm_close() for pcm_out, ret(0x%x)", audio_ret);
+ else {
+ ah->device.pcm_out = NULL;
+ AUDIO_LOG_INFO("voice pcm_out handle close success");
+ }
} else if (ah->device.pcm_in && (direction == AUDIO_DIRECTION_IN)) {
- _pcm_close(ah->device.pcm_in);
- ah->device.pcm_in = NULL;
- AUDIO_LOG_INFO("voice pcm_in handle close success");
+ if ((audio_ret = _pcm_close(ah->device.pcm_in)))
+ AUDIO_LOG_ERROR("failed to _pcm_close() for pcm_in, ret(0x%x)", audio_ret);
+ else {
+ ah->device.pcm_in = NULL;
+ AUDIO_LOG_INFO("voice pcm_in handle close success");
+ }
}
- return AUDIO_RET_OK;
+ return audio_ret;
}
-void _reset_pcm_devices(audio_hal_t *ah)
+audio_return_t _reset_pcm_devices(audio_hal_t *ah)
{
- AUDIO_RETURN_IF_FAIL(ah);
+ audio_return_t audio_ret = AUDIO_RET_OK;
+
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
if (ah->device.pcm_out) {
- _pcm_close(ah->device.pcm_out);
- ah->device.pcm_out = NULL;
- AUDIO_LOG_INFO("pcm_out handle close success");
+ if (!(audio_ret = _pcm_close(ah->device.pcm_out))) {
+ ah->device.pcm_out = NULL;
+ AUDIO_LOG_INFO("pcm_out handle close success");
+ }
}
if (ah->device.pcm_in) {
- _pcm_close(ah->device.pcm_in);
- ah->device.pcm_in = NULL;
- AUDIO_LOG_INFO("pcm_in handle close success");
+ if (!(audio_ret = _pcm_close(ah->device.pcm_in))) {
+ ah->device.pcm_in = NULL;
+ AUDIO_LOG_INFO("pcm_in handle close success");
+ }
+ }
+ if (ah->device.fmradio_pcm_out) {
+ if (!(audio_ret = _pcm_close(ah->device.fmradio_pcm_out))) {
+ ah->device.fmradio_pcm_out = NULL;
+ AUDIO_LOG_INFO("fmradio_pcm_out handle close success");
+ }
}
- return;
+ return audio_ret;
}
audio_return_t _pcm_open(void **pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods)
return AUDIO_RET_OK;
}
+audio_return_t _ucm_get_device_name(audio_hal_t *ah, const char *use_case, audio_direction_t direction, const char **value)
+{
+ char identifier[70] = { 0, };
+
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(use_case, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah->ucm.uc_mgr, AUDIO_ERR_PARAMETER);
+
+ snprintf(identifier, sizeof(identifier), "%sPCM//%s",
+ (direction == AUDIO_DIRECTION_IN) ? "Capture" : "Playback", use_case);
+
+ snd_use_case_get(ah->ucm.uc_mgr, identifier, value);
+
+ AUDIO_LOG_INFO("get device name : [%s]", *value);
+
+ return AUDIO_RET_OK;
+}
+
/* UCM sequence
1) If verb is null or verb is not changed
1-1) If device is changed
*/
/* PCM */
-int _voice_pcm_open(audio_hal_t *ah);
-int _voice_pcm_close(audio_hal_t *ah, uint32_t direction);
-void _reset_pcm_devices(audio_hal_t *ah);
+audio_return_t _fmradio_pcm_open(audio_hal_t *ah);
+audio_return_t _fmradio_pcm_close(audio_hal_t *ah);
+audio_return_t _voice_pcm_open(audio_hal_t *ah);
+audio_return_t _voice_pcm_close(audio_hal_t *ah, uint32_t direction);
+audio_return_t _reset_pcm_devices(audio_hal_t *ah);
audio_return_t _pcm_open(void **pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods);
audio_return_t _pcm_start(void *pcm_handle);
audio_return_t _pcm_stop(void *pcm_handle);
audio_return_t _pcm_set_hw_params(snd_pcm_t *pcm, audio_pcm_sample_spec_t *sample_spec, uint8_t *use_mmap, snd_pcm_uframes_t *period_size, snd_pcm_uframes_t *buffer_size);
/* Control */
+#define VBC_TD_CHANNELID 0 /* cp [3g] */
+#define VBC_ARM_CHANNELID 2 /* ap */
+#define MIXER_VBC_SWITCH "VBC Switch"
+#define PIN_SWITCH_IIS0_SYS_SEL "IIS0 pin select"
+#define PIN_SWITCH_IIS0_AP_ID 0
+#define PIN_SWITCH_IIS0_CP0_ID 1
+#define PIN_SWITCH_IIS0_CP1_ID 2
+#define PIN_SWITCH_IIS0_CP2_ID 3
+#define PIN_SWITCH_IIS0_VBC_ID 4
+#define PIN_SWITCH_BT_IIS_SYS_SEL "BT IIS pin select"
+#define PIN_SWITCH_BT_IIS_CP0_IIS0_ID 0
+#define PIN_SWITCH_BT_IIS_CP1_IIS0_ID 4
+#define PIN_SWITCH_BT_IIS_AP_IIS0_ID 8
+#define PIN_SWITCH_BT_IIS_CON_SWITCH "BT IIS con switch"
+#define MIXER_FMRADIO_L_VOLUME "VBC STR DG Set"
+#define MIXER_FMRADIO_R_VOLUME "VBC STL DG Set"
+#define MIXER_FMRADIO_MUTE "Digital FM Function"
audio_return_t _control_init(audio_hal_t *ah);
audio_return_t _control_deinit(audio_hal_t *ah);
audio_return_t _mixer_control_set_param(audio_hal_t *ah, const char* ctl_name, snd_ctl_elem_value_t* value, int size);
/* UCM */
audio_return_t _ucm_init(audio_hal_t *ah);
audio_return_t _ucm_deinit(audio_hal_t *ah);
+audio_return_t _ucm_get_device_name(audio_hal_t *ah, const char *use_case, audio_direction_t direction, const char **value);
#define _ucm_update_use_case _ucm_set_use_case
audio_return_t _ucm_set_use_case(audio_hal_t *ah, const char *verb, const char *devices[], const char *modifiers[]);
audio_return_t _ucm_set_devices(audio_hal_t *ah, const char *verb, const char *devices[]);
#define AUDIO_USE_CASE_VERB_VOICECALL "Voice"
#define AUDIO_USE_CASE_VERB_VIDEOCALL "Video"
#define AUDIO_USE_CASE_VERB_VOIP "VoIP"
-#define AUDIO_USE_CASE_VERB_LOOPBACK "Loopback"
+#define AUDIO_USE_CASE_VERB_FMRADIO "DigitalFM"
/* Modifiers */
#define AUDIO_USE_CASE_MODIFIER_VOICESEARCH "VoiceSearch"
VERB_NORMAL,
VERB_VOICECALL,
VERB_VIDEOCALL,
- VERB_VOIP
+ VERB_VOIP,
+ VERB_RADIO
} audio_route_mode_t;
typedef struct audio_hal_device {
uint32_t active_out;
snd_pcm_t *pcm_in;
snd_pcm_t *pcm_out;
+ snd_pcm_t *fmradio_pcm_out;
pthread_mutex_t pcm_lock;
uint32_t pcm_count;
device_info_t *init_call_devices;
uint32_t num_of_call_devices;
audio_route_mode_t mode;
+ uint32_t is_radio_on;
pthread_cond_t device_cond;
pthread_mutex_t device_lock;
} audio_hal_device_t;
/* Volume */
#define AUDIO_VOLUME_LEVEL_MAX 16
+#define RADIO_VOLUME_MAX 16
typedef enum audio_volume {
AUDIO_VOLUME_TYPE_SYSTEM, /**< System volume type */
typedef struct audio_hal_volume {
uint32_t volume_level[AUDIO_VOLUME_TYPE_MAX];
audio_volume_value_table_t *volume_value_table;
+ int32_t radio_volume_value_table[RADIO_VOLUME_MAX];
} audio_hal_volume_t;
/* UCM */
audio_return_t _audio_update_route_voicecall(audio_hal_t *ah, device_info_t *devices, int32_t num_of_devices);
int _audio_modem_is_call_connected(audio_hal_t *ah);
audio_return_t _audio_comm_send_message(audio_hal_t *ah, const char *name, int value);
+audio_return_t _audio_volume_set_level_radio(audio_hal_t *ah, uint32_t level);
typedef struct _dump_data {
char *strbuf;
#include "tizen-audio-impl.h"
#define vbc_thread_new pthread_create
-#define MIXER_VBC_SWITCH "VBC Switch"
-/* pin_switch */
-#define PIN_SWITCH_IIS0_SYS_SEL "IIS0 pin select"
-#define PIN_SWITCH_IIS0_AP_ID 0
-#define PIN_SWITCH_IIS0_CP0_ID 1
-#define PIN_SWITCH_IIS0_CP1_ID 2
-#define PIN_SWITCH_IIS0_CP2_ID 3
-#define PIN_SWITCH_IIS0_VBC_ID 4
-
-#define PIN_SWITCH_BT_IIS_SYS_SEL "BT IIS pin select"
-#define PIN_SWITCH_BT_IIS_CP0_IIS0_ID 0
-#define PIN_SWITCH_BT_IIS_CP1_IIS0_ID 4
-#define PIN_SWITCH_BT_IIS_AP_IIS0_ID 8
-
-#define PIN_SWITCH_BT_IIS_CON_SWITCH "BT IIS con switch"
-
-#define VBC_TD_CHANNELID 0 /* cp [3g] */
-#define VBC_ARM_CHANNELID 2 /* ap */
-
#define VBPIPE_DEVICE "/dev/spipe_w6"
#define VBPIPE_VOIP_DEVICE "/dev/spipe_w4"
#define VBC_CMD_TAG "VBC"
}
-int _audio_modem_is_call_connected(audio_hal_t *ah)
-{
- int val = -1; /* Mixer values 0 - cp [3g] ,1 - cp [2g] ,2 - ap */
-
- _mixer_control_get_value(ah, MIXER_VBC_SWITCH, &val);
- AUDIO_LOG_INFO("modem is connected for call = %d", (val == VBC_TD_CHANNELID));
-
- return (val == VBC_TD_CHANNELID) ? 1 : 0;
-}
-
static int __vbc_write_response(int fd, unsigned int cmd, uint32_t paras_size)
{
int ret = 0;
return 0;
}
-#define FM_IIS 0x10
+int _audio_modem_is_call_connected(audio_hal_t *ah)
+{
+ int val = -1; /* Mixer values 0 - cp [3g] ,1 - cp [2g] ,2 - ap */
+
+ _mixer_control_get_value(ah, MIXER_VBC_SWITCH, &val);
+ AUDIO_LOG_INFO("modem is connected for call = %d", (val == VBC_TD_CHANNELID));
+
+ return (val == VBC_TD_CHANNELID) ? 1 : 0;
+}
+
static void __i2s_pin_mux_sel(audio_hal_t *ah, int type)
{
audio_return_t ret = AUDIO_RET_OK;
AUDIO_LOG_INFO("type is %d",type);
modem = ah->modem.cp;
- if (type == FM_IIS) {
- _mixer_control_set_value(ah,
- PIN_SWITCH_IIS0_SYS_SEL, PIN_SWITCH_IIS0_VBC_ID);
- return;
- }
if (type == 0) {
if(ah->device.active_out & AUDIO_DEVICE_OUT_BT_SCO) {
if(modem->i2s_bt.is_ext) {
ah->device.pcm_in = NULL;
ah->device.pcm_out = NULL;
+ ah->device.fmradio_pcm_out = NULL;
pthread_mutex_init(&ah->device.pcm_lock, NULL);
pthread_mutex_init(&ah->device.device_lock, NULL);
pthread_cond_init(&ah->device.device_cond, NULL);
AUDIO_USE_CASE_VERB_VOICECALL,
AUDIO_USE_CASE_VERB_VIDEOCALL,
AUDIO_USE_CASE_VERB_VOIP,
+ AUDIO_USE_CASE_VERB_FMRADIO,
};
static uint32_t __convert_device_string_to_enum(const char* device_str, uint32_t direction)
return audio_ret;
}
+static audio_return_t __connect_fm_radio(audio_hal_t *ah)
+{
+ audio_return_t audio_ret = AUDIO_RET_OK;
+
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+
+ audio_ret = _mixer_control_set_value(ah,
+ PIN_SWITCH_IIS0_SYS_SEL, PIN_SWITCH_IIS0_VBC_ID);
+ return audio_ret;
+}
+
static audio_return_t __update_route_ap_playback_capture(audio_hal_t *ah, audio_route_info_t *route_info)
{
audio_return_t audio_ret = AUDIO_RET_OK;
device_info_t *devices = NULL;
const char *verb = mode_to_verb_str[VERB_NORMAL];
-#if 0 /* Disable setting modifiers, because driver does not support it yet */
- int mod_idx = 0;
- const char *modifiers[MAX_MODIFIERS] = {NULL,};
-#endif
+
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(route_info, AUDIO_ERR_PARAMETER);
if (ah->modem.is_connected) {
- AUDIO_LOG_INFO("modem is connected, skip verb[%s]", verb);
+ AUDIO_LOG_WARN("modem is connected, skip verb[%s]", verb);
return audio_ret;
}
if (ah->device.mode != VERB_NORMAL) {
- if (ah->device.mode == VERB_VOICECALL) {
- __reset_voice_devices_info(ah);
- COND_SIGNAL(ah->device.device_cond, "device_cond");
+ if (ah->device.mode == VERB_RADIO) {
+ if (ah->device.is_radio_on && !ah->modem.is_connected) {
+ /* Skip setting NORMAL VERB and keep going with RADIO VERB */
+ AUDIO_LOG_WARN("radio is in progress, skip verb[%s]", verb);
+ verb = mode_to_verb_str[VERB_RADIO];
+ } else if (!ah->device.is_radio_on) {
+ if ((audio_ret = _fmradio_pcm_close(ah)))
+ AUDIO_LOG_ERROR("failed to _fmradio_pcm_close(), ret(0x%x)", audio_ret);
+ }
+ } else {
+ if (ah->device.mode == VERB_VOICECALL) {
+ __reset_voice_devices_info(ah);
+ COND_SIGNAL(ah->device.device_cond, "device_cond");
+ }
+ _reset_pcm_devices(ah);
+ ah->device.mode = VERB_NORMAL;
}
- _reset_pcm_devices(ah);
- ah->device.mode = VERB_NORMAL;
}
- AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
- AUDIO_RETURN_VAL_IF_FAIL(route_info, AUDIO_ERR_PARAMETER);
-
devices = route_info->device_infos;
AUDIO_LOG_INFO("update_route_ap_playback_capture++ ");
AUDIO_LOG_ERROR("Failed to set devices: error = 0x%x", audio_ret);
return audio_ret;
}
- ah->device.mode = VERB_NORMAL;
-#if 0 /* Disable setting modifiers, because driver does not support it yet */
- /* Set modifiers */
- if (!strncmp("voice_recognition", route_info->role, MAX_NAME_LEN)) {
- modifiers[mod_idx++] = AUDIO_USE_CASE_MODIFIER_VOICESEARCH;
- } else if ((!strncmp("alarm", route_info->role, MAX_NAME_LEN))||(!strncmp("notifiication", route_info->role, MAX_NAME_LEN))) {
- if (ah->device.active_out &= AUDIO_DEVICE_OUT_JACK)
- modifiers[mod_idx++] = AUDIO_USE_CASE_MODIFIER_DUAL_MEDIA;
- else
- modifiers[mod_idx++] = AUDIO_USE_CASE_MODIFIER_MEDIA;
- } else if (!strncmp("ringtone", route_info->role, MAX_NAME_LEN)) {
- if (ah->device.active_out)
- modifiers[mod_idx++] = AUDIO_USE_CASE_MODIFIER_RINGTONE;
- } else {
- if (ah->device.active_in)
- modifiers[mod_idx++] = AUDIO_USE_CASE_MODIFIER_CAMCORDING;
- else
- modifiers[mod_idx++] = AUDIO_USE_CASE_MODIFIER_MEDIA;
- }
- audio_ret = _audio_ucm_set_modifiers (ah, verb, modifiers);
-#endif
return audio_ret;
}
return audio_ret;
}
+static audio_return_t __update_route_fmradio(audio_hal_t *ah, device_info_t *devices, int32_t num_of_devices)
+{
+ audio_return_t audio_ret = AUDIO_RET_OK;
+ const char *verb = mode_to_verb_str[VERB_RADIO];
+
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(devices, AUDIO_ERR_PARAMETER);
+
+ AUDIO_LOG_INFO("update_route_fmradio++");
+
+ if (!ah->device.fmradio_pcm_out) {
+ if ((audio_ret = _fmradio_pcm_open(ah))) {
+ AUDIO_LOG_ERROR("Failed to _fmradio_pcm_open(): error = 0x%x", audio_ret);
+ return audio_ret;
+ }
+ _audio_volume_set_level_radio(ah, 0);
+ }
+
+ audio_ret = __set_devices(ah, verb, devices, num_of_devices);
+ if (audio_ret) {
+ AUDIO_LOG_ERROR("Failed to set devices: error = 0x%x", audio_ret);
+ return audio_ret;
+ }
+ /* FIXME. If necessary, set VERB_VOIP */
+ ah->device.mode = VERB_RADIO;
+
+ _audio_volume_set_level_radio(ah, ah->volume.volume_level[AUDIO_VOLUME_TYPE_MEDIA]);
+ if ((audio_ret = __connect_fm_radio(ah)))
+ AUDIO_LOG_ERROR("failed to __connect_fm_radio(), ret(0x%x)", audio_ret);
+
+ /* TO DO: Set modifiers */
+ return audio_ret;
+}
+
static audio_return_t __update_route_reset(audio_hal_t *ah, uint32_t direction)
{
audio_return_t audio_ret = AUDIO_RET_OK;
}
}
if (ah->device.mode == VERB_VOICECALL) {
- _voice_pcm_close(ah, direction);
+ if ((audio_ret = _voice_pcm_close(ah, direction)))
+ AUDIO_LOG_ERROR("failed to _voice_pcm_close(), ret(0x%x)", audio_ret);
if (!ah->device.active_in && !ah->device.active_out)
ah->device.mode = VERB_NORMAL;
__reset_voice_devices_info(ah);
COND_SIGNAL(ah->device.device_cond, "device_cond");
+ } else if (ah->device.mode == VERB_RADIO) {
+ if ((audio_ret = _fmradio_pcm_close(ah)))
+ AUDIO_LOG_ERROR("failed to _fmradio_pcm_close(), ret(0x%x)", audio_ret);
+ ah->device.mode = VERB_NORMAL;
}
if (active_devices[0] == NULL) {
ah->device.active_in = 0x0;
ah->device.active_out = 0x0;
ah->device.mode = VERB_NORMAL;
+ ah->device.is_radio_on = 0;
if ((audio_ret = _ucm_init(ah)))
AUDIO_LOG_ERROR("failed to _ucm_init(), ret(0x%x)", audio_ret);
if ((audio_ret = __update_route_voip(ah, devices, info->num_of_devices)))
AUDIO_LOG_WARN("update voip route return 0x%x", audio_ret);
+ } else if (!strncmp("radio", info->role, MAX_NAME_LEN)) {
+ if ((audio_ret = __update_route_fmradio(ah, devices, info->num_of_devices)))
+ AUDIO_LOG_WARN("update radio route return 0x%x", audio_ret);
+
} else if (!strncmp("reset", info->role, MAX_NAME_LEN)) {
if ((audio_ret = __update_route_reset(ah, devices->direction)))
AUDIO_LOG_WARN("update reset return 0x%x", audio_ret);
#include <stdbool.h>
#include "tizen-audio-internal.h"
+#include "tizen-audio-impl.h"
/* Audio latency */
static const char* AUDIO_LATENCY_LOW = "low";
AUDIO_RETURN_VAL_IF_FAIL(info, AUDIO_ERR_PARAMETER);
AUDIO_LOG_INFO("role:%s, direction:%u, idx:%u, is_connected:%d", info->role, info->direction, info->idx, is_connected);
+ if (streq(info->role, "radio")) {
+ if (is_connected)
+ ah->device.is_radio_on = 1;
+ else
+ ah->device.is_radio_on = 0;
+ }
return audio_ret;
}
#include <iniparser.h>
#include "tizen-audio-internal.h"
+#include "tizen-audio-impl.h"
#define VOLUME_INI_DEFAULT_PATH SYSCONFDIR"/multimedia/mmfw_audio_volume.ini" /* SYSCONFDIR is defined at .spec */
#define VOLUME_INI_TEMP_PATH "/opt/system/mmfw_audio_volume.ini"
#define VOLUME_VALUE_MAX (1.0f)
#define GAIN_VALUE_MAX (1.0f)
+#define RADIO_TUNING_DEFUALT_FILE SYSCONFDIR"/multimedia/mmfw_fmradio.ini"
+#define RADIO_TUNING_TEMP_FILE "/opt/system/.mmfw_fmradio.ini"
+#define RADIO_TUNING_ENABLE "tuning:enable"
+#define RADIO_TUNING_VOLUME_LEVELS "fmradio:volume_levels"
+#define RADIO_TUNING_VOLUME_TABLE "fmradio:volume_table"
static const char *g_volume_vconf[AUDIO_VOLUME_TYPE_MAX] = {
"file/private/sound/volume/system", /* AUDIO_VOLUME_TYPE_SYSTEM */
return AUDIO_RET_OK;
}
+static audio_return_t __load_radio_volume_table(int** volume_table, int *number_of_elements)
+{
+ dictionary * dict = NULL;
+ const char delimiter[] = ", ";
+ char* ptr = NULL;
+ char* token = NULL;
+ char* list_str = NULL;
+ int* temp_table = NULL;
+ int index = 0;
+ int ret = 0;
+
+ bool tuning_enable = 0;
+ int not_found = -1;
+ int value = 0;
+
+ dict = iniparser_load(RADIO_TUNING_DEFUALT_FILE);
+ if (dict == NULL) {
+ AUDIO_LOG_ERROR("%s load failed", RADIO_TUNING_DEFUALT_FILE);
+ return AUDIO_ERR_UNDEFINED;
+ } else {
+ /*tuning enable */
+ value = iniparser_getboolean(dict, RADIO_TUNING_ENABLE, not_found);
+ if (value == not_found) {
+ AUDIO_LOG_ERROR("Can't get Tuning Enable value");
+ } else {
+ tuning_enable = value;
+ AUDIO_LOG_INFO("Tuning enabled.");
+ }
+ iniparser_freedict(dict); /*Cleanup*/
+ }
+
+ if (tuning_enable) {
+ AUDIO_LOG_INFO("Tuning enabled. load temp tuning file.");
+ dict = iniparser_load(RADIO_TUNING_TEMP_FILE);
+ if (!dict) {
+ AUDIO_LOG_WARN("%s load failed. Tuning enabled but there is not tuning temp file. Use temporary file", RADIO_TUNING_TEMP_FILE);
+ dict = iniparser_load(RADIO_TUNING_DEFUALT_FILE);
+ if (!dict) {
+ AUDIO_LOG_ERROR("%s load failed", RADIO_TUNING_DEFUALT_FILE);
+ return AUDIO_ERR_UNDEFINED;
+ }
+ }
+ } else {
+ AUDIO_LOG_INFO("Tuning diabled. load default tuning file.");
+ dict = iniparser_load(RADIO_TUNING_DEFUALT_FILE);
+ if (!dict) {
+ AUDIO_LOG_ERROR("%s load failed", RADIO_TUNING_DEFUALT_FILE);
+ return AUDIO_ERR_UNDEFINED;
+ }
+ }
+
+ *number_of_elements = iniparser_getint(dict, RADIO_TUNING_VOLUME_LEVELS, -1);
+ if (*number_of_elements == -1) {
+ ret = AUDIO_ERR_INTERNAL;
+ goto error;
+ }
+ temp_table = (int *)malloc ((*number_of_elements) * sizeof(int));
+ if (!temp_table) {
+ goto error;
+ }
+ *volume_table = temp_table;
+
+ list_str = iniparser_getstring(dict, RADIO_TUNING_VOLUME_TABLE, NULL);
+ if (list_str) {
+ token = strtok_r(list_str, delimiter, &ptr);
+ while (token) {
+ temp_table[index] = atoi(token);
+ AUDIO_LOG_INFO("fm volume index %d is %d", index, temp_table[index]);
+ index++;
+ token = strtok_r(NULL, delimiter, &ptr);
+ }
+ }
+error:
+ iniparser_freedict(dict);
+ return ret;
+}
+
+audio_return_t _audio_volume_set_level_radio(audio_hal_t *ah, uint32_t level)
+{
+ audio_return_t audio_ret = AUDIO_RET_OK;
+
+ int volume = 0;
+ int mute = -1;
+
+ /* Applying mute at volume zero */
+ if (level == 0) {
+ if ((audio_ret = _mixer_control_set_value(ah, MIXER_FMRADIO_MUTE, 0)))
+ AUDIO_LOG_ERROR("set mixer(%s) failed", MIXER_FMRADIO_MUTE);
+
+ } else {
+ if ((audio_ret = _mixer_control_get_value(ah, MIXER_FMRADIO_MUTE, &mute))) {
+ AUDIO_LOG_ERROR("get mixer(%s) failed", MIXER_FMRADIO_MUTE);
+ return audio_ret;
+ }
+ if (mute == 0) {
+ if ((audio_ret = _mixer_control_set_value(ah, MIXER_FMRADIO_MUTE, 1))) {
+ AUDIO_LOG_ERROR("set mixer(%s) failed", MIXER_FMRADIO_MUTE);
+ return audio_ret;
+ }
+ }
+ }
+
+ if ((_mixer_control_get_value(ah, MIXER_FMRADIO_L_VOLUME, &volume)))
+ AUDIO_LOG_ERROR("get mixer(%s) failed", MIXER_FMRADIO_L_VOLUME);
+ else {
+ if (volume != ah->volume.radio_volume_value_table[level]) {
+ if ((audio_ret = _mixer_control_set_value(ah, MIXER_FMRADIO_L_VOLUME, ah->volume.radio_volume_value_table[level]))) {
+ AUDIO_LOG_ERROR("set mixer(%s) failed", MIXER_FMRADIO_L_VOLUME);
+ return audio_ret;
+ }
+ }
+ }
+
+ if ((_mixer_control_get_value(ah, MIXER_FMRADIO_R_VOLUME, &volume)))
+ AUDIO_LOG_ERROR("get mixer(%s) failed", MIXER_FMRADIO_R_VOLUME);
+ else {
+ if (volume != ah->volume.radio_volume_value_table[level]) {
+ if ((audio_ret = _mixer_control_set_value(ah, MIXER_FMRADIO_R_VOLUME, ah->volume.radio_volume_value_table[level])))
+ AUDIO_LOG_ERROR("set mixer(%s) failed", MIXER_FMRADIO_R_VOLUME);
+ }
+ }
+
+ return audio_ret;
+}
+
audio_return_t _audio_volume_init(audio_hal_t *ah)
{
int i;
int val = 0;
audio_return_t audio_ret = AUDIO_RET_OK;
int init_value[AUDIO_VOLUME_TYPE_MAX] = { 9, 11, 7, 11, 7, 4, 4, 7 };
+ int* fm_table = NULL;
+ int number_of_steps = 0;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return AUDIO_ERR_UNDEFINED;
}
+ /* radio volume table */
+ __load_radio_volume_table(&fm_table, &number_of_steps);
+ if (fm_table) {
+ AUDIO_LOG_DEBUG("number of steps -> %d", number_of_steps);
+ /*copy from temp structure to main strcture*/
+ for (i = 0; i < number_of_steps; i++) {
+ ah->volume.radio_volume_value_table[i] = fm_table[i];
+ }
+ free(fm_table);
+ fm_table = NULL;
+ }
+
return audio_ret;
}
AUDIO_LOG_INFO("set [%s] volume_level: %d, direction(%d)", info->type, level, info->direction);
/* set mixer related to H/W volume if needed */
+ if ((__get_volume_idx_by_string_type(info->type) == AUDIO_VOLUME_TYPE_MEDIA) && ah->device.is_radio_on)
+ audio_ret = _audio_volume_set_level_radio(ah, level);
return audio_ret;
}
projects / platform / adaptation / spreadtrum / audio-hal-sc7727.git / commitdiff