提交SMOD ATSC IMX APP版本 V122
This commit is contained in:
Executable
+699
@@ -0,0 +1,699 @@
|
||||
/*------------------------------------------------------------------------------
|
||||
Copyright 2016-2019 Sony Semiconductor Solutions Corporation
|
||||
|
||||
Last Updated : 2019/02/14
|
||||
Modification ID : 83dbabba2734697e67e3d44647acf57b272c2caf
|
||||
------------------------------------------------------------------------------*/
|
||||
#include "sony_demod_j83b.h"
|
||||
#include "sony_demod_j83b_monitor.h"
|
||||
|
||||
/*------------------------------------------------------------------------------
|
||||
Static Function Prototypes
|
||||
------------------------------------------------------------------------------*/
|
||||
/**
|
||||
@brief Configure the demodulator from Sleep to Active for J.83B
|
||||
*/
|
||||
static sony_result_t SLtoACC(sony_demod_t * pDemod);
|
||||
/**
|
||||
@brief Configure the demodulator for tuner optimisations and bandwidth specific
|
||||
settings.
|
||||
*/
|
||||
static sony_result_t SLtoACC_BandSetting(sony_demod_t * pDemod);
|
||||
|
||||
/**
|
||||
@brief Configure the demodulator from Active J.83B to Active to J.83B. Used
|
||||
for changing channel parameters.
|
||||
*/
|
||||
static sony_result_t ACCtoACC(sony_demod_t * pDemod);
|
||||
|
||||
/**
|
||||
@brief Configure the demodulator from Active J.83B to Sleep.
|
||||
*/
|
||||
static sony_result_t ACCtoSL(sony_demod_t * pDemod);
|
||||
/*------------------------------------------------------------------------------
|
||||
Functions
|
||||
------------------------------------------------------------------------------*/
|
||||
sony_result_t sony_demod_j83b_Tune (sony_demod_t * pDemod, sony_j83b_tune_param_t * pTuneParam)
|
||||
{
|
||||
sony_result_t result = SONY_RESULT_OK;
|
||||
SONY_TRACE_ENTER ("sony_demod_j83b_Tune");
|
||||
|
||||
if ((!pDemod) || (!pTuneParam)) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
if ((pTuneParam->bandwidth != SONY_DTV_BW_J83B_5_06_5_36_MSPS) &&
|
||||
(pTuneParam->bandwidth != SONY_DTV_BW_J83B_5_60_MSPS)) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
if ((pDemod->state == SONY_DEMOD_STATE_ACTIVE) && (pDemod->system == SONY_DTV_SYSTEM_J83B)) {
|
||||
/* Demodulator Active and set to J.83B mode */
|
||||
pDemod->bandwidth = pTuneParam->bandwidth;
|
||||
result = ACCtoACC (pDemod);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
}
|
||||
else if((pDemod->state == SONY_DEMOD_STATE_ACTIVE) && (pDemod->system != SONY_DTV_SYSTEM_J83B)){
|
||||
/* Demodulator Active but not J.83B mode */
|
||||
result = sony_demod_Sleep (pDemod);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
pDemod->system = SONY_DTV_SYSTEM_J83B;
|
||||
pDemod->bandwidth = pTuneParam->bandwidth;
|
||||
|
||||
result = SLtoACC (pDemod);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
}
|
||||
else if (pDemod->state == SONY_DEMOD_STATE_SLEEP) {
|
||||
/* Demodulator in Sleep mode */
|
||||
pDemod->system = SONY_DTV_SYSTEM_J83B;
|
||||
pDemod->bandwidth = pTuneParam->bandwidth;
|
||||
|
||||
result = SLtoACC (pDemod);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
}
|
||||
else {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
/* Update demodulator state */
|
||||
pDemod->state = SONY_DEMOD_STATE_ACTIVE;
|
||||
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
sony_result_t sony_demod_j83b_Sleep (sony_demod_t * pDemod)
|
||||
{
|
||||
sony_result_t result = SONY_RESULT_OK;
|
||||
SONY_TRACE_ENTER ("sony_demod_j83b_Sleep");
|
||||
|
||||
if (!pDemod) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
if ((pDemod->state != SONY_DEMOD_STATE_SLEEP) && (pDemod->state != SONY_DEMOD_STATE_ACTIVE)) {
|
||||
/* This api is accepted in Sleep and Active states only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
result = ACCtoSL (pDemod);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
sony_result_t sony_demod_j83b_CheckTSLock (sony_demod_t * pDemod,
|
||||
sony_demod_lock_result_t * pLock)
|
||||
{
|
||||
sony_result_t result = SONY_RESULT_OK;
|
||||
uint8_t arLock = 0;
|
||||
uint8_t tsLock = 0;
|
||||
uint8_t unlockDetected = 0;
|
||||
SONY_TRACE_ENTER ("sony_demod_j83b_CheckTSLock");
|
||||
|
||||
if ((!pDemod) || (!pLock)) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
if (pDemod->state != SONY_DEMOD_STATE_ACTIVE) {
|
||||
/* This api is accepted in Active state only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
result = sony_demod_j83b_monitor_SyncStat (pDemod, &arLock, &tsLock, &unlockDetected);
|
||||
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
if (pDemod->scanMode) {
|
||||
if (unlockDetected == 1) {
|
||||
*pLock = SONY_DEMOD_LOCK_RESULT_UNLOCKED;
|
||||
SONY_TRACE_RETURN (SONY_RESULT_OK);
|
||||
}
|
||||
}
|
||||
|
||||
if (arLock == 0) {
|
||||
*pLock = SONY_DEMOD_LOCK_RESULT_NOTDETECT;
|
||||
SONY_TRACE_RETURN (SONY_RESULT_OK);
|
||||
}
|
||||
|
||||
*pLock = tsLock ? SONY_DEMOD_LOCK_RESULT_LOCKED : SONY_DEMOD_LOCK_RESULT_NOTDETECT;
|
||||
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------------------------
|
||||
Static Functions
|
||||
------------------------------------------------------------------------------*/
|
||||
static sony_result_t SLtoACC (sony_demod_t * pDemod)
|
||||
{
|
||||
sony_result_t result = SONY_RESULT_OK;
|
||||
SONY_TRACE_ENTER ("SLtoACC");
|
||||
|
||||
if (!pDemod) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Configure TS clock Mode and Frequency */
|
||||
result = sony_demod_SetTSClockModeAndFreq (pDemod, SONY_DTV_SYSTEM_J83B);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
/* Set SLV-X Bank : 0x00 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVX, 0x00, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Set demod mode */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVX, 0x17, 0x08) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x00 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Set TS/TLV mode */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xA9, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Enable demod clock */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x2C, 0x01) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* TADC setting */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x4B, 0x74) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* TADC setting */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x49, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* TADC setting */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVX, 0x18, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x11 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x11) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* BBAGC TARGET level setting
|
||||
* slave Bank Addr Bit default Value Name
|
||||
* ----------------------------------------------------------------------------------
|
||||
* <SLV-T> 11h 6Ah [7:0] 8'h50 8'h48 OREG_ITB_DAGC_TRGT[7:0]
|
||||
*/
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x6A, 0x48) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x10 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x10) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
if (pDemod->tunerOptimize == SONY_DEMOD_TUNER_OPTIMIZE_SONYSILICON) {
|
||||
/* ASCOT setting ON
|
||||
* slave Bank Addr Bit default Value Name
|
||||
* ----------------------------------------------------------------------------------
|
||||
* <SLV-T> 10h A5h [0] 8'h01 8'h01 OREG_ITB_GDEQ_EN
|
||||
*/
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xA5, 0x01) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
}
|
||||
else {
|
||||
/* ASCOT setting OFF
|
||||
* slave Bank Addr Bit default Value Name
|
||||
* ----------------------------------------------------------------------------------
|
||||
* <SLV-T> 10h A5h [0] 8'h01 8'h00 OREG_ITB_GDEQ_EN
|
||||
*/
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xA5, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x40 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x40) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* J.83B initial setting
|
||||
* slave Bank Addr Bit default Value Name
|
||||
* ----------------------------------------------------------------------------
|
||||
* <SLV-T> 40h 21h [2] 8'h00 8'h04 OREG_DISABLE_CSI
|
||||
* <SLV-T> 40h B3h [2:0] 8'h02 8'h05 OREG_LMS_MU_TRK[2:0]
|
||||
*/
|
||||
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x21, 0x04) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xB3, 0x05) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Settings for Transmission Parameters
|
||||
* slave Bank Addr Bit default Value Name
|
||||
* ----------------------------------------------------------------------------------
|
||||
* <SLV-T> 40h 1Eh [7] 8'h00 8'h80 OREG_DISCRETE_SEARCH
|
||||
*/
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x1E, 0x80) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* J.83B 24MHz Xtal setting
|
||||
* slave Bank Addr Bit default Value Name
|
||||
* ----------------------------------------------------------------------------------
|
||||
* <SLV-T> 40h 8Eh [7:0] 8'h0E 8'h58 OREG_AR_FEC_TIMER[7:0]
|
||||
*/
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x8E, 0x58) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x41 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x41) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* J.83B initial setting
|
||||
* slave Bank Addr Bit default Value Name
|
||||
* ----------------------------------------------------------------------------------
|
||||
* <SLV-T> 41h CFh [7:0] 8'h77 8'h99 OREG_FFE_LEAK[3:0],OREG_FBE_LEAK[3:0]
|
||||
*/
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xCF, 0x99) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x11 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x11) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* IMR Filter Bandwidth setting
|
||||
* slave Bank Addr Bit default Value Name
|
||||
* ---------------------------------------------------------------------------------
|
||||
* <SLV-T> 11h A3h [4:0] 8'h00 8'h14 OREG_IMR_FORCE_CHANNEL_WIDTH,1'b0,OREG_IMR_CHANNEL_WIDTH[2:0]
|
||||
*/
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xA3, 0x14) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
{
|
||||
/* J.83B 24MHz Xtal setting
|
||||
* Slave Bank Addr Bit Default Value Name
|
||||
* ---------------------------------------------------------------------------------
|
||||
* <SLV-T> 11h 33h [7:0] 8'hC8 8'h00 OCTL_IFAGC_INITWAIT[7:0]
|
||||
* <SLV-T> 11h 34h [7:0] 8'h02 8'h03 OCTL_IFAGC_MINWAIT[7:0]
|
||||
* <SLV-T> 11h 35h [7:0] 8'h32 8'h3B OCTL_IFAGC_MAXWAIT[7:0]
|
||||
*/
|
||||
const uint8_t data[3] = { 0x00, 0x03, 0x3B };
|
||||
if (pDemod->pI2c->WriteRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x33, data, sizeof (data)) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x00 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* TSIF setting
|
||||
* slave Bank Addr Bit default Value Name
|
||||
* ----------------------------------------------------------------------------------
|
||||
* <SLV-T> 00h CEh [0] 8'h01 8'h01 ONOPARITY
|
||||
* <SLV-T> 00h CFh [0] 8'h01 8'h01 ONOPARITY_MANUAL_ON
|
||||
*/
|
||||
{
|
||||
const uint8_t data[] = { 0x01, 0x01 };
|
||||
|
||||
if (pDemod->pI2c->WriteRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xCE, data, sizeof (data)) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x10 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x10) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/*
|
||||
* Filter settings for Sony silicon tuners
|
||||
* slave bank addr bit default name
|
||||
* ------------------------------------------------------------------
|
||||
* <SLV-T> 10h A6h [7:0] 8'h1E OREG_ITB_COEF01[7:0]
|
||||
* <SLV-T> 10h A7h [7:0] 8'h1D OREG_ITB_COEF02[7:0]
|
||||
* <SLV-T> 10h A8h [7:0] 8'h29 OREG_ITB_COEF11[7:0]
|
||||
* <SLV-T> 10h A9h [7:0] 8'hC9 OREG_ITB_COEF12[7:0]
|
||||
* <SLV-T> 10h AAh [7:0] 8'h2A OREG_ITB_COEF21[7:0]
|
||||
* <SLV-T> 10h ABh [7:0] 8'hBA OREG_ITB_COEF22[7:0]
|
||||
* <SLV-T> 10h ACh [7:0] 8'h29 OREG_ITB_COEF31[7:0]
|
||||
* <SLV-T> 10h ADh [7:0] 8'hAD OREG_ITB_COEF32[7:0]
|
||||
* <SLV-T> 10h AEh [7:0] 8'h29 OREG_ITB_COEF41[7:0]
|
||||
* <SLV-T> 10h AFh [7:0] 8'hA4 OREG_ITB_COEF42[7:0]
|
||||
* <SLV-T> 10h B0h [7:0] 8'h29 OREG_ITB_COEF51[7:0]
|
||||
* <SLV-T> 10h B1h [7:0] 8'h9A OREG_ITB_COEF52[7:0]
|
||||
* <SLV-T> 10h B2h [7:0] 8'h28 OREG_ITB_COEF61[7:0]
|
||||
* <SLV-T> 10h B3h [7:0] 8'h9E OREG_ITB_COEF62[7:0]
|
||||
*/
|
||||
if (pDemod->tunerOptimize == SONY_DEMOD_TUNER_OPTIMIZE_SONYSILICON) {
|
||||
const uint8_t itbCoef[14] = {
|
||||
/* COEF01 COEF02 COEF11 COEF12 COEF21 COEF22 COEF31 COEF32 COEF41 COEF42 COEF51 COEF52 COEF61 COEF62 */
|
||||
0x31, 0xA8, 0x29, 0x9B, 0x27, 0x9C, 0x28, 0x9E, 0x29, 0xA4, 0x29, 0xA2, 0x29, 0xA8
|
||||
};
|
||||
|
||||
if (pDemod->pI2c->WriteRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xA6, itbCoef, 14) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
}
|
||||
|
||||
/* Set tuner and bandwidth specific settings */
|
||||
result = SLtoACC_BandSetting (pDemod);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x00 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Disable HiZ Setting 1 (TAGC, SAGC(Hi-Z), TSVALID, TSSYNC, TSCLK) */
|
||||
if (sony_i2c_SetRegisterBits (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x80, 0x08, 0x1F) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Disable HiZ Setting 2 */
|
||||
result = sony_demod_SetTSDataPinHiZ (pDemod, 0);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
static sony_result_t SLtoACC_BandSetting(sony_demod_t * pDemod)
|
||||
{
|
||||
SONY_TRACE_ENTER ("SLtoACC_BandSetting");
|
||||
|
||||
if (!pDemod) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x10 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x10) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
switch (pDemod->bandwidth) {
|
||||
case SONY_DTV_BW_J83B_5_06_5_36_MSPS:
|
||||
{
|
||||
/*
|
||||
* <IF freq setting>
|
||||
* slave bank addr bit default value name
|
||||
* ---------------------------------------------------------------------------------
|
||||
* <SLV-T> 10h B6h [7:0] 8'h1F user defined OREG_DNCNV_LOFRQ_T[23:16]
|
||||
* <SLV-T> 10h B7h [7:0] 8'h38 user defined OREG_DNCNV_LOFRQ_T[15:8]
|
||||
* <SLV-T> 10h B8h [7:0] 8'h32 user defined OREG_DNCNV_LOFRQ_T[7:0]
|
||||
*/
|
||||
uint8_t data[3];
|
||||
data[0] = (uint8_t) ((pDemod->iffreqConfig.configJ83B_5_06_5_36 >> 16) & 0xFF);
|
||||
data[1] = (uint8_t) ((pDemod->iffreqConfig.configJ83B_5_06_5_36 >> 8) & 0xFF);
|
||||
data[2] = (uint8_t) (pDemod->iffreqConfig.configJ83B_5_06_5_36 & 0xFF);
|
||||
if (pDemod->pI2c->WriteRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xB6, data, sizeof (data)) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
/*
|
||||
* Settings for Transmission Parameters
|
||||
* slave Bank Addr Bit default Value Name
|
||||
* ----------------------------------------------------------------------------------
|
||||
* <SLV-T> 40h 14h [4:0] 8'h1F 8'h14 OREG_QAM_ENABLE[4:0]
|
||||
* <SLV-T> 40h 26h [3:0] 8'h09 8'h07 OREG_TRIAL_SRATE0[11:8]
|
||||
* <SLV-T> 40h 27h [7:0] 8'h9A 8'h26 OREG_TRIAL_SRATE0[7:0]
|
||||
* <SLV-T> 40h 28h [3:0] 8'h00 8'h06 OREG_TRIAL_SRATE1[11:8]
|
||||
* <SLV-T> 40h 29h [7:0] 8'hEE 8'hBE OREG_TRIAL_SRATE1[7:0]
|
||||
*/
|
||||
const uint8_t symRate[4] = {
|
||||
/* tsrate1 tsrate2 tsrate3 tsrate4 */
|
||||
0x07, 0x26, 0x06, 0xBE
|
||||
};
|
||||
|
||||
/* Set SLV-T Bank : 0x40 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x40) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x14, 0x14) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
if (pDemod->pI2c->WriteRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x26, symRate, 4) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case SONY_DTV_BW_J83B_5_60_MSPS:
|
||||
{
|
||||
/*
|
||||
* <IF freq setting>
|
||||
* slave bank addr bit default value name
|
||||
* ---------------------------------------------------------------------------------
|
||||
* <SLV-T> 10h B6h [7:0] 8'h1F user defined OREG_DNCNV_LOFRQ_T[23:16]
|
||||
* <SLV-T> 10h B7h [7:0] 8'h38 user defined OREG_DNCNV_LOFRQ_T[15:8]
|
||||
* <SLV-T> 10h B8h [7:0] 8'h32 user defined OREG_DNCNV_LOFRQ_T[7:0]
|
||||
*/
|
||||
uint8_t data[3];
|
||||
data[0] = (uint8_t) ((pDemod->iffreqConfig.configJ83B_5_60 >> 16) & 0xFF);
|
||||
data[1] = (uint8_t) ((pDemod->iffreqConfig.configJ83B_5_60 >> 8) & 0xFF);
|
||||
data[2] = (uint8_t) (pDemod->iffreqConfig.configJ83B_5_60 & 0xFF);
|
||||
if (pDemod->pI2c->WriteRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xB6, data, sizeof (data)) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
/*
|
||||
* Settings for Transmission Parameters
|
||||
* slave Bank Addr Bit default Value Name
|
||||
* ----------------------------------------------------------------------------------
|
||||
* <SLV-T> 40h 14h [4:0] 8'h1F 8'h10 OREG_QAM_ENABLE[4:0]
|
||||
* <SLV-T> 40h 26h [3:0] 8'h09 8'h07 OREG_TRIAL_SRATE0[11:8]
|
||||
* <SLV-T> 40h 27h [7:0] 8'h9A 8'h77 OREG_TRIAL_SRATE0[7:0]
|
||||
* <SLV-T> 40h 28h [3:0] 8'h00 8'h07 OREG_TRIAL_SRATE1[11:8]
|
||||
* <SLV-T> 40h 29h [7:0] 8'hEE 8'h77 OREG_TRIAL_SRATE1[7:0]
|
||||
*/
|
||||
const uint8_t symRate[4] = {
|
||||
/* tsrate1 tsrate2 tsrate3 tsrate4 */
|
||||
0x07, 0x77, 0x07, 0x77
|
||||
};
|
||||
|
||||
/* Set SLV-T Bank : 0x40 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x40) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x14, 0x10) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
if (pDemod->pI2c->WriteRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x26, symRate, 4) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (SONY_RESULT_OK);
|
||||
}
|
||||
|
||||
static sony_result_t ACCtoACC (sony_demod_t * pDemod)
|
||||
{
|
||||
sony_result_t result = SONY_RESULT_OK;
|
||||
SONY_TRACE_ENTER ("ACCtoACC");
|
||||
|
||||
if (!pDemod) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Disable TS output */
|
||||
result = sony_demod_SetStreamOutput (pDemod, 0);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
/* Set tuner and bandwidth specific settings */
|
||||
result = SLtoACC_BandSetting (pDemod);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
static sony_result_t ACCtoSL (sony_demod_t * pDemod)
|
||||
{
|
||||
sony_result_t result = SONY_RESULT_OK;
|
||||
SONY_TRACE_ENTER ("ACCtoSL");
|
||||
|
||||
if (!pDemod) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Disable TS output */
|
||||
result = sony_demod_SetStreamOutput (pDemod, 0);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x00 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Enable Hi-Z setting 1 (TAGC, SAGC, TSVALID, TSSYNC, TSCLK) */
|
||||
if (sony_i2c_SetRegisterBits (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x80, 0x1F, 0x1F) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Enable Hi-Z setting 2 */
|
||||
result = sony_demod_SetTSDataPinHiZ (pDemod, 1);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
/* Cancel J.83B Demod parameter Setting
|
||||
* slave Bank Addr Bit default Value Name
|
||||
* ---------------------------------------------------------------------------------
|
||||
* <SLV-T> 11h A3h [4:0] 8'h00 8'h00 OREG_IMR_FORCE_CHANNEL_WIDTH,1'b0,OREG_IMR_CHANNEL_WIDTH[2:0]
|
||||
* <SLV-T> 40h 21h [2] 8'h00 8'h00 OREG_DISABLE_CSI
|
||||
* <SLV-T> 40h C3h [2] 8'h00 8'h00 OREG_BNDET_EN_64
|
||||
* <SLV-T> 40h B3h [2:0] 8'h02 8'h02 OREG_LMS_MU_TRK[2:0]
|
||||
* <SLV-T> 40h 1Eh [7] 8'h00 8'h00 OREG_DISCRETE_SEARCH
|
||||
* <SLV-T> 40h 8Eh [7:0] 8'h0E 8'h0E OREG_AR_FEC_TIMER[7:0]
|
||||
* <SLV-T> 41h CFh [7:0] 8'h77 8'h77 OREG_FFE_LEAK[3:0],OREG_FBE_LEAK[3:0]
|
||||
* <SLV-T> 40h 14h [4:0] 8'h1F 8'h1F OREG_QAM_ENABLE[4:0]
|
||||
* <SLV-T> 40h 26h [3:0] 8'h09 8'h09 OREG_TRIAL_SRATE0[11:8]
|
||||
* <SLV-T> 40h 27h [7:0] 8'h9A 8'h9A OREG_TRIAL_SRATE0[7:0]
|
||||
* <SLV-T> 40h 28h [3:0] 8'h00 8'h00 OREG_TRIAL_SRATE1[11:8]
|
||||
* <SLV-T> 40h 29h [7:0] 8'hEE 8'hEE OREG_TRIAL_SRATE1[7:0]
|
||||
*/
|
||||
|
||||
/* Set SLV-T Bank : 0x11 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x11) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xA3, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x40 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x40) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x21, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xC3, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xB3, 0x02) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x1E, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x8E, 0x0E) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x41 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x41) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xCF, 0x77) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x40 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x40) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x14, 0x1F) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
{
|
||||
uint8_t data[4] = {0x09, 0x9A, 0x00, 0xEE};
|
||||
if (pDemod->pI2c->WriteRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x26, data, 4) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
}
|
||||
|
||||
/* Set SLV-X Bank : 0x00 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVX, 0x00, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* TADC setting */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVX, 0x18, 0x01) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x00 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* TADC setting */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x49, 0x33) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* TADC setting */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x4B, 0x21) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Demodulator SW reset */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xFE, 0x01) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Disable demodulator clock */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x2C, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Set tstlv mode to default */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xA9, 0x00) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Set demodulator mode to default */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVX, 0x17, 0x01) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (SONY_RESULT_OK);
|
||||
}
|
||||
Executable
+79
@@ -0,0 +1,79 @@
|
||||
/*------------------------------------------------------------------------------
|
||||
Copyright 2016-2018 Sony Semiconductor Solutions Corporation
|
||||
|
||||
Last Updated : 2018/07/27
|
||||
Modification ID : ff73ffebff57618d6a5aa6e2aa9eb009b86060d1
|
||||
------------------------------------------------------------------------------*/
|
||||
/**
|
||||
@file sony_demod_j83b.h
|
||||
|
||||
This file provides the demodulator control interface specific to J.83B.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef SONY_DEMOD_J83B_H
|
||||
#define SONY_DEMOD_J83B_H
|
||||
|
||||
#include "sony_common.h"
|
||||
#include "sony_demod.h"
|
||||
|
||||
/*------------------------------------------------------------------------------
|
||||
Structs
|
||||
------------------------------------------------------------------------------*/
|
||||
/**
|
||||
@brief The tune parameters for a J.83B signal
|
||||
*/
|
||||
typedef struct sony_j83b_tune_param_t {
|
||||
uint32_t centerFreqKHz; /**< Center frequency in kHz of the J.83B channel */
|
||||
/**
|
||||
@brief Bandwidth of the J.83B channel
|
||||
For J.83B, this parameter is used for specifying symbol rate.
|
||||
::SONY_DTV_BW_J83B_5_06_5_36_MSPS or ::SONY_DTV_BW_J83B_5_60_MSPS are available for this parameter.
|
||||
*/
|
||||
sony_dtv_bandwidth_t bandwidth;
|
||||
} sony_j83b_tune_param_t;
|
||||
|
||||
/*------------------------------------------------------------------------------
|
||||
Functions
|
||||
------------------------------------------------------------------------------*/
|
||||
/**
|
||||
@brief Enable acquisition on the demodulator for J.83B channels.
|
||||
|
||||
Called from the integration layer ::sony_integ_j83b_Tune API.
|
||||
|
||||
@param pDemod The demodulator instance
|
||||
@param pTuneParam The tune parameters.
|
||||
|
||||
@return SONY_RESULT_OK if successful.
|
||||
*/
|
||||
sony_result_t sony_demod_j83b_Tune (sony_demod_t * pDemod, sony_j83b_tune_param_t * pTuneParam);
|
||||
|
||||
/**
|
||||
@brief Put the demodulator into ::SONY_DEMOD_STATE_SLEEP state.
|
||||
|
||||
Can be called from Active, Shutdown or Sleep states.
|
||||
Called from the integration layer ::sony_integ_Sleep API.
|
||||
|
||||
@param pDemod The demodulator instance
|
||||
|
||||
@return SONY_RESULT_OK if successful.
|
||||
*/
|
||||
sony_result_t sony_demod_j83b_Sleep (sony_demod_t * pDemod);
|
||||
|
||||
/**
|
||||
@brief Check J.83B TS lock status.
|
||||
|
||||
@note This API is for checking lock status in tuning stage.
|
||||
After tuning (while receiving the signal),
|
||||
please use sony_demod_j83b_monitor_SyncStat instead
|
||||
to check current lock status.
|
||||
|
||||
@param pDemod The demodulator instance
|
||||
@param pLock TS lock state
|
||||
|
||||
@return SONY_RESULT_OK if successful.
|
||||
*/
|
||||
sony_result_t sony_demod_j83b_CheckTSLock (sony_demod_t * pDemod,
|
||||
sony_demod_lock_result_t * pLock);
|
||||
|
||||
#endif /* SONY_DEMOD_J83B_H */
|
||||
+925
@@ -0,0 +1,925 @@
|
||||
/*------------------------------------------------------------------------------
|
||||
Copyright 2016-2020 Sony Semiconductor Solutions Corporation
|
||||
|
||||
Last Updated : 2020/10/23
|
||||
Modification ID : b18046a6528522fe8de419252a316663e87b216c
|
||||
------------------------------------------------------------------------------*/
|
||||
#include "sony_demod_j83b_monitor.h"
|
||||
#include "sony_math.h"
|
||||
#include "sony_common.h"
|
||||
|
||||
/*------------------------------------------------------------------------------
|
||||
Static Function Prototypes
|
||||
------------------------------------------------------------------------------*/
|
||||
/*
|
||||
@brief Confirms AR lock state for demodulator.
|
||||
*/
|
||||
static sony_result_t IsARLocked (sony_demod_t * pDemod);
|
||||
/*
|
||||
@brief Confirms VQ lock state for demodulator.
|
||||
*/
|
||||
static sony_result_t IsVqLocked (sony_demod_t * pDemod);
|
||||
|
||||
/*------------------------------------------------------------------------------
|
||||
Functions
|
||||
------------------------------------------------------------------------------*/
|
||||
sony_result_t sony_demod_j83b_monitor_SyncStat (sony_demod_t * pDemod,
|
||||
uint8_t * pARLock,
|
||||
uint8_t * pTSLockStat,
|
||||
uint8_t * pUnlockDetected)
|
||||
{
|
||||
uint8_t rdata = 0x00;
|
||||
|
||||
SONY_TRACE_ENTER ("sony_demod_j83b_monitor_SyncStat");
|
||||
|
||||
if ((!pDemod) || (!pARLock) || (!pTSLockStat) || (!pUnlockDetected)) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Software state check */
|
||||
if (pDemod->state != SONY_DEMOD_STATE_ACTIVE) {
|
||||
/* This api is accepted in Active state only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
if (pDemod->system != SONY_DTV_SYSTEM_J83B) {
|
||||
/* Not J.83B */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x40 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x40) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* slave Bank Addr Bit Name meaning
|
||||
* ---------------------------------------------------------------------------------
|
||||
* <SLV-T> 40h 88h [0] IREG_AR_LOCK 0:Unlock 1:Lock
|
||||
* <SLV-T> 40h 88h [1] IREG_AR_TIMEOUT 0:Checking, 1:J.83B signal does not exist
|
||||
* <SLV-T> 40h 10h [5] IREG_TSIF_TS_LOCK 0:Unlock 1:Lock
|
||||
*/
|
||||
if (pDemod->pI2c->ReadRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x88, &rdata, 1) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
*pARLock = (uint8_t) ((rdata & 0x01) ? 1 : 0);
|
||||
*pUnlockDetected = (uint8_t) ((rdata & 0x02) ? 1 : 0);
|
||||
|
||||
if (pDemod->pI2c->ReadRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x10, &rdata, 1) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
*pTSLockStat = (uint8_t) ((rdata & 0x20) ? 1 : 0);
|
||||
|
||||
SONY_TRACE_RETURN (SONY_RESULT_OK);
|
||||
}
|
||||
|
||||
sony_result_t sony_demod_j83b_monitor_IFAGCOut (sony_demod_t * pDemod, uint32_t * pIFAGCOut)
|
||||
{
|
||||
uint8_t rdata[2];
|
||||
|
||||
SONY_TRACE_ENTER ("sony_demod_j83b_monitor_IFAGCOut");
|
||||
|
||||
if (!pDemod || !pIFAGCOut) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Software state check */
|
||||
if (pDemod->state != SONY_DEMOD_STATE_ACTIVE) {
|
||||
/* This api is accepted in Active state only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
if (pDemod->system != SONY_DTV_SYSTEM_J83B) {
|
||||
/* Not J.83B */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x40 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x40) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* slave Bank Addr Bit Name
|
||||
* ------------------------------------------------------------
|
||||
* <SLV-T> 40h 49h [3:0] IIFAGC_OUT[11:8]
|
||||
* <SLV-T> 40h 4Ah [7:0] IIFAGC_OUT[7:0]
|
||||
*/
|
||||
if (pDemod->pI2c->ReadRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x49, rdata, 2) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
*pIFAGCOut = (rdata[0] & 0x0F) << 8 | rdata[1];
|
||||
|
||||
SONY_TRACE_RETURN (SONY_RESULT_OK);
|
||||
}
|
||||
|
||||
sony_result_t sony_demod_j83b_monitor_QAM (sony_demod_t * pDemod, sony_j83b_constellation_t * pQAM)
|
||||
{
|
||||
uint8_t rdata = 0x00;
|
||||
|
||||
SONY_TRACE_ENTER ("sony_demod_j83b_monitor_QAM");
|
||||
|
||||
if (!pDemod || !pQAM) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Software state check */
|
||||
if (pDemod->state != SONY_DEMOD_STATE_ACTIVE) {
|
||||
/* This api is accepted in Active state only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
if (pDemod->system != SONY_DTV_SYSTEM_J83B) {
|
||||
/* Not J.83B */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
/* Freeze registers */
|
||||
if (SLVT_FreezeReg (pDemod) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* AR lock check */
|
||||
{
|
||||
sony_result_t result = IsARLocked (pDemod);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x40 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x40) != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* slave Bank Addr Bit Name
|
||||
* ------------------------------------------------------------
|
||||
* <SLV-T> 40h 19h [2:0] IREG_QAM_LEVEL[2:0]
|
||||
*/
|
||||
if (pDemod->pI2c->ReadRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x19, &rdata, 1) != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
|
||||
*pQAM = (sony_j83b_constellation_t) (rdata & 0x07);
|
||||
|
||||
SONY_TRACE_RETURN (SONY_RESULT_OK);
|
||||
}
|
||||
|
||||
sony_result_t sony_demod_j83b_monitor_SymbolRate (sony_demod_t * pDemod, uint32_t * pSymRate)
|
||||
{
|
||||
uint8_t rdata1[2];
|
||||
uint8_t rdata2[5];
|
||||
uint32_t trialsrate;
|
||||
int32_t tlfIntegral;
|
||||
uint32_t tsmDrate;
|
||||
|
||||
|
||||
SONY_TRACE_ENTER ("sony_demod_j83b_monitor_SymbolRate");
|
||||
|
||||
if (!pDemod || !pSymRate) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Software state check */
|
||||
if (pDemod->state != SONY_DEMOD_STATE_ACTIVE) {
|
||||
/* This api is accepted in Active state only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
if (pDemod->system != SONY_DTV_SYSTEM_J83B) {
|
||||
/* Not J.83B */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
/* Freeze registers */
|
||||
if (SLVT_FreezeReg (pDemod) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* AR lock check */
|
||||
{
|
||||
sony_result_t result = IsARLocked (pDemod);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x40 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x40) != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* slave Bank Addr Bit Name
|
||||
* ------------------------------------------------------------
|
||||
* <SLV-T> 40h 1Ah [3:0] IREG_TRIALSRATE[11:8]
|
||||
* <SLV-T> 40h 1Bh [7:0] IREG_TRIALSRATE[7:0]
|
||||
* <SLV-T> 40h 9Bh [7:0] IREG_TLFINTEGRAL[31:24]
|
||||
* <SLV-T> 40h 9Ch [7:0] IREG_TLFINTEGRAL[23:16]
|
||||
* <SLV-T> 40h 9Dh [7:0] IREG_TLFINTEGRAL[15:8]
|
||||
* <SLV-T> 40h 9Eh [7:0] IREG_TLFINTEGRAL[7:0]
|
||||
* <SLV-T> 40h 9Fh [1:0] IREG_TSMDRATE[1:0]
|
||||
*/
|
||||
if (pDemod->pI2c->ReadRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x1A, rdata1, sizeof(rdata1)) != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Read IREG_TLFINTEGRAL and IREG_TSMDRATE */
|
||||
if (pDemod->pI2c->ReadRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x9B, rdata2, sizeof(rdata2)) != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
|
||||
trialsrate = ((rdata1[0] & 0x0F) << 8) | rdata1[1];
|
||||
tlfIntegral = (int32_t)((rdata2[0] << 24) | (rdata2[1] << 16) | (rdata2[2] << 8) | rdata2[3]);
|
||||
tsmDrate = rdata2[4] & 0x03;
|
||||
|
||||
/*
|
||||
* Symbol rate[MSymbol/sec] = (IREG_TRIALSRATE + (IREG_TLFINTEGRAL / ( 2^(24 + IREG_TSMDRATE)))) * ick / 16384
|
||||
* (IREG_TLFINTEGRAL is 2's compliment, ick = 48)
|
||||
*
|
||||
* Symbol rate[Symbol/sec] = (IREG_TRIALSRATE + (IREG_TLFINTEGRAL / ( 2^(24 + IREG_TSMDRATE)))) * 48 / 2^14 * 10^6
|
||||
* = (IREG_TRIALSRATE + (IREG_TLFINTEGRAL / ( 2^(24 + IREG_TSMDRATE)))) * 3 * 5^6 / 2^4
|
||||
* = IREG_TRIALSRATE * 3 * 5^6 / 16 + IREG_TLFINTEGRAL * 3 * 5^6 / ( 2^(28 + IREG_TSMDRATE))
|
||||
*/
|
||||
/* Calculate IREG_TRIALSRATE * 3 * 5^6 / 16 */
|
||||
*pSymRate = (trialsrate * 46875 + 8) / 16;
|
||||
|
||||
/* Calculate IREG_TLFINTEGRAL * 3 * 5^6 / ( 2^(28 + IREG_TSMDRATE)) */
|
||||
{
|
||||
uint32_t div = 0;
|
||||
uint32_t Q = 0;
|
||||
uint32_t R = 0;
|
||||
|
||||
uint8_t isMinus = 0;
|
||||
|
||||
if (tlfIntegral < 0) {
|
||||
isMinus = 1;
|
||||
tlfIntegral *= -1;
|
||||
}
|
||||
|
||||
div = 65536; /* Divide by 2^16 first */
|
||||
|
||||
/* Divide in 2 steps to prevent overflow. */
|
||||
Q = tlfIntegral / div;
|
||||
R = tlfIntegral % div;
|
||||
|
||||
R *= 46875; /* 3 * 5^6 */
|
||||
Q = Q * 46875 + R / div;
|
||||
R = R % div;
|
||||
|
||||
if (R >= div/2) {
|
||||
Q += 1;
|
||||
}
|
||||
|
||||
/* Divide by 2^(12 + IREG_TSMDRATE) */
|
||||
Q = (Q + (1U << (11 + tsmDrate))) >> (12 + tsmDrate);
|
||||
|
||||
if (isMinus) {
|
||||
*pSymRate -= Q;
|
||||
} else {
|
||||
*pSymRate += Q;
|
||||
}
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (SONY_RESULT_OK);
|
||||
}
|
||||
|
||||
sony_result_t sony_demod_j83b_monitor_SamplingOffset (sony_demod_t * pDemod,
|
||||
int32_t * pPPM)
|
||||
{
|
||||
sony_j83b_constellation_t qam;
|
||||
uint32_t symRate = 0;
|
||||
uint32_t standardSymRate = 0;
|
||||
sony_result_t result = SONY_RESULT_OK;
|
||||
|
||||
SONY_TRACE_ENTER ("sony_demod_j83b_monitor_SamplingOffset");
|
||||
|
||||
if ((!pDemod) || (!pPPM)) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Software state check */
|
||||
if (pDemod->state != SONY_DEMOD_STATE_ACTIVE) {
|
||||
/* This api is accepted in Active state only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
if (pDemod->system != SONY_DTV_SYSTEM_J83B) {
|
||||
/* Not J.83B*/
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
result = sony_demod_j83b_monitor_QAM (pDemod, &qam);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
result = sony_demod_j83b_monitor_SymbolRate (pDemod, &symRate);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
if (pDemod->bandwidth == SONY_DTV_BW_J83B_5_06_5_36_MSPS && qam == SONY_J83B_CONSTELLATION_64QAM) {
|
||||
standardSymRate = 5056941;
|
||||
} else if (pDemod->bandwidth == SONY_DTV_BW_J83B_5_06_5_36_MSPS && qam == SONY_J83B_CONSTELLATION_256QAM) {
|
||||
standardSymRate = 5360537;
|
||||
} else if (pDemod->bandwidth == SONY_DTV_BW_J83B_5_60_MSPS && qam == SONY_J83B_CONSTELLATION_256QAM) {
|
||||
standardSymRate = 5600000;
|
||||
} else {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_HW_STATE);
|
||||
}
|
||||
|
||||
/*
|
||||
* Clock Frequency Offset[ppm] = {(Standard Sr - Sr) / Standard Sr} * 10^8
|
||||
* = {(1 - (Sr / Standard Sr)} * 10^8
|
||||
* = 10^8 - (Sr /Standard Sr) * 10^8
|
||||
* = 10^8 - {(Sr * (2^8 * 5^8) / Standard Sr)}
|
||||
* Sr * (2^8 * 5^8) / Standard Sr = Sr * 2^8 * 5^4 * 5^4 / Standard Sr
|
||||
*/
|
||||
|
||||
{
|
||||
uint32_t Q = 0;
|
||||
uint32_t R = 0;
|
||||
uint32_t div = standardSymRate;
|
||||
|
||||
Q = symRate * 256 / div;
|
||||
R = symRate * 256 % div;
|
||||
|
||||
R *= 625;
|
||||
Q = Q * 625 + R / div;
|
||||
R = R % div;
|
||||
|
||||
R *= 625;
|
||||
Q = Q * 625 + R / div;
|
||||
R = R % div;
|
||||
|
||||
if (R >= div / 2) {
|
||||
Q += 1;
|
||||
}
|
||||
|
||||
*pPPM = 100000000 - Q;
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
sony_result_t sony_demod_j83b_monitor_CarrierOffset (sony_demod_t * pDemod, int32_t * pOffset)
|
||||
{
|
||||
uint8_t rdata[2];
|
||||
|
||||
SONY_TRACE_ENTER ("sony_demod_j83b_monitor_CarrierOffset");
|
||||
|
||||
if (!pDemod || !pOffset) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Software state check */
|
||||
if (pDemod->state != SONY_DEMOD_STATE_ACTIVE) {
|
||||
/* This api is accepted in Active state only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
if (pDemod->system != SONY_DTV_SYSTEM_J83B) {
|
||||
/* Not J.83B */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
/* Freeze registers */
|
||||
if (SLVT_FreezeReg (pDemod) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* AR lock check */
|
||||
{
|
||||
sony_result_t result = IsARLocked (pDemod);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x40 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x40) != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* slave Bank Addr Bit Name
|
||||
* ---------------------------------------------------------------
|
||||
* <SLV-T> 40h 15h [5:0] IREG_FREQ_OFFSET[13:8]
|
||||
* <SLV-T> 40h 16h [7:0] IREG_FREQ_OFFSET[7:0]
|
||||
*/
|
||||
if (pDemod->pI2c->ReadRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x15, rdata, 2) != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
|
||||
/* 14bit signed value to 32bit signed value */
|
||||
*pOffset = sony_Convert2SComplement (((rdata[0] & 0x3F) << 8) | rdata[1], 14);
|
||||
|
||||
/* Carrier offset[KHz] = IREG_FREQ_OFFSET * ADC_Clock(KHz) / 16384
|
||||
*
|
||||
* ADC_Clock(KHz) = 48000
|
||||
*/
|
||||
*pOffset = *pOffset * 48000 / 16384;
|
||||
|
||||
/* Compensate for inverted spectrum. */
|
||||
{
|
||||
/* Inverted RF spectrum with non-inverting tuner architecture. */
|
||||
if (pDemod->confSense == SONY_DEMOD_TERR_CABLE_SPECTRUM_INV) {
|
||||
*pOffset *= -1;
|
||||
}
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (SONY_RESULT_OK);
|
||||
}
|
||||
|
||||
sony_result_t sony_demod_j83b_monitor_SpectrumSense (sony_demod_t * pDemod, sony_demod_terr_cable_spectrum_sense_t * pSense)
|
||||
{
|
||||
uint8_t rdata = 0x00;
|
||||
|
||||
SONY_TRACE_ENTER ("sony_demod_j83b_monitor_SpectrumSense");
|
||||
|
||||
if (!pDemod || !pSense) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Software state check */
|
||||
if (pDemod->state != SONY_DEMOD_STATE_ACTIVE) {
|
||||
/* This api is accepted in Active state only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
if (pDemod->system != SONY_DTV_SYSTEM_J83B) {
|
||||
/* Not J.83B */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
/* Freeze registers */
|
||||
if (SLVT_FreezeReg (pDemod) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* VQ lock check */
|
||||
{
|
||||
sony_result_t result = IsVqLocked (pDemod);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x80 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x80) != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* slave Bank Addr Bit Name mean
|
||||
* ---------------------------------------------------------------------------------
|
||||
* <SLV-T> 80h 55h [0] DFRMJ_IQREV 0:Normal, 1:inverted
|
||||
*/
|
||||
if (pDemod->pI2c->ReadRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x55, &rdata, 1) != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
|
||||
if (pDemod->confSense == SONY_DEMOD_TERR_CABLE_SPECTRUM_INV) {
|
||||
*pSense = (rdata & 0x01) ? SONY_DEMOD_TERR_CABLE_SPECTRUM_NORMAL : SONY_DEMOD_TERR_CABLE_SPECTRUM_INV;
|
||||
} else {
|
||||
*pSense = (rdata & 0x01) ? SONY_DEMOD_TERR_CABLE_SPECTRUM_INV : SONY_DEMOD_TERR_CABLE_SPECTRUM_NORMAL;
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (SONY_RESULT_OK);
|
||||
}
|
||||
|
||||
sony_result_t sony_demod_j83b_monitor_SNR (sony_demod_t * pDemod, int32_t * pSNR)
|
||||
{
|
||||
sony_j83b_constellation_t qam = SONY_J83B_CONSTELLATION_64QAM;
|
||||
uint16_t reg = 0x00;
|
||||
uint8_t rdata[2];
|
||||
sony_result_t result = SONY_RESULT_OK;
|
||||
|
||||
SONY_TRACE_ENTER ("sony_demod_j83b_monitor_SNR");
|
||||
|
||||
if (!pDemod || !pSNR) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Software state check */
|
||||
if (pDemod->state != SONY_DEMOD_STATE_ACTIVE) {
|
||||
/* This api is accepted in Active state only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
if (pDemod->system != SONY_DTV_SYSTEM_J83B) {
|
||||
/* Not J.83B */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
/* Freeze registers */
|
||||
if (SLVT_FreezeReg (pDemod) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* AR lock check */
|
||||
{
|
||||
result = IsARLocked (pDemod);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x40 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x40) != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* slave Bank Addr Bit Name
|
||||
* ------------------------------------------------------------
|
||||
* <SLV-T> 40h 19h [2:0] IREG_QAM_LEVEL[2:0]
|
||||
*/
|
||||
if (pDemod->pI2c->ReadRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x19, &rdata[0], 1) != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
qam = (sony_j83b_constellation_t) (rdata[0] & 0x07);
|
||||
|
||||
/* slave Bank Addr Bit Name
|
||||
* ------------------------------------------------------------
|
||||
* <SLV-T> 40h 4Ch [4:0] IREG_SNR_ESTIMATE[12:8]
|
||||
* <SLV-T> 40h 4Dh [7:0] IREG_SNR_ESTIMATE[7:0]
|
||||
*/
|
||||
if (pDemod->pI2c->ReadRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x4C, rdata, 2) != SONY_RESULT_OK) {
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
SLVT_UnFreezeReg (pDemod);
|
||||
|
||||
reg = ((rdata[0] & 0x1F) << 8) | rdata[1];
|
||||
|
||||
if (reg == 0) {
|
||||
/* log function will return INF */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_HW_STATE);
|
||||
}
|
||||
|
||||
switch (qam) {
|
||||
case SONY_J83B_CONSTELLATION_64QAM:
|
||||
case SONY_J83B_CONSTELLATION_256QAM:
|
||||
/* IREG_SNR_ESTIMATE is clipped at a minimum of 126
|
||||
*
|
||||
* SNR(dB) = -9.50 * ln(IREG_SNR_ESTIMATE / (24320))
|
||||
*/
|
||||
if (reg < 126) {
|
||||
reg = 126;
|
||||
}
|
||||
|
||||
*pSNR = -95 * (int32_t) sony_math_log (reg) + 95941;
|
||||
break;
|
||||
default:
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_HW_STATE);
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
sony_result_t sony_demod_j83b_monitor_PreRSBER (sony_demod_t * pDemod, uint32_t * pBER)
|
||||
{
|
||||
uint8_t rdata[3];
|
||||
uint32_t bitError = 0;
|
||||
uint32_t periodExp = 0;
|
||||
|
||||
SONY_TRACE_ENTER ("sony_demod_j83b_monitor_PreRSBER");
|
||||
|
||||
if (!pDemod || !pBER) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Software state check */
|
||||
if (pDemod->state != SONY_DEMOD_STATE_ACTIVE) {
|
||||
/* This api is accepted in Active state only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
if (pDemod->system != SONY_DTV_SYSTEM_J83B) {
|
||||
/* Not J.83B */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x40 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x40) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
rdata[0] = rdata[1] = rdata[2] = 0;
|
||||
|
||||
/* slave Bank Addr Bit Name
|
||||
* ------------------------------------------------------------
|
||||
* <SLV-T> 40h 62h [7] IREG_BERN_VALID
|
||||
* <SLV-T> 40h 62h [5:0] IREG_BERN_BITECNT[21:16]
|
||||
* <SLV-T> 40h 63h [7:0] IREG_BERN_BITECNT[15:8]
|
||||
* <SLV-T> 40h 64h [7:0] IREG_BERN_BITECNT[7:0]
|
||||
*/
|
||||
if (pDemod->pI2c->ReadRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x62, rdata, 3) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* Check IREG_BERN_VALID bit (bit 7) */
|
||||
if ((rdata[0] & 0x80) == 0) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_HW_STATE); /* Not ready... */
|
||||
}
|
||||
|
||||
bitError = ((rdata[0] & 0x3F) << 16) | (rdata[1] << 8) | rdata[2];
|
||||
|
||||
/* slave Bank Addr Bit default Name
|
||||
* -------------------------------------------------------------------------
|
||||
* <SLV-T> 40h 60h [4:0] 5'h0B OREG_BERN_PERIOD[4:0]
|
||||
*/
|
||||
if (pDemod->pI2c->ReadRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x60, rdata, 1) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
periodExp = (rdata[0] & 0x1F);
|
||||
|
||||
if ((periodExp <= 11) && (bitError > (1U << periodExp) * 128 * 7)) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_HW_STATE);
|
||||
}
|
||||
|
||||
/*
|
||||
BER = bitError * 10000000 / (2^N * 128 * 7)
|
||||
= bitError * 78125 / (2^N * 7)
|
||||
= bitError * 125 * 625 / (2^N * 7)
|
||||
(Divide in 2 steps to prevent overflow.)
|
||||
*/
|
||||
{
|
||||
uint32_t div = 0;
|
||||
uint32_t Q = 0;
|
||||
uint32_t R = 0;
|
||||
|
||||
if (periodExp <= 8) {
|
||||
div = (1U << periodExp) * 7;
|
||||
}
|
||||
else {
|
||||
div = (1U << 8) * 7;
|
||||
}
|
||||
|
||||
Q = (bitError * 125) / div;
|
||||
R = (bitError * 125) % div;
|
||||
|
||||
R *= 625;
|
||||
Q = Q * 625 + R / div;
|
||||
R = R % div;
|
||||
|
||||
if (periodExp > 8) {
|
||||
/* rounding */
|
||||
*pBER = (Q + (1 << (periodExp - 9))) >> (periodExp - 8);
|
||||
}
|
||||
else {
|
||||
/* rounding */
|
||||
if (R >= div/2) {
|
||||
*pBER = Q + 1;
|
||||
} else {
|
||||
*pBER = Q;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (SONY_RESULT_OK);
|
||||
}
|
||||
|
||||
sony_result_t sony_demod_j83b_monitor_PacketErrorNumber (sony_demod_t * pDemod, uint32_t * pPEN)
|
||||
{
|
||||
uint8_t rdata[3];
|
||||
|
||||
SONY_TRACE_ENTER ("sony_demod_j83b_monitor_PacketErrorNumber");
|
||||
|
||||
if (!pDemod || !pPEN) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Software state check */
|
||||
if (pDemod->state != SONY_DEMOD_STATE_ACTIVE) {
|
||||
/* This api is accepted in Active state only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
if (pDemod->system != SONY_DTV_SYSTEM_J83B) {
|
||||
/* Not J.83B */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x40 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x40) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* slave Bank Addr Bit Name
|
||||
* ------------------------------------------------------------
|
||||
* <SLV-T> 40h EAh [7:0] IREG_BER_CWRJCTCNT[15:8]
|
||||
* <SLV-T> 40h EBh [7:0] IREG_BER_CWRJCTCNT[7:0]
|
||||
* <SLV-T> 40h ECh [0] IREG_BER_CWRJCTCNT_VALID
|
||||
*/
|
||||
if (pDemod->pI2c->ReadRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0xEA, rdata, 3) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
if (!(rdata[2] & 0x01)) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_HW_STATE);
|
||||
}
|
||||
|
||||
*pPEN = (rdata[0] << 8) | rdata[1];
|
||||
|
||||
SONY_TRACE_RETURN (SONY_RESULT_OK);
|
||||
}
|
||||
|
||||
sony_result_t sony_demod_j83b_monitor_PER (sony_demod_t * pDemod, uint32_t * pPER)
|
||||
{
|
||||
sony_result_t result = SONY_RESULT_OK;
|
||||
uint32_t packetError = 0;
|
||||
uint32_t periodExp = 0;
|
||||
|
||||
SONY_TRACE_ENTER ("sony_demod_j83b_monitor_PER");
|
||||
|
||||
if (!pDemod || !pPER) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Software state check */
|
||||
if (pDemod->state != SONY_DEMOD_STATE_ACTIVE) {
|
||||
/* This api is accepted in Active state only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
if (pDemod->system != SONY_DTV_SYSTEM_J83B) {
|
||||
/* Not J.83B */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
/* slave Bank Addr Bit Name
|
||||
* ---------------------------------------------------------------------------------
|
||||
* <SLV-T> 40h 5Ch [4:0] OREG_PER_MES[4:0]
|
||||
* <SLV-T> 40h 5Dh [2] IREG_PER_VALID
|
||||
* <SLV-T> 40h 5Dh [1:0] IREG_PER_PKTERR[17:16]
|
||||
* <SLV-T> 40h 5Eh [7:0] IREG_PER_PKTERR[15:8]
|
||||
* <SLV-T> 40h 5Fh [7:0] IREG_PER_PKTERR[7:0]
|
||||
*
|
||||
* PER = IREG_PER_PKTERR / ( 2 ^ OREG_PER_MES )
|
||||
*/
|
||||
|
||||
{
|
||||
uint8_t rdata[4];
|
||||
|
||||
/* Set SLV-T Bank : 0x40 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x40) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
if (pDemod->pI2c->ReadRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x5C, rdata, sizeof (rdata)) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
if ((rdata[1] & 0x04) == 0) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_HW_STATE); /* Not ready... */
|
||||
}
|
||||
|
||||
packetError = ((rdata[1] & 0x03) << 16) | (rdata[2] << 8) | rdata[3];
|
||||
periodExp = rdata[0] & 0x1F;
|
||||
}
|
||||
|
||||
if (packetError > (1U << periodExp)) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_HW_STATE);
|
||||
}
|
||||
|
||||
/*
|
||||
PER = packetError * 1000000 / 2^N
|
||||
= packetError * 5^6 / 2^(N-6) (If N > 6)
|
||||
|
||||
= packetError * 10^6 / 2^N (If N <= 6, packetError <= 2^6)
|
||||
|
||||
Max of packeError : 0x3FFFF
|
||||
*/
|
||||
if (periodExp == 0) {
|
||||
*pPER = packetError * 1000000;
|
||||
} else if (periodExp > 6) {
|
||||
*pPER = (packetError * 15625 + (1 << (periodExp - 7))) >> (periodExp - 6);
|
||||
} else {
|
||||
*pPER = (packetError * 1000000 + (1 << (periodExp - 1))) >> periodExp;
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
sony_result_t sony_demod_j83b_monitor_Interleave (sony_demod_t * pDemod,
|
||||
sony_j83b_interleave_t * pInterleave)
|
||||
{
|
||||
sony_result_t result = SONY_RESULT_OK;
|
||||
uint8_t rdata[2];
|
||||
|
||||
SONY_TRACE_ENTER ("sony_demod_j83b_monitor_Interleave");
|
||||
|
||||
if (!pDemod || !pInterleave) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Software state check */
|
||||
if (pDemod->state != SONY_DEMOD_STATE_ACTIVE) {
|
||||
/* This api is accepted in Active state only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
if (pDemod->system != SONY_DTV_SYSTEM_J83B) {
|
||||
/* Not J.83B */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x80 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x80) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
/* slave Bank Addr Bit Name meaning
|
||||
* ---------------------------------------------------------------------------------
|
||||
* <SLV-T> 80h 53h [0] DFRMJ_ICWLOCK 0:UNLOCK, 1:LOCK
|
||||
* <SLV-T> 80h 54h [3:0] IREG_DFRMJ_ICW[3:0]
|
||||
*/
|
||||
|
||||
if (pDemod->pI2c->ReadRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x53, rdata, 2) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
if (!(rdata[0] & 0x01)) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_HW_STATE);
|
||||
}
|
||||
|
||||
*pInterleave = (sony_j83b_interleave_t) (rdata[1] & 0x0F);
|
||||
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------------------------
|
||||
Static functions
|
||||
------------------------------------------------------------------------------*/
|
||||
static sony_result_t IsARLocked (sony_demod_t * pDemod)
|
||||
{
|
||||
uint8_t ar = 0;
|
||||
uint8_t tslock = 0;
|
||||
uint8_t earlyUnlock = 0;
|
||||
sony_result_t result = SONY_RESULT_OK;
|
||||
|
||||
SONY_TRACE_ENTER ("IsARLocked");
|
||||
|
||||
if (!pDemod) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
result = sony_demod_j83b_monitor_SyncStat (pDemod, &ar, &tslock,&earlyUnlock);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
if (ar != 1) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_HW_STATE);
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (SONY_RESULT_OK);
|
||||
}
|
||||
|
||||
static sony_result_t IsVqLocked (sony_demod_t * pDemod)
|
||||
{
|
||||
uint8_t vq = 0;
|
||||
uint8_t rdata;
|
||||
|
||||
SONY_TRACE_ENTER ("IsVqLocked");
|
||||
|
||||
if (!pDemod) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Set SLV-T Bank : 0x80 */
|
||||
if (pDemod->pI2c->WriteOneRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x00, 0x80) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
/* slave Bank Addr Bit Name
|
||||
* ------------------------------------------------------------
|
||||
* <SLV-T> 80h 50h [0] VQLOCL
|
||||
*/
|
||||
if (pDemod->pI2c->ReadRegister (pDemod->pI2c, pDemod->i2cAddressSLVT, 0x50, &rdata, 1) != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_I2C);
|
||||
}
|
||||
|
||||
vq = (uint8_t) ((rdata & 0x01) ? 1 : 0);
|
||||
|
||||
if (vq != 1) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_HW_STATE);
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (SONY_RESULT_OK);
|
||||
}
|
||||
+186
@@ -0,0 +1,186 @@
|
||||
/*------------------------------------------------------------------------------
|
||||
Copyright 2016-2018 Sony Semiconductor Solutions Corporation
|
||||
|
||||
Last Updated : 2018/07/27
|
||||
Modification ID : ff73ffebff57618d6a5aa6e2aa9eb009b86060d1
|
||||
------------------------------------------------------------------------------*/
|
||||
/**
|
||||
@file sony_demod_j83b_monitor.h
|
||||
|
||||
This file provides the J.83B demodulator monitor interface.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef SONY_DEMOD_J83B_MONITOR_H
|
||||
#define SONY_DEMOD_J83B_MONITOR_H
|
||||
|
||||
#include "sony_demod.h"
|
||||
#include "sony_j83b.h"
|
||||
|
||||
/*------------------------------------------------------------------------------
|
||||
Functions
|
||||
------------------------------------------------------------------------------*/
|
||||
/**
|
||||
@brief Acquisition state monitor.
|
||||
|
||||
@note Note that early unlock condition should be used in tuning stage ONLY
|
||||
to detect that there are no desired signal in current frequency quickly.
|
||||
After tuning, early unlock condition should NOT be used to
|
||||
know current demodulator lock status.
|
||||
|
||||
@param pDemod The demodulator instance.
|
||||
@param pARLock The demodulator lock state.
|
||||
- 0: AR not Locked,
|
||||
- 1: AR Locked,
|
||||
@param pTSLockStat Indicates the TS lock condition.
|
||||
- 0: TS not locked.
|
||||
- 1: TS locked.
|
||||
@param pUnlockDetected Indicates the early unlock condition, only valid
|
||||
when demodulator is set to J.83B scan mode enabled.
|
||||
- 0: No early unlock.
|
||||
- 1: Early unlock.
|
||||
|
||||
@return SONY_RESULT_OK on success and pARLock, pTSLockStat and pUnlockDetected are valid.
|
||||
|
||||
*/
|
||||
sony_result_t sony_demod_j83b_monitor_SyncStat (sony_demod_t * pDemod,
|
||||
uint8_t * pARLock,
|
||||
uint8_t * pTSLockStat,
|
||||
uint8_t * pUnlockDetected);
|
||||
|
||||
/**
|
||||
@brief Monitor the IFAGC value. The actual dB gain is dependent on the attached tuner.
|
||||
|
||||
@param pDemod The demodulator instance.
|
||||
@param pIFAGCOut Value of IFAGC output register value. Unitless.
|
||||
|
||||
@return SONY_RESULT_OK if successful and pIFAGCOut valid.
|
||||
*/
|
||||
sony_result_t sony_demod_j83b_monitor_IFAGCOut (sony_demod_t * pDemod,
|
||||
uint32_t * pIFAGCOut);
|
||||
|
||||
/**
|
||||
@brief Monitor the constellation of the currently tuned channel.
|
||||
|
||||
@param pDemod The demodulator instance.
|
||||
@param pQAM The monitored constellation.
|
||||
|
||||
@return SONY_RESULT_OK if successful and pQAM valid.
|
||||
*/
|
||||
sony_result_t sony_demod_j83b_monitor_QAM (sony_demod_t * pDemod,
|
||||
sony_j83b_constellation_t * pQAM);
|
||||
|
||||
/**
|
||||
@brief Monitor the symbol rate of the currently tuned channel.
|
||||
|
||||
@param pDemod The demodulator instance.
|
||||
@param pSymRate Symbol rate (Symbol/sec).
|
||||
|
||||
@return SONY_RESULT_OK if successful and pSymRate valid.
|
||||
*/
|
||||
sony_result_t sony_demod_j83b_monitor_SymbolRate (sony_demod_t * pDemod,
|
||||
uint32_t * pSymRate);
|
||||
|
||||
/**
|
||||
@brief Monitor the sampling frequency offset value.
|
||||
|
||||
@param pDemod The demodulator instance.
|
||||
@param pPPM The sampling frequency offset in ppm x 100.
|
||||
|
||||
@return SONY_RESULT_OK if pPPM is valid.
|
||||
*/
|
||||
sony_result_t sony_demod_j83b_monitor_SamplingOffset (sony_demod_t * pDemod,
|
||||
int32_t * pPPM);
|
||||
|
||||
/**
|
||||
@brief Monitors the detected carrier offset of the currently tuned channel.
|
||||
|
||||
To get the estimated center frequency of the current channel:
|
||||
Freq_Est = Freq_Tune + pOffset;
|
||||
|
||||
This function will compensate for an inverting tuner architecture if the
|
||||
demodulator has been configured accordignly using ::SONY_DEMOD_CONFIG_SPECTRUM_INV
|
||||
config option for ::sony_demod_SetConfig.
|
||||
|
||||
@param pDemod The demodulator instance.
|
||||
@param pOffset Carrier offset value(kHz).
|
||||
|
||||
@return SONY_RESULT_OK if successful and pOffset valid.
|
||||
*/
|
||||
sony_result_t sony_demod_j83b_monitor_CarrierOffset (sony_demod_t * pDemod,
|
||||
int32_t * pOffset);
|
||||
|
||||
/**
|
||||
@brief Monitors the channel spectrum sense.
|
||||
|
||||
To ensure correct polarity detection
|
||||
please use the ::SONY_DEMOD_CONFIG_SPECTRUM_INV config option in
|
||||
::sony_demod_SetConfig to select the appropriate spectrum inversion
|
||||
for the tuner output.
|
||||
|
||||
@param pDemod The demodulator instance.
|
||||
@param pSense Indicates the spectrum sense.
|
||||
|
||||
@return SONY_RESULT_OK if successful and pSense valid.
|
||||
*/
|
||||
sony_result_t sony_demod_j83b_monitor_SpectrumSense (sony_demod_t * pDemod,
|
||||
sony_demod_terr_cable_spectrum_sense_t * pSense);
|
||||
|
||||
/**
|
||||
@brief Monitors the estimated SNR register value, clipped to a
|
||||
maximum of 50dB.
|
||||
|
||||
@param pDemod The demodulator instance.
|
||||
@param pSNR The estimated SNR value in dB x 1000.
|
||||
|
||||
@return SONY_RESULT_OK if successful and pSNR valid.
|
||||
*/
|
||||
sony_result_t sony_demod_j83b_monitor_SNR (sony_demod_t * pDemod,
|
||||
int32_t * pSNR);
|
||||
|
||||
/**
|
||||
@brief Monitor the Pre-RS BER.
|
||||
|
||||
@param pDemod The demodulator instance.
|
||||
@param pBER BER value (Pre-Reed Solomon decoder) x 1e7.
|
||||
|
||||
@return SONY_RESULT_OK if successful and pBER valid.
|
||||
*/
|
||||
sony_result_t sony_demod_j83b_monitor_PreRSBER (sony_demod_t * pDemod,
|
||||
uint32_t * pBER);
|
||||
|
||||
/**
|
||||
@brief Monitors the number RS (Reed-Solomon) errors detected by the
|
||||
RS decoder over 1 second. Also known as the code word reject count.
|
||||
|
||||
@param pDemod The demodulator instance.
|
||||
@param pPEN The number of RS errors detected over 1 second.
|
||||
|
||||
@return SONY_RESULT_OK if successful and pPEN valid.
|
||||
*/
|
||||
sony_result_t sony_demod_j83b_monitor_PacketErrorNumber (sony_demod_t * pDemod,
|
||||
uint32_t * pPEN);
|
||||
|
||||
/**
|
||||
@brief Monitor the J.83B PER (Packet Error Rate).
|
||||
|
||||
@param pDemod The demod instance.
|
||||
@param pPER The estimated PER x 1e6.
|
||||
|
||||
@return SONY_RESULT_OK if successful.
|
||||
*/
|
||||
sony_result_t sony_demod_j83b_monitor_PER (sony_demod_t * pDemod,
|
||||
uint32_t * pPER);
|
||||
|
||||
/**
|
||||
@brief Monitor the Interleave mode
|
||||
|
||||
@param pDemod The demod instance.
|
||||
@param pInterleave Indicates the interleave mode.
|
||||
|
||||
@return SONY_RESULT_OK if successful.
|
||||
*/
|
||||
sony_result_t sony_demod_j83b_monitor_Interleave (sony_demod_t * pDemod,
|
||||
sony_j83b_interleave_t * pInterleave);
|
||||
|
||||
#endif /* SONY_DEMOD_J83B_MONITOR_H */
|
||||
Executable
+306
@@ -0,0 +1,306 @@
|
||||
/*------------------------------------------------------------------------------
|
||||
Copyright 2016-2018 Sony Semiconductor Solutions Corporation
|
||||
|
||||
Last Updated : 2018/08/30
|
||||
Modification ID : 902dae58eb5249e028ccc5d7f60bb66cca9b43a9
|
||||
------------------------------------------------------------------------------*/
|
||||
#include "sony_integ.h"
|
||||
#include "sony_integ_j83b.h"
|
||||
#include "sony_demod.h"
|
||||
#include "sony_demod_j83b.h"
|
||||
#include "sony_demod_j83b_monitor.h"
|
||||
|
||||
/*------------------------------------------------------------------------------
|
||||
Functions
|
||||
------------------------------------------------------------------------------*/
|
||||
sony_result_t sony_integ_j83b_Tune (sony_integ_t * pInteg,
|
||||
sony_j83b_tune_param_t * pTuneParam)
|
||||
{
|
||||
sony_result_t result = SONY_RESULT_OK;
|
||||
|
||||
SONY_TRACE_ENTER ("sony_integ_j83b_Tune");
|
||||
|
||||
if ((!pInteg) || (!pTuneParam) || (!pInteg->pDemod)) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
if ((pInteg->pDemod->state != SONY_DEMOD_STATE_SLEEP) && (pInteg->pDemod->state != SONY_DEMOD_STATE_ACTIVE)) {
|
||||
/* This api is accepted in Sleep and Active states only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
/* Check bandwidth validity */
|
||||
if ((SONY_DTV_BW_J83B_5_06_5_36_MSPS != pTuneParam->bandwidth) &&
|
||||
(SONY_DTV_BW_J83B_5_60_MSPS != pTuneParam->bandwidth)) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_NOSUPPORT);
|
||||
}
|
||||
|
||||
/* Confirm Tune parameters */
|
||||
if (0 == pTuneParam->centerFreqKHz) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Tune the demodulator */
|
||||
result = sony_demod_j83b_Tune (pInteg->pDemod, pTuneParam);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
if ((pInteg->pTuner) && (pInteg->pTuner->TerrCableTune)) {
|
||||
/* Enable the I2C repeater */
|
||||
result = sony_demod_I2cRepeaterEnable (pInteg->pDemod, 0x01);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
/* Tune the RF part */
|
||||
result = pInteg->pTuner->TerrCableTune (pInteg->pTuner, pTuneParam->centerFreqKHz, SONY_DTV_SYSTEM_J83B, pTuneParam->bandwidth);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
/* Disable the I2C repeater */
|
||||
result = sony_demod_I2cRepeaterEnable (pInteg->pDemod, 0x00);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
}
|
||||
|
||||
/* Reset the demod to enable acquisition */
|
||||
result = sony_demod_TuneEnd (pInteg->pDemod);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
/* Wait for demodulator (TS) lock */
|
||||
result = sony_integ_j83b_WaitTSLock (pInteg);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
sony_result_t sony_integ_j83b_Scan (sony_integ_t * pInteg,
|
||||
sony_integ_j83b_scan_param_t * pScanParam,
|
||||
sony_integ_j83b_scan_callback_t callBack)
|
||||
{
|
||||
sony_result_t result = SONY_RESULT_OK;
|
||||
sony_integ_j83b_scan_result_t scanResult;
|
||||
|
||||
SONY_TRACE_ENTER ("sony_integ_j83b_Scan");
|
||||
|
||||
if ((!pInteg) || (!pScanParam) || (!callBack) || (!pInteg->pDemod)) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
if ((pInteg->pDemod->state != SONY_DEMOD_STATE_SLEEP) && (pInteg->pDemod->state != SONY_DEMOD_STATE_ACTIVE)) {
|
||||
/* This api is accepted in Sleep and Active states only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
/* Check bandwidth validity */
|
||||
if ((SONY_DTV_BW_J83B_5_06_5_36_MSPS != pScanParam->bandwidth) &&
|
||||
(SONY_DTV_BW_J83B_5_60_MSPS != pScanParam->bandwidth)) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_NOSUPPORT);
|
||||
}
|
||||
|
||||
/* Ensure the scan parameters are valid. */
|
||||
if (pScanParam->endFrequencyKHz < pScanParam->startFrequencyKHz) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
if (pScanParam->stepFrequencyKHz == 0) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
/* Set the start frequency */
|
||||
scanResult.centerFreqKHz = pScanParam->startFrequencyKHz;
|
||||
scanResult.tuneResult = SONY_RESULT_OK;
|
||||
scanResult.tuneParam.centerFreqKHz = pScanParam->startFrequencyKHz;
|
||||
scanResult.tuneParam.bandwidth = pScanParam->bandwidth;
|
||||
|
||||
/* Enable scan mode */
|
||||
result = sony_demod_terr_cable_SetScanMode (pInteg->pDemod, SONY_DTV_SYSTEM_J83B, 0x01);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
/* Scan routine */
|
||||
while (scanResult.centerFreqKHz <= pScanParam->endFrequencyKHz) {
|
||||
scanResult.tuneParam.centerFreqKHz = scanResult.centerFreqKHz;
|
||||
scanResult.tuneResult = sony_integ_j83b_Tune (pInteg, &scanResult.tuneParam);
|
||||
switch (scanResult.tuneResult) {
|
||||
case SONY_RESULT_OK:
|
||||
/* Channel found, callback to application */
|
||||
callBack (pInteg, &scanResult, pScanParam);
|
||||
break;
|
||||
|
||||
/* Intentional fall-through. */
|
||||
case SONY_RESULT_ERROR_UNLOCK:
|
||||
case SONY_RESULT_ERROR_TIMEOUT:
|
||||
/* Channel not found, callback to applicaiton for progress updates */
|
||||
callBack (pInteg, &scanResult, pScanParam);
|
||||
break;
|
||||
|
||||
default:
|
||||
/* Serious error occurred -> cancel operation. */
|
||||
sony_demod_terr_cable_SetScanMode (pInteg->pDemod, SONY_DTV_SYSTEM_J83B, 0x00);
|
||||
SONY_TRACE_RETURN (scanResult.tuneResult);
|
||||
}
|
||||
|
||||
scanResult.centerFreqKHz += pScanParam->stepFrequencyKHz;
|
||||
|
||||
/* Check cancellation. */
|
||||
result = sony_integ_CheckCancellation (pInteg);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
sony_demod_terr_cable_SetScanMode (pInteg->pDemod, SONY_DTV_SYSTEM_J83B, 0x00);
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
}
|
||||
|
||||
/* Clear scan mode */
|
||||
result = sony_demod_terr_cable_SetScanMode (pInteg->pDemod, SONY_DTV_SYSTEM_J83B, 0x00);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
sony_result_t sony_integ_j83b_WaitTSLock (sony_integ_t * pInteg)
|
||||
{
|
||||
sony_result_t result = SONY_RESULT_OK;
|
||||
sony_demod_lock_result_t lock = SONY_DEMOD_LOCK_RESULT_NOTDETECT;
|
||||
sony_stopwatch_t timer;
|
||||
uint8_t continueWait = 1;
|
||||
uint32_t elapsed = 0;
|
||||
|
||||
SONY_TRACE_ENTER ("sony_integ_j83b_WaitTSLock");
|
||||
|
||||
if ((!pInteg) || (!pInteg->pDemod)) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
if (pInteg->pDemod->state != SONY_DEMOD_STATE_ACTIVE) {
|
||||
/* This api is accepted in Active state only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
/* Wait for demod lock */
|
||||
result = sony_stopwatch_start (&timer);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
for (;;) {
|
||||
result = sony_stopwatch_elapsed(&timer, &elapsed);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
if (elapsed >= SONY_J83B_WAIT_DEMOD_LOCK) {
|
||||
continueWait = 0;
|
||||
}
|
||||
|
||||
result = sony_demod_j83b_CheckTSLock (pInteg->pDemod, &lock);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
switch (lock) {
|
||||
case SONY_DEMOD_LOCK_RESULT_LOCKED:
|
||||
SONY_TRACE_RETURN (SONY_RESULT_OK);
|
||||
|
||||
case SONY_DEMOD_LOCK_RESULT_UNLOCKED:
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_UNLOCK);
|
||||
|
||||
default:
|
||||
/* continue waiting... */
|
||||
break;
|
||||
}
|
||||
|
||||
/* Check cancellation. */
|
||||
result = sony_integ_CheckCancellation (pInteg);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
if (continueWait) {
|
||||
result = sony_stopwatch_sleep (&timer, SONY_J83B_WAIT_LOCK_INTERVAL);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
}
|
||||
else {
|
||||
result = SONY_RESULT_ERROR_TIMEOUT;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
sony_result_t sony_integ_j83b_monitor_RFLevel (sony_integ_t * pInteg, int32_t * pRFLeveldB)
|
||||
{
|
||||
sony_result_t result = SONY_RESULT_OK;
|
||||
|
||||
SONY_TRACE_ENTER ("sony_integ_j83b_monitor_RFLevel");
|
||||
|
||||
if ((!pInteg) || (!pInteg->pDemod) || (!pRFLeveldB)) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_ARG);
|
||||
}
|
||||
|
||||
if (pInteg->pDemod->state != SONY_DEMOD_STATE_ACTIVE) {
|
||||
/* This api is accepted in Active state only */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
if (pInteg->pDemod->system != SONY_DTV_SYSTEM_J83B) {
|
||||
/* Not J.83B */
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_SW_STATE);
|
||||
}
|
||||
|
||||
if (!pInteg->pTuner) {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_NOSUPPORT);
|
||||
}
|
||||
|
||||
if (pInteg->pTuner->rfLevelFuncTerr == SONY_TUNER_RFLEVEL_FUNC_READ && pInteg->pTuner->ReadRFLevel) {
|
||||
/* Enable the I2C repeater */
|
||||
result = sony_demod_I2cRepeaterEnable (pInteg->pDemod, 0x01);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
result = pInteg->pTuner->ReadRFLevel (pInteg->pTuner, pRFLeveldB);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
/* Disable the I2C repeater */
|
||||
result = sony_demod_I2cRepeaterEnable (pInteg->pDemod, 0x00);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
} else if (pInteg->pTuner->rfLevelFuncTerr == SONY_TUNER_RFLEVEL_FUNC_CALCFROMAGC
|
||||
&& pInteg->pTuner->CalcRFLevelFromAGC) {
|
||||
uint32_t ifAgc;
|
||||
|
||||
result = sony_demod_j83b_monitor_IFAGCOut(pInteg->pDemod, &ifAgc);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
|
||||
result = pInteg->pTuner->CalcRFLevelFromAGC (pInteg->pTuner, ifAgc, pRFLeveldB);
|
||||
if (result != SONY_RESULT_OK) {
|
||||
SONY_TRACE_RETURN (result);
|
||||
}
|
||||
} else {
|
||||
SONY_TRACE_RETURN (SONY_RESULT_ERROR_NOSUPPORT);
|
||||
}
|
||||
|
||||
/* dBm * 100 -> dBm * 1000 */
|
||||
*pRFLeveldB *= 10;
|
||||
|
||||
SONY_TRACE_RETURN (SONY_RESULT_OK);
|
||||
}
|
||||
Executable
+158
@@ -0,0 +1,158 @@
|
||||
/*------------------------------------------------------------------------------
|
||||
Copyright 2016-2018 Sony Semiconductor Solutions Corporation
|
||||
|
||||
Last Updated : 2018/07/27
|
||||
Modification ID : ff73ffebff57618d6a5aa6e2aa9eb009b86060d1
|
||||
------------------------------------------------------------------------------*/
|
||||
/**
|
||||
@file sony_integ_j83b.h
|
||||
|
||||
This file provides the integration layer interface for J.83B specific
|
||||
demodulator functions.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef SONY_INTEG_J83B_H
|
||||
#define SONY_INTEG_J83B_H
|
||||
|
||||
#include "sony_demod.h"
|
||||
#include "sony_integ.h"
|
||||
#include "sony_demod_j83b.h"
|
||||
|
||||
/*------------------------------------------------------------------------------
|
||||
Defines
|
||||
------------------------------------------------------------------------------*/
|
||||
#define SONY_J83B_WAIT_DEMOD_LOCK 1000 /**< 1s timeout for wait demodulator lock */
|
||||
#define SONY_J83B_WAIT_LOCK_INTERVAL 10 /**< 10ms interval for demodulator lock polls */
|
||||
|
||||
/*------------------------------------------------------------------------------
|
||||
Structs
|
||||
------------------------------------------------------------------------------*/
|
||||
/**
|
||||
@brief The parameters used for J.83B scanning.
|
||||
*/
|
||||
typedef struct sony_integ_j83b_scan_param_t {
|
||||
/**
|
||||
@brief The start frequency in kHz for scanning
|
||||
*/
|
||||
uint32_t startFrequencyKHz;
|
||||
|
||||
/**
|
||||
@brief The end frequency in kHz for scanning
|
||||
*/
|
||||
uint32_t endFrequencyKHz;
|
||||
|
||||
/**
|
||||
@brief The step frequency in kHz for scanning
|
||||
*/
|
||||
uint32_t stepFrequencyKHz;
|
||||
|
||||
/**
|
||||
@brief The bandwidth to use for tuning during the scan
|
||||
For J.83B, this parameter is used for specifying symbol rate.
|
||||
::SONY_DTV_BW_J83B_5_06_5_36_MSPS or ::SONY_DTV_BW_J83B_5_60_MSPS are available for this parameter.
|
||||
*/
|
||||
sony_dtv_bandwidth_t bandwidth;
|
||||
|
||||
} sony_integ_j83b_scan_param_t;
|
||||
|
||||
/**
|
||||
@brief The structure used to return a channel located or progress update
|
||||
as part of a J.83B scan.
|
||||
*/
|
||||
typedef struct sony_integ_j83b_scan_result_t {
|
||||
/**
|
||||
@brief Indicates the current frequency just attempted for the scan. This would
|
||||
primarily be used to calculate scan progress from the scan parameters.
|
||||
*/
|
||||
uint32_t centerFreqKHz;
|
||||
|
||||
/**
|
||||
@brief Indicates if the tune result at the current frequency. SONY_RESULT_OK
|
||||
means that a channel is locked and the tuneParam structure contains
|
||||
the channel information.
|
||||
*/
|
||||
sony_result_t tuneResult;
|
||||
|
||||
/**
|
||||
@brief The tune params for located J.83B channel.
|
||||
*/
|
||||
sony_j83b_tune_param_t tuneParam;
|
||||
} sony_integ_j83b_scan_result_t;
|
||||
|
||||
/*------------------------------------------------------------------------------
|
||||
Function Pointers
|
||||
------------------------------------------------------------------------------*/
|
||||
/**
|
||||
@brief Callback function that is called for every attempted frequency during a J.83B scan.
|
||||
|
||||
For successful channel results the function is called after TS lock
|
||||
is achieved.
|
||||
|
||||
@param pInteg The driver instance.
|
||||
@param pResult The current scan result.
|
||||
@param pScanParam The current scan parameters.
|
||||
*/
|
||||
typedef void (*sony_integ_j83b_scan_callback_t) (sony_integ_t * pInteg,
|
||||
sony_integ_j83b_scan_result_t * pResult,
|
||||
sony_integ_j83b_scan_param_t * pScanParam);
|
||||
|
||||
/*------------------------------------------------------------------------------
|
||||
Functions
|
||||
------------------------------------------------------------------------------*/
|
||||
/**
|
||||
@brief Performs acquisition to the channel.
|
||||
|
||||
Blocks the calling thread until the TS has locked or has timed out.
|
||||
Use ::sony_integ_Cancel to cancel the operation at any time.
|
||||
|
||||
@param pInteg The driver instance.
|
||||
@param pTuneParam The parameters required for the tune.
|
||||
|
||||
@return SONY_RESULT_OK if tuned successfully to the channel.
|
||||
*/
|
||||
sony_result_t sony_integ_j83b_Tune (sony_integ_t * pInteg,
|
||||
sony_j83b_tune_param_t * pTuneParam);
|
||||
|
||||
/**
|
||||
@brief Performs a scan over the spectrum specified.
|
||||
|
||||
Blocks the calling thread while scanning. Use ::sony_integ_Cancel to cancel
|
||||
the operation at any time.
|
||||
|
||||
@param pInteg The driver instance.
|
||||
@param pScanParam The scan parameters.
|
||||
@param callBack User registered call-back to receive scan progress information and
|
||||
notification of found channels. The call back is called for every attempted
|
||||
frequency during a scan.
|
||||
|
||||
@return SONY_RESULT_OK if scan completed successfully.
|
||||
|
||||
*/
|
||||
sony_result_t sony_integ_j83b_Scan (sony_integ_t * pInteg,
|
||||
sony_integ_j83b_scan_param_t * pScanParam,
|
||||
sony_integ_j83b_scan_callback_t callBack);
|
||||
|
||||
/**
|
||||
@brief Polls the demodulator waiting for TS lock over a maximum of 1s at 10ms intervals
|
||||
|
||||
@param pInteg The driver instance
|
||||
|
||||
@return SONY_RESULT_OK if successful.
|
||||
*/
|
||||
sony_result_t sony_integ_j83b_WaitTSLock (sony_integ_t * pInteg);
|
||||
|
||||
/**
|
||||
@brief The RF Level monitor calculates an estimated RF level based on either the demodulator
|
||||
IFAGC level or tuner internal RSSI monitor. If any compensation for external hardware
|
||||
such as, LNA, attenuators is required, then the user should make adjustment in the
|
||||
corresponding function.
|
||||
|
||||
@param pInteg The driver instance
|
||||
@param pRFLeveldB The RF Level estimation in dB * 1000
|
||||
|
||||
@return SONY_RESULT_OK if successful.
|
||||
*/
|
||||
sony_result_t sony_integ_j83b_monitor_RFLevel (sony_integ_t * pInteg, int32_t * pRFLeveldB);
|
||||
|
||||
#endif /* SONY_INTEG_J83B_H */
|
||||
Executable
+54
@@ -0,0 +1,54 @@
|
||||
/*------------------------------------------------------------------------------
|
||||
Copyright 2016 Sony Semiconductor Solutions Corporation
|
||||
|
||||
Last Updated : 2016/08/01
|
||||
Modification ID : b30d76210d343216ea52b88e9b450c8fd5c0359f
|
||||
------------------------------------------------------------------------------*/
|
||||
/**
|
||||
@file sony_j83b.h
|
||||
|
||||
This file provides J.83B related type definitions.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef SONY_J83B_H
|
||||
#define SONY_J83B_H
|
||||
|
||||
/*------------------------------------------------------------------------------
|
||||
Enumerations
|
||||
------------------------------------------------------------------------------*/
|
||||
/**
|
||||
@brief J.83B constellation.
|
||||
*/
|
||||
typedef enum {
|
||||
SONY_J83B_CONSTELLATION_RESERVED_0, /**< RESERVED */
|
||||
SONY_J83B_CONSTELLATION_RESERVED_1, /**< RESERVED */
|
||||
SONY_J83B_CONSTELLATION_64QAM, /**< 64-QAM */
|
||||
SONY_J83B_CONSTELLATION_RESERVED_3, /**< RESERVED */
|
||||
SONY_J83B_CONSTELLATION_256QAM /**< 256-QAM */
|
||||
} sony_j83b_constellation_t;
|
||||
|
||||
|
||||
/**
|
||||
@brief J.83B Interleave Mode.
|
||||
*/
|
||||
typedef enum {
|
||||
SONY_J83B_INTERLEAVE_ENHANCED_128_1, /**< Enhanced Interleaving mode I = 128, J = 1 */
|
||||
SONY_J83B_INTERLEAVE_REDUCED_128_1, /**< Reduced Interleaving mode I = 128, J = 1 */
|
||||
SONY_J83B_INTERLEAVE_ENHANCED_128_2, /**< Enhanced Interleaving mode I = 128, J = 2 */
|
||||
SONY_J83B_INTERLEAVE_REDUCED_64_2, /**< Reduced Interleaving mode I = 64, J = 2 */
|
||||
SONY_J83B_INTERLEAVE_ENHANCED_128_3, /**< Enhanced Interleaving mode I = 128, J = 3 */
|
||||
SONY_J83B_INTERLEAVE_REDUCED_32_4, /**< Reduced Interleaving mode I = 32, J = 4 */
|
||||
SONY_J83B_INTERLEAVE_ENHANCED_128_4, /**< Enhanced Interleaving mode I = 128, J = 4 */
|
||||
SONY_J83B_INTERLEAVE_REDUCED_16_8, /**< Reduced Interleaving mode I = 16, J = 8 */
|
||||
SONY_J83B_INTERLEAVE_ENHANCED_128_5, /**< Enhanced Interleaving mode I = 128, J = 5 */
|
||||
SONY_J83B_INTERLEAVE_REDUCED_8_16, /**< Reduced Interleaving mode I = 8, J = 16 */
|
||||
SONY_J83B_INTERLEAVE_ENHANCED_128_6, /**< Enhanced Interleaving mode I = 128, J = 6 */
|
||||
SONY_J83B_INTERLEAVE_RESERVED_11, /**< Reserved */
|
||||
SONY_J83B_INTERLEAVE_ENHANCED_128_7, /**< Enhanced Interleaving mode I = 128, J = 7 */
|
||||
SONY_J83B_INTERLEAVE_RESERVED_13, /**< Reserved */
|
||||
SONY_J83B_INTERLEAVE_ENHANCED_128_8, /**< Enhanced Interleaving mode I = 128, J = 8 */
|
||||
SONY_J83B_INTERLEAVE_RESERVED_15 /**< Reserved */
|
||||
} sony_j83b_interleave_t;
|
||||
|
||||
#endif /* SONY_J83B_H */
|
||||
Reference in New Issue
Block a user