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)
}