You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
814 lines
27 KiB
814 lines
27 KiB
|
|
/********************************************************************************************************
|
|
*Copyright (C) 2019-2030, Altobeam
|
|
*File name: ATBM253Api.c
|
|
*Description: Implement of ATBM253 SDK APIs.
|
|
*
|
|
*Modification History:
|
|
* 2019-03-20:
|
|
* 1. Release v1.0.0
|
|
* 2019-06-11:
|
|
* 1. Release v1.0.1
|
|
* 2019-06-21:
|
|
* 1. Release v1.0.2
|
|
* 2019-07-19:
|
|
* 1. Release v1.0.3
|
|
* 2019-08-09:
|
|
* 1. Release v1.0.4
|
|
* 2019-09-06:
|
|
* 1. Release v1.0.5
|
|
* 2019-10-10:
|
|
* 1. Release v1.0.6
|
|
* 2019-10-29:
|
|
* 1. Release v1.0.7
|
|
* 2019-12-03:
|
|
* 1. Release v1.0.8
|
|
* 2019-12-26:
|
|
* 1. Release v1.0.9
|
|
* 2020-04-20:
|
|
* 1. Release v1.1.0
|
|
* 2020-05-09:
|
|
* 1. Release v1.1.1
|
|
* 2020-06-12:
|
|
* 1. Release v1.1.2
|
|
* 2020-12-17:
|
|
* 1. Release v1.1.3
|
|
*********************************************************************************************************/
|
|
#include "ATBM253Porting.h"
|
|
#include "ATBM253Driver.h"
|
|
#include "ATBM253Api.h"
|
|
#define ATBM253_DEFAULT_I2C_ADDR (0xC0)
|
|
#define ATBM253_DEFAULT_IF (5000000)
|
|
#define ATBM253_DEFAULT_OSC_FREQKHZ (24000)
|
|
#define ATBM253_DEFAULT_OSC_CAP (0x08)
|
|
#define ATBM253_MAGIC_CODE (0x4D425441) /*('ATBM')*/
|
|
static ATBM253_t ATBM253Tuner[ATBM253_TUNER_COUNT];
|
|
static ATBM_BOOL ATBM253MutexInitFlag = ATBM_FALSE;
|
|
/********************************************************************
|
|
* Function: ATBM253Init
|
|
* Description: Do initialization for ATBM253 hardware .
|
|
*
|
|
* Input: DevId -- ID of ATBM253;
|
|
* pConfig -- Pointer to config data
|
|
* Output: N/A
|
|
* Retrun: ATBM253_ERROR_NO_ERROR -- no error; others refer to ATBM253_ERROR_e
|
|
********************************************************************/
|
|
ATBM253_ERROR_e ATBM253Init(ATBM_U32 DevId,ATBM253InitConfig_t *pConfig)
|
|
{
|
|
ATBM253_ERROR_e ret = ATBM253_NO_ERROR;
|
|
ATBM253_t *pTuner = ATBM_NULL;
|
|
|
|
if((ATBM_NULL == pConfig)||(ATBM253_MAGIC_CODE != pConfig->MagicCode)||(DevId >= ATBM253_TUNER_COUNT))
|
|
{
|
|
ATBM253Print(("[Error]ATBM253Init(),invalid parameter!\n"));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
if(!ATBM253MutexInitFlag)
|
|
{
|
|
ret = ATBM253MutexInit();
|
|
if(ATBM253_NO_ERROR != ret)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253MutexInit() Failed!\n"));
|
|
return ret;
|
|
}
|
|
ATBM253MutexInitFlag = ATBM_TRUE;
|
|
}
|
|
ret = ATBM253MutexLock();
|
|
pTuner = &ATBM253Tuner[DevId];
|
|
pTuner->Config = *pConfig; /*Save user parameters.*/
|
|
|
|
ret |= ATBM253DrvInit(pTuner);
|
|
ATBM253CfgPrint(pTuner); /*Debug info print*/
|
|
ATBM253Print(("[Info]ATBM253Init()v112,ret =%d\n",ret));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Function: ATBM253DefaultCfgGet
|
|
* Description: Get default config of ATBM253 .
|
|
*
|
|
* Input: N/A
|
|
* Output: pConfig -- Pointer to config buffer
|
|
* Retrun: ATBM253_ERROR_NO_ERROR -- no error; others refer to ATBM253_ERROR_e
|
|
********************************************************************/
|
|
ATBM253_ERROR_e ATBM253DefaultCfgGet(ATBM253InitConfig_t *pConfig)
|
|
{
|
|
if(ATBM_NULL == pConfig)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253DefaultCfgGet(),invalid parameter!\n"));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
/*Default config of ATBM253*/
|
|
pConfig->MagicCode = ATBM253_MAGIC_CODE;
|
|
pConfig->I2CParam.I2CSlaveAddr = ATBM253_DEFAULT_I2C_ADDR;
|
|
pConfig->I2CParam.Param = 0;
|
|
pConfig->ClkMode = ATBM253_CLK_MODE_CRYSTAL;
|
|
pConfig->OSCFreqKHz = ATBM253_DEFAULT_OSC_FREQKHZ;
|
|
pConfig->OSCCap.CalibValue = ATBM253_DEFAULT_OSC_CAP;
|
|
pConfig->Mode = ATBM253_SIGNAL_MODE_DTMB;
|
|
pConfig->DtvIFOut.IFOutFreqHz = ATBM253_DEFAULT_IF;
|
|
#ifdef ATBM253_SPECIAL_SETTING_PLT12
|
|
pConfig->DtvIFOut.IFOutLevel = ATBM253_IF_OUT_LEVEL1;
|
|
#else
|
|
pConfig->DtvIFOut.IFOutLevel = ATBM253_IF_OUT_LEVEL2;
|
|
#endif
|
|
pConfig->AtvIFOut.IFOutFreqHz = ATBM253_DEFAULT_IF;
|
|
pConfig->AtvIFOut.IFOutLevel = ATBM253_IF_OUT_LEVEL1;
|
|
pConfig->DacOutDriveUp = 0x00;
|
|
pConfig->ClkOut.ClkOutEnable = ATBM253_CLK_OUT_DISABLE;
|
|
pConfig->ClkOut.ClkOutAmp = ATBM253_CLK_OUT_AMP_L4;
|
|
pConfig->FEFMode = ATBM253_FEF_INTERNAL;
|
|
pConfig->PinsCfg[0].PinName = ATBM253_PIN_NAME_GPO1;
|
|
pConfig->PinsCfg[0].PinState = ATBM253_GPO_STATE_HIZ;
|
|
pConfig->PinsCfg[1].PinName = ATBM253_PIN_NAME_GPO2;
|
|
pConfig->PinsCfg[1].PinState = ATBM253_GPO_STATE_HIZ;
|
|
pConfig->LTAOut = ATBM253_RF_LTA_OUT_DISABLE;
|
|
pConfig->DtvBackgroundProcess = ATBM_FALSE;
|
|
pConfig->DemodType = 0;
|
|
|
|
ATBM253Print(("[Info]ATBM253DefaultCfgGet(),ret =%d\n",ATBM253_NO_ERROR));
|
|
return ATBM253_NO_ERROR;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Function: ATBM253CfgSet
|
|
* Description: Change some config parameter to ATBM253 .
|
|
*
|
|
* Input: DevId -- ID of ATBM253;
|
|
* pCfgCmd -- Pointer to config command data
|
|
* Output: N/A
|
|
* Retrun: ATBM253_ERROR_NO_ERROR -- no error; others refer to ATBM253_ERROR_e
|
|
********************************************************************/
|
|
ATBM253_ERROR_e ATBM253CfgSet(ATBM_U32 DevId,ATBM253CfgCMD_t *pCfg)
|
|
{
|
|
ATBM253_ERROR_e ret = ATBM253_NO_ERROR;
|
|
ATBM253_t *pTuner = ATBM_NULL;
|
|
|
|
if((DevId >= ATBM253_TUNER_COUNT)||(ATBM_NULL == pCfg))
|
|
{
|
|
ATBM253Print(("[Error]ATBM253CfgSet(),invalid parameter!\n"));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
|
|
ret = ATBM253MutexLock();
|
|
pTuner = &ATBM253Tuner[DevId];
|
|
if(!pTuner->Inited)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253CfgSet(),ATBM253 is not initialized!\n"));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ATBM253_ERROR_NOT_INIT;
|
|
}
|
|
|
|
ret |= ATBM253DrvCfgSet(pTuner,pCfg);
|
|
ATBM253Print(("[Info]ATBM253CfgSet(),ret =%d\n",ret));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Function: ATBM253ChannelTune
|
|
* Description: Tune to a channel with special parameter.
|
|
*
|
|
* Input: DevId -- ID of ATBM253;
|
|
* Mode -- RF signal mode, refer to ATBM253_SIGNAL_MODE_e
|
|
* FreqKHz -- RF center frequency in KHz
|
|
* BandWidthKHz -- Signal bandwidth in KHz
|
|
* SpectrumMode -- IF out with inversed spectrum or not
|
|
Attention: ATV PAL-BG mode:
|
|
[FreqKHz < 300 MHz ] set BandWidthKHz 7000KHz, tune frequency to ATV frequency offset euqals 2.25M
|
|
[ FreqKHz > 300 MHz] set BandWidthKHz 8000KHz. tune frequency to ATV frequency offset euqals 2.75M
|
|
* Output: N/A
|
|
* Retrun: ATBM253_ERROR_NO_ERROR -- no error; others refer to ATBM253_ERROR_e
|
|
********************************************************************/
|
|
ATBM253_ERROR_e ATBM253ChannelTune(ATBM_U32 DevId,ATBM253_SIGNAL_MODE_e Mode,ATBM_U32 FreqKHz,ATBM_U32 BandWidthKHz,ATBM253_SPECTRUM_MODE_e SpectrumMode)
|
|
{
|
|
ATBM253_ERROR_e ret = ATBM253_NO_ERROR;
|
|
ATBM253_t *pTuner = ATBM_NULL;
|
|
|
|
if((DevId >= ATBM253_TUNER_COUNT)
|
|
#ifndef ATBM253_CHIP_DEBUG_OPEN /*No limit for GUI debug*/
|
|
||(FreqKHz > 1000000)||(FreqKHz < 40000)
|
|
#endif
|
|
||(BandWidthKHz > 10000))
|
|
{
|
|
ATBM253Print(("[Error]ATBM253ChannelTune(),invalid parameter!\n"));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
|
|
ret = ATBM253MutexLock();
|
|
pTuner = &ATBM253Tuner[DevId];
|
|
if(!pTuner->Inited)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253ChannelTune(),ATBM253 is not initialized!\n"));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ATBM253_ERROR_NOT_INIT;
|
|
}
|
|
#if ATBM253_DUPLICATE_TUNE_CHK
|
|
if(!ATBM253DrvIsDuplicateTune(pTuner,Mode,FreqKHz,BandWidthKHz,SpectrumMode))
|
|
#endif
|
|
{
|
|
#if ATBM253_ATV_AUTO_FINE_TUNE
|
|
if((ATBM253_SIGNAL_MODE_ATV == Mode)&&(ATBM253_FAST_TUNE_MODE_FAST == pTuner->FastTuneMD)
|
|
&&(BandWidthKHz == pTuner->BWKHz)&&(Mode == pTuner->SignalMode)
|
|
&&(((ATBM253_SPECTRUM_NORMAL==SpectrumMode)?(ATBM_FALSE):(ATBM_TRUE)) == pTuner->InvertSpectrum))
|
|
{
|
|
pTuner->FineTuneFreqKHz = FreqKHz;
|
|
ret |= ATBM253DrvATVFineTune(pTuner);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
pTuner->FreqKHz = FreqKHz;
|
|
pTuner->BWKHz = BandWidthKHz;
|
|
pTuner->InvertSpectrum = (ATBM253_SPECTRUM_NORMAL==SpectrumMode)?(ATBM_FALSE):(ATBM_TRUE);
|
|
pTuner->SignalMode = Mode;
|
|
ret |= ATBM253DrvFreqTune(pTuner);
|
|
}
|
|
ATBM253Print(("[Info]ATBM253ChannelTune(%d,%d,%d,%d),ret =%d\n",(ATBM_U32)Mode,FreqKHz,BandWidthKHz,(ATBM_U32)SpectrumMode,ret));
|
|
}
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Function: ATBM253ATVFineTune
|
|
* Description: ATV fine tune.
|
|
*
|
|
* Input: DevId -- ID of ATBM253;
|
|
* DeltaFreqKHz -- delta frequency in KHz
|
|
* Output: N/A
|
|
* Retrun: ATBM253_ERROR_NO_ERROR -- no error; others refer to ATBM253_ERROR_e
|
|
********************************************************************/
|
|
ATBM253_ERROR_e ATBM253ATVFineTune(ATBM_U32 DevId,ATBM_S32 DeltaFreqKHz)
|
|
{
|
|
ATBM253_ERROR_e ret = ATBM253_NO_ERROR;
|
|
ATBM253_t *pTuner = ATBM_NULL;
|
|
|
|
if(DevId >= ATBM253_TUNER_COUNT)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253ATVFineTune(),invalid parameter!\n"));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
|
|
pTuner = &ATBM253Tuner[DevId];
|
|
if(!pTuner->Inited)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253ATVFineTune(),ATBM253 is not initialized!\n"));
|
|
return ATBM253_ERROR_NOT_INIT;
|
|
}
|
|
ret = ATBM253MutexLock();
|
|
pTuner->FineTuneFreqKHz += DeltaFreqKHz;
|
|
ret |= ATBM253DrvATVFineTune(pTuner);
|
|
ATBM253Print(("[Info]ATBM253ATVFineTune(%d),ret =%d\n",DeltaFreqKHz,ret));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Function: ATBM253GetLockStatus
|
|
* Description: Get RF signal locking status .
|
|
*
|
|
* Input: DevId -- ID of ATBM253;
|
|
* Output: pLockStatus -- Pointer to lock status
|
|
* Retrun: ATBM253_ERROR_NO_ERROR -- no error; others refer to ATBM253_ERROR_e
|
|
********************************************************************/
|
|
ATBM253_ERROR_e ATBM253GetLockStatus(ATBM_U32 DevId,ATBM_BOOL *pLockStatus)
|
|
{
|
|
ATBM253_ERROR_e ret = ATBM253_NO_ERROR;
|
|
ATBM_U8 Val = 0;
|
|
ATBM253_t *pTuner = ATBM_NULL;
|
|
|
|
if(DevId >= ATBM253_TUNER_COUNT)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253GetLockStatus(),invalid parameter!\n"));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
ret |= ATBM253MutexUnLock();
|
|
pTuner = &ATBM253Tuner[DevId];
|
|
if(!pTuner->Inited)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253GetLockStatus(),ATBM253 is not initialized!\n"));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ATBM253_ERROR_NOT_INIT;
|
|
}
|
|
*pLockStatus = ATBM_FALSE;
|
|
ret |= ATBM253RegRead(&pTuner->Config.I2CParam,0x14,0xAA, &Val); /*ro_reg_agc_setting_state[1:0]*/
|
|
if((ATBM253_NO_ERROR == ret)&&((0x02 == Val)||(0x03 == Val)))
|
|
{
|
|
*pLockStatus = ATBM_TRUE;
|
|
}
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Function: ATBM253GetIFFreq
|
|
* Description: Get IF Frequency(in Hz).
|
|
*
|
|
* Input: DevId -- ID of ATBM253;
|
|
* Output: pIFFreqHz -- Pointer to IF frequency(in Hz)
|
|
* Retrun: ATBM253_ERROR_NO_ERROR -- no error; others refer to ATBM253_ERROR_e
|
|
********************************************************************/
|
|
ATBM253_ERROR_e ATBM253GetIFFreq(ATBM_U32 DevId,ATBM_U32 *pIFFreqHz)
|
|
{
|
|
ATBM253_ERROR_e ret = ATBM253_NO_ERROR;
|
|
ATBM253_t *pTuner = ATBM_NULL;
|
|
ATBM253InitConfig_t Config;
|
|
|
|
if((DevId >= ATBM253_TUNER_COUNT)||(ATBM_NULL == pIFFreqHz))
|
|
{
|
|
ATBM253Print(("[Error]ATBM253GetIFFreq(),invalid parameter!\n"));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
pTuner = &ATBM253Tuner[DevId];
|
|
ret = ATBM253MutexLock();
|
|
if(pTuner->Inited)
|
|
{
|
|
Config = pTuner->Config;
|
|
}
|
|
else
|
|
{
|
|
ret |= ATBM253DefaultCfgGet(&Config);
|
|
if(ATBM253_NO_ERROR != ret)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253DefaultCfgGet(),failed!ret = %d\n",ret));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
}
|
|
}
|
|
if(ATBM253_SIGNAL_MODE_ATV == Config.Mode)
|
|
{
|
|
*pIFFreqHz = pTuner->Config.AtvIFOut.IFOutFreqHz;
|
|
}
|
|
else
|
|
{
|
|
*pIFFreqHz = pTuner->Config.DtvIFOut.IFOutFreqHz;
|
|
}
|
|
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Function: ATBM253GetAtvCfo
|
|
* Description: Get CFO(in KHz) for analog signal. (CFO = RF_signal - RF_ATBM253)
|
|
*
|
|
* Input: DevId -- ID of ATBM253;
|
|
* Output: pCfoHz -- Pointer to CFO(in Hz)
|
|
* Retrun: ATBM253_ERROR_NO_ERROR -- no error; others refer to ATBM253_ERROR_e
|
|
********************************************************************/
|
|
ATBM253_ERROR_e ATBM253GetAtvCfo(ATBM_U32 DevId,ATBM_S32 *pCfoKHz)
|
|
{
|
|
ATBM253_ERROR_e ret = ATBM253_NO_ERROR;
|
|
ATBM253_t *pTuner = ATBM_NULL;
|
|
|
|
if((DevId >= ATBM253_TUNER_COUNT)||(ATBM_NULL == pCfoKHz))
|
|
{
|
|
ATBM253Print(("[Error]ATBM253GetAtvCfo(),invalid parameter!\n"));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
*pCfoKHz = 0;
|
|
ret = ATBM253MutexLock();
|
|
pTuner = &ATBM253Tuner[DevId];
|
|
if(!pTuner->Inited)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253GetAtvCfo(DevId=%d),ATBM253 is not initialized!\n",DevId));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ATBM253_ERROR_NOT_INIT;
|
|
}
|
|
ret = ATBM253DrvGetATVCfo(&pTuner->Config.I2CParam,pCfoKHz);
|
|
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Function: ATBM253GetRSSI
|
|
* Description: Get current RSSI(in dBm) .
|
|
*
|
|
* Input: DevId -- ID of ATBM253;
|
|
* Output: pRSSI -- Pointer to RSSI
|
|
* Retrun: ATBM253_ERROR_NO_ERROR -- no error; others refer to ATBM253_ERROR_e
|
|
********************************************************************/
|
|
ATBM253_ERROR_e ATBM253GetRSSI(ATBM_U32 DevId,ATBM_S32 *pRSSI)
|
|
{
|
|
ATBM253_ERROR_e ret = ATBM253_NO_ERROR;
|
|
ATBM_S16 SignalPow = 0;
|
|
ATBM253_t *pTuner = ATBM_NULL;
|
|
|
|
if((DevId >= ATBM253_TUNER_COUNT)||(ATBM_NULL == pRSSI))
|
|
{
|
|
ATBM253Print(("[Error]ATBM253GetRSSI(),invalid parameter!\n"));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
ret = ATBM253MutexLock();
|
|
pTuner = &ATBM253Tuner[DevId];
|
|
if(!pTuner->Inited)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253GetRSSI(),ATBM253 is not initialized!\n"));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ATBM253_ERROR_NOT_INIT;
|
|
}
|
|
ret |= ATBM253DrvGetRSSI(&pTuner->Config.I2CParam,&SignalPow);
|
|
|
|
if(SignalPow < -1168) /*-73*/
|
|
{
|
|
SignalPow = SignalPow + 16;
|
|
}else if(SignalPow < -1120) /*-70*/
|
|
{
|
|
SignalPow = SignalPow + 8;
|
|
}else
|
|
{
|
|
}
|
|
|
|
*pRSSI = SignalPow/16;
|
|
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Function: ATBM253Standby
|
|
* Description: Make ATBM253 enter into standby state .
|
|
*
|
|
* Input: DevId -- ID of ATBM253;
|
|
* Output: N/A
|
|
* Retrun: ATBM253_ERROR_NO_ERROR -- no error; others refer to ATBM253_ERROR_e
|
|
********************************************************************/
|
|
ATBM253_ERROR_e ATBM253Standby(ATBM_U32 DevId)
|
|
{
|
|
ATBM253_ERROR_e ret = ATBM253_NO_ERROR;
|
|
ATBM253_t *pTuner = ATBM_NULL;
|
|
|
|
if(DevId >= ATBM253_TUNER_COUNT)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253Standby(),invalid parameter!\n"));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
ret = ATBM253MutexLock();
|
|
pTuner = &ATBM253Tuner[DevId];
|
|
if(!pTuner->Inited)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253Standby(),ATBM253 is not initialized!\n"));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ATBM253_ERROR_NOT_INIT;
|
|
}
|
|
ret |= ATBM253DrvStandby(pTuner);
|
|
ATBM253Print(("[Info]ATBM253Standby(),ret =%d\n",ret));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Function: ATBM253Wakeup
|
|
* Description: Make ATBM253 enter into wakeup state .
|
|
*
|
|
* Input: DevId -- ID of ATBM253;
|
|
* Output: N/A
|
|
* Retrun: ATBM253_ERROR_NO_ERROR -- no error; others refer to ATBM253_ERROR_e
|
|
********************************************************************/
|
|
ATBM253_ERROR_e ATBM253Wakeup(ATBM_U32 DevId)
|
|
{
|
|
ATBM253_ERROR_e ret = ATBM253_NO_ERROR;
|
|
ATBM253_t *pTuner = ATBM_NULL;
|
|
|
|
if(DevId >= ATBM253_TUNER_COUNT)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253Wakeup(),invalid parameter!\n"));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
ret |= ATBM253MutexLock();
|
|
pTuner = &ATBM253Tuner[DevId];
|
|
if(!pTuner->Inited)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253Wakeup(),ATBM253 is not initialized!\n"));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ATBM253_ERROR_NOT_INIT;
|
|
}
|
|
ret |= ATBM253DrvWakeup(pTuner);
|
|
ATBM253Print(("[Info]ATBM253Wakeup(),ret =%d\n",ret));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Function: ATBM253GetSDKVer
|
|
* Description: Get version of ATBM253 SDK .
|
|
*
|
|
* Input: DevId -- ID of ATBM253;
|
|
* Output: pVersion -- Pointer to version number(e.g. 102 means v1.0.2)
|
|
* Retrun: ATBM253_ERROR_NO_ERROR -- no error; others refer to ATBM253_ERROR_e
|
|
********************************************************************/
|
|
ATBM253_ERROR_e ATBM253GetSDKVer(ATBM_U32 DevId,ATBM_U32 *pVersion)
|
|
{
|
|
ATBM253_ERROR_e ret = ATBM253_NO_ERROR;
|
|
ATBM253_t *pTuner = ATBM_NULL;
|
|
|
|
if((DevId >= ATBM253_TUNER_COUNT)||(ATBM_NULL == pVersion))
|
|
{
|
|
ATBM253Print(("[Error]ATBM253GetSDKVer(),invalid parameter!\n"));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
ret = ATBM253MutexLock();
|
|
pTuner = &ATBM253Tuner[DevId];
|
|
if(!pTuner->Inited)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253GetSDKVer(),ATBM253 is not initialized!\n"));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ATBM253_ERROR_NOT_INIT;
|
|
}
|
|
ret |= ATBM253DrvGetSDKVer(pTuner,pVersion);
|
|
ATBM253Print(("[Info]ATBM253GetSDKVer(),ret =%d\n",ret));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Function: ATBM253Process
|
|
* Input: DevId -- ID of ATBM253;
|
|
* Description: This API should be called constantly by user application, for example every 200ms one time.
|
|
********************************************************************/
|
|
ATBM253_ERROR_e ATBM253Process(ATBM_U32 DevId)
|
|
{
|
|
ATBM253_ERROR_e ret = ATBM253_NO_ERROR;
|
|
ATBM253_t *pTuner = ATBM_NULL;
|
|
|
|
if(DevId >= ATBM253_TUNER_COUNT)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253Process(),invalid parameter!\n"));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
ret = ATBM253MutexLock();
|
|
pTuner = &ATBM253Tuner[DevId];
|
|
if(!pTuner->Inited)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253Process(),ATBM253 is not initialized!\n"));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ATBM253_ERROR_NOT_INIT;
|
|
}
|
|
ret |= ATBM253DrvProcess(pTuner);
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Function: ATBM253Detect
|
|
* Description: Check if ATBM253 exist or not.
|
|
*
|
|
* Input: pI2CInfo -- I2C paramters, including slave address and other user paramter;
|
|
*
|
|
* Output: N/A
|
|
* Retrun: ATBM253_ERROR_NO_ERROR -- ATBM253 exist; others refer to ATBM253_ERROR_e
|
|
********************************************************************/
|
|
ATBM253_ERROR_e ATBM253Detect(ATBM253I2CAddr_t *pI2CInfo)
|
|
{
|
|
ATBM253_ERROR_e ret = ATBM253_NO_ERROR;
|
|
|
|
if(ATBM_NULL == pI2CInfo)
|
|
{
|
|
ATBM253Print(("[Error]pI2CInfo(),invalid parameter!\n"));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
if(!ATBM253MutexInitFlag)
|
|
{
|
|
ret = ATBM253MutexInit();
|
|
if(ATBM253_NO_ERROR != ret)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253MutexInit() Failed!\n"));
|
|
return ret;
|
|
}
|
|
ATBM253MutexInitFlag = ATBM_TRUE;
|
|
}
|
|
ret = ATBM253MutexLock();
|
|
ret |= ATBM253DrvDetect(pI2CInfo);
|
|
ATBM253Print(("[Info]ATBM253Detect(),ret =%d\n",ret));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
}
|
|
|
|
|
|
#ifdef ATBM253_CHIP_DEBUG_OPEN
|
|
ATBM253_t *ATBM253ObjGet(ATBM_U32 DevId)
|
|
{
|
|
ATBM253_t *pTuner = ATBM_NULL;
|
|
|
|
if(DevId >= ATBM253_TUNER_COUNT)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253Wakeup(),invalid parameter!\n"));
|
|
return ATBM_NULL;
|
|
}
|
|
pTuner = &ATBM253Tuner[DevId];
|
|
|
|
return pTuner;
|
|
}
|
|
#endif
|
|
|
|
|
|
/********************************************************************
|
|
* Function: ATBM253SecamLLSpecialDagcRefIFSet
|
|
* Description: This is optional function for ATV SECAM LL signal DagcRef and IF setting.
|
|
* ATV SECAM LL signal: set ATV IF output level1 and set DagcRef 0x04D0
|
|
* ATV Other signal: set ATV IF and DagcRef from ATV user setting.
|
|
*
|
|
* Attention: the parameters in this function was set according to SOC platform.
|
|
*
|
|
* Input: DevId ---- ID of ATBM253;
|
|
* IsSecamLL -- 1: ATV SECAM LL signal, 0: other ATV signal;
|
|
*
|
|
* Output: N/A
|
|
* Retrun: ATBM253_ERROR_NO_ERROR -- ATBM253 exist; others refer to ATBM253_ERROR_e
|
|
********************************************************************/
|
|
ATBM253_ERROR_e ATBM253SecamLLSpecialDagcRefIFSet(ATBM_U32 DevId, ATBM_U32 IsSecamLL)
|
|
{
|
|
ATBM253_ERROR_e ret = ATBM253_NO_ERROR;
|
|
ATBM_U16 dagcRef = 0x04E0;
|
|
ATBM253_t *pTuner = ATBM_NULL;
|
|
unsigned char Data[2] = {0};
|
|
ATBM253CfgCMD_t Config;
|
|
if(DevId >= ATBM253_TUNER_COUNT)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253SecamLLSpeicalDagcRefIFSet(%d),invalid parameter!\n",DevId));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
ret |= ATBM253MutexLock();
|
|
pTuner = &ATBM253Tuner[DevId];
|
|
if(!pTuner->Inited)
|
|
{
|
|
ret |= ATBM253MutexUnLock();
|
|
ATBM253Print(("[Error]ATBM253SecamLLSpeicalDagcRefIFSet(%d),ATBM253 is not initialized!\n",DevId));
|
|
return ATBM253_ERROR_NOT_INIT;
|
|
}
|
|
if(ATBM253_NO_ERROR != ATBM253DrvDetect(&pTuner->Config.I2CParam))
|
|
{
|
|
ret |= ATBM253MutexUnLock();
|
|
return ATBM253_NO_ERROR;
|
|
}
|
|
|
|
if(IsSecamLL)
|
|
{
|
|
dagcRef = 0x04D0;
|
|
}else
|
|
{
|
|
dagcRef = pTuner->DAgc2AmpRef0;
|
|
}
|
|
|
|
Data[0] = (ATBM_U8)(dagcRef&0xFF);
|
|
Data[1] = (ATBM_U8)((dagcRef>>8)&0xFF);
|
|
ret |= ATBM253DrvRegDataFlushWrite(&pTuner->Config.I2CParam,0x13,0xA6, Data,2);/*0x13,0xA6*/
|
|
|
|
/*If you want to change some parameters, call 'ATBM253CfgSet' to do it. */
|
|
Config.CfgCmd = ATBM253_CFG_CMD_ATV_IF_OUT_SETTING;
|
|
Config.Cfg.IFOut.IFOutFreqHz = pTuner->Config.AtvIFOut.IFOutFreqHz ;
|
|
if(IsSecamLL)
|
|
{
|
|
Config.Cfg.IFOut.IFOutLevel = ATBM253_IF_OUT_LEVEL1;
|
|
}else
|
|
{
|
|
Config.Cfg.IFOut.IFOutLevel = pTuner->Config.AtvIFOut.IFOutLevel;
|
|
}
|
|
ret |= ATBM253DrvCfgSet(pTuner,&Config);
|
|
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
}
|
|
|
|
|
|
#if 1
|
|
ATBM253_ERROR_e ATBM253AGCLockingFreeze(ATBM_U32 DevId, ATBM_U32 freeze_flag)
|
|
{
|
|
ATBM253_ERROR_e ret = ATBM253_NO_ERROR;
|
|
|
|
ATBM253_t *pTuner = ATBM_NULL;
|
|
unsigned char Val = 0;
|
|
|
|
if(DevId >= ATBM253_TUNER_COUNT)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253AGCLockingFreeze(%d),invalid parameter!\n",DevId));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
ret |= ATBM253MutexLock();
|
|
pTuner = &ATBM253Tuner[DevId];
|
|
if(!pTuner->Inited)
|
|
{
|
|
ret |= ATBM253MutexUnLock();
|
|
ATBM253Print(("[Error]ATBM253AGCLockingFreeze(%d),ATBM253 is not initialized!\n",DevId));
|
|
return ATBM253_ERROR_NOT_INIT;
|
|
}
|
|
if(ATBM253_NO_ERROR != ATBM253DrvDetect(&pTuner->Config.I2CParam))
|
|
{
|
|
ret |= ATBM253MutexUnLock();
|
|
return ATBM253_NO_ERROR;
|
|
}
|
|
|
|
if(ATBM253_SIGNAL_MODE_ATV == pTuner->SignalMode)
|
|
{
|
|
ret |= ATBM253MutexUnLock();
|
|
return ATBM253_NO_ERROR;
|
|
}
|
|
|
|
if(!pTuner->Config.DtvBackgroundProcess)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253AGCLockedFreeze(%d),DtvBackgroundProcess option is FALSE!\n",DevId));
|
|
ret |= ATBM253MutexUnLock();
|
|
return ATBM253_NO_ERROR;
|
|
}
|
|
|
|
ret |= ATBM253RegRead(&pTuner->Config.I2CParam,0x14,0xAA, &Val); /*ro_reg_agc_setting_state[1:0]*/
|
|
if(Val < 0x02)
|
|
{
|
|
ret |= ATBM253MutexUnLock();
|
|
return ATBM253_NO_ERROR;
|
|
}
|
|
|
|
ret |= ATBM253RegRead(&pTuner->Config.I2CParam,0x14,0x27, &Val);
|
|
|
|
if(freeze_flag)
|
|
{
|
|
if(Val == 0)
|
|
{
|
|
ret |=ATBM253RegWrite(&pTuner->Config.I2CParam,0x14,0x4C, 0x01);
|
|
ret |=ATBM253RegWrite(&pTuner->Config.I2CParam,0x14,0x47, 0x01);
|
|
if(ATBM_FALSE == pTuner->BypassMD)
|
|
{
|
|
ret |=ATBM253RegWrite(&pTuner->Config.I2CParam,0x14,0x27, 0x01);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(Val == 1)
|
|
{
|
|
ret |=ATBM253RegWrite(&pTuner->Config.I2CParam,0x14,0x4C, 0x00);
|
|
ret |=ATBM253RegWrite(&pTuner->Config.I2CParam,0x14,0x47, 0x00);
|
|
if(ATBM_FALSE == pTuner->BypassMD)
|
|
{
|
|
ret |=ATBM253RegWrite(&pTuner->Config.I2CParam,0x14,0x27, 0x00);
|
|
}
|
|
}
|
|
}
|
|
|
|
ATBM253Print(("[Info]ATBM253AGCLockedFreeze(%d),freeze_flag:%d,Val:%d ret =%d\n",DevId, freeze_flag,Val,ret));
|
|
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
|
|
ATBM253_ERROR_e ATBM253ChipDebugStatusGet(ATBM_U32 DevId,ATBM_U8 *pStatus)
|
|
{
|
|
ATBM253_ERROR_e ret = ATBM253_NO_ERROR;
|
|
ATBM_U8 Data[16] = {0};
|
|
ATBM253_t *pTuner = ATBM_NULL;
|
|
ATBM253I2CAddr_t *pI2CAddr = ATBM_NULL;
|
|
|
|
if(DevId >= ATBM253_TUNER_COUNT)
|
|
{
|
|
ATBM253Print(("[Error]ATBM253ChipDebugStatusGet(%d),invalid parameter!\n",DevId));
|
|
return ATBM253_ERROR_BAD_PARAM;
|
|
}
|
|
ret |= ATBM253MutexLock();
|
|
pTuner = &ATBM253Tuner[DevId];
|
|
if(!pTuner->Inited)
|
|
{
|
|
ret |= ATBM253MutexUnLock();
|
|
ATBM253Print(("[Error]ATBM253ChipDebugStatusGet(%d),ATBM253 is not initialized!\n",DevId));
|
|
return ATBM253_ERROR_NOT_INIT;
|
|
}
|
|
|
|
pI2CAddr = &pTuner->Config.I2CParam;
|
|
|
|
(void)ATBM253RegWrite(pI2CAddr,0x01,0x0D, 0x01); /*Latch on*/
|
|
(void)ATBM253I2CRead(pI2CAddr,0x14,0xAA, Data,1);
|
|
pStatus[0] = Data[0];/* agc state */
|
|
|
|
(void)ATBM253I2CRead(pI2CAddr,0x14,0xAC, Data,2);
|
|
pStatus[1] = Data[0];/* selection finish */
|
|
pStatus[2] = Data[1];/* mode selection */
|
|
|
|
(void)ATBM253I2CRead(pI2CAddr,0x14,0xBB, Data,1);
|
|
pStatus[3] = Data[0];/* lna_gain_virtual */
|
|
|
|
(void)ATBM253I2CRead(pI2CAddr,0x14,0xC2, Data,1);
|
|
pStatus[4] = Data[0];/* ifvga2_gain_step */
|
|
|
|
(void)ATBM253I2CRead(pI2CAddr,0x14,0xA6, Data,1);
|
|
pStatus[5] = Data[0];/* power_rssi_lna_out_dbm */
|
|
|
|
(void)ATBM253I2CRead(pI2CAddr,0x14,0xD0, Data,1);
|
|
pStatus[6] = Data[0];/* signal_power_rf_dbm */
|
|
|
|
(void)ATBM253I2CRead(pI2CAddr,0x15,0x44, Data,3); /* ro_params_dagc2_scale U(21,10) */
|
|
pStatus[7] = Data[0];/* dagc2_scale */
|
|
pStatus[8] = Data[1];
|
|
pStatus[9] = Data[2];
|
|
|
|
(void)ATBM253RegWrite(pI2CAddr,0x01,0x0D, 0x00); /*Latch off*/
|
|
|
|
ret |= ATBM253MutexUnLock();
|
|
return ret;
|
|
|
|
} |