rtcodeccomm.cpp

freesacle mx21下的声卡alc5620的驱动程序

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



//ALC5620 I2C's device ID is 0x32(A1 pull low,the Device ID=0x30,A1 pull high the device ID=0x32)
#define DEV_AUDIO				0x32
BYTE		   CodecDevId=DEV_AUDIO;


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

CodecRegister Set_Codec_Reg_Init[]=
{
	{RT_SPEAKER_OUT_VOL		,0x0000},//default Speark to 0DB,Enable ZC
	{RT_HP_OUT_VOL			,0x0000},//default HP to 0DB,Enable ZC
	{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 1			//Speaker is Class AB	

	{RT_OUTPUT_MIXER_CTRL	,0x4b40},//default output mixer control,CLASS AB
	{RT_EQ_ANALOG_CTRL_INDEX,0x0044},//advacne register of Class AB control
	{RT_EQ_ANALOG_CTRL_DATA	,0xf920},//power on Class_AB Positive/Negative channel

#else			//Speaker Class D

	{RT_OUTPUT_MIXER_CTRL	,0x6b40},//default output mixer control,CLASS D	
	{RT_EQ_ANALOG_CTRL_INDEX,0x0046},//advacne register of Class D control
	{RT_EQ_ANALOG_CTRL_DATA	,0xff00},//power on Class_D Positive/Negative channel
	
#endif
	
	{RT_MAIN_SDP_CTRL		,0x0002},	//set I2S codec to slave mode	//flove053007


#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			
						RT_MAIN_SDP_CTRL,			//0x34
						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 1		//Speaker is Class AB
						CLASS_AB_REG,				//0x44	
#else		//Speaker is Class D
						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)
{
	 m_i2c = DDKCreateI2CObject();

    if(!m_i2c)
    {
      //  ERRORMSG(ZONE_WM8731_ERROR, (TEXT("RT_CodecComm: I2cClass NULL pointer!\r\n")));
        return;
    }
}

RT_CodecComm::~RT_CodecComm(void)
{
	if(m_i2c)
    {
        DDKDeleteObject(m_i2c);
        m_i2c = NULL;
    }
}

BOOL RT_CodecComm::Init(unsigned short int SampleRate)
{

	m_WaveOutSampleRate=SampleRate;
	m_WaveInSampleRate=SampleRate;
		
	return TRUE;
}

void RT_CodecComm::DelayMSTime(unsigned int MilliSec)
{

}

//*****************************************************************************
//
//function:Initialize Register of Codec function
//
//*****************************************************************************
BOOL RT_CodecComm::InitRTCodecReg(void)
{
	int i;
	BOOL bRetVal=FALSE;
			
	for(i=0;i<SET_CODEC_REG_INIT_NUM;i++)
	{
		bRetVal=ShadowWriteCodec( Set_Codec_Reg_Init[i].CodecIndex,Set_Codec_Reg_Init[i].wCodecValue, CodecDevId ); 

		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],CodecDevId))
		{
			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],CodecDevId))
			{
				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, BYTE DevId)
{
	BOOL b_retVal=TRUE;
	BYTE bytesBuf[2];

    DDKI2CLock(m_i2c);

    DDKSetI2CFrequency(m_i2c, 300000);

	DDKI2CWriteMasterData(m_i2c, DevId, (BYTE *)&Offset, sizeof(Offset));
    
	DDKI2CReadMasterData(m_i2c, DevId,bytesBuf, sizeof(bytesBuf));

    DDKI2CUnlock(m_i2c);

	
    if(DDKGetI2CErrorCode(m_i2c))
        return FALSE;

	*Data=(bytesBuf[0]<<8) | (bytesBuf[1]);	
	
	return b_retVal;
}
//*****************************************************************************
//
//function:restore shadow write register to codec
//
//*****************************************************************************
BOOL RT_CodecComm::ShadowWriteCodec(BYTE Offset, unsigned short int Data, BYTE DevId)
{
	BOOL b_retVal=TRUE;
	BYTE bytesBuf[3];

	bytesBuf[0]=(BYTE)(Offset);
	bytesBuf[1]=(BYTE)((Data&0xff00)>>8);
	bytesBuf[2]=(BYTE)(Data&0xff);

    DDKI2CLock(m_i2c);

    DDKSetI2CFrequency(m_i2c, 300000);

    DDKI2CWriteMasterData(m_i2c, DevId, bytesBuf, sizeof(bytesBuf));

    DDKI2CUnlock(m_i2c);

    if(DDKGetI2CErrorCode(m_i2c))
        return FALSE;


	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,DEV_AUDIO))
		{
			CodecData&=~Mask;
			CodecData|=(Data&Mask);
			RetVal=ShadowWriteCodec(Offset,CodecData,DEV_AUDIO);
		}
	 }		
	else
	{
		RetVal=ShadowWriteCodec(Offset,Data,DEV_AUDIO);
	}

	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,CodecDevId);	// write codec advance index

		if(RetVal)
		{
			RetVal=ShadowWriteCodec(RT_EQ_ANALOG_CTRL_DATA,Ext_Data,CodecDevId);//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,CodecDevId);	// write codec advance index		

	if(RetVal)
	 {
		RetVal=ShadowReadCodec(RT_EQ_ANALOG_CTRL_DATA,Data,CodecDevId);	// 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);
	}

	return bRetVal;
}

//*****************************************************************************
//
//function:Enable/Disable Pseudio Stereo function(use this function,enable Main Spatial function first)
//
//*****************************************************************************
BOOL RT_CodecComm::Enable_Pseudo_Stereo(BOOL Enable_Pseudo_Stereo)
{
	BOOL bRetVal=FALSE;

	if(Enable_Pseudo_Stereo)
	{
		Enable_Main_Spatial(TRUE);
		Enable_All_Pass_Filter(TRUE);
		//Enable Pseudio stereo 
		bRetVal=WriteCodecRegMask(RT_PSEDUEO_SPATIAL_CTRL,PSEUDO_STEREO_EN,PSEUDO_STEREO_EN);
	}
	else
	{
		Enable_All_Pass_Filter(FALSE);	
		//Disable Pseudio stereo
		bRetVal=WriteCodecRegMask(RT_PSEDUEO_SPATIAL_CTRL,0,PSEUDO_STEREO_EN);
		
	}

	return bRetVal;
}

//*****************************************************************************
//
//function:Enable/Disable All Pass Filter function(use this function,enable Main Spatial function first)
//
//*****************************************************************************
BOOL RT_CodecComm::Enable_All_Pass_Filter(BOOL Enable_APF)
{
	BOOL bRetVal=FALSE;
	
	if(Enable_APF)
	{