AudioEqualizer_en_t AUDDRV_GetEquType( AUDDRV_TYPE_Enum_t path )
{
#if ( defined(FUSE_DUAL_PROCESSOR_ARCHITECTURE) && defined(FUSE_APPS_PROCESSOR) )
Log_DebugPrintf(LOGID_AUDIO, " AUDDRV_GetEquType (AP before read from CP) %d \n\r", sEqualizerType);
sEqualizerType = (AudioEqualizer_en_t) audio_control_generic( AUDDRV_CPCMD_READ_AUDVOC_AEQMODE, (UInt32) path, 0, 0, 0, 0 );
Log_DebugPrintf(LOGID_AUDIO, " AUDDRV_GetEquType (AP after read from CP) %d \n\r", sEqualizerType);
#else
UInt16 * ptr=0;
// PCG could chagned the equ type from PC.
// Read equ type from sysinterface/dsp/audio/audioapi.c.
ptr = (UInt16 *) AUDIO_GetAudioParam( PARAM_AUDVOC_AEQMODE );
sEqualizerType = (AudioEqualizer_en_t) *ptr;
Log_DebugPrintf(LOGID_AUDIO, " AUDDRV_GetEquType (CP) %d \n\r", sEqualizerType);
#endif
return sEqualizerType;
}
//============================================================================
//
// Function Name: chal_audiomixertap_EnableNb
//
// Description: Enable or Disable NB MIXER TAP
//
//============================================================================
cVoid chal_audiomixertap_EnableNb(
CHAL_HANDLE handle,
Boolean enable
)
{
Log_DebugPrintf(LOGID_SOC_AUDIO_DETAIL, "chal_audiomixertap_EnableNb: enable = %d", enable );
BRCM_WRITE_REG_FIELD( sMixerTap.base, DSP_AUDIO_BTMIXER_CFG2_R, BTNB_ENABLE, enable );
}
//============================================================================
//
// Function Name: chal_audiomixertap_DisableWbAudInt
//
// Description: Disable audio interrupt in WB mixer Tap
//
//============================================================================
cVoid chal_audiomixertap_DisableWbAudInt(
CHAL_HANDLE handle,
Boolean disable
)
{
Log_DebugPrintf(LOGID_SOC_AUDIO_DETAIL, "chal_audiomixertap_DisableWbAudInt" );
BRCM_WRITE_REG_FIELD( sMixerTap.base, DSP_AUDIO_BTMIXER_CFG_R, BTMIXER_WBINTDIS, disable );
}
//============================================================================
//
// Function Name: chal_audiomixertap_EnableWbDma
//
// Description: Enable DMA in WB mixer Tap
//
//============================================================================
cVoid chal_audiomixertap_EnableWbDma(
CHAL_HANDLE handle,
Boolean enable
)
{
Log_DebugPrintf(LOGID_SOC_AUDIO_DETAIL, "chal_audiomixertap_EnableWbDma" );
BRCM_WRITE_REG_FIELD( sMixerTap.base, DSP_AUDIO_BTMIXER_CFG_R, BTMIXER_DMA_EN, enable );
}
// ==========================================================================
//
// Function Name: BTW_DMA_CB
//
// Description: The callback function when there is DMA request to audio path
//
// =========================================================================
static void BTW_DMA_CB(OSDAL_DMA_CALLBACK_STATUS status)
{
CSL_AUDVOC_Drv_t *audDrv = NULL;
Log_DebugPrintf(LOGID_SOC_AUDIO, "BTW_DMA_CB:: DMA callback.\n");
if (status != OSDAL_ERR_OK)
{
Log_DebugPrintf(LOGID_SOC_AUDIO, "BTW_DMA_CB:: Fatal error! DMA transfer failure.\n");
return;
}
audDrv = GetDriverByType(CSL_AUDVOC_STREAM_BTW);
if (audDrv->dmaCB != NULL)
audDrv->dmaCB(audDrv->streamID);
}
//============================================================================
//
// Function Name: AUDIO_DRIVER_Write
//
// Description: This function is used to set the ring buffer pointer and size from which data
// has to be written.
//
//============================================================================
void AUDIO_DRIVER_Write(AUDIO_DRIVER_HANDLE_t drv_handle,
UInt8* pBuf,
UInt32 nBufSize)
{
Log_DebugPrintf(LOGID_AUDIO,"AUDIO_DRIVER_Write:: \n" );
return;
}
// ==========================================================================
//
// Function Name: csl_audvoc_capture_init
//
// Description: Init audio path capture.
//
// =========================================================================
UInt32 csl_audio_capture_init( CSL_AUDIO_DEVICE_e source, CSL_AUDIO_DEVICE_e sink )
{
OSDAL_DMA_CLIENT srcClient = OSDAL_DMA_CLIENT_AUDIO_IN_FIFO;
CSL_AUDVOC_Drv_t *audDrv = NULL;
UInt32 streamID = CSL_AUDVOC_STREAM_NONE;
Log_DebugPrintf(LOGID_SOC_AUDIO, "csl_audvoc_capture_init:: \n");
if (source == CSL_AUDVOC_DEV_CAPTURE_BTW)
srcClient = OSDAL_DMA_CLIENT_AUDIO_WB_MIXERTAP;
// Get DMA channel
if(OSDAL_DMA_Obtain_Channel(srcClient, OSDAL_DMA_CLIENT_MEMORY, &dmaChAudio) != OSDAL_ERR_OK)
{
Log_DebugPrintf(LOGID_SOC_AUDIO, "csl_audvoc_capture_init:: Error, Obtain channel failed.\n");
return CSL_AUDVOC_STREAM_NONE;
}
Log_DebugPrintf(LOGID_SOC_AUDIO, "csl_audvoc_capture_init:: DMA channel for audio path capture 0x%x\n", dmaChAudio);
if (source == CSL_AUDVOC_DEV_CAPTURE_AUDIO)
{
streamID = CSL_AUDVOC_STREAM_AUDIO;
}
else if (source == CSL_AUDVOC_DEV_CAPTURE_BTW)
{
streamID = CSL_AUDVOC_STREAM_BTW;
}
else
{
return streamID;
}
audDrv = GetDriverByType (streamID);
if (audDrv == NULL)
return CSL_AUDVOC_STREAM_NONE;
memset(audDrv, 0, sizeof(CSL_AUDVOC_Drv_t));
audDrv->streamID = streamID;
audDrv->source = source;
audDrv->sink = sink;
audDrv->dmaCH = dmaChAudio;
return audDrv->streamID;
}
void EEM_RegisterRecvCb(eem_cb_t *cbs)
{
if(!cbs)
{
Log_DebugPrintf(LOGID_SYSEEMRPC, "EEM_RegisterRecvCb NULL cbs");
return;
}
memcpy(&sEemCb, cbs, sizeof(eem_cb_t));
}
static SysAudioParm_t* AudioParmAccessor(UInt32 app,UInt32 mode)
{
SysAudioParm_t* parm_ptr;
SysAudioParm_t** p_parm_ptr;
Log_DebugPrintf(LOGID_AUDIO,"\n app - %d mode - %d\n",app,mode);
parm_ptr = SYSPARM_GetExtAudioParmAccessPtr(app);
p_parm_ptr =(SysAudioParm_t**)parm_ptr;
Log_DebugPrintf(LOGID_AUDIO,"\n volume_max - %d\n",p_parm_ptr[0][mode].voice_volume_max);
Log_DebugPrintf(LOGID_AUDIO,"\n ext_speaker_pga - %d\n",p_parm_ptr[0][mode].ext_speaker_pga);
return &p_parm_ptr[0][mode];
}
//============================================================================
//
// Function Name: AUDIO_DRIVER_UpdateBuffer
//
// Description: This function is used to update the buffer indexes
//
//============================================================================
void AUDIO_DRIVER_UpdateBuffer (AUDIO_DRIVER_HANDLE_t drv_handle,
UInt8* pBuf,
UInt32 nBufSize,
UInt32 nCurrentIndex,
UInt32 nSize)
{
Log_DebugPrintf(LOGID_AUDIO,"AUDIO_DRIVER_UpdateBuffer:: \n" );
return;
}
// ==========================================================================
//
// Function Name: csl_audvoc_render_init
//
// Description: Init the audio path render
//
// =========================================================================
UInt32 csl_audio_render_init (CSL_AUDIO_DEVICE_e source, CSL_AUDIO_DEVICE_e sink)
{
OSDAL_DMA_CLIENT dstClient = OSDAL_DMA_CLIENT_AUDIO_OUT_FIFO;
CSL_AUDVOC_Drv_t *audDrv = NULL;
UInt32 streamID = CSL_AUDVOC_STREAM_NONE;
if (sink == CSL_AUDVOC_DEV_RENDER_POLYRINGER)
dstClient = OSDAL_DMA_CLIENT_POLYRING_OUT_FIFO;
// Get DMA channel
if(OSDAL_DMA_Obtain_Channel(OSDAL_DMA_CLIENT_MEMORY, dstClient, &dmaChAudio) != OSDAL_ERR_OK)
{
Log_DebugPrintf(LOGID_SOC_AUDIO, "csl_audvoc_render_init:: Error, Obtain channel failed.\n");
return CSL_AUDVOC_STREAM_NONE;
}
Log_DebugPrintf(LOGID_SOC_AUDIO, "csl_audvoc_render_init:: DMA channel for audio path render 0x%x\n", dmaChAudio);
if (sink == CSL_AUDVOC_DEV_RENDER_AUDIO)
{
streamID = CSL_AUDVOC_STREAM_AUDIO;
}
else if (sink == CSL_AUDVOC_DEV_RENDER_POLYRINGER)
{
streamID = CSL_AUDVOC_STREAM_POLYRINGER;
}
else
{
return streamID;
}
audDrv = GetDriverByType (streamID);
if (audDrv == NULL)
return CSL_AUDVOC_STREAM_NONE;
memset(audDrv, 0, sizeof(CSL_AUDVOC_Drv_t));
audDrv->streamID = streamID;
audDrv->source = source;
audDrv->sink = sink;
audDrv->dmaCH = dmaChAudio;
return audDrv->streamID;
}
//============================================================================
//
// Function Name: AUDIO_DRIVER_CaptureFMCallback
//
// Description: This function processes the callback from the dma
//
//============================================================================
static Boolean AUDIO_DRIVER_CaptureFMCallback(Boolean ok)
{
//Log_DebugPrintf(LOGID_AUDIO,"AUDIO_DRIVER_CaptureFMCallback::\n");
if((audio_capture_driver == NULL))
{
Log_DebugPrintf(LOGID_AUDIO, "AUDIO_DRIVER_CaptureFMCallback:: Spurious call back\n");
return 0;
}
if(audio_capture_driver->pCallback != NULL)
{
audio_capture_driver->pCallback(audio_capture_driver);
}
else
Log_DebugPrintf(LOGID_AUDIO, "AUDIO_DRIVER_CaptureFMCallback:: No callback registerd\n");
return 0;
}
static void AUDIO_DRIVER_RenderDmaCallback(UInt32 stream_id)
{
//Log_DebugPrintf(LOGID_AUDIO,"AUDIO_DRIVER_RenderDmaCallback::\n");
if((audio_render_driver == NULL))
{
Log_DebugPrintf(LOGID_AUDIO, "AUDIO_DRIVER_RenderDmaCallback:: Spurious call back\n");
return;
}
if(audio_render_driver->pCallback != NULL)
{
audio_render_driver->pCallback(audio_render_driver);
}
else
Log_DebugPrintf(LOGID_AUDIO, "AUDIO_DRIVER_RenderDmaCallback:: No callback registerd\n");
return;
}
// ==========================================================================
//
// Function Name: CheckBufDoneUponStop
//
// Description: Check if there is a pending buffer done CB when we are stopping
//
// =========================================================================
static void CheckBufDoneUponStop (VORENDER_Drv_t *audDrv)
{
// If a buffer has been copied to driver queue and bufDoneCB is not called,
// we need to call the buffer done
if (audDrv->srcBufCopied < audDrv->srcBufSize)
{
Log_DebugPrintf(LOGID_SOC_AUDIO, "%s Catch a pending bufDoneCB! total buffer size 0x%x, copied buffer size 0x%x.", __FUNCTION__, audDrv->srcBufSize, audDrv->srcBufCopied);
audDrv->bufDoneCb (audDrv->srcBuf, audDrv->srcBufCopied, audDrv->drvType);
}
}
void AUDDRV_SetEquType(
AUDDRV_TYPE_Enum_t path,
AudioEqualizer_en_t equ_id
)
{
#if ( defined(FUSE_DUAL_PROCESSOR_ARCHITECTURE) && defined(FUSE_APPS_PROCESSOR) )
sEqualizerType = equ_id;
Log_DebugPrintf(LOGID_AUDIO, " AUDDRV_SetEquType (AP) %d \n\r", sEqualizerType);
audio_control_generic( AUDDRV_CPCMD_WRITE_AUDVOC_AEQMODE, (UInt32) equ_id, 0, 0, 0, 0 );
#else
SysCalDataInd_t* pSysparm;
pSysparm = SYSPARM_GetAudioParmAccessPtr();
sEqualizerType = equ_id;
Log_DebugPrintf(LOGID_AUDIO, " AUDDRV_SetEquType (CP) %d \n\r", sEqualizerType);
// CP: update audvoc_aeqMode in sysinterface/dsp/audio/audioapi.c
AUDIO_SetAudioParam( PARAM_AUDVOC_AEQMODE, (void *) & sEqualizerType );
//set these parameters
AUDDRV_SetFilter( AUDDRV_AEQPATHGAIN, (const UInt16 *)& pSysparm->AUDVOC_AEQPATHGAIN[ sEqualizerType ][0] );
AUDDRV_SetFilter( AUDDRV_AEQ, (const UInt16 *)& pSysparm->AUDVOC_AEQCOF[ sEqualizerType ][0] );
AUDDRV_SetFilter( AUDDRV_PEQPATHGAIN, (const UInt16 *)& pSysparm->AUDVOC_PEQPATHGAIN[ sEqualizerType ][0] );
AUDDRV_SetFilter( AUDDRV_PEQ, (const UInt16 *)& pSysparm->AUDVOC_PEQCOF[ sEqualizerType ][0] );
//AUDDRV_SetFilter( AUDDRV_PEQPATHOFST, (const UInt16 *)& pSysparm->AUDVOC_PEQCOF[ sEqualizerType ][0] );
//to remove this after the sys parm are readable at AP
AUDDRV_SetFilter( AUDDRV_AFIR, (const UInt16 *) & SYSPARM_GetAudioParmAccessPtr()->AUDVOC_ADAC_FIR[0] );
Log_DebugPrintf(LOGID_AUDIO, " AUDDRV_SetEquType (CP) FIR [0] %x, [32] %x, [33] %x \n\r",
SYSPARM_GetAudioParmAccessPtr()->AUDVOC_ADAC_FIR[0],
SYSPARM_GetAudioParmAccessPtr()->AUDVOC_ADAC_FIR[32],
SYSPARM_GetAudioParmAccessPtr()->AUDVOC_ADAC_FIR[33]
);
#endif
}
// ==========================================================================
//
// Function Name: csl_audio_render_resume
//
// Description: Resume the data transfer of audio path render
//
// =========================================================================
Result_t csl_audio_render_resume( UInt32 streamID )
{
Log_DebugPrintf(LOGID_SOC_AUDIO, "csl_audvoc_render_resume streamID=%d.\n", streamID);
#if 0
if (streamID == CSL_AUDVOC_STREAM_AUDIO)
{
// pre-fill fifo
UInt32 zeroSamples[CHAL_AOFIFO_SIZE] = {0};
chal_audioaopath_WriteFifo (NULL, &zeroSamples[0], CHAL_AOFIFO_SIZE);
// enable DMA
AUDDRV_EnableHWOutput (
AUDDRV_AUDIO_OUTPUT,
AUDDRV_SPKR_NONE, //this param bears no meaning in this context.
FALSE, //this param bears no meaning in this context.
AUDIO_SAMPLING_RATE_UNDEFINED, //this param bears no meaning in this context.
AUDIO_CHANNEL_STEREO,
AUDDRV_REASON_DATA_DRIVER
);
}
else if (streamID == CSL_AUDVOC_STREAM_POLYRINGER)
{
// pre-fill fifo
UInt32 zeroSamples[CHAL_POFIFO_SIZE] = {0};
chal_audiopopath_WriteFifo (NULL, &zeroSamples[0], CHAL_POFIFO_SIZE);
// enable DMA
AUDDRV_EnableHWOutput (
AUDDRV_RINGTONE_OUTPUT,
AUDDRV_SPKR_NONE, //this param bears no meaning in this context.
FALSE, //this param bears no meaning in this context.
AUDIO_SAMPLING_RATE_UNDEFINED, //this param bears no meaning in this context.
AUDIO_CHANNEL_STEREO,
AUDDRV_REASON_DATA_DRIVER
);
}
#else
if (streamID == CSL_AUDVOC_STREAM_AUDIO)
{
// pre-fill fifo
UInt32 zeroSamples[CHAL_AOFIFO_SIZE] = {0};
chal_audioaopath_WriteFifo (NULL, &zeroSamples[0], CHAL_AOFIFO_SIZE);
// enable DMA
chal_audioaopath_EnableDMA(NULL, TRUE);
}
else if (streamID == CSL_AUDVOC_STREAM_POLYRINGER)
{
// pre-fill fifo
UInt32 zeroSamples[CHAL_POFIFO_SIZE] = {0};
chal_audiopopath_WriteFifo (NULL, &zeroSamples[0], CHAL_POFIFO_SIZE);
// enable DMA
chal_audiopopath_EnableDMA(NULL, TRUE);
}
#endif
return RESULT_OK;
}
void AUDDRV_Disable_Output ( AUDDRV_InOut_Enum_t path )
{
#if defined(FUSE_APPS_PROCESSOR)
switch(path)
{
case AUDDRV_VOICE_OUTPUT:
Log_DebugPrintf(LOGID_AUDIO, "\n\r\t* AUDDRV_Disable_Output *\n\r" );
if(inVoiceCall != TRUE)
{
if ( voiceInPathEnabled==FALSE )
{
//if inVoiceCall== TRUE, assume the telphony_init() function sends ENABLE and CONNECT_DL
audio_control_dsp(DSPCMD_TYPE_AUDIO_CONNECT_DL, 0, 0, 0, 0, 0 );
audio_control_dsp(DSPCMD_TYPE_AUDIO_ENABLE, 0, 0, 0, 0, 0 );
voicePlayOutpathEnabled = FALSE;
Log_DebugPrintf(LOGID_AUDIO, "\n\r\t* AUDDRV_Disable_Output: inVoiceCall = %d, voicePlayOutpathEnabled = %d\n\r", voicePlayOutpathEnabled);
}
}
if (currVoiceSpkr == AUDDRV_SPKR_PCM_IF) //turn off PCM i/f
{
currVoiceSpkr = AUDDRV_SPKR_NONE;
if(currVoiceMic != AUDDRV_MIC_PCM_IF)
VPRIPCMDQ_DigitalSound( FALSE );
} //else, no need to care PCM i/f.
currVoiceSpkr = AUDDRV_SPKR_NONE;
break;
default:
break;
}
OSTASK_Sleep( 3 ); //make sure audio is done
AUDDRV_DisableHWOutput ( path, AUDDRV_REASON_HW_CTRL );
#endif //#if defined(FUSE_APPS_PROCESSOR)
}
// ==========================================================================
//
// Function Name: GetDriverByType
//
// Description: Get the audio render driver reference from the steamID.
//
// =========================================================================
static CSL_AUDVOC_Drv_t* GetDriverByType (UInt32 streamID)
{
CSL_AUDVOC_Drv_t *audDrv = NULL;
if (streamID != CSL_AUDVOC_STREAM_NONE)
audDrv = &sAudvocDrv[streamID];
else
Log_DebugPrintf(LOGID_SOC_AUDIO, "%s GetDriverByType:: Doesn't support audio driver streamID = 0x%x\n", __FILE__, streamID);
return audDrv;
}
// =========================================================================
// Function Name: AMRWB_Render_Request
//
// Description: DSP AMRWB Request new data. The DSP interrupt handler will call it to request
// new data.
//====================================================================================
void AMRWB_Render_Request(VPStatQ_t reqMsg)
{
VORENDER_MSG_t msg;
VORENDER_Drv_t *audDrv = NULL;
// we may still get dsp int after task is gone, ignore these late fellows
audDrv = GetDriverByType (VORENDER_TYPE_AMRWB);
if ((audDrv == NULL) || (audDrv->isRunning == FALSE))
{
Log_DebugPrintf(LOGID_AUDIO, "## [AMRWB][%s] entered wrong state ##\n", __FUNCTION__);
return;
}
memset (&msg, 0, sizeof(VORENDER_MSG_t));
switch (reqMsg.status)
{
case VP_STATUS_PRAM_CODEC_DONEPLAY:
// dsp finishes play, need to stop.
OSSEMAPHORE_Release (audDrv->stopDspAmrWbSema);
break;
case VP_STATUS_PRAM_CODEC_INPUT_EMPTY:
case VP_STATUS_PRAM_CODEC_INPUT_LOW:
msg.msgID = VORENDER_MSG_SHM_REQUEST;
msg.parm1 = reqMsg.arg1; //dsp_read_index
msg.parm2 = reqMsg.arg2; //dsp_write_index
OSQUEUE_Post(sAMRWB_Drv.msgQueue, (QMsg_t*)&msg, TICKS_FOREVER);
break;
#if 0 // not supported by DSP since Athena
case VP_STATUS_PRAM_CODEC_CANCELPLAY:
// dsp cancels play, need to stop immediately.
// should go through normal process, set done flag, disble vpu stuff ???
msg.msgID = VORENDER_MSG_STOP;
OSQUEUE_Post(sAMRWB_Drv.msgQueue, (QMsg_t*)&msg, TICKS_FOREVER);
break;
#endif
default:
Log_DebugPrintf(LOGID_AUDIO, "## [AMRWB][%s] received unknown msg ##\n", __FUNCTION__);
break;
}
}
void AUDDRV_Telephony_SelectMicSpkr (
AUDDRV_MIC_Enum_t mic,
AUDDRV_SPKR_Enum_t speaker )
{
Log_DebugPrintf(LOGID_AUDIO, "\n\r\t* AUDDRV_Telephony_SelectMicSpkr (1) mic %d, spkr %d *\n\r", mic, speaker);
#if defined(FUSE_APPS_PROCESSOR)
#if defined(THUNDERBIRD)
//thunderbird, loud speaker go to PMU
if( currVoiceMic == mic && currVoiceSpkr == speaker)
return;
#else
//AthenaRay board
// loud speaker should go to PMU, but right now, using the same as HANDSET
//if( currVoiceMic == mic && currVoiceSpkr == speaker)
// return;
#endif
Log_DebugPrintf(LOGID_AUDIO, "\n\r\t* AUDDRV_Telephony_SelectMicSpkr (2) mic %d, spkr %d *\n\r", mic, speaker);
currVoiceMic = mic;
currVoiceSpkr = speaker;
//need to follow the sequence. avoid enable again
AUDDRV_SelectSpkr( AUDDRV_VOICE_OUTPUT, speaker, AUDDRV_SPKR_NONE );
//select mic input, include DMIC support
AUDDRV_SelectMic( AUDDRV_VOICE_INPUT, mic);
//if( speaker == AUDDRV_SPKR_PCM_IF || mic==AUDDRV_MIC_PCM_IF )
if( mic==AUDDRV_MIC_PCM_IF )
{
//use audio_control_dsp( ), and combine this file with csl_aud_drv_hw.c
AUDDRV_SetPCMOnOff( 1 );
}
else
{
AUDDRV_SetPCMOnOff( 0 );
}
#endif //#if defined(FUSE_APPS_PROCESSOR)
}
void EEM_Init(void)
{
RPC_Result_t result;
result = RPC_PACKET_RegisterDataInd (0,INTERFACE_USB_EEM, EEM_DataIndCb, EEM_FlowControlCb);
Log_DebugPrintf(LOGID_SYSEEMRPC, "AP EEM_Init result:%d", result);
eem_data_Queue = OSQUEUE_Create(QUEUESIZE_EEM, sizeof(EEM_QueueEntry_t), OSSUSPEND_PRIORITY);
OSQUEUE_ChangeName (eem_data_Queue, "EEMQ");
OSTASK_Create( eemDataTask_Entry, (TName_t)"EEMT", NORMAL, STACKSIZE_MSC*2);
}
// ==========================================================================
//
// Function Name: csl_audvoc_capture_pause
//
// Description: Pause the data transfer of the audio path capture
//
// =========================================================================
Result_t csl_audio_capture_pause( UInt32 streamID )
{
Log_DebugPrintf(LOGID_AUDIO, " csl_audvoc_capture_pause:: streamID = 0x%x.\n", streamID);
if (streamID == CSL_AUDVOC_STREAM_AUDIO)
chal_audioaipath_EnableDMA(NULL, FALSE);
else if (streamID == CSL_AUDVOC_STREAM_BTW)
chal_audiomixertap_EnableWbDma(NULL, FALSE);
return RESULT_OK;
}
static enum hrtimer_restart hrtimer_callback( struct hrtimer *timer )
{
if ( intr_workqueue )
{
hrtimer_forward_now(timer, ktime);
queue_work(intr_workqueue, &intr_work);
Log_DebugPrintf(LOGID_AUDIO," hrtimer_callback \r\n");
return HRTIMER_RESTART;
}
printk(" hrtimer_callback timer not started again\r\n");
return HRTIMER_NORESTART;
}
//=============================================================================
//
// Function Name: AUDDRV_SetTelephonyMicMute
//
// Description: UL Mute/Unmute
//
//=============================================================================
void AUDDRV_SetTelephonyMicMute(Boolean mute)
{
if( voiceULMute != mute )
{
voiceULMute = mute;
if( AUDDRV_GetVCflag() )
{
if ( !voiceULMute )
{
Log_DebugPrintf(LOGID_AUDIO, "\n\r\t* AUDDRV_SetTelephonyMicMute : DSP UL is unmuted \n\r");
audio_control_dsp( DSPCMD_TYPE_UNMUTE_DSP_UL, 0, 0, 0, 0, 0 );
}
else
{
Log_DebugPrintf(LOGID_AUDIO, "\n\r\t* AUDDRV_SetTelephonyMicMute : DSP UL is muted \n\r");
audio_control_dsp( DSPCMD_TYPE_MUTE_DSP_UL, 0, 0, 0, 0, 0 );
}
}
}
}
// =========================================================================
// Function Name: ARM2SP2_Render_Request
//
// Description: DSP ARM2SP2 Request new data. The DSP interrupt handler will call it to request
// new data.
//====================================================================================
void ARM2SP2_Render_Request(VPStatQ_t reqMsg)
{
VORENDER_MSG_t msg;
Log_DebugPrintf(LOGID_AUDIO, "ARM2SP_Render_Request:: render interrupt callback. arg1 = 0x%x\n", reqMsg.arg1);
memset (&msg, 0, sizeof(VORENDER_MSG_t));
msg.msgID = VORENDER_MSG_SHM_REQUEST;
msg.parm1 = reqMsg.arg1; // buffer position
OSQUEUE_Post(sARM2SP_Drv[AUDDRV_ARM2SP_GetInstanceID(VORENDER_TYPE_PCM_ARM2SP2)].msgQueue, (QMsg_t*)&msg, TICKS_FOREVER);
}
// =========================================================================
// Function Name: VPU_Render_Request
//
// Description: DSP VPU Request new data. The DSP interrupt handler will call it to request
// new data.
//====================================================================================
void VPU_Render_Request(VPStatQ_t reqMsg)
{
VORENDER_MSG_t msg;
Log_DebugPrintf(LOGID_AUDIO, "VPU_Render_Request:: render interrupt callback.\n");
memset (&msg, 0, sizeof(VORENDER_MSG_t));
msg.msgID = VORENDER_MSG_SHM_REQUEST;
msg.parm1 = reqMsg.arg0; // buffer index
OSQUEUE_Post(sVPU_Drv.msgQueue, (QMsg_t*)&msg, TICKS_FOREVER);
}
//============================================================================
//
// Function Name: chal_audioaopath_SetSlopeGain
//
// Description: Set Left/Right slope gain in Audio Output Path
//
//============================================================================
cVoid chal_audioaopath_SetSlopeGain(
CHAL_HANDLE handle,
cInt32 left_gain,
cInt32 right_gain
)
{
//chal_audio_aopath_t * dev = (chal_audio_aopath_t *) handle;
UInt32 reg_addr;
DSP_AUDIO_ALSLOPGAIN_R_TYPE reg_value = 0;
cInt16 gain=0;
if(left_gain>0 || right_gain>0)
return;
// left gain
gain = (left_gain/25) + 0x1FF;
if (gain<0)
gain=0;
reg_addr = sAOPath.base + DSP_AUDIO_ALSLOPGAIN_R_OFFSET;
reg_value = DSP_AUDIO_ALSLOPGAIN_R_ALSLOPGAINEN_MASK | (SLOPE_GAIN_MODE << DSP_AUDIO_ALSLOPGAIN_R_ALSLOPMOD_SHIFT);
reg_value = reg_value | ( gain << DSP_AUDIO_ALSLOPGAIN_R_ALTARGETGAIN_SHIFT );
*(volatile UInt16 *) reg_addr = reg_value;
Log_DebugPrintf(LOGID_SOC_AUDIO_DETAIL, "chal_audioaopath_SetSlopeGain: left gain=0x%x \n", gain );
// right gain
gain = (right_gain/25) + 0x1FF;
if (gain<0)
gain=0;
reg_addr = sAOPath.base + DSP_AUDIO_ARSLOPGAIN_R_OFFSET;
reg_value = DSP_AUDIO_ARSLOPGAIN_R_ARSLOPGAINEN_MASK | (SLOPE_GAIN_MODE << DSP_AUDIO_ARSLOPGAIN_R_ARSLOPMOD_SHIFT);
reg_value = reg_value | ( gain << DSP_AUDIO_ARSLOPGAIN_R_ARTARGETGAIN_SHIFT );
*(volatile UInt16 *) reg_addr = reg_value;
Log_DebugPrintf(LOGID_SOC_AUDIO_DETAIL, "chal_audioaopath_SetSlopeGain: right gain=0x%x \n", gain );
}
static void IPC_AudioRxTaskEntry( void )
{
Log_DebugPrintf(LOGID_AUDIO, "IPC_AudioRxTaskEntry\n");
while (TRUE)
{
IPC_ProcessEvents();
OSTASK_Sleep( TICKS_ONE_SECOND / 50 );
}
}
//******************************************************************************
// Function Name: CP_Audio_ISR_TaskEntry
//
// Description: This is the task entry to process both audio and VPU related status
//******************************************************************************
static void CP_Audio_ISR_TaskEntry( void )
{
ISRCMD_t cmd;
while(1)
{
OSQUEUE_Pend(qAudioMsg, (QMsg_t *)&cmd, TICKS_FOREVER );
if (cmd.type == TYPE_SEND_IPC_AUDIO_CTRL)
{
StatQ_t msg;
msg = cmd.payload;
Log_DebugPrintf(LOGID_AUDIO, "CP_Audio_ISR_TaskEntry (AUDIO Type): 0x%x : 0x%x : 0x%x :0x%x \r\n",msg.status,msg.arg0,msg.arg1,msg.arg2);
IPC_AudioControlSend((char *)&msg, sizeof(StatQ_t));
}
else
Log_DebugPrintf(LOGID_AUDIO, "CP_Audio_ISR_TaskEntry invalid status type \r\n");
}
}
//**************************************************
void AudioControlAp_DeliveryFunction (IPC_Buffer Buffer)
{
char * Response = IPC_BufferDataPointer (Buffer);
U32 ResponseLength = IPC_BufferDataSize (Buffer);
char dd[256];
//(void) dprintf(5, "\n\nAudioControlCp_DeliveryFunction: Length %d. First 16 bytes...\n\n", ResponseLength);
memcpy(dd, Response, ResponseLength);
#if 0
{
int i=0;
Log_DebugPrintf(LOGID_AUDIO,"\n%02X %02X %02X %02X %02X %02X %02X %02X\n", dd[i], dd[i+1], dd[i+2], dd[i+3], dd[i+4], dd[i+5], dd[i+6], dd[i+7]);
i=8;
Log_DebugPrintf(LOGID_AUDIO,"\n%02X %02X %02X %02X %02X %02X %02X %02X\n", dd[i], dd[i+1], dd[i+2], dd[i+3], dd[i+4], dd[i+5], dd[i+6], dd[i+7]);
i=16;
}
#endif
IPC_process_dsp_interrupt(dd, ResponseLength);
IPC_FreeBuffer (Buffer);
}
