tua6034.c

mstar 776 开发的车载dvd

// Outputs:
//		none
//
// Returns:
//		int, tuner locked
//
// Description:
//		returns status of Tuner Locked
//
int TUN_GetLocked(void* Instance, Bool* Locked)
{
	TUN_DC *pDC, *pDummy;

	pDC = FindTunDC(Instance, &pDummy);

	if (pDC == NULL_INSTANCE) return TUN_MEMORY_PB;

	TUN_ReadStatus(Instance, &pDC->Status_Byte);
	*Locked=(!(pDC->Status_Byte & TUNER_LOCK_MASK))? FALSE:TRUE;
	return TUN_OK;
} //TUN_GetLocked


/////////////////////////////////////////////////////////////////////////////
// TUN_SetFreq
//
// Inputs:
//		void *Instance, points to device instance
//		double dFMHz - frequency, in MHz, to be tuned
//
// Outputs:
//		none
//
// Returns:
//		0 = no error
//		TUN_FREQUENCY_RANGE_ERROR
//
// Description:
//	range-check the specified frequency
//	if the frequency is in range
//		store current frequency
//		tune the frequency
//	else
//		indicate out-of-range error
//
int TUN_SetFreq(void* Instance, double dFMHz)
{
	TUN_DC *pDC, *pDummy;

	pDC = FindTunDC(Instance, &pDummy);

	if (pDC == NULL_INSTANCE) return TUN_MEMORY_PB;

	//	range-check the specified frequency
	if ( (dFMHz <= FREQ_MIN) && (FREQ_MAX <= dFMHz))
		return TUN_FREQUENCY_RANGE_ERROR;
	else
	{
		pDC->frequency=dFMHz;
		return SetFrequency(Instance, dFMHz);
	}
} // TUN_SetFreq


 /**************************************************************************
**
** NON-EXPORTED FUNCTIONS NEXT
**
**
**
***************************************************************************/

/////////////////////////////////////////////////////////////////////////////
// GetAddr
//
// Inputs:
//		void *Instance, points to device instance
//
// Outputs:
//		Data8 *pAddr = I2C address of tuner device
//
// Returns:
//		0 = no error (always)
//
static int GetAddr(void* Instance, Data8 *pAddr)
{
	TUN_DC *pDC, *pDummy;

	pDC = FindTunDC(Instance, &pDummy);

	if (pDC == NULL_INSTANCE) return TUN_MEMORY_PB;

	*pAddr = pDC->IIC_Addr;
	return TUN_OK;
} // GetAddr


/////////////////////////////////////////////////////////////////////////////
// GetFreq
//
// Inputs:
//		void *Instance, points to device instance
//
// Outputs:
//		double *pdFMHz - current frequency, in MHz
//
// Returns:
//		0 = no error
//		TUN_OTHER_ERROR -- no (unknown) frequency currently tuned
//
static int GetFreq(void* Instance, double *pdFMHz)
{
	TUN_DC *pDC, *pDummy;

	pDC = FindTunDC(Instance, &pDummy);

	if (pDC == NULL_INSTANCE) return TUN_MEMORY_PB;

	*pdFMHz = pDC->frequency;
	if (pDC->frequency) {
		return TUN_OK;
	}
	else {
		return TUN_OTHER_ERROR;
	}

} // GetFreq


/////////////////////////////////////////////////////////////////////////////
// SetStandard
//
// Inputs:
//		void *Instance, points to device instance
//		TUN_Standard_t* std -- OFF_AIR_STD or CABLE_STD
//
// Outputs:
//		none
//
// Returns:
//		0 = no error
//		TUN_STANDARD_RANGE_ERROR
//
static int SetStandard(void* Instance, TUN_Standard_t* std)
{
	TUN_DC *pDC, *pDummy;

	pDC = FindTunDC(Instance, &pDummy);

	if (pDC == NULL_INSTANCE) return TUN_MEMORY_PB;

	switch (*std) {
	case OFF_AIR_STD:
	case CABLE_STD:
	case CABLE_IRC:
	case CABLE_HRC:
		pDC->standard = *std;
        break;
	default:
		return TUN_STANDARD_RANGE_ERROR;
	}
        return TUN_OK;
} // SetStandard


/////////////////////////////////////////////////////////////////////////////
// GetStandard
//
// Inputs:
//		void *Instance, points to device instance
//
// Outputs:
//		TUN_Standard_t *pStd = current standard
//
// Returns:
//		0 = no error (always)
//
static int GetStandard(void* Instance, TUN_Standard_t *pStd)
{
	TUN_DC *pDC, *pDummy;

	pDC = FindTunDC(Instance, &pDummy);

	if (pDC == NULL_INSTANCE) return TUN_MEMORY_PB;

	*pStd = pDC->standard;
	return TUN_OK;
} // GetStandard

/////////////////////////////////////////////////////////////////////////////
// MapChanToFreq
//
// Inputs:
//		void *Instance, points to device instance
//		Data8 Channel - channel to convert to frequency
//
// Outputs:
//		double *pdFMHz - frequency corresponding to specified channel
//
// Returns:
//		0 = no error
//		TUN_CHANNEL_RANGE_ERROR
//
static int MapChanToFreq(void* Instance, Data8 Channel, double *pdFMHz)
{
	TUN_DC *pDC, *pDummy;
	double Freq;
	Data8  CHAN_MAX, CHAN_MIN;

	pDC = FindTunDC(Instance, &pDummy);

	if (pDC == NULL_INSTANCE) return TUN_MEMORY_PB;

	*pdFMHz = 0;

	CHAN_MAX= ((pDC->standard == OFF_AIR_STD) ? CHAN_MAX_OFF_AIR : CHAN_MAX_CABLE );
	CHAN_MIN= ((pDC->standard == OFF_AIR_STD) ? CHAN_MIN_OFF_AIR : CHAN_MIN_CABLE );

	if ( (CHAN_MIN > Channel) || (CHAN_MAX < Channel) )
	{
		// channel out of range
		return TUN_CHANNEL_RANGE_ERROR;
	}

	if (pDC->standard == OFF_AIR_STD)
	{
		switch (Channel)
		{
			/* Lo VHF */
			case 2:		Freq = 57;	break;
			case 3:		Freq = 63;	break;
			case 4:		Freq = 69;	break;
			case 5:		Freq = 79;	break;
			case 6:		Freq = 85;	break;
			/* Hi VHF */
			case 7:		Freq = 177;	break;
			case 8:		Freq = 183;	break;
			case 9:		Freq = 189;	break;
			case 10:	Freq = 195;	break;
			case 11:	Freq = 201;	break;
			case 12:	Freq = 207;	break;
			case 13:	Freq = 213;	break;
			/* UHF */
			default:	Freq = Channel*6 + 389;
		}
	}
	else // CABLE_STD || CABLE_IRC || CABLE_HRC
	{
		switch (Channel)
		{
			case 1:		Freq = 73.25;	break;
			case 2:		Freq = 55.25;	break;
			case 3:		Freq = 61.25;	break;
			case 4:		Freq = 67.25;	break;
			case 5:		Freq = 77.25;	break;
			case 6:		Freq = 83.25;	break;
			case 23:	Freq = 217.25;	break;
			case 24:	Freq = 223.25;	break;
			case 42:	Freq = 331.275; break;
			case 95:	Freq = 91.25;	break;
			case 96:	Freq = 97.25;	break;
			case 97:	Freq = 103.25;	break;
			case 98:	Freq = 109.275;	break;
			case 99:	Freq = 115.275;	break;
			default:
				if		((Channel >=   7) && (Channel <=   13))
					Freq = (Channel -   7)*6 + 175.25;
				else if	((Channel >=  14) && (Channel <=   22))
					Freq = (Channel -  14)*6 + 121.2625;
				else if	((Channel >=  25) && (Channel <=   41))
					Freq = (Channel -  25)*6 + 229.2625;
				else if	((Channel >=  43) && (Channel <=   53))
					Freq = (Channel -  43)*6 + 337.2625;
				else if	((Channel >=  54) && (Channel <=   94))
					Freq = (Channel -  54)*6 + 403.25;
				else if	((Channel >= 100) && (Channel <=  158))
					Freq = (Channel - 100)*6 + 649.25;
		}

		/* map to HRC system: Freq_HRC = Freq_STD - 1.25 Mhz*/
		if (pDC->standard == CABLE_HRC)
			Freq -= 1.25;

		/* Center_carrier = Video_carrier + 1.75 Mhz */
		Freq += 1.75; // add offset from Peak-of-sync
	}

	*pdFMHz = Freq;
	return TUN_OK;

} // MapFreqToChannel

/////////////////////////////////////////////////////////////////////////////
// MapFreqToChan
//
// Inputs:
//		void *Instance, points to device instance
//		double* dFMHz - frequency to convert to channel, according to
//			currently selected standard map.
//
// Outputs:
//		Data8 *pChannel - channel corresponding to specified frequency
//
// Returns:
//		0 = no error
//		TUN_FREQUENCY_RANGE_ERROR
//
static int MapFreqToChan(void* Instance, double* dFMHz, Data8 *pChannel)
{
	Data8	chan;
	Data8 	CHAN_MAX, CHAN_MIN;
	double	freq;
	TUN_DC *pDC, *pDummy;

	pDC = FindTunDC(Instance, &pDummy);

	if (pDC == NULL_INSTANCE) return TUN_MEMORY_PB;

	CHAN_MAX= ((pDC->standard == OFF_AIR_STD) ? CHAN_MAX_OFF_AIR : CHAN_MAX_CABLE );
	CHAN_MIN= ((pDC->standard == OFF_AIR_STD) ? CHAN_MIN_OFF_AIR : CHAN_MIN_CABLE );

	if ((FREQ_MIN > *dFMHz) || (FREQ_MAX < *dFMHz)) {
		return TUN_FREQUENCY_RANGE_ERROR;
	}

	for (chan = CHAN_MIN; chan <= CHAN_MAX; chan++)
	{
		MapChanToFreq(Instance, chan, &freq );
		freq = fabs(freq - *dFMHz);
		if ( freq < 0.0312) {
			*pChannel = chan;
			return TUN_OK;
		}
	}

	*pChannel = 0;
	return TUN_FREQUENCY_RANGE_ERROR;

} // MapFreqToChannel


/////////////////////////////////////////////////////////////////////////////
// SetPLLDivider
//
// Inputs:
//		void *Instance, points to device instance
//		ratio - PLL divider ratio
//
// Outputs:
//		none
//
// Returns:
//		none
//
// Description:
//		shift and mask divider ratio into tuner I2C data array
//
static int	 SetPLLDivider(void* Instance, int ratio)
{
	TUN_DC *pDC, *pDummy;

	pDC = FindTunDC(Instance, &pDummy);

	if (pDC == NULL_INSTANCE) return TUN_MEMORY_PB;

	pDC->tunerConfig[DIVIDER1] = (Data8) (0x7f & (ratio >> 8));
	pDC->tunerConfig[DIVIDER2] = (Data8) (0xff & ratio);
	return TUN_OK;
}


/////////////////////////////////////////////////////////////////////////////
// SetOSBit
//
// Inputs:
//		void *Instance, points to device instance
//		bool OSValue
//
// Outputs:
//		none
//
// Returns:
//		none
//
// Description:
//		set OS bit in CB Byte
//
static int	 SetOSBit(void* Instance, bool OSValue)
{
	TUN_DC *pDC, *pDummy;

	pDC = FindTunDC(Instance, &pDummy);

	if (pDC == NULL_INSTANCE) return TUN_MEMORY_PB;

	if(!OSValue)	pDC->CB_Byte &= ~OS_BIT;	// OS = 0
	else	pDC->CB_Byte |= OS_BIT;				// OS = 1
	return TUN_OK;
} // SetTunerInput


/////////////////////////////////////////////////////////////////////////////
// SetChargePump
//
// Inputs:
//		void *Instance, points to device instance
//		bool pumpSetting - TRUE or FALSE
//
// Outputs:
//		none
//
// Returns:
//		none
//
// Description:
//		set CP bit in CB byte
//
static int	 SetChargePump(void* Instance, bool pumpSetting)
{
	TUN_DC *pDC, *pDummy;

	pDC = FindTunDC(Instance, &pDummy);

	if (pDC == NULL_INSTANCE) return TUN_MEMORY_PB;

	if(!pumpSetting) pDC->CB_Byte &=~HIGH_PUMP;	// CP = 0
	else pDC->CB_Byte |= HIGH_PUMP;				// CP = 1
	return TUN_OK;
} // SetChargePump


/////////////////////////////////////////////////////////////////////////////
// SetRSBits
//
// Inputs:
//		void *Instance, points to device instance
//		Data8 RSValue
//
// Outputs:
//		none
//
// Returns:
//		none
//
// Description:
//		set RS bits in CB byte and select F_ref
//
static int	 SetRSBits(void* Instance, Data8 RSValue)
{
	TUN_DC *pDC, *pDummy;
	Data8 temp = (pDC->CB_Byte & ~TEST_BITS)>>4; // isolate T2T1 - TUA6034 only

	pDC = FindTunDC(Instance, &pDummy);

	if (pDC == NULL_INSTANCE) return TUN_MEMORY_PB;

	if((0<=RSValue) && (RSValue<=3))
	{
		pDC->CB_Byte &= 0xF9;
		pDC->CB_Byte |= (RSValue<<1);
	}

	switch(RSValue)
	{
		case(0): if(((temp & 0x03)==0) || (pDC->AB_Byte != 0xFF)) pDC->F_ref=F_REF1;
			else if((temp & 0x03)==3) pDC->F_ref=F_REF5; break;
		case(1): if(((temp & 0x03)==0) || (pDC->AB_Byte != 0xFF)) pDC->F_ref=F_REF2;
			else if((temp & 0x03)==3) pDC->F_ref=F_REF6; break;
		case(2): if(pDC->CB_Byte != 0xFF) pDC->F_ref=F_REF1; // TDA6508
			else pDC->F_ref=F_REF3; break;
		case(3): default: pDC->F_ref=F_REF4; break;
	}
	return TUN_OK;
} // SetRSBits


/////////////////////////////////////////////////////////////////////////////
// SetTestBits
//
// Inputs:
//		void *Instance, points to device instance
//		Data8 TestValue
//
// Outputs:
//		none
//
// Returns:
//		none
//
// Description:
//		set test (T2/T1/T0) bits in CB byte
//
static int	 SetTestBits(void* Instance, Data8 TestValue)
{
	TUN_DC *pDC, *pDummy;

	pDC = FindTunDC(Instance, &pDummy);

	if (pDC == NULL_INSTANCE) return TUN_MEMORY_PB;

	pDC->CB_Byte &= 0xC7;

	if((0<=TestValue) && (TestValue<=7) && (TestValue!=5))
		pDC->CB_Byte |= (TestValue<<3);
	else pDC->CB_Byte |= (1<<3); // default
	return TUN_OK;
} // SetTestBits



/////////////////////////////////////////////////////////////////////////////
// SetTunerBand
//
// Inputs:
//		void *Instance, points to device instance
//		double dFMHz - tuner frequency
//
// Outputs:
//		none
//
// Returns:
//		none
//
// Description:
//		set BB_Byte byte based on frequency range
//      and antenna input selection
//
static int	 SetTunerBand(void* Instance, double dFMHz)
{
	TUN_DC *pDC, *pDummy;

	pDC = FindTunDC(Instance, &pDummy);

	if (pDC == NULL_INSTANCE) return TUN_MEMORY_PB;

	if(pDC->AB_Byte != 0xFF)
	{
		pDC->BB_Byte &= 0xF8;
		//set values
		if (dFMHz < 160.0) {
			pDC->BB_Byte |= LOW_BAND;
		}