📄 hamaro_api.c
字号:
return(False);
break;
}
} /* switch(... */
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
switch (mpeg_out->StartSignalWhenFail)
{
case HAMARO_START_SIGNAL_INACTIVE_WHEN_FAIL:
case HAMARO_START_SIGNAL_ACTIVE_WHEN_FAIL:
{
ulRegVal = (mpeg_out->StartSignalWhenFail == HAMARO_START_SIGNAL_INACTIVE_WHEN_FAIL) ? 0x01UL : 0x00UL;
if (HAMARO_RegisterWrite(nim,CX2430X_MPGFAILSTARTDIS,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return(False);
break;
}
default:
{
HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
return(False);
break;
}
} /* switch(... */
/* no errors encountered, indicate such to caller */
memcpy(&nim->mpeg_out,mpeg_out,sizeof(HAMARO_MPEG_OUT));
return(True);
}
return(False);
} /* HAMARO_SetOutputOptions() */
/*******************************************************************************************************/
/* HAMARO_SetInterruptOptions() */
/*******************************************************************************************************/
BOOL HAMARO_SetInterruptOptions( /* function to set interrupt options */
HAMARO_NIM *nim, /* pointer to nim */
HAMARO_INTEROPTS interopts) /* interrupt settings */
{
unsigned long ulRegVal = (unsigned long)interopts;
unsigned long valid_ints;
/* validate nim and mpeg storage */
HAMARO_DRIVER_VALIDATE_NIM(nim);
/* test for valid interrupt settings */
valid_ints = ((unsigned long)HAMARO_INTR_ACQ_SYNC|(unsigned long)HAMARO_INTR_ACQ_FAILURE|(unsigned long)HAMARO_INTR_VITERBI_LOSS|(unsigned long)HAMARO_INTR_VITERBI_SYNC|
(unsigned long)HAMARO_INTR_DEMOD_LOSS|(unsigned long)HAMARO_INTR_DEMOD_SYNC);
/* or-in new interrupts */
valid_ints |= (unsigned long)HAMARO_INTR_LNB_REPLY_READY;
/* test value to be written to demod for range error (bad range indicates invalid parameter passed) */
if (ulRegVal > valid_ints)
{
HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
return(False);
}
/* write new interrupt options to the demod */
return(HAMARO_RegisterWrite(nim,CX2430X_INTRENABLE,ulRegVal, HAMARO_DEMOD_I2C_IO));
} /* HAMARO_SetInterruptOptions() */
/*******************************************************************************************************/
/* HAMARO_SetSearchRangeLimit() */
/*******************************************************************************************************/
BOOL HAMARO_SetSearchRangeLimit( /* function to set LNB search range limit */
HAMARO_NIM *nim, /* pointer to nim */
unsigned long lnboffset, /* desired LNB offset limit in hz (if in KHz, converted to Hz) */
unsigned long *actual) /* returned actual LNB offset limit */
{
unsigned long bins;
unsigned long symbolrate;
unsigned long sr;
/* validate nim */
HAMARO_DRIVER_VALIDATE_NIM(nim);
/* validate input parameters */
if (lnboffset == 0UL || actual == NULL)
{
HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
return(False);
}
/* use the requested symbol rate if it is available, otherwise use the real symbol rate */
if ((symbolrate = (nim->symbol_rate_ideal * HAMARO_M)) == 0UL)
{
if (HAMARO_GetSymbolRate(nim,&symbolrate) == False)
{
return (False);
}
}
/* save the requested LNB offset */
nim->lnboffset = lnboffset;
/* remove excess LNB offset that the driver/hardware doesn't support */
if (lnboffset > (HAMARO_LNB_RANGE_HIGH * HAMARO_M)) lnboffset = (HAMARO_LNB_RANGE_HIGH * HAMARO_M);
*actual = 0UL;
sr = (symbolrate/8UL);
if (sr == 0)
{
return (False);
}
/* compute the number of bins needed */
bins = (((unsigned long)labs((long)lnboffset)) / (sr));
if ((bins * sr) < lnboffset) bins += 1UL;
if (bins < HAMARO_MIN_NO_BINS) bins = HAMARO_MIN_NO_BINS;
if (bins > HAMARO_MAX_NO_BINS_CAM) bins = HAMARO_MAX_NO_BINS_CAM;
if (HAMARO_RegisterWrite(nim, CX2430X_ACQFREQRANGE,bins, HAMARO_DEMOD_I2C_IO) == False) return(False);
/* compute actual search rage limit, return to caller */
*actual = bins * (sr);
return(True);
} /* HAMARO_SetSearchRangeLimit() */
/*******************************************************************************************************/
/* HAMARO_GetSearchRangeLimit() */
/*******************************************************************************************************/
BOOL HAMARO_GetSearchRangeLimit( /* function to return current search range limit to caller */
HAMARO_NIM *nim, /* pointer to nim */
unsigned long *lnboffset) /* returned lnb offset */
{
unsigned long bins;
unsigned long symbolrate;
/* validate nim */
HAMARO_DRIVER_VALIDATE_NIM(nim);
/* validate input parameters */
if (lnboffset == NULL)
{
HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
return(False);
}
if (HAMARO_GetSymbolRate(nim,&symbolrate) == True)
{
if (HAMARO_RegisterRead(nim,CX2430X_ACQFREQRANGE,&bins, HAMARO_DEMOD_I2C_IO) == False) return(False);
/* compute actual search range limit, return to caller */
/* *lnboffset = bins * (symbolrate/8UL) * HAMARO_M; <-- CR6870 */
*lnboffset = bins * (symbolrate/8UL);
/* (CR 6243) */
/* (CR 6323) removed because else would never be executed */
/* if (nim->tuner_offset >= 0) *lnboffset = ((*lnboffset) + (unsigned long)nim->tuner_offset); */
/* else *lnboffset = ((*lnboffset) - (unsigned long)(nim->tuner_offset * -1L)); */
*lnboffset = ((*lnboffset) + (unsigned long)nim->tuner_offset);
return(True);
}
return(False);
} /* HAMARO_GetSearchRangeLimit() */
/*******************************************************************************************************/
/* HAMARO_SetModulation() */
/*******************************************************************************************************/
BOOL HAMARO_SetModulation( /* function to set the modulation type */
HAMARO_NIM *nim, /* HAMARO_NIM pointer */
HAMARO_MODTYPE modtype) /* modulation type: QPSK, BPSK */
{
unsigned long ulRegVal;
/* validate nim and mpeg storage */
HAMARO_DRIVER_VALIDATE_NIM(nim);
switch(modtype)
{
case HAMARO_MOD_QPSK:
case HAMARO_MOD_BPSK:
{
ulRegVal = (modtype == HAMARO_MOD_QPSK ? HAMARO_BIT_ZERO : HAMARO_BIT_ONE);
if (HAMARO_RegisterWrite(nim,CX2430X_SYSMODTYPE,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return(False);
break;
}
case HAMARO_MOD_UNDEF:
default:
{
/* bad parameter passed */
HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
return(False);
break;
}
} /* switch(... */
return(True);
} /* HAMARO_SetModulation() */
/*******************************************************************************************************/
/* HAMARO_SetSampleFrequency() */
/*******************************************************************************************************/
BOOL
HAMARO_SetSampleFrequency(HAMARO_NIM *nim)
{
unsigned long pllmult;
unsigned long samplerate = 0UL;
/* validate nim and mpeg storage */
HAMARO_DRIVER_VALIDATE_NIM(nim);
samplerate = nim->sample_freq_nom_val;
pllmult = HAMARO_SAMPLE_FREQ_NOM_VAL_PLL_MULT;
if (nim->symbol_rate_ideal <= HAMARO_SYMBOL_RATE_BREAKPOINT)
{
/* sampling freq when symbol rate is less than 4Msps */
samplerate = nim->sample_freq_less_than_4msps;
pllmult = HAMARO_SAMPLE_FREQ_LT_4MSPS_PLL_MULT;
}
/* set the value to write to the demod */
if (HAMARO_RegisterWritePLLMult(nim,pllmult) == False)
{
return(False);
}
return (True);
} /* HAMARO_SetSampleFrequency() */
/*******************************************************************************************************/
/* HAMARO_GetSampleFrequency() */
/*******************************************************************************************************/
BOOL HAMARO_GetSampleFrequency( /* function to read demod's current sample rate */
HAMARO_NIM *nim, /* pointer to nim */
unsigned long *samplerate) /* returned sample rate */
{
unsigned long pllmult;
unsigned long rate;
/* validate nim and mpeg storage */
HAMARO_DRIVER_VALIDATE_NIM(nim);
if (samplerate != NULL)
{
/* read the pll mult from the demod, find the associated HAMARO_SAMPFRQ */
pllmult = (unsigned long)nim->ucPLLMult_shadow;
rate = HAMARO_DRIVER_compute_fs(pllmult,nim->crystal_freq);
*samplerate = rate;
return(True);
}
HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
return(False);
} /* HAMARO_GetSampleFrequency() */
/*******************************************************************************************************/
/* HAMARO_SetTransportSpec() */
/*******************************************************************************************************/
BOOL HAMARO_SetTransportSpec( /* function to set the HAMARO_NIM's transport spec */
HAMARO_NIM *nim, /* pointer to nim */
HAMARO_TRANSPEC transpec) /* transport specification */
{
unsigned long ulRegVal;
unsigned char b;
/* test for valid HAMARO_NIM and parm not NULL */
HAMARO_DRIVER_VALIDATE_NIM(nim);
/* CR13148, set register 0x66 again after reset */
b = 0xff;
if (HAMARO_WriteReg(nim,0x66,&b) == False)
{
return(False);
}
/* set the transport spec */
switch (transpec)
{
case HAMARO_SPEC_DVB:
{
/* modulation in BVDs */
ulRegVal = 0x00UL;
if (HAMARO_RegisterWrite(nim,CX2430X_SYSTRANSTD,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return(False);
/* new transpec mods 8/29/01 */
ulRegVal = 0x08UL;
if (HAMARO_RegisterWrite(nim,CX2430X_ACQSYNCBYTEWIN,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return(False);
ulRegVal = 0x05UL;
if (HAMARO_RegisterWrite(nim,CX2430X_ACQRSSYNCTHRESH,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return(False);
/* (CR 7930) */
ulRegVal = 0xfe;
if (HAMARO_RegisterWrite(nim,CX2430X_ACQVITNORMTHRESH,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return(False);
ulRegVal = 0x09;
if (HAMARO_RegisterWrite(nim,CX2430X_ACQVITNORMWIN12,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return(False);
ulRegVal = 0x15;
if (HAMARO_RegisterWrite(nim,CX2430X_ACQVITNORMWIN23,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return(False);
ulRegVal = 0x56;
if (HAMARO_RegisterWrite(nim,CX2430X_ACQVITNORMWIN67,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return(False);
ulRegVal = 0x10;
if (HAMARO_RegisterWrite(nim,CX2430X_ACQFULLSYNCWIN,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return(False);
break;
}
case HAMARO_SPEC_UNDEF:
default:
{
nim->tspec = HAMARO_SPEC_UNDEF;
/* bad parameter passed */
HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
return(False);
break;
}
} /* switch(... */
/* (CR 7951) save a copy of the current transport spec to the nim */
nim->tspec = transpec;
return(True);
} /* HAMARO_SetTransportSpec() */
/*******************************************************************************************************/
/* HAMARO_GetTransportSpec() */
/*******************************************************************************************************/
BOOL HAMARO_GetTransportSpec( /* function to return HAMARO_NIM's transport spec */
HAMARO_NIM *nim, /* pointer to nim */
HAMARO_TRANSPEC *transpec) /* returned transport spec setting */
{
int temp_modtype;
unsigned long ulRegVal;
/* test for valid HAMARO_NIM and parm not NULL */
HAMARO_DRIVER_VALIDATE_NIM(nim);
if (transpec == NULL)
{
HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
return (False);
}
*transpec = HAMARO_SPEC_UNDEF;
if (nim->tspec == HAMARO_SPEC_UNDEF)
{
/* read the modulation type */
if (HAMARO_RegisterRead(nim,CX2430X_SYSTRANSTD,&ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return(False);
temp_modtype = (int)ulRegVal;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -