lv2410x.c

LV24000的单片机DEMO程序

			byValue = 1;
		break;

	case IHCAP_BEEPSOURCE:
		// Beep source: check beep source enable bit and beep tone select bits
		// Source enable	BeepSelect		HW beep Value
		//	Disable		X			off (=0)
		//	Enable		Beep_High		off
		//	Enable		500/1000/2000Hz		1,2,3

		// Fist beep source enable bit
		byTmp = GetSwRegValue(IR01_RADIO_CTRL3_REG);
		if ( byTmp & IR1_RCTL3_SE_BEEP )		// Beep source is enabled
		{
			byTmp = (BYTE)(GetSwRegValue(IR01_AUDIO_CTRL2_REG) & IR1_ACTL2_BPFREQ);
			if (byTmp == IR1_BEEP_500Hz) 		// 0.5 kHz beep tone
				byValue = 1;
			else if (byTmp == IR1_BEEP_1KHz)	// 1 kHz beep tone
				byValue = 2;
			else if (byTmp == IR1_BEEP_2KHz)	// 2 kHz beep tone
				byValue = 3;
		}
		break;

	case IHCAP_DYNBASSBOOST:	// Dynamic bass boost feature
		byValue = g_byDynBassBoost;
		break;

	case IHCAP_HPA:			// Headphone amplifier
		if ( g_byHwFlag1 & HF1_HP )
		{
			if ( GetSwRegValue(IR01_PW_SCTRL_REG) & IR2_PSCTL_HPA )
				byValue=1;
		}
		break;

//	case IHCAP_CNT2:

	// Software settings
	case IHCAP_SCANLVL:	// Scan level
		byValue = g_byScanLevel;
		break;

	case IHCAP_SCANWRP:	// Scan wrapping
		byValue = (BYTE)(g_byStnFlag & STN_WRAP_MODE);
		break;

	case IHCAP_REGION:	// Region
		byValue = g_byRegion;
		break;

	case IHCAP_BEEPVOL:	// Beep volume
		byValue = g_byBeepVol;
		break;

#ifdef USE_EXTCLK
	case IHCAP_EXTCLK:
		byValue = (BYTE)(g_bySwFlag1 & SF1_EXTCLK);
		break;
#endif //USE_EXTCLK

	default:
		break;
		//break;
	} // EndSwitch

	return(byValue);
} // End GetHwFeatureValue
/* ************************************************************************************************
 *
 *  Function:   SetHwFeatureValue
 *
 *  Authors:    Hung van Le
 *  Purpose:    Setting capability value of the device
 *  Input:	byFeatureId: see Lv24Ekit.h for definitions
 *		pbyValue: pointer to the value to be set
 *  Output:     Status as defined in LvErr.h
 *  Comments:   None
 *
 * ************************************************************************************************
 * Copyright (c) 2004. Semiconductor Ideas to the Market (ItoM) B.V. All rights reserved.
 * ************************************************************************************************ */
BYTE SetHwFeatureValue(BYTE byFeatureId, BYTE byValue)
{
	BYTE byResult;
	BYTE byTmp;

	// Some features can not be set in AM mode
	if ( (g_byStnFlag & STN_AM_MODE) == STN_AM_MODE )
	{
		if ( (byFeatureId == IHCAP_STEREO) || 		// Stereo/Mono
		     (byFeatureId == IHCAP_SOFT_ST) )		// Soft stereo
		{
			return(LVLS_FEATURE_NA_NOW_ERR);
		}
	}

	// Init local
	byResult = LVLS_NO_ERROR;

	switch (byFeatureId)
	{
	case IHCAP_TUNERPWR:		// Tuner power
		DriveBit(IR01_PW_SCTRL_REG, IR1_PSCTL_PW_RAD, byValue);
		break;

	case IHCAP_AMUTE:		// Audio mute
		SetChipAudioMute(byValue, MUTESRC_APPLICATION);
		break;

	case IHCAP_VOLUME:		// Volume
		AdjustVolume(byValue);
		break;

	case IHCAP_STEREO:		// Stereo/Mono
		byResult = SetStereoMono(byValue);
		break;

	//case IHCAP_DEEMP:
	//	SetDeemphasis(byValue);
	//	break;

	case IHCAP_SMUTE:		// Soft mute
		// Soft mute is in bit [4:2] of IR01_PW_SCTRL_REG
		byTmp = (BYTE)((byValue) & 0x7);	// Make sure we have valid level
		SetRegBits(IR01_PW_SCTRL_REG, IR1_PSCTL_SOFT_MUTE, (byTmp<<2));
		break;

	case IHCAP_SOFT_ST:		// Soft stereo
		// Soft stereo is in bit [7:5] of IR01_PW_SCTRL_REG
		byTmp = (BYTE)((byValue) & 0x7);	// Make sure we have valid level
		SetRegBits(IR01_PW_SCTRL_REG, IR1_PSCTL_SOFT_ST, (byTmp<<5));
		break;

	//case IHCAP_AFC:		// AFC (automatic frequency control)
	//	SetAFCMode(byValue);
	//	break;

	case IHCAP_ATREBLE:		// Audio treble
		if ( byValue >= IMR1_TREBLE_LSIZE)
			byResult = LVLS_INV_FEATURE_VALUE_ERR;
		else
		{
			SetRegBits(IR01_AUDIO_CTRL2_REG, IR1_ATREBLE_MASK, g_Lv24001Treble[byValue]);
			AdjustHwToneControl();
		}
		break;

	case IHCAP_ABASS:		// Audio bass
		if ( byValue >= IMR1_BASS_LSIZE)
			byResult = LVLS_INV_FEATURE_VALUE_ERR;
		else
		{
			SetRegBits(IR01_AUDIO_CTRL2_REG, IR1_ABASS_MASK, g_Lv24001Bass[byValue]);
			AdjustHwToneControl();
		}
		break;

	case IHCAP_RADIOSOURCE:
		// Input: 0: off, 1: FM, 2: AM
		if (byValue == RBAND_FM) // FM
		{
			SetRadioFm();
			SetRegBits(IR01_RADIO_CTRL3_REG, IR3_RCTL3_AMFM_MASK, IR1_RCTL3_SE_FM);
		}
		else if (byValue == RBAND_AM) // AM
		{
			if ( (g_byHwFlag1 & HF1_AM)==0 )	// Wrong device connected
			{
				byResult =  LVLS_IMPROPER_HW_SETTING_ERR;
			}
			else
			{
				SetRadioAm();
				SetRegBits(IR01_RADIO_CTRL3_REG, IR3_RCTL3_AMFM_MASK, IR3_RCTL3_SE_AM);
			}
		}
		else // RBAND_OFF - turn off radio source
		{
			SetChipStereo(g_byFmStereo);	// Retore stereo state when changing source
			SetRegBits(IR01_RADIO_CTRL3_REG, IR3_RCTL3_AMFM_MASK, IR3_RCTL3_NO_AMFM);
		}
		break;

	case IHCAP_EXTSOURCE:
		// Input: 0=off 1=on
		DriveBit(IR01_RADIO_CTRL3_REG, IR1_RCTL3_SE_EXT, byValue);
		break;

	case IHCAP_BEEPSOURCE:
		// Beep source: Driving beep source enable bit and beep tone select bits
		// HW beep Value	Source enable	BeepSelect
		//	0 (off)		Disable		High    
		//	1,2,3		Enable		500/1000/2000Hz

	       	// Adjust registers according to input value
		if ( byValue==1)		// Beep at 500 Hz
			byTmp = IR1_BEEP_500Hz;
		else if ( byValue==2)	// Beep at 1000 Hz
			byTmp = IR1_BEEP_1KHz;
		else if ( byValue==3)	// Beep at 2000 Hz
			byTmp = IR1_BEEP_2KHz;
		else
			byTmp = IR1_BEEP_OFF;		// 0 or unknown values: turn off

		// Change beep frequency select bits
		SetRegBits(IR01_AUDIO_CTRL2_REG, IR1_ACTL2_BPFREQ, byTmp);
			
		// Change beep source enable bit
		DriveBit(IR01_RADIO_CTRL3_REG, IR1_RCTL3_SE_BEEP, (byTmp != IR1_BEEP_OFF));
		break;

	/*
	case IHCAP_BEEPBIT:
		if (pValue->Beep.byDuration != SET_BEEP_OFF) // Always OK to turn off
		{
			if (GetSwRegValue(IR01_RADIO_CTRL3_REG) & IR1_RCTL3_SE_BEEP ) // Hardware beep busy - can not set software beep value
				dwResult = LVLS_IMPROPER_HW_SETTING_ERR;
		}
		if (dwResult == LVLS_NO_ERROR)
		{
			// Update the shadow software beep state
			if (pValue->Beep.byDuration == SET_BEEP_OFF) // Always OK to turn off
				m_bSwBeepOn = false;
			else
				m_bSwBeepOn = true;
			dwResult = BeepHandler(pValue->Beep.wFreqHz, pValue->Beep.byDuration);
		}
		break;
	*/
	case IHCAP_DYNBASSBOOST:	// Dynamic bass boost feature
		if (g_byDynBassBoost != byValue )
		{
			BYTE byTone, byVolume;

			// Dynamic bass level changed
			g_byDynBassBoost = byValue;		// Fecth new dynamic bass boost level

			// IR01_AUDIO_CTRL1_REG has bit[7:4] as tone control, [3:0] as volume. 
			// Set the tone control level if it is not correct
			byVolume = GetSwRegValue(IR01_AUDIO_CTRL1_REG);		// Fetch tone and volume value
			byTone = (BYTE)((byVolume & IR1_ACTL1_TONE_LVL)>>4);	// extract tone value
			byVolume &= (IR1_ACTL1_VOL_LVL);			// extract volume value
			byVolume = 15-byVolume;					// IMR01 has volume bits inverted - we have now the logical volume level
			byTone = 15 - byTone;									// The 4 tone bits are inverted - we have now the logical tone level
			// Modify tone when it's not equal to dynamic bass level
			if ( byTone != g_byDynBassBoost )
			{
				if (byVolume < g_byDynBassBoost )	// Logical volume level doesn't exceed dynamic bass boost level
					byTone = byVolume;		// Let tone level follow volume level
				else					// Volume level exceeds dynamic bass boost
					byTone = g_byDynBassBoost;	// Keep tone level fixed at dynamic bass boost level
				byTone = 15 - byTone;			// Convert tone level to tone value (the 4 tone bits are inverted)
				byTone <<= 4;				// Shift tone to correction position
				SetRegBits(IR01_AUDIO_CTRL1_REG, IR1_ACTL1_TONE_LVL, byTone);
			}
		}
		break;

	case IHCAP_HPA:	// Headphone amplifier
		// Input: 0=off 1=on
		// Check if headphone support
		if ( g_byHwFlag1 & HF1_HP)
			DriveBit(IR01_PW_SCTRL_REG, IR2_PSCTL_HPA, byValue);
		break;
		
//	case IHCAP_CNT2:
//  		m_dwCnt2ExtClk = pValue->Cnt2.dwExtClock; // Save the external clock (in Hz) for later usage
//		break;

	// Software settings
	case IHCAP_SCANLVL:	// Scan level
		g_byScanLevel = byValue;
		break;

	case IHCAP_SCANWRP:	// Scan wrapping
		g_byStnFlag &= (~STN_WRAP_MODE);	// clear old setting
		g_byStnFlag |= (byValue & STN_WRAP_MODE);
		break;

	case IHCAP_REGION:	// Region
		byResult = SetRegion(byValue);
		break;

	case IHCAP_BEEPVOL:	// Audible feedback volume
		g_byBeepVol = byValue;
		break;

#ifdef USE_EXTCLK
	case IHCAP_EXTCLK:
		g_bySwFlag1 &= (BYTE)(~SF1_EXTCLK);
		g_bySwFlag1 |= (BYTE)(byValue & SF1_EXTCLK);
		break;
#endif //USE_EXTCLK

	default:
		byResult = LVLS_NSU_FEATURE_ERR;
		break;
	} // EndSwitch
	return(byResult);
} // End SetHwFeatureValue

void AdjustHwToneControl(void)
{
	// Control the ToneMute bit (IR1_RCTL3_TONE_MUTE_L of IR01_RADIO_CTRL3_REG)
	// Unmute the tone control if bass or treble is not 0
	BYTE byTmp;
	BOOL bState;
		
	byTmp = GetSwRegValue(IR01_AUDIO_CTRL2_REG);
	
	if (byTmp & (IR1_ATREBLE_MASK|IR1_ABASS_MASK)) // One or more tone bit is set
		bState = FALSE;	// Don't mute the tone
	else
		bState = TRUE;	// All tone bits are 0, mute the tone control
	DriveBitNeg(IR01_RADIO_CTRL3_REG, IR1_RCTL3_TONE_MUTE_L, bState);
} // End AdjustHwToneControl

// ==============================================================================
// Following routines are modified for LV2410x
// ==============================================================================
/* ************************************************************************************************
 *
 *  Function:   GetOutputSelect
 *
 *  Authors:    Hung van Le
 *  Purpose:    Select an output of IMR01 chip
 *  Input:      Nothing
 *  Output:     The output select
 *  Comments:   The output select is virtualized.
 *
 * ************************************************************************************************
 * Copyright (c) 2004. Semiconductor Ideas to the Market (ItoM) B.V. All rights reserved.
 * ************************************************************************************************ */
BYTE GetOutputSelect(void)
{ 
	BYTE byCurOutputSel;

	// Get current measuring mask
	byCurOutputSel = GetSwRegValue(IR01_MSRC_SEL_REG) & IR1_MSRCS_MSS_MASK;
	if (byCurOutputSel == IR1_MSRCS_MSS_FM)
		return(CO_RF_OSC);	// RF frequency
	else if (byCurOutputSel == IR1_MSRCS_MSS_IF)
		return(CO_IF_OSC);	// IF frequency
	else if (byCurOutputSel == IR1_MSRCS_MSS_SD)
		return(CO_SD_OSC);	// SD frequency
	else // other settings
		return(CO_NONE);
} // End GetOutputSelect

/* ************************************************************************************************
 *
 *  Function:   SetOutputSelect
 *
 *  Authors:    Hung van Le
 *  Purpose:    Select an output of IMR01 chip
 *  Input:      
 *		WORD wOutputCfg: desired output (See SetUpChipMode in Lv24Ekit.h for possible outputs)
 *  Output:     The original output select
 *  Comments:   The output select is virtualized.
 *
 * ************************************************************************************************
 * Copyright (c) 2004. Semiconductor Ideas to the Market (ItoM) B.V. All rights reserved.
 * ************************************************************************************************ */
WORD SetOutputSelect(WORD wOutputCfg)
{
	WORD wCurOutputCfg;

	// Determine current chip output
	wCurOutputCfg = GetOutputSelect();

	// Do nothing if no change
	if (wCurOutputCfg == wOutputCfg)
		return(wCurOutputCfg);		

	// Output select change - update chip
	switch (wOutputCfg)
	{
	case CO_NONE:	// Disable all measurements
		SetRegBits(IR01_MSRC_SEL_REG, IR1_MSRCS_MSS_MASK, 0);
		break;

	case CO_RF_OSC:	// RF frequency
		SetRegBits(IR01_MSRC_SEL_REG, IR1_MSRCS_MSS_MASK