tmbsltda18211.c

TDA8211芯片驱动程序

		// get PLAGC1 value
		*puValue = 3 * (2 + ((pObj->I2CMap.uBx02.bF.Power_Level_7_to_0 & 0x7F) >> 5));
		break;

	case PLAGC2:
		// get PLAGC2 value
		*puValue = 3 * (2 + (3 - (pObj->I2CMap.uBx03.bF.Power_Level_8 << 1 | pObj->I2CMap.uBx02.bF.Power_Level_7_to_0 >> 7)));
		break;

	case PLRFAGC:
		// get PLRFAGC value (PLRFAGC = PLRFAGC - 11)
		if (((pObj->I2CMap.uBx25.EXTENDED_BYTE_22 & 0x7F) >> 4) < 5)
			*puValue = 11 + (92 + 2 * ((pObj->I2CMap.uBx25.EXTENDED_BYTE_22 & 0x7F) >> 4)) - (103 - (pObj->I2CMap.uBx02.bF.Power_Level_7_to_0 & 0x1F));
		else
			*puValue = 11 + 102 - (103 - (pObj->I2CMap.uBx02.bF.Power_Level_7_to_0 & 0x1F));
		// limit PLRFAGC value
		if (*puValue > 33)
			*puValue = 33;
		else if (*puValue < 1)
			*puValue = 1;
		break;

	case RFCALOK:
		// get RFCALOK value
		*puValue = pObj->I2CMap.uBx03.bF.RF_CAL_OK;
		break;

	case RFCAL_TCOMP:
		// get RFCAL_TCOMP value
		*puValue = pObj->Config.uRFCAL_TCOMP;
		break;

	case IRCALOK:
		// get IRCALOK value
		*puValue = pObj->I2CMap.uBx03.bF.IR_CAL_OK;
		break;

	case BPFILTER:
		// get BPFILTER value
		*puValue = pObj->I2CMap.uBx03.bF.BP_Filter;
		break;

	case RFBAND:
		// get RFBAND value
		*puValue = pObj->I2CMap.uBx04.bF.RF_Band;
		break;

	case GAINTAPER:
		// get GAINTAPER value
		*puValue = pObj->I2CMap.uBx04.bF.Gain_Taper;
		break;

	case POWERSTATE:
		// get POWERSTATE
		TDA18211GetPowerState(pObj,(ptmTDA18211PowerState_t)puValue);
		break;

	case LPFC:
		// get LPFC value
		*puValue = pObj->I2CMap.uBx05.bF.Std & 0x03;
		break;


	case CALRFN:
		*puValue = pObj->I2CMap.uBx06.bF.CAL_RFn;
		break;

	case STANDARDMODE:
		// get STANDARDMODE
		TDA18211GetStandardMode(pObj, (ptmTDA18211StandardMode_t)puValue);
		break;

	case XTOUT:
		// get XTout_ON & Xtout_400mV value
		*puValue = (UInt32)(pObj->I2CMap.uBx06.bF.XTout_ON << 1 | pObj->I2CMap.uBx06.bF.Xtout_400mV);
		break;

	case IFLEVEL:
		// get IFLEVEL value
		*puValue = pObj->I2CMap.uBx06.bF.IF_Level;
		break;

	case EXTENDEDREG:
		// get EXTENDEDREG value
		*puValue = pObj->I2CMap.uBx07.bF.Extended_Reg;
		break;

	case CALPOSTDIV:
		// get CALPOSTDIV value
		*puValue = pObj->I2CMap.uBx08.CAL_POST_DIV_BYTE & 0x7F;
		break;

	case CALDIV:
		// get CALDIV value
		*puValue = pObj->I2CMap.uBx09.bF.CAL_Div_22_to_16 << 16 | pObj->I2CMap.uBx0A.bF.CAL_Div_15_to_8 << 8 | pObj->I2CMap.uBx0B.bF.CAL_Div_7_to_0;
		break;

	case MAINPOSTDIV:
		// get MAINPOSTDIV value
		*puValue = pObj->I2CMap.uBx0C.bF.MAIN_Post_Div;
		break;

	case MAINDIV:
		// get MAINDIV value
		*puValue = pObj->I2CMap.uBx0D.bF.MAIN_Div_22_to_16 << 16 | pObj->I2CMap.uBx0E.bF.MAIN_Div_15_to_8 << 8 | pObj->I2CMap.uBx0F.bF.MAIN_Div_7_to_0;
		break;

	case MAPVALUE:
		// set pointer on wanted cell
		switch (pObj->Config.uMAPNAME)
		{
		case tmTDA18211_IR_MEAS_Map:
			// test map column & row
			if ((pObj->Config.uMAPCOLUMN > TDA18211_IR_MEAS_NB_COLUMNS - 1) || (pObj->Config.uMAPROW > TDA18211_IR_MEAS_NB_ROWS - 1))
				return TM_ERR_NOT_SUPPORTED;
			// pDataMap initialization
			pDataMap = &(pObj->Config.IR_MEAS_Map[pObj->Config.uMAPROW].uRF_Max);
			break;	

		case tmTDA18211_IR_CAL_Map:
			// test map column & row
			if ((pObj->Config.uMAPCOLUMN > TDA18211_IR_CAL_NB_COLUMNS - 1) || (pObj->Config.uMAPROW > TDA18211_IR_CAL_NB_ROWS - 1))
				return TM_ERR_NOT_SUPPORTED;
			// pDataMap initialization
			pDataMap = &(pObj->Config.IR_CAL_Map[pObj->Config.uMAPROW].uRF);
			break;

		case tmTDA18211_BP_FILTER_Map:
			// test map column & row
			if ((pObj->Config.uMAPCOLUMN > TDA18211_BP_FILTER_NB_COLUMNS - 1) || (pObj->Config.uMAPROW > TDA18211_BP_FILTER_NB_ROWS - 1))
				return TM_ERR_NOT_SUPPORTED;
			// pDataMap initialization
			pDataMap = &(pObj->Config.BP_FILTER_Map[pObj->Config.uMAPROW].uRF_Max);
			break;

		case tmTDA18211_RF_BAND_Map:
			// test map column & row
			if ((pObj->Config.uMAPCOLUMN > TDA18211_RF_BAND_NB_COLUMNS - 1) || (pObj->Config.uMAPROW > TDA18211_RF_BAND_NB_ROWS - 1))
				return TM_ERR_NOT_SUPPORTED;
			// pDataMap initialization
			pDataMap = &(pObj->Config.RF_BAND_Map[pObj->Config.uMAPROW].uRF_Max);
			break;	

		case tmTDA18211_GAIN_TAPER_Map:
			// test map column & row
			if ((pObj->Config.uMAPCOLUMN > TDA18211_GAIN_TAPER_NB_COLUMNS - 1) || (pObj->Config.uMAPROW > TDA18211_GAIN_TAPER_NB_ROWS - 1))
				return TM_ERR_NOT_SUPPORTED;
			// pDataMap initialization
			pDataMap = &(pObj->Config.GAIN_TAPER_Map[pObj->Config.uMAPROW].uRF_Max);
			break;

		case tmTDA18211_RF_CAL_Map:
			// test map column & row
			if ((pObj->Config.uMAPCOLUMN > TDA18211_RF_CAL_NB_COLUMNS - 1) || (pObj->Config.uMAPROW > TDA18211_RF_CAL_NB_ROWS - 1))
				return TM_ERR_NOT_SUPPORTED;
			// pDataMap initialization
			pDataMap = &(pObj->Config.RF_CAL_Map[pObj->Config.uMAPROW].uRF_Max);
			break;

		case tmTDA18211_RF_CAL_DC_OVER_DT_Map:
			// test map column & row
			if ((pObj->Config.uMAPCOLUMN > TDA18211_RF_CAL_DC_OVER_DT_NB_COLUMNS - 1) || (pObj->Config.uMAPROW > TDA18211_RF_CAL_DC_OVER_DT_NB_ROWS - 1))
				return TM_ERR_NOT_SUPPORTED;
			// pDataMap initialization
			pDataMap = &(pObj->Config.RF_CAL_DC_OVER_DT_Map[pObj->Config.uMAPROW].uRF_Max);
			break;

		case tmTDA18211_RF_CAL_KMCO_Map:
			// test map column & row
			if ((pObj->Config.uMAPCOLUMN > TDA18211_RF_CAL_KMCO_NB_COLUMNS - 1) || (pObj->Config.uMAPROW > TDA18211_RF_CAL_KMCO_NB_ROWS - 1))
				return TM_ERR_NOT_SUPPORTED;
			// pDataMap initialization
			pDataMap = &(pObj->Config.RF_CAL_KMCO_Map[pObj->Config.uMAPROW].uRF_Max);
			break;

		case tmTDA18211_RF_CAL_CID_TARGET_Map:
			// test map column & row
			if ((pObj->Config.uMAPCOLUMN > TDA18211_RF_CAL_CID_TARGET_NB_COLUMNS - 1) || (pObj->Config.uMAPROW > TDA18211_RF_CAL_CID_TARGET_NB_ROWS - 1))
				return TM_ERR_NOT_SUPPORTED;
			// pDataMap initialization
			pDataMap = &(pObj->Config.RF_CAL_CID_TARGET_Map[pObj->Config.uMAPROW].uRF_Max);
			break;

		case tmTDA18211_THERMOMETER_Map:
			// test map column & row
			if ((pObj->Config.uMAPCOLUMN > TDA18211_THERMOMETER_NB_COLUMNS - 1) || (pObj->Config.uMAPROW > TDA18211_THERMOMETER_NB_ROWS - 1))
				return TM_ERR_NOT_SUPPORTED;
			// pDataMap initialization
			pDataMap = &(pObj->Config.THERMOMETER_Map[pObj->Config.uMAPROW].uTM_D);
			break;	

		case tmTDA18211_CAL_PLL_Map:
			// test map column & row
			if ((pObj->Config.uMAPCOLUMN > TDA18211_CAL_PLL_NB_COLUMNS - 1) || (pObj->Config.uMAPROW > TDA18211_CAL_PLL_NB_ROWS - 1))
				return TM_ERR_NOT_SUPPORTED;
			// pDataMap initialization
			pDataMap = &(pObj->Config.CAL_PLL_Map[pObj->Config.uMAPROW].uLO_Max);
			break;	

		case tmTDA18211_MAIN_PLL_Map:
			// test map column & row
			if ((pObj->Config.uMAPCOLUMN > TDA18211_MAIN_PLL_NB_COLUMNS - 1) || (pObj->Config.uMAPROW > TDA18211_MAIN_PLL_NB_ROWS - 1))
				return TM_ERR_NOT_SUPPORTED;
			// pDataMap initialization
			pDataMap = &(pObj->Config.MAIN_PLL_Map[pObj->Config.uMAPROW].uLO_Max);
			break;

		case tmTDA18211_I2C_Map:
			// test map column & row
			if ((pObj->Config.uMAPCOLUMN > 0) || (pObj->Config.uMAPROW > TDA18211_NB_BYTES - 1))
				return TM_ERR_NOT_SUPPORTED;
			// pI2CMap initialization
			pI2CMap = &(pObj->I2CMap.uBx00.ID_BYTE) + pObj->Config.uMAPROW;
			break;
		}
		// get cell value
		if  (pObj->Config.uMAPNAME == tmTDA18211_I2C_Map)
			*puValue = *(pI2CMap + pObj->Config.uMAPCOLUMN);
		else
			*puValue = *(pDataMap + pObj->Config.uMAPCOLUMN);
		break;

		// backdoor functions
	case IDENTITY:
		pObj->SystemFunc.SY_Read( pObj->uHwAddress, TDA18211_IDENTITY_IND, 1, &uByte); 
		/*if (uByte != 0x82) 
		*puValue = False; 
		else 
		*puValue = True; 
		*/
		switch (pObj->Config.uBoard & 0xffff0000)
		{ 
		case 0x57750000: 
			*puValue = True; 
			break;
		default:
			*puValue = False;
			break;
		}
		break;

	}
	return TM_OK;
}


//-------------------------------------------------------------------------------------
// FUNCTION:    tmbslTDA18211SetRf:
//
// DESCRIPTION: Calculate i2c I2CMap & write in TDA18211
//
// RETURN:      TMBSL_ERR_TUNER_BAD_UNIT_NUMBER
//              TMBSL_ERR_TUNER_NOT_INITIALIZED
//              TMBSL_ERR_TUNER_BAD_PARAMETER
//              TMBSL_ERR_IIC_ERR
//              TM_OK
//
// NOTES:       
//-------------------------------------------------------------------------------------
//
tmErrorCode_t
TMBSL_FUNC(SetRf)
(
 tmUnitSelect_t		TunerUnit,  //  I: Tuner unit number
 UInt32				uRF			//  I: RF frequency in hertz
 )
{	
	tmErrorCode_t ret = TMBSL_ERR_IIC_ERR;

	UInt32	uCounter = 0;
	UInt32	uTMVALUE_CURRENT = 0;

	UInt8	uCprog_table = 0;
	UInt8	uCapprox = 0;

	ptmTDA18211Object_t		pObj;

	//------------------------------
	// test input parameters
	//------------------------------
	// test the instance number
	if (TunerUnit > TDA18211_MAX_UNITS)
		return TMBSL_ERR_TUNER_BAD_UNIT_NUMBER;

	// test the Object
	if (gTDA18211Instance[TunerUnit].init == False)
		return TMBSL_ERR_TUNER_NOT_INITIALIZED;

	// pObj initialization
	pObj = &gTDA18211Instance[TunerUnit];

	// Config.uRF update
	pObj->Config.uRF = uRF;

	//----------------------
	// configuration reset
	//----------------------
	// set power level indicator to off
	pObj->Config.uPLMODE = 1;

	//----------------------
	// normal mode restore
	//----------------------
	// power up in calibration standard
	pObj->I2CMap.uBx05.bF.SM = 0x00;
	pObj->I2CMap.uBx05.bF.SM_LT = 0x00;
	pObj->I2CMap.uBx05.bF.SM_XT = 0x00;
	// write byte EASY_PROG_BYTE_3
	if (TDA18211Write(pObj,0x5,1) != True)
		return TMBSL_ERR_IIC_ERR;

	//----------------------
	// RF tracking filter correction
	//----------------------
	// sense temperature
	ret = TDA18211ThermometerRead(pObj, (UInt8 *)&uTMVALUE_CURRENT);
	if (ret != TM_OK)
		return ret;

	//----------------------
	// frequency dependent parameters update
	//----------------------
	// search for uCprog_table corresponding to uRF
	uCounter = 0;
	do uCounter ++;
	while (uRF > pObj->Config.RF_CAL_Map[uCounter - 1].uRF_Max && uCounter < TDA18211_RF_CAL_NB_ROWS);
	uCprog_table = (UInt8)pObj->Config.RF_CAL_Map[uCounter - 1].uRFC_Cprog;

	// search for sub-band corresponding to uRF
	uCounter = 0;
	do uCounter ++;
	while (uRF > pObj->Config.RF_BAND_Map[uCounter - 1].uRF_Max && uCounter < TDA18211_RF_BAND_NB_ROWS);

	// calculate Capprox
	if (pObj->Config.RF_BAND_Map[uCounter - 1].uRF1 == 0)
	{
		// Capprox = uCprog_table
		uCapprox = uCprog_table;
	}
	else if ((pObj->Config.RF_BAND_Map[uCounter - 1].uRF3 != 0) && (uRF >= pObj->Config.RF_BAND_Map[uCounter - 1].uRF2))
	{
		// Capprox = A2 * (uRF - uRF2) + B2 + uCprog_table
		uCapprox = (Int8)(((pObj->Config.RF_BAND_Map[uCounter - 1].uRF_A2 * ((Int32)(uRF - pObj->Config.RF_BAND_Map[uCounter - 1].uRF2) / 1000000)) / 1000000)
			+ pObj->Config.RF_BAND_Map[uCounter - 1].uRF_B2 + uCprog_table);
	}
	else
	{
		// Capprox = A1 * (uRF - uRF1) + B1 + uCprog_table
		uCapprox = (Int8)(((pObj->Config.RF_BAND_Map[uCounter - 1].uRF_A1 * ((Int32)(uRF - pObj->Config.RF_BAND_Map[uCounter - 1].uRF1) / 1000000)) / 1000000)
			+ pObj->Config.RF_BAND_Map[uCounter - 1].uRF_B1 + uCprog_table);
	}

	// search for udC_Over_dT corresponding to uRF
	uCounter = 0;
	do uCounter ++;
	while (uRF > pObj->Config.RF_CAL_DC_OVER_DT_Map[uCounter - 1].uRF_Max && uCounter < TDA18211_RF_CAL_DC_OVER_DT_NB_ROWS);

	// calculate CTcomp
	pObj->Config.uRFCAL_TCOMP = (Int32)(pObj->Config.RF_CAL_DC_OVER_DT_Map[uCounter - 1].udC_Over_dT * (uTMVALUE_CURRENT - pObj->Config.uTMVALUE_RFCAL)) / 1000;

	// calculate Cprog
	pObj->I2CMap.uBx1D.RFC_Cprog = uCapprox + (Int8)pObj->Config.uRFCAL_TCOMP;

	// write byte RFC_Cprog
	if (TDA18211Write(pObj,0x1D,1) != True)
		return TMBSL_ERR_IIC_ERR;

	//----------------------
	// standard mode update
	//----------------------
	// update TV broadcast parameters
	ret = TDA18211SetStandardMode(pObj, pObj->StandardMode);
	if (ret != TM_OK)
		return ret;

	// write bytes EXTENDED_BYTE_21 to EXTENDED_BYTE_23
	if (TDA18211Write(pObj,0x24,3) != True)
		return TMBSL_ERR_IIC_ERR;

	//----------------------
	// update frequency dependent parameters
	//----------------------
	// search for IR_Meas corresponding to wanted frequency
	uCounter = 0;
	do uCounter ++;
	while (uRF > pObj->Config.IR_MEAS_Map[uCounter - 1].uRF_Max && uCounter < TDA18211_IR_MEAS_NB_ROWS);
	pObj->I2CMap.uBx07.bF.IR_Meas = (UInt8)pObj->Config.IR_MEAS_Map[uCounter - 1].uIR_Meas;

	// search for BP_Filter corresponding to uRF
	uCounter = 0;
	do uCounter ++;
	while (uRF > pObj->Config.BP_FILTER_Map[uCounter - 1].uRF_Max && uCounter < TDA18211_BP_FILTER_NB_ROWS);
	pObj->I2CMap.uBx03.bF.BP_Filter = (UInt8)pObj->Config.BP_FILTER_Map[uCounter - 1].uBP_Filter;

	// search for RF_BAND corresponding to uRF
	uCounter = 0;
	do uCounter ++;
	while (uRF > pObj->Config.RF_BAND_Map[uCounter - 1].uRF_Max && uCounter < TDA18211_RF_BAND_NB_ROWS);
	pObj->I2CMap.uBx04.bF.RF_Band = (UInt8)pObj->Config.RF_BAND_Map[uCounter - 1].uRF_Band;

	// search for Gain_Taper corresponding to uRF
	uCounter = 0;
	do uCounter ++;
	while (uRF > pObj->Config.GAIN_TAPER_Map[uCounter - 1].uRF_Max && uCounter < TDA18211_GAIN_TAPER_NB_ROWS);
	pObj->I2CMap.uBx04.bF.Gain_Taper = (UInt8)pObj->Config.GAIN_TAPER_Map[uCounter - 1].uGain_Taper;

	//---------------------
	// dual tuner and AGC1 extra configuration management
	//---------------------
	// use MAIN VCO when master, CAL VCO when slave
	pObj->I2CMap.uBx10.bF.CALVCO_forLOn = (TunerUnit == 0) ? 1 : 0;

	// AGC1 & AGC2 management
	pObj->I2CMap.uBx10.bF.AGC1_always_mastern = 0x00;
	pObj->I2CMap.uBx10.bF.AGC1_firstn = 0x00;

	// write byte EXTENDED_BYTE_1
	if (TDA18211Write(pObj,0x10,1) != True)
		return TMBSL_ERR_IIC_ERR;

	//---------------------
	// tune to wanted channel frequency
	//---------------------
	// use MAIN VCO when master, CAL VCO when slave
	if (TunerUnit == 0) // master
	{
		// calculate MAIN PLL
		if (TDA18211CalcMAINPLL(pObj, uRF + pObj->Config.uIF) == False)
			return TM_FALSE;

		// write bytes 0x01 to 0x0F
		if (TDA18211Write(pObj,0x01,15) != True)
			return TMBSL_ERR_IIC_ERR;