rtcodeccomm.cpp

realtek562x系列驱动源码。wince

//-----------------------------------------------------------------
// INCLUDE FILES
//-----------------------------------------------------------------
#include <windows.h>
#include <types.h>
#include <memory.h>
#include <excpt.h>
#include <wavepdd.h>
#include <waveddsi.h>
#include "RTCodecComm.h"

#if USE_I2S_INTERFACE

#include <i2s_control.h>

#else

#include <aclink.h>

#endif

BYTE		   CodecDevId=DEV_AUDIO;	

//*************************************************************************************************************
//initize codec register

CodecRegister Set_Codec_Reg_Init[]=
{
	{RT_SPEAKER_OUT_VOL		,0x0000},//default Speark to 0DB
	{RT_HP_OUT_VOL			,0x0808},//default HP to -12DB
	{RT_ADC_RECORD_MIXER	,0x3F3F},//default Record is MicIn
	{RT_STEREO_DAC_VOL		,0x0808},//default stereo DAC volume
	{RT_MICROPHONE_CTRL		,0x0400},//set boost to +20DB
	{RT_POWERDOWN_CTRL_STAT	,0x0000},//power on all PR bit
	{RT_EQ_ANALOG_CTRL_INDEX,0x0054},//AD_DA_Mixer_internal Register5
	{RT_EQ_ANALOG_CTRL_DATA	,0xE184},//To reduce power consumption for DAC reference

#if USE_CLASS_AB_SPEAKER	

	{RT_OUTPUT_MIXER_CTRL	,0x4b40},//default output mixer control,CLASS AB

#else

	{RT_OUTPUT_MIXER_CTRL	,0x6b40},//default output mixer control,CLASS D	
	
#endif

#if !USE_I2S_INTERFACE

	{RT_TONE_CTRL			,0x0001},//Enable varible sample rate		

#endif

#if USE_I2S_INTERFACE
	
	{RT_MAIN_SDP_CTRL		,0x8000},	//set I2S codec to slave mode

#endif

#if 0//if you need use AVC function,please fill below initize value of AVC,below value only be refer	

	{RT_EQ_ANALOG_CTRL_INDEX,0x0020},//Auto Volume Control Register 0 
	{RT_EQ_ANALOG_CTRL_DATA	,0x0058},//2^11 samples for monitor window control
	{RT_EQ_ANALOG_CTRL_INDEX,0x0021},//Auto Volume Control Register 1 
	{RT_EQ_ANALOG_CTRL_DATA	,0x0400},//Maximum PCM absolute level
	{RT_EQ_ANALOG_CTRL_INDEX,0x0022},//Auto Volume Control Register 2 
	{RT_EQ_ANALOG_CTRL_DATA	,0x0350},//Mimimum PCM absolute level
	{RT_EQ_ANALOG_CTRL_INDEX,0x0023},//Auto Volume Control Register 3 
	{RT_EQ_ANALOG_CTRL_DATA	,0x0001},//Non-active PCM absolute level
	{RT_EQ_ANALOG_CTRL_INDEX,0x0024},//Auto Volume Control Register 4 
	{RT_EQ_ANALOG_CTRL_DATA	,0x03FF},//control the sensitivity to increase Gain
	{RT_EQ_ANALOG_CTRL_INDEX,0x0025},//Auto Volume Control Register 5 
	{RT_EQ_ANALOG_CTRL_DATA	,0x0400},//control the sensitivity to decrease Gain

#endif	
};

#define SET_CODEC_REG_INIT_NUM	(sizeof(Set_Codec_Reg_Init)/sizeof(CodecRegister))

//*************************************************************************************************************
//Hardware EQ 

HW_EQ_PRESET *HwEq_Preset;

HW_EQ_PRESET HwEq_Preset_48k[]={
//		0x0	0x1	0x2  0x3   0x4	0x5	0x6	0x7	0x8	0x9	0xa	0xb	0xc	0x10	
	{CLUB,{0x1F2C,0x13D1,0xC1CB,0x1E5D,0x0C73,0xCD47,0x188D,0x0C73,0xC3B5,0x1CD0,0x0C73,0x1DF8,0x2FB2},0x800E},
	{DANCE,{0x1F2C,0x13D1,0xC070,0x1F95,0x0BCE,0xCA43,0x1A29,0xFA73,0xDEDF,0x0ED8,0xF8B1,0x1DF8,0x2FB2},0x800F},
	{LIVE,{0x1E74,0xFA92,0xC249,0x1DF8,0x2298,0xC882,0x1C10,0x0D73,0xDA40,0x1561,0x0556,0x1DF8,0x2FB2},0x800F},
	{POP,{0x1EB5,0xFCB5,0xC1D3,0x1E5D,0x1FC4,0xD9D7,0x15F6,0xFB53,0xFFFF,0x06D3,0xF804,0x1DF8,0x2FB2},0x800F},
	{ROCK,{0x1EB5,0xFCB5,0xC070,0x1F95,0x0556,0xC3D8,0x1C56,0xF6E7,0x0C5D,0x0FC7,0x4030,0x1DF8,0x2FB2},0x800F},
};

HW_EQ_PRESET HwEq_Preset_44k[]={
//			0x0		0x1		0x2	  0x3	0x4		0x5		0x6		0x7	0x8		0x9		0xa	0xb		0xc		0x10			
	{CLUB ,{0x1DCC,0x13D1,0xC289,0x1E39,0x0C73,0xE1A2,0x17F8,0x0C73,0xC5E5,0x1C8B,0x0C73,0x1180,0x2FB2},0x800E},
	{DANCE,{0x1DCC,0x13D1,0xC08E,0x1F8C,0x0BCE,0xCB7E,0x19B2,0xFA73,0x0655,0x0DBB,0xF8B1,0x1180,0x2FB2},0x800F},
	{LIVE ,{0x1CB9,0xFA92,0xC36D,0x1DCC,0x2298,0xD8CA,0x1BBC,0x0D73,0x0748,0x1496,0x0556,0x1180,0x2FB2},0x800F},
	{POP  ,{0x1D40,0xFCB5,0xC2AE,0x1E39,0x1FC4,0x075E,0x1537,0xFB53,0x23D6,0x056C,0xF804,0x1180,0x2FB2},0x800F},
	{ROCK ,{0x1D40,0xFCB5,0xC08E,0x1F8C,0x0556,0xC4D7,0x1C08,0xF6E7,0x2CAB,0x0EA5,0x4030,0x1180,0x2FB2},0x800F},
};


//*************************************************************************************************************
//store/restore register in the suspend/resume mode
BYTE RestoreRegIndex[]={
						RT_SPEAKER_OUT_VOL,			//0x02
						RT_HP_OUT_VOL,				//0x04
						RT_PHONEIN_MONO_OUT_VOL,	//0x08
						RT_LINE_IN_VOL,				//0x0A
						RT_STEREO_DAC_VOL,			//0x0C
						RT_MIC_VOL,					//0x0E
						RT_MIC_ROUTING_CTRL,		//0x10
						RT_ADC_RECORD_GAIN,			//0x12
						RT_ADC_RECORD_MIXER,		//0x14
						RT_VOICE_DAC_OUT_VOL,		//0x18
						RT_OUTPUT_MIXER_CTRL,		//0x1C
						RT_MICROPHONE_CTRL,			//0x22
						RT_POWERDOWN_CTRL_STAT,		//0x26			

#if USE_I2S_INTERFACE
						RT_MAIN_SDP_CTRL,			//0x34
#else
						RT_TONE_CTRL,				//0x2A
#endif
						RT_MISC_CTRL,				//0X5E
					   };

#define RESTORE_REG_INDEX_NUM	(sizeof(RestoreRegIndex)/sizeof(BYTE))

unsigned short int 	CodecShadowRegisters[RESTORE_REG_INDEX_NUM];


EXT_CODEC_INDEX RestoreExtRegIndex[]={

						HW_EQ_LP0_A1,				//0x00
						HW_EQ_LP0_H0,				//0x01
						HW_EQ_BP1_A1,				//0x02
						HW_EQ_BP1_A2,				//0x03
						HW_EQ_BP1_H0,				//0x04
						HW_EQ_BP2_A1,				//0x05
						HW_EQ_BP2_A2,				//0x06
						HW_EQ_BP2_H0,				//0x07
						HW_EQ_BP3_A1,				//0x08
						HW_EQ_BP3_A2,				//0x09
						HW_EQ_BP3_H0,				//0x0A
						HW_EQ_BP4_A1,				//0x0B
						HW_EQ_HP4_H0,				//0x0C
						HW_EQ_CONTROL,				//0x10
#if USE_CLASS_AB_SPEAKER
						CLASS_AB_REG,				//0x44	
#else
						CLASS_D_REG,				//0x46
#endif
						AD_DA_MIXER_IR5,			//0x54
						};

#define RESTORE_EXTREG_INDEX_NUM	(sizeof(RestoreExtRegIndex)/sizeof(EXT_CODEC_INDEX)) 

unsigned short int 	ExtCodecShadowRegisters[RESTORE_EXTREG_INDEX_NUM];

//------------------------------------------------------------------------
// function implement
//------------------------------------------------------------------------

RT_CodecComm::RT_CodecComm(void)
{
	
}

RT_CodecComm::~RT_CodecComm(void)
{
	
}

//*****************************************************************************	
//
//function:init Class member of codec
//
//*****************************************************************************
BOOL RT_CodecComm::Init(HardwareContext *HwCxt)
{
	m_pHWContext=HwCxt;

	if(!m_pHWContext)
	{
		return FALSE;
	}
	m_WaveOutSampleRate=SAMPLERATE;
	m_WaveInSampleRate=SAMPLERATE;
		
	return TRUE;
}
//*****************************************************************************	
//
//function:implement delay function
//
//*****************************************************************************
void RT_CodecComm::DelayMSTime(unsigned int MilliSec)
{
	if(m_pHWContext)
	{
		m_pHWContext->OSTDelayMilliSecTime(MilliSec);	
	}	
}

//*****************************************************************************
//
//function:Initialize Register of Codec function
//
//*****************************************************************************
BOOL RT_CodecComm::InitRTCodecReg(void)
{
	int i;
	BOOL bRetVal=FALSE;

		ShadowWriteCodec(RT_POWERDOWN_CTRL_STAT,0x0);	//power on all PR bit
	
		WriteCodecRegMask(RT_PWR_MANAG_ADD2,PWR_MIXER_VREF,PWR_MIXER_VREF);	//power on Vref for All analog circuit
		
		WriteCodecRegMask(RT_PWR_MANAG_ADD1,PWR_MAIN_BIAS,PWR_MAIN_BIAS);	//power on main bias

		WriteCodecRegMask(RT_PWR_MANAG_ADD3,PWR_HP_R_OUT|PWR_HP_L_OUT,PWR_HP_R_OUT|PWR_HP_L_OUT);	//power on HP volume AMP	
			
	for(i=0;i<SET_CODEC_REG_INIT_NUM;i++)
	{
		bRetVal=ShadowWriteCodec(Set_Codec_Reg_Init[i].CodecIndex,Set_Codec_Reg_Init[i].wCodecValue); 

		if(!bRetVal)
			break;
	}	
 	
	return bRetVal;
}
//*****************************************************************************
//
//function:Save codec register to shadow
//
//*****************************************************************************
void RT_CodecComm::SaveCodecRegToShadow()
{
	int i;

	for(i=0;i<RESTORE_REG_INDEX_NUM;i++)
	{		
		if(!ShadowReadCodec(RestoreRegIndex[i],&CodecShadowRegisters[i]))
		{
			return;
		}			
	}	
}
//*****************************************************************************
//
//function:restore shadow register to codec
//
//*****************************************************************************
void RT_CodecComm::RestoreRegToCodec()
{
	int i;

	for(i=0;i<RESTORE_REG_INDEX_NUM;i++)
	{
		if(!ShadowWriteCodec(RestoreRegIndex[i],CodecShadowRegisters[i]))
			{
				return;
			}
	}	

}
//*****************************************************************************
//
//function:Save codec extend register to shadow
//
//*****************************************************************************
void RT_CodecComm::SaveCodecExtRegToShadow()
{
	int i;

	for(i=0;i<RESTORE_EXTREG_INDEX_NUM;i++)
	{
		if(!ReadCodecAdvance(RestoreExtRegIndex[i],&ExtCodecShadowRegisters[i]))
		{
			return;
		}
	}	

}
//*****************************************************************************
//
//function:restore shadow extend register to codec
//
//*****************************************************************************
void RT_CodecComm::ReStoreExtRegToCodec()
{
	int i;

	for(i=0;i<RESTORE_EXTREG_INDEX_NUM;i++)
	{
		if(!WriteCodecAdvance(RestoreExtRegIndex[i],ExtCodecShadowRegisters[i]))
		{
			return;
		}
	}	
}

//*****************************************************************************
//
//function:restore shadow read register to codec
//
//*****************************************************************************
BOOL RT_CodecComm::ShadowReadCodec(BYTE Offset, unsigned short int *Data)
{
	BOOL b_retVal;
	
	if(!m_pHWContext)
	{
		return FALSE;
	}
	
	b_retVal=m_pHWContext->SafeReadCodec(Offset,Data ,DEV_AUDIO);	
	
	return b_retVal;
}
//*****************************************************************************
//
//function:restore shadow write register to codec
//
//*****************************************************************************
BOOL RT_CodecComm::ShadowWriteCodec(BYTE Offset, unsigned short int Data)
{
	BOOL b_retVal;
	
	if(!m_pHWContext)
	{
		return FALSE;	
	}	
	
	b_retVal=m_pHWContext->SafeWriteCodec(Offset,Data ,DEV_AUDIO);	

	return b_retVal;
}

//*****************************************************************************
//
//function:write codec register with mask
//
//*****************************************************************************
BOOL RT_CodecComm::WriteCodecRegMask(BYTE Offset, unsigned short int Data,unsigned short int Mask)
{
	BOOL RetVal=FALSE;
	unsigned short int CodecData;

	if(!Mask)
		return RetVal; 

	if(Mask!=ALL_FIELD)
	 {
		if(ShadowReadCodec(Offset,&CodecData))
		{
			CodecData&=~Mask;
			CodecData|=(Data&Mask);
			RetVal=ShadowWriteCodec(Offset,CodecData);
		}
	 }		
	else
	{
		RetVal=ShadowWriteCodec(Offset,Data);
	}

	return RetVal;
}
//*****************************************************************************
//
//function:Write advance register of codec
//
//*****************************************************************************
BOOL RT_CodecComm::WriteCodecAdvance(EXT_CODEC_INDEX Ext_Index,unsigned short int Ext_Data)
{
	BOOL RetVal=FALSE;
			
		RetVal=ShadowWriteCodec(RT_EQ_ANALOG_CTRL_INDEX,Ext_Index);	// write codec advance index

		if(RetVal)
		{
			RetVal=ShadowWriteCodec(RT_EQ_ANALOG_CTRL_DATA,Ext_Data);//write codec advance data
		}		
			
		return  RetVal;	
			
}
//*****************************************************************************
//
//function:Read advance register of codec
//
//*****************************************************************************
BOOL RT_CodecComm::ReadCodecAdvance(EXT_CODEC_INDEX Ext_Index,unsigned short int *Data)
{
	BOOL RetVal=FALSE;		

	RetVal=ShadowWriteCodec(RT_EQ_ANALOG_CTRL_INDEX,Ext_Index);	// write codec advance index		

	if(RetVal)
	 {
		RetVal=ShadowReadCodec(RT_EQ_ANALOG_CTRL_DATA,Data);	// read codec advance data			
	 }

	return RetVal;
}
//*****************************************************************************
//
//function:Write advance register of codec compare with Mask bit
//
//*****************************************************************************

BOOL RT_CodecComm::WriteCodecAdvanceMask(EXT_CODEC_INDEX Ext_Index,unsigned short int Ext_Data,unsigned short int Ext_Data_Mask)
{
	
	unsigned short int CodecAdvData;
	BOOL RetVal=FALSE;

	if(!Ext_Data_Mask)
		return RetVal; 

	if(Ext_Data_Mask!=ALL_FIELD)
	 {
		if(ReadCodecAdvance(Ext_Index,&CodecAdvData))
		{
			CodecAdvData&=~Ext_Data_Mask;
			CodecAdvData|=(Ext_Data&Ext_Data_Mask);			
			RetVal=WriteCodecAdvance(Ext_Index,CodecAdvData);
		}
	 }		
	else
	{
		RetVal=WriteCodecAdvance(Ext_Index,Ext_Data);
	}

	return RetVal;

}
//*****************************************************************************
//
//Function:Enable/Disable Main Spatial function
//
//*****************************************************************************
BOOL RT_CodecComm::Enable_Main_Spatial(BOOL Enable_Main_Spatial)
{
	BOOL bRetVal=FALSE;
	
	if(Enable_Main_Spatial)
	{
		//Enable Main Spatial 
		bRetVal=WriteCodecRegMask(RT_PSEDUEO_SPATIAL_CTRL,SPATIAL_CTRL_EN,SPATIAL_CTRL_EN);		
	}
	else
	{
		//Disable Main Spatial 
		bRetVal=WriteCodecRegMask(RT_PSEDUEO_SPATIAL_CTRL,0,SPATIAL_CTRL_EN);	
	}

	return bRetVal;
}
//*****************************************************************************
//
//Function:Enable/Disable 3D spatial control function(use this function,enable Main Spatial function first)
//
//*****************************************************************************
BOOL RT_CodecComm::Enable_3D_Spatial(S_3D_SPATIAL s3D_Spatial)
{
	BOOL bRetVal=FALSE;
	
	if(s3D_Spatial.bEnable3D)
	{
		Enable_Main_Spatial(TRUE);

		bRetVal=WriteCodecRegMask(RT_PSEDUEO_SPATIAL_CTRL,(STEREO_EXPENSION_EN  | (s3D_Spatial.b3D_Gain<<6) | (s3D_Spatial.b3D_Ratio<<4) ) 
														 ,SPATIAL_GAIN_MASK | SPATIAL_RATIO_MASK | STEREO_EXPENSION_EN );
	}
	else
	{
		bRetVal=WriteCodecRegMask(RT_PSEDUEO_SPATIAL_CTRL,0,STEREO_EXPENSION_EN);