/* 
 	Micronas MSPH Driver

*/

#include <stdio.h>

//#include "typedef.h"
#include "dsthalcommon.h"
#include "MSPH.h"
#include "dsthalsys.h"
//#include "debug.h"
short standard_select = 0;
short modus_reg 			= 0;
short i2s_config 			= 0;
short i2s5_spdif			=	0;

static short dc_level = DEFAUL_DC_LEVEL;
static int bCarrierMute = 0;

DS_U8 MSP_Read(unsigned char address, unsigned short reg_address, short *data){
	int result;
	unsigned char buf[2];
	short t_data = 0;
	if(address != 0){	// dsp, demodulator register
		result = DHL_SYS_MSPRead(address+1,reg_address,2,buf);
	}else{
		result = DHL_SYS_I2cReadEx(1,0x80,1,address,buf,2);
	}

	t_data |= buf[0] << 8;
	t_data |= (0x00ff & buf[1]);

	*data = t_data;

	if ( result < 0 )
		printf("Audio I2C Read Error\n");
	
	return result;
}

DS_U8 MSP_Write(unsigned char address, unsigned short reg_address, short value){
	int result;
	unsigned char buf[2] = {0};
	if(address != 0){
		result = DHL_SYS_MSPWrite(address,reg_address,2,value);
	}else{
		buf[0] = (unsigned char)(value>>8);
		buf[1] = (unsigned char)(value&0xff);
		result = DHL_SYS_I2cWriteEx(1,0x80,1,address,buf,2);
	}
	
	if( result < 0){
		printf("Audio I2C Write Error\n");
		return 1;
	}
	return 0;
}

AUD_RESULT MSP_SPDIF_ON_OFF(DS_BOOL enable)
{
	AUD_RESULT result = AUD_NO_ERROR;

	if(enable){
		MSP_Write(MSP_DSP_ADDRESS,MSP_SPDIF_SRC,0x1020);
		// SPDIF Path 바꿀 때 디코더에서 preamble 맞지 않을 때 Noise 발생됨.
		// 따라서 Mute일 때 아예 SPDIF 신호를 off 하여 디코더 측에서 리셋을 하도록...
		// 디코더가 다시 시작하므로 소리가 늦게 나옴.
		MSP_Write(MSP_DEMOD_ADDRESS,MSP_SPDIF_CONF,0x0400|0x0800);
//		value |= 1 << 10;
	}else{
		MSP_Write(MSP_DEMOD_ADDRESS,MSP_SPDIF_CONF,0x0000|0x0800);
		MSP_Write(MSP_DSP_ADDRESS,MSP_SPDIF_SRC,0x1220);
	}
	
//	MSP_Write(MSP_DEMOD_ADDRESS,MSP_SPDIF_CONF,value);
	
	return result;
}

AUD_RESULT MSP_Mute(DS_BOOL enable)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value;
	if(enable){
		MSP_Read(MSP_DSP_ADDRESS,MSP_VOL,&value);
		value |= FAST_MUTE;
		MSP_Write(MSP_DSP_ADDRESS,MSP_VOL,value);
		OS_mDelay(MSP_MUTE_DELAY);	// mute할 경우 최소 80m delay를 주게 됨.
		MSP_Read(MSP_DSP_ADDRESS,MSP_VOL,&value);
		if((value & FAST_MUTE) != FAST_MUTE){
			result = AUD_ERROR_COMMUNICATION;
			return result;
		}
	}else{
		printf("Not Support\n");
	}
	// MSP 의 경우 별도로 Unmute할 수 없음으로 이는 상위에서 원래 volume으로 변경.
	// mute는 fast mute command로.
	// 
	return result;
}
static int n_SRS = 0;
AUD_RESULT MSP_VolumeSet(int inDB)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value;

	if((inDB > 12 ) || (inDB < -114)){
		printf("out of range\n");
		return AUD_ERROR_BAD_PARAM;
	}
	
	inDB = inDB + 114;	// 0 db를 설정하기 위해서 0x72값을 writing한다.
	if(n_SRS == 1){
		inDB += 2;
		if(inDB > 0x7f){
			inDB = 0x7f;
		}
	}
	MSP_Read(MSP_DSP_ADDRESS,MSP_VOL,&value);
	
	value = value & ~VOLUME_MASK;

	value = value | (inDB << 8);
	
	MSP_Write(MSP_DSP_ADDRESS,MSP_VOL,value);
	value = 0;
	MSP_Read(MSP_DSP_ADDRESS,MSP_VOL,&value);
	value = ((value & VOLUME_MASK)>>8);
	if(value != inDB){
		printf("error\n");
		return AUD_ERROR_COMMUNICATION;
	}
	return result;
}

AUD_RESULT MSP_BalanceSet(char Percentage)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value;
	short new_value;

	if((Percentage < -100) || (Percentage > 100)){
		printf("invalid parameter\n");
		return AUD_ERROR_BAD_PARAM;
	}


	if(Percentage == 100){
		Percentage = 127;
	}else if(Percentage == -100){
		Percentage = -127;
	}else{
		Percentage = (Percentage*128)/100;
	}	
	

	new_value = (Percentage);

	new_value = new_value << 8;

	
	MSP_Read(MSP_DSP_ADDRESS,MSP_BALANCE,&value);
	
	value = value & ~BALANCE_MASK;

	value = value | (new_value);

	MSP_Write(MSP_DSP_ADDRESS,MSP_BALANCE,value);
	MSP_Read(MSP_DSP_ADDRESS,MSP_BALANCE,&value);
	
	value = value & BALANCE_MASK;
	if(value != new_value){
		printf("error\n");
		return AUD_ERROR_COMMUNICATION;
	}
	return result;
}


AUD_RESULT MSP_AudioDelayPath(AUD_SOURCE src)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value = 0;
	short temp = 0;
	
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_AUDIO_DELAY,&value);	
	
	value &= 0x00ff;
	
	value |= (src << 8);
	
	MSP_Write(MSP_DSP_ADDRESS,MSP_AUDIO_DELAY,value);
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_AUDIO_DELAY,&temp);
	
	if(value != temp){
		printf("Error\n");
		return AUD_ERROR_COMMUNICATION;
	}
	
	return result;
}
AUD_RESULT MSP_AudioDelaySet(unsigned int Delay)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value = 0;
	short temp = 0;
	
	if(Delay > 120){
		printf("BAD Param\n");
		return AUD_ERROR_BAD_PARAM;
	}
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_AUDIO_DELAY,&value);	
	
	value &= 0xff00;
	
	value |= Delay & 0xff;
	
	MSP_Write(MSP_DSP_ADDRESS,MSP_AUDIO_DELAY,value);
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_AUDIO_DELAY,&temp);
	
	if(value != temp){
		printf("Error\n");
		return AUD_ERROR_COMMUNICATION;
	}
	
	return result;
}

AUD_RESULT MSP_SetScartToDSP(int num)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value = 0;
	short temp = 0;
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_ACB_REG,&value);
	
	value &= ~(0x1ff << 5);
	
	switch(num){
		case 1:
			break;
		case 2:
			value |= (0x10 << 5);
			break;
		case 3:
			value |= (0x18 << 5);
			break;
		case 4:
			value |= (0x1 << 5);
			break;		
		case 5:
			value |= (0x8 << 5);
			break;		
		default :
			printf("Bad Param\n");
			return AUD_ERROR_BAD_PARAM;
			break;
	}
	
	MSP_Write(MSP_DSP_ADDRESS,MSP_ACB_REG,value);
	MSP_Read(MSP_DSP_ADDRESS,MSP_ACB_REG,&temp);
	
	if(value != temp){
		printf("Error\n");
		return AUD_ERROR_COMMUNICATION;
	}
	
	return result;
}

AUD_RESULT MSP_SetI2S3Matrix(AUD_I2S_IN mode)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value;
	short temp;
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_DOWNMIX,&value);
	value &= 0xff00;
	value |= mode;
	MSP_Write(MSP_DSP_ADDRESS,MSP_DOWNMIX,value);
	MSP_Read(MSP_DSP_ADDRESS,MSP_DOWNMIX,&temp);
	
	if(value != temp){
		printf("Error\n");
		return AUD_ERROR_COMMUNICATION;
	}
	
	return result;
}
AUD_RESULT MSP_SetAudioMatrix(AUD_OUTPUT out,AUD_SOURCE src)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value;
	short temp;
	
	if((out >= AUD_OUT_MAX) || (src >= AUD_INPUT_MAX)){
		printf("Bad Parameter\n");
		return AUD_ERROR_BAD_PARAM;
	}

	//printf("out is %d , source is %d\n",out,src);
	value = src << 8;
	
	value |= 0x20;
	
	if(out == AUD_MAIN_LR){
		MSP_Write(MSP_DSP_ADDRESS,MSP_MAIN_SRC,value);
		MSP_Read(MSP_DSP_ADDRESS,MSP_MAIN_SRC,&temp);
	}else if ( out == AUD_SPDIF_OUTPUT){
		MSP_Write(MSP_DSP_ADDRESS,MSP_SPDIF_SRC,value);
		MSP_Read(MSP_DSP_ADDRESS,MSP_SPDIF_SRC,&temp);
	}else if ( out == AUD_SURROUND_PROCESSING_INPUT){
		MSP_Write(MSP_DSP_ADDRESS,MSP_SURROUND_SRC,value);
		MSP_Read(MSP_DSP_ADDRESS,MSP_SURROUND_SRC,&temp);
    }else if ( out == AUD_I2S) {
		MSP_Write(MSP_DSP_ADDRESS,MSP_I2S_SRC,value);
		MSP_Read(MSP_DSP_ADDRESS,MSP_I2S_SRC,&temp);
	}else{
		printf("Not Implemented\n");
		return AUD_ERROR_BAD_PARAM;
	}
	
	if(value != temp){
		printf("Error\n");
		return AUD_ERROR_COMMUNICATION;
	}
	
	return result;
}

AUD_RESULT MSP_SetI2SInputConfig(AUD_I2S_Config config)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short data = 0;
	
	if(config.align == RIGHT_ALIGN){
		data |= (1 << 11 );	// 11bit align
	}
	
	if( config.pol	== HIGH_LEFT ){
		data |= (1 << 10);	// 10bit is strobe polarity
	}
	
	if( config.delay == ONE_DELAY ){
		data |= (1 << 9 );	// I2S Mode ( not left align mode )
	}
	
	if( config.mode == SAMPLE_MULTI ){
		data |= (1 << 8 ); // 7bit is sampling mode
	}
	
	switch(config.bit_word){
		case INPUT_16:
			data |= (7 << 4);
			break;
		case INPUT_32:
		default:
			data |= (0xf << 4);
			break;
	}
	
	if( config.in_out == I2S_OUTPUT){
		data |= (1 << 3 ); 
	}
	
	data |= (1 << 2);	// all i2s input (1/2/3/4) use same configuration
	
	data |= 2;
	i2s_config	 = data;
	printf("|%s| i2s_config=0x%x\n", __FUNCTION__, i2s_config);
	//MSP_Write(MSP_DSP_ADDRESS,MSP_VOL,i2s_config);
	
	return result;
}

AUD_RESULT MSP_GetI2SInputFrequency(unsigned int *freq)
{
	AUD_RESULT result = AUD_NO_ERROR;
	return result;
}

AUD_RESULT MSP_SetI2SOutput(int bI2S)
{
    AUD_RESULT result = AUD_NO_ERROR;
    
    if ( bI2S ) {
   	    modus_reg |= 0x40;      // I2S output - I2S format.
   	    i2s_config &= ~3;
   	    i2s_config |= 1;
   	} else {
   	    modus_reg &= ~0x40;      // I2S output - I2S format.
   	    i2s_config &= ~3;
   	    i2s_config |= 2;
   	}
   	
   	return result;
}

AUD_RESULT MSP_SetAntiClipping(AUD_ANTICLIPPING_Mode mode)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value;
	if(mode > CLIPPING_WITH_DYNAMIC){
		printf("Bad Parameter\n");
		return AUD_ERROR_BAD_PARAM;
	}
	
		
	MSP_Read(MSP_DSP_ADDRESS,MSP_VOL,&value);
	
	value = value & ~CLIPPING_MODE_MASK;

	value = value | (mode);

	MSP_Write(MSP_DSP_ADDRESS,MSP_VOL,value);
	MSP_Read(MSP_DSP_ADDRESS,MSP_VOL,&value);
	
	value = value & CLIPPING_MODE_MASK;

	if(value != mode){
		printf("Error\n");
		return AUD_ERROR_COMMUNICATION;
	}

	return result;
}

int MSP_ConfTest(int value)
{
		AUD_GPIO_Config config;
		if(value){
			config.direction = GPIO_IN;
		}else{
			config.direction = GPIO_OUT;
		}
		
		MSP_PreConfigGPIO(config);	
		return 1;
}

AUD_RESULT MSP_PreConfigGPIO(AUD_GPIO_Config config)
{
	AUD_RESULT result = AUD_NO_ERROR;
	
	if (config.direction == GPIO_IN){
		modus_reg = modus_reg | 8;
	}else{
		modus_reg = modus_reg & ~8;
	}
	return result;
}

AUD_RESULT MSP_PresetAudioStandard(AUDIO_STANDARD std)
{
	AUD_RESULT result = AUD_NO_ERROR;
	
	modus_reg = modus_reg & ~0x6000;
	
	modus_reg |= (std << 13);
	
	return result;
}

AUD_RESULT MSP_PresetASS(DS_BOOL enable)
{
	AUD_RESULT result = AUD_NO_ERROR;
	
	if(enable){
		modus_reg |= 1;
	}else{
		modus_reg &= ~1;
	}
	
	return result;	
} 

AUD_RESULT MSP_SetGPIO(int num, int val)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value = 0;
	short temp = 0;
	
	if( (num != 0) && (num != 1) ){
		printf("%d : BAD Param\n",__LINE__);
		return AUD_ERROR_BAD_PARAM;
	}
	
	if( (val != 0) && (val != 1)){
		printf("%d : BAD Param\n",__LINE__);
		return AUD_ERROR_BAD_PARAM;
	}
	
//	MSP_Write(MSP_DSP_ADDRESS,MSP_VOL,value);
	MSP_Read(MSP_DSP_ADDRESS,MSP_ACB_REG,&value);
	if(val){
		value |= (1<<(num+14));
	}else{
		value &= ~(1<<(num+14));
	}
	
	MSP_Write(MSP_DSP_ADDRESS,MSP_ACB_REG,value);
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_ACB_REG,&temp);
	
	if(value != temp){
		printf("Error\n");
		return AUD_ERROR_COMMUNICATION;
	}
	
	return result;
}

AUD_RESULT MSP_GetChipInfo(unsigned short *info)
{
	AUD_RESULT result = AUD_NO_ERROR;
	return result;	
}

AUD_RESULT MSP_PrintChipInfo(void)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value = 0;
	MSP_Read(MSP_DSP_ADDRESS,MSP_VENDOR,&value);
	
	if((value & 0xff00) == 0x0400){
		printf("Hardware : MSP44/46xyK - D7\n");
	}else if ((value & 0xff00 ) == 0x0500){
		printf("Hardware : MSP44/46xyK - E8\n");
	}else{
		printf("Hardware : UNKNOWN\n");
	}
	
	if((value & 0x00F0) == 0x0010){
		printf("Familly Code : 40ms Delay\n");
	}else if((value & 0x00F0) == 0x0010){
		printf("Familly Code : 120ms Delay\n");
	}else{
		printf("Familly Code : UNKNOWN\n");
	}
	
	if((value & 0xf) == 0xb){
		printf("Revisino : MSP 44xyK/ MSP 46xyK - D7\n");
	}else{
		printf("Revision : UNKNOWN\n");
	}
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_PRODUCT,&value);
	
	printf("Product Code : ");
	if((value & 0xff00) == 0x0){
		printf("MSP 4400K / MSP 4600K - D7\n");
	}else if((value & 0xff00) == 0x0a00){
		printf("MSP 4410K / MSP 4610K - D7\n");
	}else if((value & 0xff00) == 0x2800){
		printf("MSP 4440K / MSP 4640K - D7\n");
	}else if((value & 0xff00) == 0x3200){
		printf("MSP 4450K / MSP 4650K - D7\n");
	}else if((value & 0xff00) == 0x0100){
		printf("MSP 4401K / MSP 4601K - D7\n");
	}else if((value & 0xff00) == 0x0b00){
		printf("MSP 4411K / MSP 4611K - D7\n");
	}else if((value & 0xff00) == 0x2900){
		printf("MSP 4441K / MSP 4641K - D7\n");
	}else if((value & 0xff00) == 0x3300){
		printf("MSP 4451K / MSP 4651K - D7\n");
	}else if((value & 0xff00) == 0x0200){
		printf("MSP 4402K / MSP 4602K - D7\n");
	}else if((value & 0xff00) == 0x0c00){
		printf("MSP 4412K / MSP 4612K - D7\n");
	}else if((value & 0xff00) == 0x2a00){
		printf("MSP 4442K / MSP 4642K - D7\n");
	}else if((value & 0xff00) == 0x3400){
		printf("MSP 4452K / MSP 4652K - D7\n");
	}else {
		printf("UNKNOWN\n");
	}
	printf("ROM Revision Code : ");
	if((value & 0xff) == 0x67){
		printf("MSP 44/46xyK - D7\n");
	}else if((value & 0xff) == 0x67){
		printf("MSP 44/46xyK - E8\n");
	}else{
		printf("UNKNOWN\n");
	}
	
	return result;	
}

int MSP_GetGPIO(int num)
{
	short value;
	
	MSP_Read(MSP_DEMOD_ADDRESS,MSP_STATUS,&value);
	
	return ((value & (1<<(num+3))) ? 1 : 0);
}

AUD_RESULT MSP_SetDC(DS_BOOL enable)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value = 0;
	short  temp = 0;
	
	if(enable){
		
		value = dc_level | SRS_INPUT_MONO | SRS_FRONT_INPUT_PASSIVE_MATRIX;
		
		MSP_Write(MSP_DSP_ADDRESS,MSP_XT_PROCESSING,value);
		MSP_Read(MSP_DSP_ADDRESS,MSP_XT_PROCESSING,&temp);
		
		if(value != temp){
			printf("Error\n");
			return AUD_ERROR_COMMUNICATION;
		}
	}else{
		
		value = DC_OFF | SRS_INPUT_MONO | SRS_FRONT_INPUT_PASSIVE_MATRIX;
		
		MSP_Write(MSP_DSP_ADDRESS,MSP_XT_PROCESSING,value);
		MSP_Read(MSP_DSP_ADDRESS,MSP_XT_PROCESSING,&temp);
		
		if(value != temp){
			printf("Error\n");
			return AUD_ERROR_COMMUNICATION;
		}	
	}
	
	
	return result;
} 

AUD_RESULT MSP_SetDCLevel(short val)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value;
	
	if( val & ~0x7f ){
		printf("Bad Param\n");
		return AUD_ERROR_BAD_PARAM;
	}
	
	val = val << 8;
	
	dc_level = val;
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_XT_PROCESSING,&value);
	
	if(value & 0xff00){
		MSP_SetDC(_TRUE_);
	}
	
	return result;
}	
	
	
AUD_RESULT MSP_SetSRS(DS_BOOL enable)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value;
	short temp;
	
	if(enable){
		value = 0x1070;	// srs enable
		n_SRS = 1;
	}else{
		value = 0x1000;	// srs disable
		n_SRS = 0;
	}
	
	MSP_Write(MSP_DSP_ADDRESS,MSP_SRS_CONF,value);
	MSP_Read(MSP_DSP_ADDRESS,MSP_SRS_CONF,&temp);
	
	if( value != temp){
		printf("Error\n");
		return AUD_ERROR_COMMUNICATION;
	}
	
	
	return result;
}

const short trubass[6][6] = 
{
	{ 0x0602, 0x0400, 0x0600, 0x0, 0x0, 0x0 },
	{ 0x0602, 0x0400, 0x0600, 0x0, 0x0, 0x0 },
	{ 0x0902, 0x0600, 0x0900, 0x0, 0x0, 0x0 },
	{ 0x0f02, 0x0a00, 0x0f00, 0x0, 0x0, 0x0 },
	{ 0x1602, 0x0f00, 0x1600, 0x0, 0x0, 0x0 },
	{ 0x1e02, 0x1400, 0x1e00, 0x0, 0x0, 0x0 },
};

const short trubass_str[5] = {
	0x0,
	0x1200,
	0x2500,
	0x3800,
	0x4b00,
};

AUD_RESULT MSP_SetTruBass(DS_BOOL enable,AUD_SPEAKER spk_size, int str)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short temp  = 0;
	short value = 0;
		
	if(enable){
		
		value = trubass[spk_size][AUD_SUBW_FREQ];
		
		MSP_Write(MSP_DSP_ADDRESS,MSP_SUBWOOFER,value);
		MSP_Read(MSP_DSP_ADDRESS,MSP_SUBWOOFER,&temp);
		
		if(value != temp ){
			printf("Error\n");
			return AUD_ERROR_COMMUNICATION;
		}

		value = trubass[spk_size][AUD_MP_HP];
		
		MSP_Write(MSP_DSP_ADDRESS,MSP_MB_HIGH_PASS,value);
		MSP_Read(MSP_DSP_ADDRESS,MSP_MB_HIGH_PASS,&temp);
		
		if(value != temp ){
			printf("Error\n");
			return AUD_ERROR_COMMUNICATION;
		}
		
		value = trubass[spk_size][AUD_MP_LP];
		
		MSP_Write(MSP_DSP_ADDRESS,MSP_MB_LOW_PASS,value);
		MSP_Read(MSP_DSP_ADDRESS,MSP_MB_LOW_PASS,&temp);
		
		if(value != temp ){
			printf("Error\n");
			return AUD_ERROR_COMMUNICATION;
		}
		
		value = trubass[spk_size][AUD_MB_LIM];
		
		MSP_Write(MSP_DSP_ADDRESS,MSP_MB_AMP_LIMIT,value);
		MSP_Read(MSP_DSP_ADDRESS,MSP_MB_AMP_LIMIT,&temp);
		
		if(value != temp ){
			printf("Error\n");
			return AUD_ERROR_COMMUNICATION;
		}

		value = trubass[spk_size][AUD_MB_HMC];
		
		MSP_Write(MSP_DSP_ADDRESS,MSP_MB_HMC,value);
		MSP_Read(MSP_DSP_ADDRESS,MSP_MB_HMC,&temp);
		
		if(value != temp ){
			printf("Error\n");
			return AUD_ERROR_COMMUNICATION;
		}
				
		value = trubass[spk_size][AUD_SUBW_LEVEL];
		
		MSP_Write(MSP_DSP_ADDRESS,MSP_MB_WOOFER_LEV,value);
		MSP_Read(MSP_DSP_ADDRESS,MSP_MB_WOOFER_LEV,&temp);
		
		if(value != temp ){
			printf("Error\n");
			return AUD_ERROR_COMMUNICATION;
		}
		
		value = trubass_str[str];
		
		MSP_Write(MSP_DSP_ADDRESS,MSP_MB_STR,value);
		MSP_Read(MSP_DSP_ADDRESS,MSP_MB_STR,&temp);
		
		if(value != temp ){
			printf("Error\n");
			return AUD_ERROR_COMMUNICATION;
		}		

	}else{
		value = CORNER_FREQ | MB_UNFILTER;
		
		MSP_Write(MSP_DSP_ADDRESS,MSP_SUBWOOFER,value);
		MSP_Read(MSP_DSP_ADDRESS,MSP_SUBWOOFER,&temp);
		
		if(value != temp ){
			printf("Error\n");
			return AUD_ERROR_COMMUNICATION;
		}
	}	
	return result;
}

AUD_RESULT MSP_ChangeTruBassLevel(short val)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value;
	
	if( val & ~0x7f ){
		printf("Bad Param\n");
		return AUD_ERROR_BAD_PARAM;
	}
	
	val = val << 8;
	
	MSP_Write(MSP_DSP_ADDRESS,MSP_MB_STR,val);
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_MB_STR,&value);
	
	if( value != val ){
		printf("Error\n");
		return AUD_ERROR_COMMUNICATION;
	}
	
	return result;
}

AUD_RESULT MSP_SetSVC(DS_BOOL enable)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value;
	short temp;
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_AVC,&value);
	
	if( enable ){
		value |= 0x8100;
	}else{
		value &= ~0x8000;
	}
	
	MSP_Write(MSP_DSP_ADDRESS,MSP_AVC,value);
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_AVC,&temp);
	
	if( temp != value ){
		printf("Error\n");
		return AUD_ERROR_COMMUNICATION;
	}
	
	return result;
}

AUD_RESULT MSP_SetEQ(char trebledb, char bassdb)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value = 0;
	short t_value = 0;

	if((trebledb > 20) || (trebledb < -12)){
		printf("Bad Parameter\n");
		return AUD_ERROR_BAD_PARAM;
	}

	if((bassdb > 20) || (bassdb < -12)){
		printf("Bad Parameter\n");
		return AUD_ERROR_BAD_PARAM;
	}	
	
	if(bassdb < 13){
		value = bassdb*8;
	}else{
		value = 12*8 + ((bassdb-12)*4);
	}
	
	if(value >= 0x80){
		value = 0x7f;
	}
	t_value = value << 8;
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_BASS,&value);
	
	value = value & ~UPPER_BYTE_MASK;

	value = value | (t_value);

	MSP_Write(MSP_DSP_ADDRESS,MSP_BASS,value);
	MSP_Read(MSP_DSP_ADDRESS,MSP_BASS,&value);
	
	value = value & UPPER_BYTE_MASK;
	
	if(value != (t_value)){
		printf("Error\n");
		return AUD_ERROR_COMMUNICATION;
	}
	
	if(trebledb < 13){
		trebledb = trebledb*8;
	}else{
		trebledb = 12*8 + ((trebledb-12)*4);
	}

	t_value = trebledb << 8;

	MSP_Read(MSP_DSP_ADDRESS,MSP_TREBLE,&value);
	
	value = value & ~UPPER_BYTE_MASK;

	value = value | (t_value);

	MSP_Write(MSP_DSP_ADDRESS,MSP_TREBLE,value);
	MSP_Read(MSP_DSP_ADDRESS,MSP_TREBLE,&value);
	
	value = value & UPPER_BYTE_MASK;
	
	if(value != t_value){
		printf("Error\n");
		return AUD_ERROR_COMMUNICATION;
	}
	return result;
}

AUD_RESULT MSP_GetBTSC(AUD_SAP *src)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value;
	
	MSP_Read(MSP_DEMOD_ADDRESS,MSP_STATUS,&value);
	
	if( ( value & 0x6 ) == 0x6 ){
		src->signal = 0;
	}else{
		src->signal = 1;
	}
	src->sap 			= ( value & ( 1 << 8 ) ) ? 1 : 0;
	src->stereo		= ( value & ( 1 << 6 ) ) ? 1 : 0;
	
	return result;
}

AUD_RESULT MSP_SetI2SSync(DS_BOOL enable)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value = 0;
	short temp  = 0;
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_I2S3_PRESCALE,&value);
	
	if(enable){ 	// i2s3 to sync with 48khz
		printf("value : 0x%x\n",value);
		value &= ~0xff;
		printf("value : 0x%x\n",value);
		MSP_Write(MSP_DSP_ADDRESS,MSP_I2S3_PRESCALE,value);
		printf("value : 0x%x\n",value);
	}else{			//	i2s3 to async 6khz to 49khz
	printf("value : 0x%x\n",value);
		value |= 0x1;
		MSP_Write(MSP_DSP_ADDRESS,MSP_I2S3_PRESCALE,value);
		printf("value : 0x%x\n",value);
	}
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_I2S3_PRESCALE,&temp);
	
	if(temp != value){
		printf("Error\n");
		return AUD_ERROR_COMMUNICATION;
	}
	
	return result;
}
AUD_RESULT MSP_SetSoundForFM(AUD_SOUND_FOR_FM src)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value = 0;
	short temp = 0;
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_FM_AM_PRESCALE,&value);
	
	value &= 0xff00;
	
	value |= src;
	
	MSP_Write(MSP_DSP_ADDRESS,MSP_FM_AM_PRESCALE,value);
	
	MSP_Read(MSP_DSP_ADDRESS,MSP_FM_AM_PRESCALE,&temp);
	
	if(value != temp){
		printf("Error\n");
		return AUD_ERROR_COMMUNICATION;
	}
		
	
	return result;
}

AUD_RESULT MSP_SetCarrierMute(DS_BOOL bEn)
{
	DS_U8 result=0;

     bCarrierMute = bEn;
     
     //result = MSP_Write(MSP_DEMOD_ADDRESS, MSP_CARRIER_MUTE_THRESHOLD, bEn ? 0x2a : 0x7ff);
     result = MSP_Write(MSP_DEMOD_ADDRESS, MSP_AD_CV, bEn ? 0x2D0 : 0xD0);
     
     if ( result == 0 )
          return AUD_NO_ERROR;
     
     return AUD_ERROR_COMMUNICATION;
}

AUD_RESULT MSP_SetPrescale(AUD_SOURCE src, short valuedb)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value = 0;
	short reg_ad = 0;
	short temp = 0;
	
	switch(src){
		case AUD_SCART:
			reg_ad = MSP_SCART_PRESCALE;
			break;
		case AUD_I2S_3_12:
			reg_ad = MSP_I2S3_PRESCALE;
			break;
		case AUD_FM_AM:
			reg_ad = MSP_FM_AM_PRESCALE;
			break;
		default:
			printf("BAD Param\n");
			return AUD_ERROR_BAD_PARAM;
			break;
	}
	
	
	MSP_Read(MSP_DSP_ADDRESS,reg_ad,&value);
	
	value &= 0x00ff;
	
	value |= ( valuedb << 8 );
	
	
	MSP_Write(MSP_DSP_ADDRESS,reg_ad,value);
	
	
	MSP_Read(MSP_DSP_ADDRESS,reg_ad,&temp);
	
	if(value != temp){
		printf("Error\n");
		return AUD_ERROR_COMMUNICATION;
	}
	
	return result;
}

AUD_RESULT MSP_DemodSet(AUD_AUDIO_STANDARD std)
{
	AUD_RESULT result = AUD_NO_ERROR;
	
	MSP_Write(MSP_DEMOD_ADDRESS,MSP_STANDARD_SEL,std);
	OS_mDelay(10);
	MSP_SetCarrierMute(bCarrierMute);
	
	return result;
}

AUD_RESULT MSP_Start(void)
{
	AUD_RESULT result = AUD_NO_ERROR;

	MSP_Write(0x12,0x35,0x600);	// overall gain을 높임.
	
	MSP_Write(0x10,0x50,0x400);
	
	MSP_Write(MSP_DEMOD_ADDRESS,MSP_MODUS,modus_reg);
	MSP_SetCarrierMute(bCarrierMute);
	
	MSP_Write(MSP_DEMOD_ADDRESS,MSP_I2S_CONF,i2s_config);
	
	MSP_Write(MSP_DSP_ADDRESS,MSP_VOL,0);
	
	MSP_SPDIF_ON_OFF(1);
	
	return result;
	// software reset
}

AUD_RESULT MSP_SetClippingThreshold(AUD_TH th)
{
	AUD_RESULT result = AUD_NO_ERROR;
	short value = 0;
	short temp = 0;
	
	if( th == AUD_TH_3DBFS ){
		value = 0x2d33;
	}else if( th == AUD_TH_2DBFS ){
		value = 0x2849;
	}else if( th == AUD_TH_1DBFS ){
		value = 0x23e7;
	}else if( th == AUD_TH_0DBFS ){
		value = 0x2000;
	}else if( th == AUD_TH_N1DBFS ){
		value = 0x1c85;
	}else if( th == AUD_TH_N2DBFS ){
		value = 0x1999;
	}else if( th == AUD_TH_N3DBFS ){
		value = 0x16a7;
	}else if( th == AUD_TH_N4DBFS ){
		value = 0x1430;
	}else if( th == AUD_TH_N5DBFS ){
		value = 0x11fe;
	}else if( th == AUD_TH_N6DBFS ){
		value = 0x1000;
	}else{
		printf("BAD Param\n");
		return AUD_ERROR_BAD_PARAM;
	}
	
	MSP_Write(MSP_DSP_ADDRESS, MSP_TH_FOR_CLIP , value );
	OS_mDelay(10);
	MSP_Read(MSP_DSP_ADDRESS,MSP_TH_FOR_CLIP, &temp );
	
	if( value != temp ){
		printf("Error : value : %x  temp : %x\n",value,temp);
		return AUD_ERROR_COMMUNICATION;
	}
	
	return result;
}

AUD_RESULT MSP_Reset(void)
{
	AUD_RESULT result = AUD_NO_ERROR;
	DHL_RESULT dhlResult;
	int try = 0;
	short test = 0;

	while(try < 5 ){
		MSP_Write(MSP_CONTROL_ADDRESS,MSP_RESET,0x8000);
		MSP_Read(MSP_CONTROL_ADDRESS,MSP_RESET,&test);
		OS_mDelay(10);
		MSP_Write(MSP_CONTROL_ADDRESS,MSP_RESET,0x0);
		MSP_Read(MSP_CONTROL_ADDRESS,MSP_RESET,&test);
		if(test != 0x0){
			try++;
			if(try == 5){
				result = AUD_ERROR_COMMUNICATION;
			}
            
			dhlResult = DHL_SYS_SetGPIO(GPIO_AP_RESETN,0);
			OS_mDelay(300);
			dhlResult = DHL_SYS_SetGPIO(GPIO_AP_RESETN,1);
			OS_mDelay(300);
            
			if(dhlResult != DHL_OK){
				printf("\n\n\nError In AP Reset with GPIO\n\n\n");
				result = AUD_ERROR_COMMUNICATION;
				goto done;
			}
		}else{
		  break;
		}
		
	}
done:
	return result;
}

int test(void)
{
	AUD_I2S_Config config;
	MSP_ConfTest(1);
	MSP_PresetAudioStandard(STANDARD_M_BTSC);
	
	config.align 		= LEFT_ALIGN;
	config.pol			= HIGH_LEFT;
	config.mode			=	SAMPLE_2;
	config.delay		= ONE_DELAY;
	config.bit_word	= INPUT_32;
	config.in_out		= I2S_INPUT;
	
	MSP_SetI2SInputConfig(config);
	
	printf("modus 			: 0x%x\n", modus_reg);
	printf("i2s_config 	: 0x%x\n", i2s_config);	

	MSP_Write(MSP_DEMOD_ADDRESS,MSP_MODUS,0);
	
	MSP_Write(MSP_DEMOD_ADDRESS,MSP_I2S_CONF,i2s_config);
	
	return 1;
}

int red(void){
	short value = 0;
	MSP_Read(MSP_DSP_ADDRESS,MSP_TH_FOR_CLIP,&value);
	printf("value is 0x%x\n",value);
	return 0;
}
	
int getb(void)
{
	AUD_SAP test;
	
	test.sap = 0;
	test.stereo = 0;
	
	MSP_GetBTSC(&test);
	printf("%s\n",test.signal ? "SIGNAL AVAIL" : "SIGNAL NOT AVAIL");
	printf("%s%s\n",test.sap ? "SAP\n" : "", test.stereo ? "STEREO" : " MONO ");
	
	return 1;
	
}	

int msp_w(short address, short subaddress, short value)
{
	MSP_Write(address,subaddress,value);
	return 1;
}
int msp_r(short address, short subaddress)
{
	short data = 0;
	MSP_Read(address,subaddress,&data);
	printf("%x[%x] : %x\n",address,subaddress,data);
	return 1;
}