samsungdtvs205.c

mstar 776 开发的车载dvd

#define _SAMSUNGDTVS205_C_

/* ------------------------------------
    Header Files
   ------------------------------------ */
#include <stdio.h>
#include <string.h>
#include "SamsungDTVS205.h"

#define SAMSUNG_S5H1409_I2C_ADDR        0xF2
#define INIT_1409_TABLE_NUMS 43//42
#define QAM_CHECK_LOCK_TIME_SLICE   100
#define QAM_WAIT_LOCK_TOTAL_TIME   400
#define QAM_CHECK_LOCK_COUNTER  QAM_WAIT_LOCK_TOTAL_TIME/QAM_CHECK_LOCK_TIME_SLICE
#define QAM_WAIT_AGC_LOCK_TOTAL_TIME   300
#define QAM_CHECK_AGC_LOCK_TIME_SLICE       50
#define QAM_CHECK_AGC_LOCK_COUNTER          QAM_WAIT_AGC_LOCK_TOTAL_TIME/QAM_CHECK_AGC_LOCK_TIME_SLICE

SamsungChipInit_t tDTVS5H1409_Tbl[INIT_1409_TABLE_NUMS] =
{
    {0xFA, 0x0000},
    {0x1C, 0x001D},
    {0x1F, 0x002D},
    {0x20, 0x001D},
    {0x22, 0x0022},
    {0x23, 0x0020},
    {0x28, 0x1010},
    {0x29, 0x110F},
    {0x2A, 0x10B4},
    {0x2B, 0x10AE},
    {0x2C, 0x0031},
    {0x31, 0x010D},
    {0x32, 0x0100},
    {0x44, 0x0510},
    {0x54, 0x0104},
    {0x5D, 0x0370},
    {0x5E, 0x0296},
    {0x58, 0x2222},
    {0x59, 0x1162},
    {0x5A, 0x3211},
    {0x61, 0x0010}, // bubbling channel tuning_Init 1.4
    {0x63, 0x4A00},
    {0x65, 0x0800},
    {0x71, 0x0003},
    {0x72, 0x0470},
    {0x96, 0x000C}, // QAM PTL on mode  for 1.2
    {0x99, 0x0101},
    {0x9C, 0x2E37}, // QAM PTL on mode  for 1.2
    {0x9D, 0x2C37}, // QAM PTL on mode  for 1.2
    {0x9E, 0x2E37}, // QAM PTL on mode  for 1.2
    {0x81, 0x0003}, //
    {0x82, 0x0600},
    {0x86, 0x0002},
    {0x8A, 0x2C38},
    {0x8B, 0x2A37},
    {0x92, 0x302F},
    {0x93, 0x3332},
    {0xAC, 0x1003},
    {0xAD, 0x103F},
    {0xB1, 0x000E},
    {0xE2, 0x0100},
    {0xF5, 0x0000},
    {0xF5, 0x0001},
};

BOOLEAN SamsungS5H1409_Init(void)
{
    U8 i;
    BOOLEAN Result;

    for(i = 0 ; i < INIT_1409_TABLE_NUMS ; i++)
    {
        Result = MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, tDTVS5H1409_Tbl[i].Reg, tDTVS5H1409_Tbl[i].Value);
    }

    return Result;
}

SamsungReturn_t SamsungS5H1409AlterMpegMode(SamsungMpegMode_t mode)
{
    SamsungReturn_t Result;
    if(mode != Samsung_PARAL && mode != Samsung_SERIAL)
        return (SamsungReturn_t)(Samsung_ERR_PARAM|Samsung_ERR_ALTER_FUNC);

    if(mode == Samsung_PARAL)
	    Result = MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xAB, 0x1001);
    else
        Result = MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xAB, 0x1101);

	return Result;
}

/**************************************************************************
* S5H1409 Set the Mpeg Output Timing
*	Conditions:
*	Description : Inverting output clk.(Default)
*	After this function is called,TS timing could be changed.
*	Addr : 0xac
*	Value: 0x0330
/**************************************************************************/
BOOLEAN SamsungS5H1409_MpegClk_InvertedSet(void)
{
	return MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xAC,0x0330);
}

/**************************************************************************
* S5H1409 Set the Mpeg Output Timing
*	Conditions:
*	Description : Non-inverting output clk.
*	After this function is called,TS timing could be changed.
*	Addr : 0xac
*	Value: 0x1330
/**************************************************************************/
BOOLEAN SamsungS5H1409_MpegClk_Non_InvertedSet(void)
{
	return MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xAC,0x1330);
}

BOOLEAN SamsungS5H1409xRepeaterEnable(void)
{
	return MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xF3, 0x0001);
}
BOOLEAN SamsungS5H1409xRepeaterDisable(void)
{
	return MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xF3, 0x0000);
}

BOOLEAN SamsungS5H1409xSleepOn(void)
{
	return MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xF2, 0x0001);
}

BOOLEAN SamsungS5H1409xSleepOff(void)
{
    BOOLEAN result;
    result = MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xF2, 0x0000);
    if(result!=FALSE)
        result=SamsungS5H1409_SoftReset();
    return result;
}

BOOLEAN SamsungS5H1409xCheckIsSleep(void)
{
    if(MDrv_IIC_Read2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x00F2)==0x0001)
        return TRUE;
    else
        return FALSE;
}

BOOLEAN SamsungS5H1409_SoftReset(void)
{
    BOOLEAN result;
    result=MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xF5, 0x0000);
    MDrv_Timer_Delayms(5);
    result=MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xF5, 0x0001);
    return result;
}

#if 0
BOOLEAN SamsungS5H1409_SoftResetOn(void)
{
	return MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xF5, 0x0000);
}

BOOLEAN SamsungS5H1409_SoftResetOff(void)
{
	return MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xF5, 0x0001);
}
#endif
BOOLEAN SamsungS5H1409VsbMode(void)
{
	BOOLEAN result;
	result = MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xF4, 0x0000);
	return result;
}

BOOLEAN SamsungS5H1409x64QamMode(void)
{
	BOOLEAN result;
	result = MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xF4,0x0001);
	result = MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x85,0x0100);
	return result;
}

BOOLEAN SamsungS5H1409x256QamMode(void)
{
	BOOLEAN result;
	result = MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xF4,0x0001);
	result = MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x85,0x0101);
	return result;
}

/*********************************************************************************************************
* S5H1409 QAM Interleave mode set driver
* Conditions: Only in qam mode
* Description: In the TOV state at low SNR, this driver can improve the performance.
* Addr: 0xab
* Value: 0x1000 -> manually write the interleaver mode.
* There are two interleave mode set drivers depending on the TS type.
**********************************************************************************************************/
void SamsungS5H1409_Interleave_Parallel_ModeSet()
{
    static U16 temp,temp1,temp2=0;
    static U16 qam_up = 0;

    temp = MDrv_IIC_Read2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x00F1);
    temp1= MDrv_IIC_Read2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x00B2);
    temp2= MDrv_IIC_Read2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x00AD);

    if((temp>>15)&0x1) //  if (master lock)
    {
        if(qam_up!=2)
        {
            qam_up = 2;
            MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x96,0x0020);
            MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xAD,(((temp1&0xF000)>>4)|( temp2&0xF0FF )) );
            MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xAB,0x1000);
        }
    }
    else		   //  if (unlock)
    {
    	if(qam_up!=1)
    	{
            qam_up = 1;
            MDrv_IIC_Write2Bytes (SAMSUNG_S5H1409_I2C_ADDR, 0x96, 0x0008);
            MDrv_IIC_Write2Bytes (SAMSUNG_S5H1409_I2C_ADDR, 0xAB, 0x1001);
    	}
    }
}

void SamsungS5H1409_Interleave_Serial_ModeSet()
{
    static U16 temp,temp1,temp2=0;
    static U16 qam_up = 0;

    temp = MDrv_IIC_Read2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x00F1);
    temp1= MDrv_IIC_Read2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x00B2);
    temp2= MDrv_IIC_Read2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x00AD);

    if((temp>>15)&0x1) //  if (master lock)
    {
        if(qam_up!=2)
        {
            qam_up = 2;
            MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x96,0x0020);
            MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xAD,(((temp1&0xF000)>>4)|( temp2&0xF0FF )) );
            MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xAB,0x1100);
        }
    }
    else		   //  if (unlock)
    {
    	if(qam_up!=1)
    	{
            qam_up = 1;
            MDrv_IIC_Write2Bytes (SAMSUNG_S5H1409_I2C_ADDR, 0x96, 0x0008);
            MDrv_IIC_Write2Bytes (SAMSUNG_S5H1409_I2C_ADDR, 0xAB, 0x1101);
    	}
    }
}

/*******************************************************************************************************************************
* S5H1409 QAM AM HUM set driver
* Conditions: Only in QAM mode
* Description: This function set the equalizer step size automatically while monitoring the equalizer output values.
* The AM_HUM performance gets better through this function. This function should be always set and work in
* 64/256QAM mode.
* Addr: 0x93, 0x9e
* Value: 0x93: 0x3332 (in normal condition), 0x3130(in the TOV state)
*        0x9e: 0x2c37 (in normal condition), 0x2836(in the TOV state)
*******************************************************************************************************************************/
void SamsungS5H1409AMHUM_SetDriver()
{
    U16 temp;

    temp = MDrv_IIC_Read2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x00F0);
    if((temp>>13)&0x1) //EQ lock
    {
        MDrv_IIC_Write2Bytes (SAMSUNG_S5H1409_I2C_ADDR, 0x96, 0x000C);
        if((temp&0xff)<0x38 || ((temp&0xff)>0x68))
        {
            MDrv_IIC_Write2Bytes (SAMSUNG_S5H1409_I2C_ADDR, 0x93, 0x3332);
        }
        else if( ((temp&0xff)>0x40) && ((temp&0xff)<0x68) )
        {
            MDrv_IIC_Write2Bytes (SAMSUNG_S5H1409_I2C_ADDR, 0x93, 0x3130);
        }

        if((temp&0xff)<0x38 || ((temp&0xff)>0x68))
        {
            MDrv_IIC_Write2Bytes (SAMSUNG_S5H1409_I2C_ADDR, 0x9E, 0x2E37);
        }
        else if( ((temp&0xff)>0x40) && ((temp&0xff)<0x68) )
        {
            MDrv_IIC_Write2Bytes (SAMSUNG_S5H1409_I2C_ADDR, 0x9E, 0x2836);
        }
    }
    else//EQ unlock
    {
        MDrv_IIC_Write2Bytes (SAMSUNG_S5H1409_I2C_ADDR, 0x96, 0x0008);
        MDrv_IIC_Write2Bytes (SAMSUNG_S5H1409_I2C_ADDR, 0x93, 0x3332);
        MDrv_IIC_Write2Bytes (SAMSUNG_S5H1409_I2C_ADDR, 0x9E, 0x2E37);
    }
}

BOOLEAN SamsungS5H1409xVSBScanInit(void)
{
	BOOLEAN result;
	result = MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x3B,0x1000);
	result = MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x44,0x0500);
	return result;
}

BOOLEAN SamsungS5H1409xVSBScanEnd(void)
{
	BOOLEAN result;
	result = MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x3B,0x1010);
	result = MDrv_IIC_Write2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x44,0x0510);
	return result;
}

/**************************************************************************
* S5H1409 VSB/QAM Master Lock Check Driver
*	Conditions:
*	Description :
*	This function is used to check whether the channel chip is lock
*	or not in VSB mode.
*	Addr : 0x40
*	Value:
*	0bit -> 1:Lock , 0:Unlock
***************************************************************************/
BOOLEAN SamsungS5H1409xVsb_Sync_Lock(void)
{
	U16 value;
	BOOLEAN result;

	value = MDrv_IIC_Read2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0x40);
	result = (BOOLEAN)(((U16)value) & 0x01);   // 1 -->Sync lock

	return (result);
}

BOOLEAN SamsungS5H1409xQAM_IsAGC_Lock(void)
{
    U16 value;
    value = MDrv_IIC_Read2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xA0);
    //if((value>0xF870)&&(value<0xFB00))
    if(value>0xF870)
        return FALSE;       //AGC Unlock
    else
        return TRUE;
}

/**************************************************************************
* S5H1409 VSB/QAM Master Lock Check Driver
*	Conditions:
*	Description :
*	This function is used to check whether the channel chip is lock
*	or not in VSB mode.
*	Addr : 0xf1
*	Value:
*	15bit -> 1:Lock , 0:Unlock
***************************************************************************/
BOOLEAN SamsungS5H1409xVsb_QAM_Master_Lock(void)
{
	U16 value;
	BOOLEAN result;

	value = MDrv_IIC_Read2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xF1);
	result = (BOOLEAN)(((U16)value >> 15) & 0x01);   // 1 -->Master lock
	return (result);
}

/**************************************************************************
* S5H1409 VSB FEC Lock Check Driver
*	Conditions:
*	Description :
*	This function is used to check whether the channel
*	chip is lock or not in VSB mode.
*	Addr : 0xf1
*	Value:
*	12bit -> 0:Lock , 1:Unlock
***************************************************************************/
BOOLEAN SamsungS5H1409xVsb_FEC_Lock(void)
{
	U16 value;
	BOOLEAN result;

	value = MDrv_IIC_Read2Bytes(SAMSUNG_S5H1409_I2C_ADDR, 0xF1);
	result = (BOOLEAN)(((U16)value >> 12) & 0x01);           // 1 --> FEC LOCK

	return (result);
}

void SamsungS5H1409xCheckSignalCondition(SamsungSignalCondition_t* pstatus)
{
	U16 value,value1,value2;
	double SnrValue = 0;


	value = MDrv_IIC_Read2Bytes( SAMSUNG_S5H1409_I2C_ADDR, 0xf4 ); //mode check
	if(value==0)//VSB mode
	{
		SnrValue=SamsungS5H1409xVsbSnrResultCheck();
        if(!SamsungS5H1409xVsb_FEC_Lock())
            SnrValue=0;
		if(SnrValue==0)
			*pstatus=Samsung_SIGNAL_NO;
		else if(SnrValue<18.4)
			*pstatus=Samsung_SIGNAL_WEAK;
		else if(SnrValue<21.8)
			*pstatus=Samsung_SIGNAL_MODERATE;
		else if(SnrValue<26.9)
			*pstatus=Samsung_SIGNAL_STRONG;
		else
			*pstatus=Samsung_SIGNAL_VERY_STRONG;
	}
	else//qam MODE
	{
        if(SamsungS5H1409xVsb_QAM_Master_Lock()==0)
        {
            *pstatus=Samsung_SIGNAL_NO;
            return;
        }
		SnrValue=SamsungS5H1409xQamSnrResultCheck();
		value1 = MDrv_IIC_Read2Bytes( SAMSUNG_S5H1409_I2C_ADDR, 0x85 );
		value2 = MDrv_IIC_Read2Bytes( SAMSUNG_S5H1409_I2C_ADDR, 0xf0 );
		value2 = ( ( unsigned int ) value2 >> 8 & 0x01 );

		if (( value1 == 0x110 && value2 == 1)||( value1 == 0x101 ))
		{
			if(SnrValue==0)
				*pstatus=Samsung_SIGNAL_NO;
			else if(SnrValue<31.2)
				*pstatus=Samsung_SIGNAL_WEAK;
			else if(SnrValue<32.4)
				*pstatus=Samsung_SIGNAL_MODERATE;
			else if(SnrValue<34.2)
				*pstatus=Samsung_SIGNAL_STRONG;
			else
				*pstatus=Samsung_SIGNAL_VERY_STRONG;
		}
		else if ( (value1 == 0x110 && value2 == 0 )||( value1 == 0x100 ))
		{
			if(SnrValue==0)
				*pstatus=Samsung_SIGNAL_NO;
			else if(SnrValue<25.4)
				*pstatus=Samsung_SIGNAL_WEAK;
			else if(SnrValue<27.8)
				*pstatus=Samsung_SIGNAL_MODERATE;
			else if(SnrValue<31.4)
				*pstatus=Samsung_SIGNAL_STRONG;
			else
				*pstatus=Samsung_SIGNAL_VERY_STRONG;
		}
		else
		{
			*pstatus=Samsung_SIGNAL_NO;
		}
	}
}

/**************************************************************************
* S5H1409 VSB SNR value(Signal Strength) Check Driver
*	Conditions:
*	Description :
*	This function lets the user's application software read a value
*	that is related to the SNR through the SNR Look Up Table in VSB mode.
*	Addr : 0xf1
*	Value: [9:0]
/**************************************************************************/

double SnrLookUpTable ( int SnrRead )
{
	double SnrLookUP;
	if ( SnrRead == 1023 )
	{
		SnrLookUP = 77 ;
	}  // Something Wrong
	else if ( SnrRead > 923 )
	{
		SnrLookUP = 30 ;
	}
	else if ( SnrRead > 918 )
	{
		SnrLookUP = 29.5 ;
	}
	else if ( SnrRead > 915 )
	{
		SnrLookUP = 28.5 ;
	}
	else if ( SnrRead > 911 )
	{
		SnrLookUP = 28.5 ;
	}
	else if ( SnrRead > 906 )
	{
		SnrLookUP = 28.0 ;
	}
	else if ( SnrRead > 901 )
	{
		SnrLookUP = 27.5 ;
	}
	else if ( SnrRead > 896 )
	{
		SnrLookUP = 27.0 ;
	}
	else if ( SnrRead > 891 )
	{
		SnrLookUP = 26.5 ;
	}
	else if ( SnrRead > 885 )
	{
		SnrLookUP = 26.0 ;
	}
	else if ( SnrRead > 879 )
	{
		SnrLookUP = 25.5 ;
	}
	else if ( SnrRead > 873 )
	{
		SnrLookUP = 25.0 ;
	}
	else if ( SnrRead > 864 )
	{
		SnrLookUP = 24.5 ;
	}
	else if ( SnrRead > 858 )
	{
		SnrLookUP = 24.0 ;
	}
	else if ( SnrRead > 850 )
	{
		SnrLookUP = 23.5 ;
	}
	else if ( SnrRead > 841 )
	{
		SnrLookUP = 23.0 ;
	}
	else if ( SnrRead > 832 )
	{
		SnrLookUP = 22.5 ;
	}
	else if ( SnrRead > 823 )
	{
		SnrLookUP = 22.0 ;
	}
	else if ( SnrRead > 812 )
	{
		SnrLookUP = 21.5 ;
	}
	else if ( SnrRead > 802 )
	{
		SnrLookUP = 21.0 ;
	}
	else if ( SnrRead > 788 )
	{
		SnrLookUP = 20.5 ;
	}
	else if ( SnrRead > 778 )
	{
		SnrLookUP = 20.0 ;
	}
	else if ( SnrRead > 767 )
	{
		SnrLookUP = 19.5 ;
	}
	else if ( SnrRead > 753 )
	{
		SnrLookUP = 19.0 ;
	}
	else if ( SnrRead > 740 )
	{
		SnrLookUP = 18.5 ;
	}
	else if ( SnrRead > 725 )
	{
		SnrLookUP = 18.0 ;
	}
	else if ( SnrRead > 707 )
	{
		SnrLookUP = 17.5 ;
	}
	else if ( SnrRead > 689 )
	{
		SnrLookUP = 17.0 ;
	}
	else if ( SnrRead > 671 )
	{
		SnrLookUP = 16.5 ;
	}
	else if ( SnrRead > 656 )
	{
		SnrLookUP = 16.0 ;
	}
	else if ( SnrRead > 637 )
	{
		SnrLookUP = 15.5 ;
	}
	else if ( SnrRead > 616 )
	{
		SnrLookUP = 15.0 ;
	}
	else if ( SnrRead > 542 )
	{
		SnrLookUP = 14.5 ;
	}
	else if ( SnrRead > 519 )
	{
		SnrLookUP = 14.0 ;
	}
	else if ( SnrRead > 507 )
	{
		SnrLookUP = 13.5 ;
	}
	else if ( SnrRead > 497 )
	{
		SnrLookUP = 13.0 ;
	}
	else if ( SnrRead > 492 )
	{
		SnrLookUP = 12.5 ;
	}
	else if ( SnrRead > 474 )
	{
		SnrLookUP = 12.0 ;
	}
	else if ( SnrRead > 300 )
	{
		SnrLookUP = 1.11 ;
	}
	else
	{
		SnrLookUP = 0;
	}
	return SnrLookUP;
}


double SamsungS5H1409xVsbSnrResultCheck ( void )
{
	U16 value;
	double SnrValue;
	value = MDrv_IIC_Read2Bytes( SAMSUNG_S5H1409_I2C_ADDR, 0xf1 );
	value = ( value & 0x3ff );
	SnrValue = SnrLookUpTable( value );
	return SnrValue;