/*====================================================================
FUNCTION sharp_bb_get_status
DESCRIPTION
DEPENDENCIES
RETURN VALUE
SIDE EFFECTS
======================================================================*/
void sharp_bb_get_status(tIsdbtSigInfo *sig_info)
{
//ISDBT_MSG_SHARP_BB("[%s] \n", __func__);
tIsdbtSignalStatus status;
memset(&status, 0, sizeof(tIsdbtSignalStatus));
status.get_simple_mode = 1; /* if zero, you will get all signal information. */
nmi_isdbt_get_status(nMaster, &status);
sig_info->ber = status.dberinst;
sig_info->per = status.dperinst;
// ant level -> sqindicator (0~100) by NMI.
sig_info->cninfo = sharp_bb_get_ant_value(status.sqindicator);
if(status.lock)
{
ISDBT_MSG_SHARP_BB("[%s] Locked, freq=[%d], ant=[%d], rssi=[%d]\n", __func__, status.frequency, sig_info->cninfo, status.rssi);
}
else
{
ISDBT_MSG_SHARP_BB("[%s] Unlocked, freq=[%d], ant=[%d], rssi=[%d]\n", __func__, status.frequency, sig_info->cninfo,status.rssi);
}
}
/*====================================================================
FUNCTION sharp_test
DESCRIPTION
DEPENDENCIES
RETURN VALUE
SIDE EFFECTS
======================================================================*/
void sharp_test(int index)
{
#ifdef FEATURE_TEST_READ_CHIPID
int i;
#else
tIsdbtSigInfo sig_info;
#endif
ISDBT_MSG_SHARP_BB("[%s] start!!!\n", __func__);
sharp_bb_pre_init();
#ifdef FEATURE_TEST_READ_CHIPID
sky_isdbt_pre_init();
for(i = 0; i < 100; i++)
{
//nmi_test();
read_chipID();
}
#else
sharp_bb_init();
ISDBT_MSG_SHARP_BB("[%s] freq index[%d]\n", __func__, index);
sharp_bb_set_frequency(index);
sharp_bb_start_ts(1);
sharp_bb_get_status(&sig_info);
#endif
ISDBT_MSG_SHARP_BB("[%s] end!!!\n", __func__);
}
/*====================================================================
FUNCTION sharp_bb_set_frequency
DESCRIPTION
DEPENDENCIES
RETURN VALUE
SIDE EFFECTS
======================================================================*/
int sharp_bb_set_frequency(int freq_idx)
{
tIsdbtScan scan;
tIsdbtRun tune;
memset(&scan, 0, sizeof(tIsdbtScan));
if(freq_idx == 100)
{
scan.frequency = 473143000;
}
else
{
scan.frequency = isdbt_bb_index2freq(freq_idx);
}
nmi_drv_scan(nISDBTMode, nMaster, &scan);
if(scan.found)
{
ISDBT_MSG_SHARP_BB("[%s] found the channel, freq=[%d]\n", __func__, scan.frequency);
}
else
{
ISDBT_MSG_SHARP_BB("[%s] No. channel, freq=[%d]\n", __func__, scan.frequency);
}
tune.highside = 0;
tune.frequency = scan.frequency;
nmi_drv_run(nISDBTMode, nMaster, &tune);
ISDBT_MSG_SHARP_BB("[%s] freq[%d] result [%d]\n", __func__, scan.frequency, scan.found);
return scan.found;
}
/*====================================================================
FUNCTION read_chipID
DESCRIPTION
DEPENDENCIES
RETURN VALUE
SIDE EFFECTS
======================================================================*/
static void read_chipID(void)
{
unsigned int nChipId = 0;
ISDBT_MSG_SHARP_BB("[%s] start!!!\n", __func__);
//DRV_MASTER_CTL(NMI_DRV_GET_CHIPID, &nChipId);
//nChipId = isdbt_get_chipid(nMaster);
//nChipId = 0;
nChipId = i2c_read_chipID();
ISDBT_MSG_SHARP_BB("[%s] chipID[0x%x]\n", __func__, nChipId);
}
static boolean sharp_function_register(isdbt_bb_function_table_type *ftable_ptr)
{
ISDBT_MSG_SHARP_BB("[%s] !!!\n", __func__);
ftable_ptr->isdbt_bb_power_on = sharp_power_on;
ftable_ptr->isdbt_bb_power_off = sharp_power_off;
ftable_ptr->isdbt_bb_init = sharp_bb_init;
ftable_ptr->isdbt_bb_set_freq = sharp_bb_set_frequency;
ftable_ptr->isdbt_bb_fast_search = sharp_bb_fast_search;
ftable_ptr->isdbt_bb_start_ts = sharp_bb_start_ts;
ftable_ptr->isdbt_bb_get_status = sharp_bb_get_status;
ftable_ptr->isdbt_bb_get_tuner_info = sharp_bb_get_tuner_info;
#if 0
ftable_ptr->isdbt_bb_bus_deinit = nmi_bus_deinit;
ftable_ptr->isdbt_bb_bus_init = nmi_bus_init;
ftable_ptr->isdbt_bb_bus_set_mode = nmi_bus_set_mode;
ftable_ptr->isdbt_bb_deinit = nmi_isdbt_deinit;
ftable_ptr->isdbt_bb_init_core = npm_init_core;
ftable_ptr->isdbt_bb_get_status = npm_isdbt_get_status;
ftable_ptr->isdbt_bb_get_status_slave = npm_isdbt_get_status_slave;
#endif
ftable_ptr->isdbt_bb_test = sharp_test;
return TRUE;
}
/*====================================================================
FUNCTION sharp_bb_start_ts
DESCRIPTION
DEPENDENCIES
RETURN VALUE
SIDE EFFECTS
======================================================================*/
int sharp_bb_start_ts(int enable)
{
int result = 0;
//ISDBT_MSG_SHARP_BB("[%s] enable [%d]\n", __func__, enable);
tNmDtvStream stream;
ISDBT_MSG_SHARP_BB("[%s] enable [%d]",__func__,enable);
memset(&stream, 0, sizeof(tNmDtvStream));
stream.transporttype = nTS;
stream.tso.mode = nSingle;
stream.tso.tstype = nSerial;
stream.tso.blocksize = 1;
stream.tso.clkrate = nClk_s_2; // 2Mhz
stream.tso.datapol = 0; /* refer to the comment in nmi325test.c */
stream.tso.validpol = 0; /* refer to the comment in nmi325test.c */
stream.tso.syncpol = 0; /* refer to the comment in nmi325test.c */
stream.tso.clkedge = 0; /* refer to the comment in nmi325test.c */
nmi_drv_video(nISDBTMode, &stream, enable);
return result;
}
/*====================================================================
FUNCTION sharp_bb_init
DESCRIPTION
DEPENDENCIES
RETURN VALUE
SIDE EFFECTS
======================================================================*/
int sharp_bb_init(void)
{
tNmDrvInit nmiDrvInit;
int ret = 0;
//ISDBT_MSG_SHARP_BB("[%s] \n", __func__);
sharp_bb_pre_init();
memset(&nmiDrvInit, 0, sizeof(tNmDrvInit));
nmiDrvInit.isdbt.bustype = nI2C;
nmiDrvInit.isdbt.transporttype = nTS;
nmiDrvInit.isdbt.blocksize = 1;
nmiDrvInit.isdbt.ai2c.adrM = 0x61;
nmiDrvInit.isdbt.core.bustype = nmiDrvInit.isdbt.bustype;
nmiDrvInit.isdbt.core.transporttype = nmiDrvInit.isdbt.transporttype;
nmiDrvInit.isdbt.core.dco = 1;
nmiDrvInit.isdbt.core.ldoby = 1; /* Set to 1 if the IO voltage is less than 2.2v */
nmiDrvInit.isdbt.core.op = nSingle;
//nmiDrvInit.isdbt.core.xo = 32.;
nmi_drv_init(&nmiDrvInit);
ret = nmi_drv_init_core(nISDBTMode, nMaster);
ISDBT_MSG_SHARP_BB("[%s] result [%d]\n", __func__, ret);
return ret;
}
/*====================================================================
FUNCTION sharp_bb_fast_search
DESCRIPTION
DEPENDENCIES
RETURN VALUE
SIDE EFFECTS
======================================================================*/
int sharp_bb_fast_search(int freq)
{
int result=0;
ISDBT_MSG_SHARP_BB("[%s] freq[%d] \n", __func__, freq);
return result;
}
/*====================================================================
FUNCTION sharp_bb_pre_init
DESCRIPTION
DEPENDENCIES
RETURN VALUE
SIDE EFFECTS
======================================================================*/
static void sharp_bb_pre_init(void)
{
ISDBT_MSG_SHARP_BB("[%s] start\n", __func__);
poem->prnt = NULL;//ISDBT_MSG_SHARP_BB;
poem->os.delay = msleep;
poem->os.gettick = GetTick;
poem->bus.i2cw = sharp_i2c_write_data;
poem->bus.i2cr = sharp_i2c_read_data;
poem->bus.spiw = NULL;
poem->bus.spir = NULL;
poem->bus.burstr = NULL;
ntv->tsdmasize = NMI_TS_BUF_SIZE; // cys temp
ISDBT_MSG_SHARP_BB("[%s] end\n", __func__);
}
static void nmi_log(char *str)
{
#ifdef FEATURE_SKY_ISDBT
ISDBT_MSG_SHARP_BB("%s", str);
#else
if(ISVALID(poem->prnt))
poem->prnt(str);
#endif
}
/*====================================================================
FUNCTION i2c_read_chipID
DESCRIPTION
DEPENDENCIES
RETURN VALUE
SIDE EFFECTS
======================================================================*/
static unsigned int i2c_read_chipID(void)
{
uint8_t b[16];
uint32_t val;
int len;
uint32_t adr = 0x6400;
int ret = 0;
ISDBT_MSG_SHARP_BB("[%s] \n", __func__);
b[0] = 0x80; /* word access */
b[1] = (uint8_t)(adr >> 16);
b[2] = (uint8_t)(adr >> 8);
b[3] = (uint8_t)(adr);
b[4] = 0x00;
b[5] = 0x04;
len = 6;
//chip.inp.hlp.read(cix, b, len, (uint8_t *)&val, 4)
ret = sharp_i2c_write_data(NMI_I2C_ID >> 1, b, len);
if (ret)
{
ISDBT_MSG_SHARP_BB("[%s] 1111111\n", __func__);
}
else
{
ISDBT_MSG_SHARP_BB("[%s] 2222222\n", __func__);
}
ret = sharp_i2c_read_data(NMI_I2C_ID >> 1, (uint8_t *)&val, 4);
if(ret)
{
ISDBT_MSG_SHARP_BB("[%s] 3333333\n", __func__);
}
else
{
ISDBT_MSG_SHARP_BB("[%s] 4444444\n", __func__);
}
return val;
}
/*====================================================================
FUNCTION sharp_bb_get_tuner_info
DESCRIPTION
DEPENDENCIES
RETURN VALUE
SIDE EFFECTS
======================================================================*/
void sharp_bb_get_tuner_info(tIsdbtTunerInfo *tuner_info)
{
tIsdbtSignalStatus status;
//ISDBT_MSG_SHARP_BB("[%s] \n", __func__);
memset(&status, 0, sizeof(tIsdbtSignalStatus));
status.get_simple_mode = 0; /* if zero, you will get all signal information. */
nmi_isdbt_get_status(nMaster, &status);
// ant level -> sqindicator (0~100) by NMI.
tuner_info->rssi = status.rssi;
tuner_info->ant_level = sharp_bb_get_ant_value(status.sqindicator);
if(status.lock)
{
tuner_info->ber = status.dberinst;
}
else
{
tuner_info->ber = 9999;
}
tuner_info->per = status.dperinst;
tuner_info->snr = status.nsnr;
tuner_info->doppler_freq = status.doppler; // Hz ´ÜÀ§
//tuner_info->doppler_freq = 0;
tuner_info->tmcc_info.carrier_mod = status.modulation;
tuner_info->tmcc_info.coderate= status.fec;
tuner_info->tmcc_info.interleave_len= status.interleaver;
if(status.lock)
{
ISDBT_MSG_SHARP_BB("[%s] Locked, freq=[%d], sq=[%d], rssi=[%d]\n", __func__, status.frequency, status.sqindicator, status.rssi);
ISDBT_MSG_SHARP_BB("[%s] ber=[%ld], Dfreq=[%ld]\n", __func__, tuner_info->ber, tuner_info->doppler_freq);
}
else
{
ISDBT_MSG_SHARP_BB("[%s] Unlocked, freq=[%d], sq=[%d], rssi=[%d]\n", __func__, status.frequency, status.sqindicator,status.rssi);
}
}
/*====================================================================
FUNCTION sharp_power_off
DESCRIPTION
DEPENDENCIES
RETURN VALUE
SIDE EFFECTS
======================================================================*/
void sharp_power_off(void)
{
// 1. DMB_RESET : LOW
// 2. DMB_PWR_EN : LOW
ISDBT_MSG_SHARP_BB("[%s] start!!![%d]\n", __func__, isdbt_chip_power_on);
if(!isdbt_chip_power_on)
{
return;
}
dmb_set_gpio(DMB_RESET, 0);
msleep(1);
dmb_power_off();
isdbt_chip_power_on = FALSE;
ISDBT_MSG_SHARP_BB("[%s] end!!!\n", __func__);
}
/*====================================================================
FUNCTION sharp_power_on
DESCRIPTION
DEPENDENCIES
RETURN VALUE
SIDE EFFECTS
======================================================================*/
void sharp_power_on(void)
{
// 1. DMB_RESET : LOW
// 2. DMB_PWR_EN : HIGH
// 3. DMB_RESET : HIGH
ISDBT_MSG_SHARP_BB("[%s] start!!!\n", __func__);
dmb_power_on();
dmb_set_gpio(DMB_RESET, 0);
msleep(1);
dmb_power_on_chip();
msleep(100);
dmb_set_gpio(DMB_RESET, 1);
msleep(100);
isdbt_chip_power_on = TRUE;
ISDBT_MSG_SHARP_BB("[%s] end!!!\n", __func__);
}
static void nmi_debug(uint32_t zone, char *fmt,...)
{
#if 1 // cys Android porting
char buf[256];
va_list args;
int len;
if (zone & chip.inp.zone) {
va_start(args, fmt);
strcpy(buf, "[Nmi Isdbt]: ");
len = vsprintf(&buf[13], fmt, args);
va_end(args);
ISDBT_MSG_SHARP_BB("%s\n",buf);
//if (chip.inp.hlp.log) {
// chip.inp.hlp.log(buf);
//}
}
#endif
return;
}
void nmi_isdbt_get_status(tNmiIsdbtChip cix, tIsdbtSignalStatus *p)
{
int tmcclock;
tNmiDrv *pd = &drv;
tIsdbtBer ber;
//tIsdbtPer per;
uint32_t nber; // cys
//int nber;//, nper;
tIsdbtGainInfo ginfo;
#ifndef FIX_POINT
tIsdbtAcqTime acqtime;
#endif
tIsdbtTmccInfo tmccinfo;
uint32_t sq, coeff;
int acq_mode = p->get_simple_mode;
//dPrint(N_INFO, "nmi_isdbt_get_status: cix=[%d]\n", cix);
tmcclock = 0;
pd->dtv.vf.chkpll(cix); // it shoud be checked with system guys...
tmcclock = pd->dtv.vf.tmcclock(cix);
if (tmcclock) {
p->lock = 1;
if(!pd->decoder_initialized) {
dPrint(N_INFO, "nmi_isdbt_get_status: pd->decoder_initialized != 1\n");
pd->dtv.vf.decoder(cix, 0, NULL);
pd->dtv.vf.gettmccinfo(cix,&tmccinfo);
memcpy((void *)&pd->tmcc, (void *)&tmccinfo, sizeof(tIsdbtTmccInfo));
pd->decoder_initialized = 1;
}
#if 0
pd->dtv.vf.gettmccinfo(cix,&tmccinfo);
if ((tmccinfo.mode != pd->tmcc.mode) ||
(tmccinfo.guard != pd->tmcc.guard) ||
(tmccinfo.coderate != pd->tmcc.coderate) ||
(tmccinfo.modulation != pd->tmcc.modulation) ||
(tmccinfo.interleaver != pd->tmcc.interleaver)) {
dPrint(N_INFO, "nmi_isdbt_get_status: calling the decoder...\n");
pd->dtv.vf.decoder(cix, 0, NULL);
}
p->mode = tmccinfo.mode;
p->guard = tmccinfo.guard;
p->modulation = tmccinfo.modulation;
p->interleaver = tmccinfo.interleaver;
p->fec = tmccinfo.coderate;
// [[ added by tony
p->emerg_flag = tmccinfo.emerg_flag;
// ]]
#else
// nmi_drv_run() should have the backup of the tmcc.
p->mode = pd->tmcc.mode;
p->guard = pd->tmcc.guard;
p->modulation = pd->tmcc.modulation;
p->interleaver = pd->tmcc.interleaver;
p->fec = pd->tmcc.coderate;
p->emerg_flag = pd->tmcc.emerg_flag;
#endif
if(acq_mode != __DEBUG_SIMPLE__) {
p->doppler = pd->dtv.vf.getdoppler(cix);
#ifndef FIX_POINT
p->chanlen = pd->dtv.vf.getchanlen(cix);
#endif
}
} else {
dPrint(N_INFO, "nmi_isdbt_get_status, tmcclock = 0\n");
p->lock = 0;
}
/* get snr */
if ((cix == nMaster) && (pd->opmode == nDiversity)) {
#ifndef FIX_POINT
p->dsnr = pd->dtv.vf.getsnr(cix, 1); /* combiner */
#else
p->nsnr = pd->dtv.vf.getsnr(cix, 1);
#endif
p->dsmstate = pd->dtv.vf.dsmstate();
p->dsmlock = pd->dtv.vf.dsmlock();
} else {
#ifndef FIX_POINT
p->dsnr = pd->dtv.vf.getsnr(cix, 0);
#else
p->nsnr = pd->dtv.vf.getsnr(cix, 0);
#endif
}
#ifndef FIX_POINT
dPrint(N_VERB, "lock (%d), snr (%f)\n", p->lock, p->dsnr);
#else
dPrint(N_VERB, "lock (%d), snr (%d)\n", p->lock, p->nsnr);
#endif
if(acq_mode != __DEBUG_SIMPLE__) {
/**
get ber before viterbi
**/
if (pd->dtv.vf.getberb(cix, (void *)&ber) > 0) {
nber = ber.bec / ber.becw;
p->dbbvinst = nber;
pd->sq[cix].abbv = ((pd->sq[cix].abbv * pd->sq[cix].npol) + nber)/(pd->sq[cix].npol + 1);//pd->sq[cix].abbv = ((pd->sq[cix].abbv * pd->sq[cix].npol) + dber)/(pd->sq[cix].npol + 1);
p->dbbv = pd->sq[cix].abbv;
} else {
/**
review: BER counter not turn on
**/
p->dbbvinst = 1;
p->dbbv = 1;
}
}
/**
get ber
ber should be less than 0.0002.
**/
if (tmcclock) {
pd->dtv.vf.getber(cix, (void *)&ber);
nber = ((ber.bec * 1000000) / ber.becw); // cys
//nber = ber.bec/ber.becw;
p->dberinst = nber;
pd->sq[cix].aber = ((pd->sq[cix].aber * pd->sq[cix].npol) + nber)/(pd->sq[cix].npol + 1);
p->dber = pd->sq[cix].aber;
} else {
p->dberinst = 1;
}
#ifdef FIX_POINT
if(tmcclock)
p->dperinst = 0;
else
p->dperinst = 1;
#else
if(acq_mode != __DEBUG_SIMPLE__) {
/**
get per
per should be less than 0.0001.
**/
pd->dtv.vf.getper(cix, (void *)&per);
nper = per.pec /per.pecw;
p->dperinst = nper;
pd->sq[cix].aper = ((pd->sq[cix].aper * pd->sq[cix].npol) + nper)/(pd->sq[cix].npol + 1);
p->dper = pd->sq[cix].aper;
pd->sq[cix].npol++;
}
#endif
/**
get rssi
**/
pd->dtv.vf.getrssi(cix, (void *)&ginfo);
p->dagc = ginfo.dagc;
p->lnagain = (int)ginfo.bblnadb;
p->lnagaincode = ginfo.bblnacode;
p->lnamode = ginfo.rflna;
p->rssi = ginfo.rssi;
if(acq_mode != __DEBUG_SIMPLE__) {
/**
get offset
**/
#ifndef FIX_POINT
p->freqoffset = pd->dtv.vf.getfreqoffset(cix);
p->timeoffset = pd->dtv.vf.gettimeoffset(cix);
#endif
/* get acquisation time */
if(cix == nMaster) {
#ifndef FIX_POINT
pd->dtv.vf.getacqtime(cix,&acqtime);
p->agcacq = acqtime.agcacq;
p->syracq = acqtime.syracq;
p->ppmacq = acqtime.ppmacq;
p->tmccacq = acqtime.tmccacq;
p->tsacq = acqtime.tsacq;
p->totalacq = acqtime.totalacq;
#endif
}
if (pd->opmode == nDiversity) {
p->regad48 = pd->dtv.vf.r32(cix, 0xad48);
p->regad4c = pd->dtv.vf.r32(cix, 0xad4c);
p->regacc8 = pd->dtv.vf.r32(cix, 0xacc8);
}
}
/**
save the current frequency
**/
if(cix == nMaster)
p->frequency = pd->mfrequency;
else
p->frequency = pd->sfrequency;
if(p->rssi < -100)
p->rssi = -100;
#ifndef FIX_POINT
coeff = p->dsnr * 0.0625;
#else
coeff = p->nsnr * 1;
#endif
sq = 2 * (100 + p->rssi);
sq *= coeff;
if(p->lock == 0)
p->sqindicator = 0;
else if(sq > 100)
p->sqindicator = 100;
else
p->sqindicator = (unsigned int)sq;
#if 1 //cys test
ISDBT_MSG_SHARP_BB("[%s] snr=[%d], rssi=[%d], bec=[%d], becw=[%d], lnamode=[%d], dagc=[%d], lnagain=[%d], lnagaincode=[%d]\n",
__func__, p->nsnr, p->rssi, ber.bec, ber.becw, p->lnamode, p->dagc, p->lnagain, p->lnagaincode);
#endif
return;
}
