msp4450g.c

SigmDesign SMP8634 media decode chip development SDK

	/* Step 4 : If Automatic Sound Select is not active:
	Choose FM matrix repeatedly according to the
	sound mode indicated in the STATUS register. */

	/*** SCART and I2S Inputs ***/
	/* Step 1 : Select preferred prescale for SCART.*/
	/* Step 2 : Select preferred prescale for I2S inputs
	(set to 0 dB after RESET).*/

	/*** Output Channels ***/
	/* Step 1 : Select the source channel and matrix for each output
	channel.*/
	/* Step 2 : Set audio baseband processing. */
	/* Step 3 : Select volume for each output channel. */
	
	//I2S inputs prescale (set to 0 db after RESET) 
	//msp4450g_reset(pInstance); 
	regAdd=0x0011; //I2S 3 Prescale
	read_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_RDDSP,regAdd,&regValue);
	regValue = regValue & 0x0000;
	regValue=regValue | 0x1000; //0 db gain and mod synchronous input mode
if (1) {

	regValue=regValue | 0x1001; //asynchronous input mode .
}
	write_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_WRDSP,regAdd,regValue);
	
	regAdd=0x30;
	//regValue=0x30a9;
	regValue=0x0024; //bit [5] = 0 
	if (1) {//slave
	
	msp4450g_writeDemod(pInstance,regAdd,regValue);
	}
	//Matrix Source for I2S 3 input and Loudspeaker output:	
	regAdd=0x08; //LoudSpeaker Output
	read_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_RDDSP,regAdd,&regValue);
	regValue = regValue & 0x00ff;
	regValue =regValue | 0x07ff; //I2S 3 input channels 1 and 2
	//regValue =regValue | 0x0800; //I2S 3 input channels 3 and 4
	//regValue =regValue | 0x09ff; //I2S 3 input channels 5 and 6
	//regValue =regValue | 0x0aff; //I2S 3 input channels 7 and 8
	
	write_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_WRDSP,regAdd,regValue);
	
	//Matrix Mode for LoudSpeaker output : (0x08)
	
	regAdd=0x08;
	read_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_RDDSP,regAdd,&regValue);
	regValue =regValue & 0xff00;
	regValue =regValue | 0x0020; //Stereo(transparent mode)
	write_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_WRDSP,regAdd,regValue);
	
	//Set Volume for headphone :
	regAdd=0x00;
	read_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_RDDSP,regAdd,&regValue);
	
	regValue = regValue & 0x00ff;
	//regValue =regValue | 0x7300; //Stereo(transparent mode)
	regValue =regValue | 0x0100;
	write_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_WRDSP,regAdd,regValue);
	
	//msp4450g_headphone_SetVolume(pInstance,volume);
	return err;
	
}

RMstatus msp4450g_initScartInputThoughtI2s(struct RUA *pInstance, 
								 RMuint8 isMaster,  
								 RMuint8 scartInput ,
								 RMuint8 isMultiSampleInput,
								 RMuint8 howManyBit,
								 RMuint8 isLoudSpeakerOutput,
								 RMuint8 is32BitsOutput,
								 RMuint8 is8ChannelOutput
								 )
{
	RMstatus err=RM_OK;
	RMuint32 regValue=0x00;
	RMuint32 regAdd=0x00;
	//Scart1 input to I2s and headphone output 
	printf("Scart %d input throught i2s and output to ",scartInput);
	if (isLoudSpeakerOutput) {
		printf("LoudSpeaker. ");
	}else
		printf("HeadPhone. ");
	msp4450g_detect(pInstance);
	msp4450g_reset(pInstance);

	/*
	 *	Config Demod
	 */
	regAdd=0x30;
	//regValue=0x30a9;
	regValue=0x00;
	if (!isMaster) {//slave	
		regValue= regValue | 0x0020;		
		printf("MSP is Slaver \n");
	}else {
		regValue= regValue & 0xffdf;		
		printf("MSP is Master \n");
	}
	printf("Write Demod 0x%lx value 0x%lx \n",regAdd,regValue);
	msp4450g_writeDemod(pInstance,regAdd,regValue);
	
	regAdd=0x40;
	regValue=0x00;
	switch(is8ChannelOutput) {
	case 0:
		regValue = regValue & 0xfc;
		switch(is32BitsOutput) {
		case 0:
			break;
		case 1:
			regValue = regValue | 0x01;
			break;
		default:
			break;
		}
		break;
		case 1: //Alway 32 bit output.
			regValue = regValue & 0xfd;
			regValue = regValue | 0x02;
			break;
		default:
			break;
	}
	
	switch(isMultiSampleInput) {
	case 0: //Two Sample 24 bit Input Mode. May be not to need specify how many bit.
		regValue=0xb1; // Or can use 0x01.
		regValue = regValue | 0x01;
		break;
	case 1:
		regValue = regValue | 0x0100; //bit[8]=1
		switch(howManyBit) {
		case 16:
			regValue =regValue | 0x70;
			break;
		case 18:
			regValue =regValue | 0x80;
			break;
		case 20:
			regValue =regValue | 0x90;
			break;
		case 22:
			regValue =regValue | 0xa0;
			break;
		case 24:
			regValue =regValue | 0xb0;
			break;
		case 26:
			regValue =regValue | 0xc0;
			break;
		case 28:
			regValue =regValue | 0xd0;
			break;
		case 30:
			regValue =regValue | 0xe0;
			break;
		case 32:
			regValue =regValue | 0xf0;
			break;
		default:
			break;
		}
		break;
		default:
			break;
	}
	
	//Multi Sample 32 bit Input Mode. Required specify how many bit.
	//	regValue=0x1f2;
	printf("Write Demod 0x%lx value 0x%lx \n",regAdd,regValue);
	
	msp4450g_writeDemod(pInstance,regAdd,regValue);

	/*** SCART Signal Path ***/
	/* Step 1 : Select analog input for the SCART baseband processing
	(SCART DSP Input Select) by means of the
	ACB register.  0x13 Page 45 */
	regAdd=0x0013;
	//read_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_RDDSP,regAdd,&regValue);
	regValue=0x00;
	// high of digital output pin D_CTR_I/O_0 : (Note MODUS[3]=0)
	/*
	switch(digitalOutputPin) {
		case 1:
			regValue = regValue & 0xbfff; //bit [14] = 0
			regValue = regValue | 0x8000; //bit [15] = 1
			break;
		default:
		case 0:
			regValue = regValue & 0x7fff; //bit [15] = 0
			regValue = regValue | 0x4000; //bit [14] = 1
			break;
		}*/
	
	
	regValue=regValue & (~(0x19<<5)); 

	switch(scartInput) {
	case 0: //Mono Input, (apply with tuner)
		regValue=regValue | 0x08<<5; //Scart 1 to Dsp input
		break;
	case 1:		
		break;
	case 2:
		regValue=regValue | 0x10<<5; //Scart 1 to Dsp input
		break;
	case 3:
		regValue=regValue | 0x18<<5; //Scart 3 to Dsp input
		break;
	case 4:
		regValue=regValue | 0x01<<5; //Scart 1 to Dsp input
		break;
	default://Mute
		printf("Mute DSP Input\n");
		regValue=regValue & (~(0x00<<5));
		break;
	}

	write_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_WRDSP,regAdd,regValue);
	/* Step 2 :	Select the source for each analog SCART output
	(SCART Output Select) by means of the ACB register. 0x13 Page 45 */
	
	/*** Demodulator ***/
	/* Step 1 : Set MODUS register to the preferred mode and
	Sound IF input. */

	/* Step 2 : Choose preferred prescale (FM and NICAM) values.*/
	/* Step 3 : Write STANDARD SELECT register. */
	/* Step 4 : If Automatic Sound Select is not active:
	Choose FM matrix repeatedly according to the
	sound mode indicated in the STATUS register. */

	/*** SCART and I2S Inputs ***/
	/* Step 1 : Select preferred prescale for SCART. 0x0D*/
	regAdd=0x000d;
	regValue = 0x1900;
	write_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_WRDSP,regAdd,regValue);
	

	/* Step 2 : Select preferred prescale for I2S inputs	
	(set to 0 dB after RESET).*/
	

	regAdd=0x11; //I2S 3
	//read_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_RDDSP,regAdd,&regValue);	
	regValue=0x1000;
	//regValue=regValue | 0x1000; //0 db gain and mod synchronous input mode
	printf("Write DSP 0x%lx value 0x%lx \n",regAdd,regValue);
	write_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_WRDSP,regAdd,regValue);		
		
/*
	regAdd=0x16; //I2S 1
	//read_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_RDDSP,regAdd,&regValue);	
	regValue=0x1000;
	//regValue=regValue | 0x1000; //0 db gain and mod synchronous input mode
	write_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_WRDSP,regAdd,regValue);		
	
	regAdd=0x12; //I2S 2
	//read_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_RDDSP,regAdd,&regValue);	
	regValue=0x1000;
	//regValue=regValue | 0x1000; //0 db gain and mod synchronous input mode
	write_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_WRDSP,regAdd,regValue);		
*/

	
	/*** Output Channels ***/
	/* Step 1 : Select the source channel and matrix for each output
	channel.*/
	/* Step 2 : Set audio baseband processing. */
	/* Step 3 : Select volume for each output channel. */
		
	

	
	regAdd=0x0b;
	regValue=0x0200;//Scart Input;
	regValue = regValue | 0x0020; // Stereo
	write_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_WRDSP,regAdd,regValue);
	

	if (isLoudSpeakerOutput) {
		regAdd=0x08; //LoudSpeaker Output	
	}else
		regAdd=0x09; //LoudSpeaker Output
	
	//read_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_RDDSP,regAdd,&regValue);
	regValue = 0x00;
	//regValue = regValue & 0x00ff;
	regValue =regValue | 0x0700; //I2S 3 input channels 1 and 2
	//regValue =regValue | 0x0800; //I2S 3 input channels 3 and 4
	//regValue =regValue | 0x0900; //I2S 3 input channels 5 and 6
	//regValue =regValue | 0x0a00; //I2S 3 input channels 7 and 8
	

	regValue =regValue | 0x0020; //Stereo(transparent mode)
	
	write_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_WRDSP,regAdd,regValue);
	
	//Matrix Mode for LoudSpeaker output : (0x08)
/*

	//Set Volume for headphone :
	regAdd=0x00;
	read_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_RDDSP,regAdd,&regValue);
	
	regValue = regValue & 0x00ff;
	//regValue =regValue | 0x7300; //Stereo(transparent mode)
	regValue =regValue | 0x0100;
	write_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_WRDSP,regAdd,regValue);
*/
	
	//msp4450g_headphone_SetVolume(pInstance,volume);
	return err;
			
}

static void printBinary(RMuint32 val,RMuint8 bits)
{
	RMuint8 i=0;
	RMuint32 tmp=0;
	for(i=1;i<=bits;i++)
	{
		tmp=val >> (bits-i);
		tmp=tmp & 0x01;
		printf("%ld",tmp);
	}
	
}

static RMstatus msp4450g_checkRegisterSet(struct RUA *pInstance)

{
	RMstatus err=RM_OK;
	RMuint32 regAdd;
	RMuint32 regValue;
	printf("\n--Demod Registers-------------------------\n");

	regAdd=0x7e;
	read_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_RDDEMOD,regAdd,&regValue);
	printf("<Demod addr=\"%4lX\" value=\"%4lX\" ( dec = %5ld , bin = ",regAdd,regValue,regValue);
	printBinary(regValue,16);
	printf(")\\>\n");

	regAdd=0x200;
	read_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_RDDEMOD,regAdd,&regValue);
	printf("<Demod addr=\"%4lX\" value=\"%4lX\" ( dec = %5ld , bin = ",regAdd,regValue,regValue);
	printBinary(regValue,16);
	printf(")\\>\n");
	

	printf("\n--DSP Registers-------------------------\n");

//	printf("RMuint8 i2c_data[][2] = { \n");
	printf("<devicevalues name=\"AD9880 Family\">\n");
	for(regAdd=0x00;regAdd<=0x6c;regAdd++)
	{
		read_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_RDDSP,regAdd,&regValue);
		if (RMFAILED(err))
		{
			printf("Can't Read I2C \n");
			//return err;
		}
		printf("<DSP addr=\"%4lX\" value=\"%4lX\" ( dec = %5ld , bin = ",regAdd,regValue,regValue);
		printBinary(regValue,16);
		printf(")\\>\n");
		
	}
//	printf("};\n");
	printf("\n---END------------------------\n");

	


	return err;
}

static RMstatus msp4450g_WriteDSPRegisterHighBit(struct RUA *pInstance,										 
										 RMuint32 regAdd,
										 RMuint32 highBitValue)
{
	RMstatus err=RM_OK;
	RMuint32 regValue=0;
	err=read_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_RDDSP,regAdd,&regValue);
	if (RMFAILED(err))
	{
		printf("Can't Read DSP regAdd = 0x%lx \n",regAdd);
		return err;
	}
	regValue=regValue & 0x00ff;
	regValue=regValue | ((highBitValue << 8) & 0xff00);
	err=write_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_WRDSP,regAdd,regValue);
	if (RMFAILED(err))
	{
		printf("Can't Write DSP regAdd = 0x%lx \n",regAdd);
		return err;
	}
	return err;
}

static RMstatus msp4450g_WriteDSPRegisterLowBit(struct RUA *pInstance,												 
												 RMuint32 regAdd,
												 RMuint32 lowBitValue)
{
	RMstatus err=RM_OK;
	RMuint32 regValue=0;
	err=read_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_RDDSP,regAdd,&regValue);
	if (RMFAILED(err))
	{
		printf("Can't Read DSP regAdd = 0x%lx \n",regAdd);
		return err;
	}
	regValue=regValue & 0xff00;
	regValue=regValue | (lowBitValue & 0x00ff);
	err=write_i2c_dsp_msp4450g(pInstance,10,0x80>>1,MSP4450G_SADDR_WRDSP,regAdd,regValue);
	if (RMFAILED(err))
	{
		printf("Can't Write DSP regAdd = 0x%lx \n",regAdd);
		return err;
	}
	return err;
}

static RMstatus msp4450g_TestDSPRegister(struct RUA *pInstance,
									RMuint32 regAdd,
									RMint8 isHightBit)
{
	
	RMstatus err=RM_OK;
	RMuint32 i=0;
	
	if (isHightBit) { //HIGH PART
		switch(regAdd) {
		case 0x08:
		case 0x09:
		case 0