ssize_t FMDirPlaySysfs_store(struct device *dev, struct device_attribute *attr,const char *buf, size_t count)
{
//int i=0;
if(5!= sscanf(buf, "%d %d %d %d %d",&sgFMDirectPlayValues[0], &sgFMDirectPlayValues[1], &sgFMDirectPlayValues[2], &sgFMDirectPlayValues[3], &sgFMDirectPlayValues[4]))
{
DEBUG("\n<-FMDirectPlay SysFS Handler: On_Off=%d OpMode=%d, samplerate=%d, channel=%d, volume=%d \n", sgFMDirectPlayValues[0],
sgFMDirectPlayValues[1],
sgFMDirectPlayValues[2],
sgFMDirectPlayValues[3],
sgFMDirectPlayValues[4]);
DEBUG("error reading buf=%s count=%d\n", buf, count);
return count;
}
DEBUG("\n<-FMDirectPlay SysFS Handler: On_Off=%d OpMode=%d, samplerate=%d, channel=%d, volume=%d \n", sgFMDirectPlayValues[0],
sgFMDirectPlayValues[1],
samplerate_tbl[sgFMDirectPlayValues[2]],
FM_chmode[sgFMDirectPlayValues[3]],
sgFMDirectPlayValues[4]);
#ifdef FM_ENABLE_SYSFS_INTERFACE
if(sgFMDirectPlayValues[0]) // enable path
{
if ( FMIsOn == 0 )
{
AUDCTRL_SaveAudioModeFlag((AUDCTRL_SPEAKER_t)sgFMDirectPlayValues[1],AUDIO_APP_FM);
AUDCTRL_EnablePlay(AUDIO_HW_I2S_IN,
AUDIO_HW_AUDIO_OUT,
AUDIO_HW_NONE,
(AUDCTRL_SPEAKER_t)sgFMDirectPlayValues[1],
(AUDIO_CHANNEL_NUM_t)FM_chmode[sgFMDirectPlayValues[3]],
samplerate_tbl[sgFMDirectPlayValues[2]]
);
FMIsOn = 1;
}
AUDCTRL_SetPlayVolume(AUDIO_HW_AUDIO_OUT,
(AUDCTRL_SPEAKER_t)sgFMDirectPlayValues[1],
AUDIO_GAIN_FORMAT_FM_RADIO_DIGITAL_VOLUME_TABLE,
sgFMDirectPlayValues[4],
sgFMDirectPlayValues[4]
);
}
else //disable path
{
if ( FMIsOn )
{
AUDCTRL_DisablePlay(AUDIO_HW_I2S_IN,
AUDIO_HW_AUDIO_OUT,
(AUDCTRL_SPEAKER_t)sgFMDirectPlayValues[1]
);
FMIsOn = 0;
}
}
#endif //FM_ENABLE_SYSFS_INTERFACE
return count;
}
static int HandlePlayCommand(void)
{
unsigned long period_ms;
unsigned long copy_bytes;
static AUDIO_DRIVER_HANDLE_t drv_handle = NULL;
//static AUDIO_DRIVER_BUFFER_t buf_param;
static AUDIO_DRIVER_CONFIG_t drv_config;
static dma_addr_t dma_addr;
static AUDCTRL_SPEAKER_t spkr;
char* src;
char* dest;
//temp
//int ret, irq;
switch(sgBrcm_auddrv_TestValues[1])
{
case 1://open the plyabck device
{
//dump_audio_registers();
DEBUG(" Audio DDRIVER Open\n");
drv_handle = AUDIO_DRIVER_Open(AUDIO_DRIVER_PLAY_AUDIO);
DEBUG(" Audio DDRIVER Open Complete\n");
#ifdef ENABLE_AUDVOC_ISR //enable this for direct interrupt- csl_aud_drv_hw.c file also needs to be changed along with this
// Temporory code
ret = request_irq(IRQ_AUDVOC, audvoc_isr, IRQF_DISABLED, "aud_voc", NULL);
if (ret != 0) {
DEBUG(("Failed to register ISR.\n"));
return ret;
}
#endif
}
break;
case 2://configure playback device
{
DEBUG(" Audio DDRIVER Config\n");
//set the callback
AUDIO_DRIVER_Ctrl(drv_handle,AUDIO_DRIVER_SET_CB,(void*)AUDIO_DRIVER_TEST_InterruptPeriodCB);
// configure defaults
drv_config.sample_rate = AUDIO_SAMPLING_RATE_8000;
drv_config.num_channel = AUDIO_CHANNEL_STEREO;
drv_config.bits_per_sample = AUDIO_16_BIT_PER_SAMPLE;
if(sgBrcm_auddrv_TestValues[2] != 0)
drv_config.sample_rate = sgBrcm_auddrv_TestValues[2];
if(sgBrcm_auddrv_TestValues[3] != 0)
drv_config.num_channel = sgBrcm_auddrv_TestValues[3];
DEBUG("Config:sr=%d nc=%d bs=%d \n",drv_config.sample_rate,drv_config.num_channel,drv_config.bits_per_sample);
AUDIO_DRIVER_Ctrl(drv_handle,AUDIO_DRIVER_CONFIG,(void*)&drv_config);
period_ms = 100;
if(sgBrcm_auddrv_TestValues[4] != 0)
period_ms = sgBrcm_auddrv_TestValues[4];
//set the interrupt period
period_bytes = period_ms * (drv_config.sample_rate/1000) * (drv_config.num_channel) * 2;
num_blocks = PCM_TEST_MAX_PLAYBACK_BUF_BYTES/period_bytes;
DEBUG("Period: ms=%d bytes=%d blocks:%d\n",period_ms,period_bytes,num_blocks);
AUDIO_DRIVER_Ctrl(drv_handle,AUDIO_DRIVER_SET_INT_PERIOD,(void*)&period_bytes);
buf_param.buf_size = PCM_TEST_MAX_PLAYBACK_BUF_BYTES;
buf_param.pBuf = dma_alloc_coherent (NULL, buf_param.buf_size, &dma_addr,GFP_KERNEL);
if(buf_param.pBuf == NULL)
{
DEBUG("Cannot allocate Buffer \n");
return -1;
}
buf_param.phy_addr = (UInt32)dma_addr;
DEBUG("virt_addr = 0x%x phy_addr=0x%x\n",buf_param.pBuf,(UInt32)dma_addr);
current_ipbuffer_index = 0;
dma_buffer_write_index = 0;
#if 1
// copy the buffer with data
if((num_blocks * period_bytes) <= sizeof(hqAudioTestBuf))
copy_bytes = (num_blocks * period_bytes);
else
copy_bytes = sizeof(hqAudioTestBuf);
src = ((char*)hqAudioTestBuf) + current_ipbuffer_index;
dest = buf_param.pBuf + dma_buffer_write_index;
//memset(buf_param.pBuf,0,PCM_TEST_MAX_PLAYBACK_BUF_BYTES);
memcpy(dest,src,copy_bytes);
current_ipbuffer_index += copy_bytes;
//if(current_ipbuffer_index >= sizeof(hqAudioTestBuf))
// current_ipbuffer_index = 0;
//memset(buf_param.pBuf,0xbaba,PCM_TEST_MAX_PLAYBACK_BUF_BYTES);
#else
if(PCM_TEST_MAX_PLAYBACK_BUF_BYTES <= sizeof(samplePCM16_inaudiotest))
copy_bytes = PCM_TEST_MAX_PLAYBACK_BUF_BYTES;
else
copy_bytes = sizeof(samplePCM16_inaudiotest);
//memset(buf_param.pBuf,0,PCM_TEST_MAX_PLAYBACK_BUF_BYTES);
memcpy(buf_param.pBuf,samplePCM16_inaudiotest,copy_bytes);
#endif
//set the buffer params
AUDIO_DRIVER_Ctrl(drv_handle,AUDIO_DRIVER_SET_BUF_PARAMS,(void*)&buf_param);
//disable the voice path -- Just to be sure
//AUDCTRL_DisableTelephony(AUDIO_HW_NONE, AUDIO_HW_NONE, AUDCTRL_MIC_MAIN , AUDCTRL_SPK_HANDSET);
// clear anacr1
// *((UInt32 *) (SYSCFG_BASE_ADDR+SYSCFG_ANACR1_OFFSET)) = 0;
dump_audio_registers();
DEBUG(" Audio DDRIVER Config Complete\n");
}
break;
case 3: //Start the playback
{
//signed long timeout_jiffies = 2;
DEBUG(" Start Playback\n");
spkr = sgBrcm_auddrv_TestValues[2];
AUDCTRL_SaveAudioModeFlag(spkr,0);
AUDCTRL_EnablePlay(AUDIO_HW_NONE,
AUDIO_HW_AUDIO_OUT,
AUDIO_HW_NONE,
spkr,
drv_config.num_channel,
drv_config.sample_rate
);
AUDIO_DRIVER_Ctrl(drv_handle,AUDIO_DRIVER_START,NULL);
#if 0
DEBUG("Playback started\n");
do
{
DEBUG("Waiting...%d \n",timeout_jiffies);
//set_current_state(TASK_UNINTERRUPTIBLE);
// wait for 10sec 128 jiffies = 1 sec
timeout_jiffies = schedule_timeout (timeout_jiffies);
}while (timeout_jiffies > 0);
DEBUG(" Stop playback\n");
AUDIO_DRIVER_Ctrl(drv_handle,AUDIO_DRIVER_STOP,NULL);
//disable the playback path
AUDCTRL_DisablePlay(AUDIO_HW_NONE,AUDIO_HW_AUDIO_OUT,spkr);
AUDIO_DRIVER_Close(drv_handle);
#endif
}
break;
default:
DEBUG(" Invalid Playback Command\n");
}
return 0;
}
void AUDIO_Ctrl_Process(
BRCM_AUDIO_ACTION_en_t action_code,
void *arg_param,
void *callback,
int block
)
{
TMsgAudioCtrl msgAudioCtrl;
unsigned int len;
AUDIO_DRIVER_TYPE_t drv_type;
UInt32 app_profile = 0 ;
static AudioApp_t prev_app_profile = 0;
static AudioMode_t prev_mode_profile = 0;
static bool mode_restore = FALSE;
if(arg_param == NULL)
{
DEBUG("AUDIO_Ctrl_Process: arg_param is NULL \n");
return;
}
switch (action_code)
{
case ACTION_AUD_StartPlay:
{
BRCM_AUDIO_Param_Start_t* param_start = (BRCM_AUDIO_Param_Start_t*) arg_param;
//20110905 //prev_app_profile = AUDDRV_GetAudioApp();
app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_MUSIC);
AUDIO_DRIVER_Ctrl(param_start->drv_handle,AUDIO_DRIVER_START,NULL);
AUDIO_DRIVER_Ctrl(param_start->drv_handle,AUDIO_DRIVER_GET_DRV_TYPE,(void*)&drv_type);
if (AUDIO_Policy_GetState() == BRCM_STATE_INCALL)
{
DEBUG("Play Music During Voice call \n");
musicduringcall = TRUE;
if ( sgTableIDChannelOfDev[param_start->substream_number].speaker == AUDCTRL_SPK_HEADSET ||
sgTableIDChannelOfDev[param_start->substream_number].speaker == AUDCTRL_SPK_BTM )
{
DEBUG("Play Music During Voice call to HEADSET or BTM\n");
if ( app_profile == AUDIO_APP_VOICE_CALL )
{
DEBUG(" Play music during Voice call with BT Tap at 8k \r\n");
AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_BTM, 8000);
}
else
{
DEBUG(" Play music during Voice call with BT Tap at 16k \r\n");
if ( sgTableIDChannelOfDev[param_start->substream_number].speaker == AUDCTRL_SPK_BTM )
{
AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_BTM, 8000);
}
else
{
AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_BTM, 16000);
}
}
AUDCTRL_EnablePlay(AUDIO_HW_NONE,
sgTableIDChannelOfDev[param_start->substream_number].hw_id,
AUDIO_HW_TAP_VOICE,
AUDCTRL_SPK_BTM,
param_start->channels,
param_start->rate
);
}
else
{
DEBUG("Play Music During Voice call to HANDSET or LOUDSPEAKER\n");
if ( app_profile == AUDIO_APP_VOICE_CALL )
{
DEBUG(" Play music during Voice call with BT Tap at 8k \r\n");
AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_HEADSET, 8000);
}
else
{
DEBUG(" Play music during Voice call with BT Tap at 16k \r\n");
AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_HEADSET, 16000);
}
AUDCTRL_EnablePlay(AUDIO_HW_NONE,
sgTableIDChannelOfDev[param_start->substream_number].hw_id,
AUDIO_HW_TAP_VOICE,
AUDCTRL_SPK_HEADSET,
param_start->channels,
param_start->rate
);
}
}
else
{
AUDCTRL_SaveAudioModeFlag( sgTableIDChannelOfDev[param_start->substream_number].speaker,app_profile);
if( sgTableIDChannelOfDev[param_start->substream_number].speaker == AUDCTRL_SPK_BTM )
{
AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, sgTableIDChannelOfDev[param_start->substream_number].speaker, 8000);
// Enable the playback the path
AUDCTRL_EnablePlay(AUDIO_HW_NONE,
sgTableIDChannelOfDev[param_start->substream_number].hw_id,
AUDIO_HW_TAP_VOICE,
sgTableIDChannelOfDev[param_start->substream_number].speaker,
param_start->channels,
param_start->rate
);
}
else
{
// Enable the playback the path
AUDCTRL_EnablePlay(AUDIO_HW_NONE,
sgTableIDChannelOfDev[param_start->substream_number].hw_id,
AUDIO_HW_NONE,
sgTableIDChannelOfDev[param_start->substream_number].speaker,
param_start->channels,
param_start->rate
);
//if (param_start->substream_number == 5) // Ring case
if(extra_speaker)
{
DEBUG("Play to speaker as well \n");
AUDCTRL_AddPlaySpk(sgTableIDChannelOfDev[param_start->substream_number].hw_id, // AUDIO_HW_ID_t sink,
AUDCTRL_SPK_LOUDSPK // AUDCTRL_SPEAKER_t spk
);
}
}
}
// set the slopgain register to max value
AUDCTRL_SetPlayVolume(sgTableIDChannelOfDev[param_start->substream_number].hw_id,
sgTableIDChannelOfDev[param_start->substream_number].speaker,
AUDIO_GAIN_FORMAT_VOL_LEVEL,
AUDIO_VOLUME_MAX,
AUDIO_VOLUME_MAX
);
// start DMA now
AUDIO_DRIVER_Ctrl(param_start->drv_handle,AUDIO_DRIVER_RESUME,NULL);
playback_prev_time = 0;
playback_triggered = 1;
}
break;
case ACTION_AUD_StopPlay:
{
BRCM_AUDIO_Param_Stop_t* param_stop = (BRCM_AUDIO_Param_Stop_t*) arg_param;
// stop DMA first
AUDIO_DRIVER_Ctrl(param_stop->drv_handle,AUDIO_DRIVER_PAUSE,NULL);
AUDIO_DRIVER_Ctrl(param_stop->drv_handle,AUDIO_DRIVER_GET_DRV_TYPE,(void*)&drv_type);
//if (param_stop->substream_number == 5) // Ring case
if(extra_speaker)
{
DEBUG(" REMOVING LOUDSPK \n");
AUDCTRL_RemovePlaySpk(sgTableIDChannelOfDev[param_stop->substream_number].hw_id, // AUDIO_HW_ID_t sink,
AUDCTRL_SPK_LOUDSPK // AUDCTRL_SPEAKER_t spk
);
}
//20110905 //AUDCTRL_SaveAudioModeFlag( AUDDRV_GetAudioMode(), prev_app_profile );
//disable the playback path
if (AUDIO_Policy_GetState() == BRCM_STATE_INCALL)
{
musicduringcall = FALSE;
if ( sgTableIDChannelOfDev[param_stop->substream_number].speaker == AUDCTRL_SPK_HEADSET ||
sgTableIDChannelOfDev[param_stop->substream_number].speaker == AUDCTRL_SPK_BTM )
{
AUDCTRL_DisablePlay(AUDIO_HW_NONE,
sgTableIDChannelOfDev[param_stop->substream_number].hw_id,
AUDCTRL_SPK_BTM
);
}
else
{
AUDCTRL_DisablePlay(AUDIO_HW_NONE,
sgTableIDChannelOfDev[param_stop->substream_number].hw_id,
AUDCTRL_SPK_HEADSET
);
}
AUDCTRL_DisableTap (AUDIO_HW_TAP_VOICE);
}
else
{
if( sgTableIDChannelOfDev[param_stop->substream_number].speaker == AUDCTRL_SPK_BTM )
{
AUDCTRL_DisablePlay(AUDIO_HW_NONE,
sgTableIDChannelOfDev[param_stop->substream_number].hw_id,
sgTableIDChannelOfDev[param_stop->substream_number].speaker
);
AUDCTRL_DisableTap (AUDIO_HW_TAP_VOICE);
}
else
{
AUDCTRL_DisablePlay(AUDIO_HW_NONE,
sgTableIDChannelOfDev[param_stop->substream_number].hw_id,
sgTableIDChannelOfDev[param_stop->substream_number].speaker
);
}
}
AUDIO_DRIVER_Ctrl(param_stop->drv_handle,AUDIO_DRIVER_STOP,NULL);
playback_prev_time = 0;
playback_triggered = 0;
}
break;
case ACTION_AUD_PausePlay:
{
BRCM_AUDIO_Param_Pause_t* param_pause = (BRCM_AUDIO_Param_Pause_t*) arg_param;
AUDIO_DRIVER_Ctrl(param_pause->drv_handle,AUDIO_DRIVER_GET_DRV_TYPE,(void*)&drv_type);
//disable the playback path
AUDCTRL_DisablePlay(AUDIO_HW_NONE,
sgTableIDChannelOfDev[param_pause->substream_number].hw_id,
sgTableIDChannelOfDev[param_pause->substream_number].speaker
);
if( sgTableIDChannelOfDev[param_pause->substream_number].speaker == AUDCTRL_SPK_BTM )
{
AUDCTRL_DisableTap (AUDIO_HW_TAP_VOICE);
}
AUDIO_DRIVER_Ctrl(param_pause->drv_handle,AUDIO_DRIVER_PAUSE,NULL);
}
break;
case ACTION_AUD_ResumePlay:
{
BRCM_AUDIO_Param_Resume_t* param_resume = (BRCM_AUDIO_Param_Resume_t*) arg_param;
AUDIO_DRIVER_Ctrl(param_resume->drv_handle,AUDIO_DRIVER_GET_DRV_TYPE,(void*)&drv_type);
AUDIO_DRIVER_Ctrl(param_resume->drv_handle,AUDIO_DRIVER_RESUME,NULL);
if( sgTableIDChannelOfDev[param_resume->substream_number].speaker == AUDCTRL_SPK_BTM )
{
AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, sgTableIDChannelOfDev[param_resume->substream_number].speaker, param_resume->rate);
// Enable the playback the path
AUDCTRL_EnablePlay(AUDIO_HW_NONE,
sgTableIDChannelOfDev[param_resume->substream_number].hw_id,
AUDIO_HW_TAP_VOICE,
sgTableIDChannelOfDev[param_resume->substream_number].speaker,
param_resume->channels,
param_resume->rate
);
}
else
{
// Enable the playback the path
AUDCTRL_EnablePlay(AUDIO_HW_NONE,
sgTableIDChannelOfDev[param_resume->substream_number].hw_id,
AUDIO_HW_NONE,
sgTableIDChannelOfDev[param_resume->substream_number].speaker,
param_resume->channels,
param_resume->rate
);
}
}
break;
case ACTION_AUD_StartRecord:
{
AudioApp_t app_prof = AUDIO_APP_RECORDING;
AudioMode_t new_mode = AUDIO_MODE_SPEAKERPHONE;
AudioMode_t cur_mode;
BRCM_AUDIO_Param_Start_t* param_start = (BRCM_AUDIO_Param_Start_t*) arg_param;
DEBUG("ACTION_AUD_StartRecord : param_start->substream_number - %d \n",param_start->substream_number);
prev_app_profile = AUDDRV_GetAudioApp();
cur_mode = AUDCTRL_GetAudioMode();
if ( cur_mode >= AUDIO_MODE_NUMBER )
cur_mode = (AudioMode_t) (cur_mode - AUDIO_MODE_NUMBER);
if (param_start->substream_number == 6 || param_start->substream_number == 7) // record request with Google voice search profile
{
app_prof = AUDIO_APP_RECORDING_GVS;
mode_restore = TRUE;
prev_mode_profile = cur_mode;
DEBUG("ACTION_AUD_StartRecord : [%d, %d]", prev_app_profile, prev_mode_profile);
}
if (param_start->substream_number == 9 || param_start->substream_number == 10) // record request with voip profile
{
app_prof = AUDIO_APP_VOIP;
new_mode = cur_mode; // use current mode based on earpiece or speaker
}
if (param_start->substream_number == 11 || param_start->substream_number == 12) // record request with voip incomm profile
{
app_prof = AUDIO_APP_VOIP_INCOMM;
new_mode = cur_mode; // use current mode based on earpiece or speaker
}
if (param_start->substream_number == 1 || param_start->substream_number == 7 || param_start->substream_number == 8
|| param_start->substream_number == 10 || param_start->substream_number == 12) // record request with auxilary mic
new_mode = AUDIO_MODE_HEADSET;
app_profile = AUDIO_Policy_Get_Profile(app_prof);
new_mode = AUDIO_Policy_Get_Mode(new_mode);
AUDCTRL_SaveAudioModeFlag(new_mode,app_profile);
AUDCTRL_EnableRecord(sgTableIDChannelOfCaptDev[param_start->substream_number].hw_id,
AUDIO_HW_NONE,
sgTableIDChannelOfCaptDev[param_start->substream_number].mic,
param_start->channels,
param_start->rate);
AUDIO_DRIVER_Ctrl(param_start->drv_handle,AUDIO_DRIVER_START,NULL);
AUDIO_Policy_SetState(BRCM_STATE_RECORD);
}
break;
case ACTION_AUD_StopRecord:
{
BRCM_AUDIO_Param_Stop_t* param_stop = (BRCM_AUDIO_Param_Stop_t*) arg_param;
AUDIO_DRIVER_Ctrl(param_stop->drv_handle,AUDIO_DRIVER_STOP,NULL);
if (mode_restore)
{
mode_restore = FALSE;
AUDCTRL_SaveAudioModeFlag( prev_mode_profile, prev_app_profile );
DEBUG("ACTION_AUD_StartRecord : [%d, %d]", prev_app_profile, prev_mode_profile);
}
else
{
AUDCTRL_SaveAudioModeFlag( AUDDRV_GetAudioMode(), prev_app_profile );
}
AUDCTRL_DisableRecord(sgTableIDChannelOfCaptDev[param_stop->substream_number].hw_id,
AUDIO_HW_NONE,
sgTableIDChannelOfCaptDev[param_stop->substream_number].mic);
AUDIO_Policy_RestoreState();
}
break;
case ACTION_AUD_OpenPlay:
{
BRCM_AUDIO_Param_Open_t* param_open = (BRCM_AUDIO_Param_Open_t*) arg_param;
param_open->drv_handle = AUDIO_DRIVER_Open(sgTableIDChannelOfDev[param_open->substream_number].drv_type);
DEBUG("param_open->drv_handle - 0x%x \n",param_open->drv_handle);
}
break;
case ACTION_AUD_ClosePlay:
{
BRCM_AUDIO_Param_Close_t* param_close = (BRCM_AUDIO_Param_Close_t*) arg_param;
DEBUG("param_close->drv_handle - 0x%x \n",param_close->drv_handle);
AUDIO_DRIVER_Close(param_close->drv_handle);
}
break;
case ACTION_AUD_OpenRecord:
{
BRCM_AUDIO_Param_Open_t* param_open = (BRCM_AUDIO_Param_Open_t*) arg_param;
param_open->drv_handle = AUDIO_DRIVER_Open(sgTableIDChannelOfCaptDev[param_open->substream_number].drv_type);
DEBUG("param_open->drv_handle - 0x%x \n",param_open->drv_handle);
}
break;
case ACTION_AUD_CloseRecord:
{
BRCM_AUDIO_Param_Close_t* param_close = (BRCM_AUDIO_Param_Close_t*) arg_param;
DEBUG("param_close->drv_handle - 0x%x \n",param_close->drv_handle);
AUDIO_DRIVER_Close(param_close->drv_handle);
}
break;
case ACTON_VOICECALL_START:
{
BRCM_VOICE_Param_Start_t* param_voice_start = (BRCM_VOICE_Param_Start_t*)arg_param;
int vol_level;
telephony_stream_number = param_voice_start->substream_number;
if ( telephony_codecId == 10 )
{
DEBUG("Enable telephony WB Call \r\n");
app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_VOICE_CALL_WB);
AUDCTRL_SaveAudioModeFlag( sgTableIDChannelOfVoiceCallDev[telephony_stream_number-VOICE_CALL_SUB_DEVICE].speaker + AUDIO_MODE_NUMBER,app_profile);
}
else if ( telephony_codecId == 6 )
{
DEBUG("Enable telephony NB Call \r\n");
app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_VOICE_CALL);
AUDCTRL_SaveAudioModeFlag( sgTableIDChannelOfVoiceCallDev[telephony_stream_number-VOICE_CALL_SUB_DEVICE].speaker,app_profile);
}
else
{
DEBUG("Enable telephony Invalid Codec : Setting as NB \r\n");
app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_VOICE_CALL);
AUDCTRL_SaveAudioModeFlag( sgTableIDChannelOfVoiceCallDev[telephony_stream_number-VOICE_CALL_SUB_DEVICE].speaker,app_profile);
}
if ( (telephony_stream_number-VOICE_CALL_SUB_DEVICE) == 4 )
{
if ( telephony_codecId == 10 )
{
DEBUG("Enable telephony WB Call for BT NREC \r\n");
app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_VOICE_CALL_WB);
AUDCTRL_SaveAudioModeFlag(AUDCTRL_SPK_HANDSFREE, app_profile);
}
else if ( telephony_codecId == 6 )
{
DEBUG("Enable telephony NB Call BT NREC \r\n");
app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_VOICE_CALL);
AUDCTRL_SaveAudioModeFlag(AUDCTRL_SPK_HANDSFREE, app_profile);
}
DEBUG(" Telephony : Turning Off EC and NS \r\n");
//AUDCTRL_EC(FALSE, 0);
//AUDCTRL_NS(FALSE);
}
else
{
DEBUG(" Telephony : Turning On EC and NS \r\n");
//AUDCTRL_EC(TRUE, 0);
//AUDCTRL_NS(TRUE);
}
vol_level= GetCtrlValue(BRCM_CTL_EAR_Playback_Volume);
if(vol_level > 5)
vol_level = 5;
AUDCTRL_SetPlayVolume(AUDIO_HW_VOICE_OUT,AUDCTRL_SPK_HANDSET,AUDIO_GAIN_FORMAT_DSP_VOICE_VOL_GAIN,vol_level,vol_level);
AUDCTRL_RateChangeTelephony();
AUDCTRL_EnableTelephony(AUDIO_HW_VOICE_IN,AUDIO_HW_VOICE_OUT,sgTableIDChannelOfVoiceCallDev[telephony_stream_number-VOICE_CALL_SUB_DEVICE].mic,sgTableIDChannelOfVoiceCallDev[telephony_stream_number-VOICE_CALL_SUB_DEVICE].speaker);
telephony_started = 1;
if(TRUE==GetCtrlValue(BRCM_CTL_Mic_Capture_Mute))
{
DEBUG("Muting device \r\n");
AUDCTRL_SetTelephonyMicMute(AUDIO_HW_VOICE_OUT,AUDCTRL_MIC_MAIN,TRUE);;
}
AUDIO_Policy_SetState(BRCM_STATE_INCALL);
}
break;
case ACTON_VOICECALL_STOP:
{
BRCM_VOICE_Param_Stop_t* param_voice_stop = (BRCM_VOICE_Param_Stop_t*)arg_param;
telephony_stream_number = param_voice_stop->substream_number;
DEBUG("DISABLE TELEPHONY substream = %d \r\n", telephony_stream_number);
AUDCTRL_DisableTelephony(AUDIO_HW_VOICE_IN,AUDIO_HW_VOICE_OUT,sgTableIDChannelOfVoiceCallDev[telephony_stream_number-VOICE_CALL_SUB_DEVICE].mic,sgTableIDChannelOfVoiceCallDev[telephony_stream_number-VOICE_CALL_SUB_DEVICE].speaker);
telephony_started = 0;
AUDIO_Policy_RestoreState();
}
break;
case ACTON_VOICECALL_UPDATE:
{
int local_sub_stream_number = 0;
BRCM_VOICE_Param_Update_t* param_voice_update = (BRCM_VOICE_Param_Update_t*)arg_param;
DEBUG("TELEPHONY UPDATE codecId = %d \r\n", param_voice_update->voicecall_codecId);
if ( telephony_codecId != param_voice_update->voicecall_codecId )
{
telephony_codecId = param_voice_update->voicecall_codecId;
if (telephony_started)
{
if ( telephony_codecId == 10 )
{
app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_VOICE_CALL_WB);
DEBUG("call_CodedId_hander : changing Mode to AMR-WB ===>\r\n");
AUDCTRL_SaveAudioModeFlag( sgTableIDChannelOfVoiceCallDev[telephony_stream_number - VOICE_CALL_SUB_DEVICE].speaker + AUDIO_MODE_NUMBER,app_profile);
DEBUG("call_CodedId_hander : changing Mode to AMR-WB <===\r\n");
}
else
{
app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_VOICE_CALL);
DEBUG("call_CodedId_hander : changing Mode to AMR-NB ===>\r\n");
AUDCTRL_SaveAudioModeFlag( sgTableIDChannelOfVoiceCallDev[telephony_stream_number - VOICE_CALL_SUB_DEVICE].speaker,app_profile );
DEBUG("call_CodedId_hander : changing Mode to AMR-NB <===\r\n");
}
DEBUG("call_CodedId_hander : AUDCTRL_RateChangeTelephony ===>\r\n");
if ( musicduringcall == TRUE )
{
local_sub_stream_number = (telephony_stream_number - VOICE_CALL_SUB_DEVICE)*2;
// wired headphone
if(telephony_stream_number == 17)
{
// set the substream number to same as headset
local_sub_stream_number = 4;
}
AUDCTRL_DisableTap (AUDIO_HW_TAP_VOICE);
if ( app_profile == AUDIO_APP_VOICE_CALL )
{
AUDCTRL_RateChangeTelephony();
if( sgTableIDChannelOfDev[local_sub_stream_number].speaker == AUDCTRL_SPK_HEADSET ||
sgTableIDChannelOfDev[local_sub_stream_number].speaker == AUDCTRL_SPK_BTM )
{
AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_BTM, 8000);
}
else
{
AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_HEADSET, 8000);
}
}
else
{
AUDCTRL_RateChangeTelephony();
if( sgTableIDChannelOfDev[local_sub_stream_number].speaker == AUDCTRL_SPK_HEADSET )
{
AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_BTM, 16000);
}
else if ( sgTableIDChannelOfDev[local_sub_stream_number].speaker == AUDCTRL_SPK_BTM )
{
AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_BTM, 8000);
}
else
{
AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_HEADSET, 16000);
}
}
}
else
{
AUDCTRL_RateChangeTelephony();
}
DEBUG("call_CodedId_hander : AUDCTRL_RateChangeTelephony <===\r\n");
}
}
}
break;
case ACTON_FM_START:
{
BRCM_FM_Param_Start_t* param_start = (BRCM_FM_Param_Start_t*) arg_param;
app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_FM);
AUDCTRL_SaveAudioModeFlag( sgTableIDChannelOfDev[param_start->substream_number].speaker,app_profile);
// Enable the FM playback the path
AUDCTRL_EnablePlay(AUDIO_HW_I2S_IN,
sgTableIDChannelOfDev[param_start->substream_number].hw_id,
AUDIO_HW_NONE,
sgTableIDChannelOfDev[param_start->substream_number].speaker,
param_start->channels,
param_start->rate
);
// set the slopgain register to max value
// 20110530 FM radio volume is controlled by FM radio chip.
AUDCTRL_SetPlayVolume(sgTableIDChannelOfDev[param_start->substream_number].hw_id,
sgTableIDChannelOfDev[param_start->substream_number].speaker,
AUDIO_GAIN_FORMAT_FM_RADIO_DIGITAL_VOLUME_TABLE,
AUDIO_VOLUME_MAX,
AUDIO_VOLUME_MAX
);
AUDIO_Policy_SetState(BRCM_STATE_FM);
}
break;
case ACTON_FM_STOP:
{
BRCM_FM_Param_Stop_t* param_fm_stop = (BRCM_FM_Param_Stop_t*)arg_param;
//disable the FM playback path
AUDCTRL_DisablePlay(AUDIO_HW_I2S_IN,
sgTableIDChannelOfDev[param_fm_stop->substream_number].hw_id,
sgTableIDChannelOfDev[param_fm_stop->substream_number].speaker
);
AUDIO_Policy_RestoreState();
}
break;
case ACTON_ROUTE:
{
BRCM_AUDIO_Param_Route_t* parm_route = (BRCM_AUDIO_Param_Route_t*)arg_param;
DEBUG("ACTON_ROUTE \n");
if(playback_triggered == 1){
if(parm_route->command == 1)
{
DEBUG(" ADDING SPK - %d \n",parm_route->speaker);
AUDCTRL_AddPlaySpk(AUDIO_HW_PLR_OUT,
parm_route->speaker
);
extra_speaker = 1;
}
else if (parm_route->command == 0)
{
DEBUG(" REMOVING SPK - %d \n",parm_route->speaker);
AUDCTRL_RemovePlaySpk(AUDIO_HW_PLR_OUT,
parm_route->speaker
);
extra_speaker = 0;
}
}
else
{
if(parm_route->command == 1)
extra_speaker = 1;
else if (parm_route->command == 0)
extra_speaker = 0;
}
}
break;
default:
DEBUG("Error AUDIO_Ctrl_Process Invalid acction command \n");
}
if(block)
{
// put the message in output fifo if waiting
msgAudioCtrl.action_code = action_code;
if(arg_param)
memcpy(&msgAudioCtrl.param, arg_param, sizeof(BRCM_AUDIO_Control_Params_un_t));
else
memset(&msgAudioCtrl.param, 0, sizeof(BRCM_AUDIO_Control_Params_un_t));
msgAudioCtrl.pCallBack = callback;
msgAudioCtrl.block = block;
len = kfifo_in_locked(&sgThreadData.m_pkfifo_out, (unsigned char *)&msgAudioCtrl, sizeof(TMsgAudioCtrl), &sgThreadData.m_lock_out);
if(len != sizeof(TMsgAudioCtrl))
DEBUG("Error AUDIO_Ctrl_Process len=%d expected %d \n", len, sizeof(TMsgAudioCtrl));
#if 1
// release the semaphore
DEBUG("Semaphore released - %d \n",action_code);
OSSEMAPHORE_Release(sgThreadData.action_complete);
#endif
}
}
