4000 lines
130 KiB
C
Executable File
4000 lines
130 KiB
C
Executable File
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <inttypes.h>
|
|
#include "../inc/i2c_drv.h"
|
|
#include "../inc/orx_power.h"
|
|
#include "../inc/delay.h"
|
|
#include "../inc/type.h"
|
|
#include "../inc/lcd_task.h"
|
|
#include "../inc/eeprom.h"
|
|
#include "../inc/fpga.h"
|
|
#include "../inc/os_task.h"
|
|
#include "../inc/log_task.h"
|
|
#include "../inc/dpd_proc.h"
|
|
#include "../inc/ipara_cfg.h"
|
|
#include "../inc/isys_config.h"
|
|
#include "../inc/tcp_task.h"
|
|
#include "../inc/isys_com.h"
|
|
#include "../inc/iweb_task.h"
|
|
#include "../inc/adrv9009_ext.h"
|
|
|
|
|
|
#define CFG_USR_NAME_PASSWD_FILE "/aw/anywave/web/usr.conf"
|
|
|
|
extern void tcp_spect_calc_sn_licence(uint32 key,uint64 *psn);
|
|
|
|
#if 1//add
|
|
void *alloc_mem(uint32 size)
|
|
{
|
|
return malloc(size);
|
|
}
|
|
void free_mem(void* p)
|
|
{
|
|
free(p);
|
|
}
|
|
#endif//add
|
|
|
|
|
|
//------------------------
|
|
|
|
|
|
#include "../inc/config.h"
|
|
#include "../inc/dryloop.h"
|
|
#include "../inc/tsoip.h"
|
|
extern S_ATSC_PARA atsc_para;
|
|
#if USE_PSTS
|
|
extern void psts_para_clear(S_PSTS_PARA *ppara);
|
|
#endif
|
|
#if USE_TS2IP
|
|
extern TS_NET_STRUCT ts_net_para;
|
|
#endif
|
|
extern uint8 std_r[];
|
|
extern uint8 std_w[];
|
|
extern uint8 off_rf;
|
|
extern BOOL dryloop_version_flag;
|
|
|
|
#if USE_PSTS
|
|
void psts_para_clear(S_PSTS_PARA *ppara);
|
|
#endif
|
|
void str_trunc_space(char *pstr);
|
|
|
|
|
|
//测试获取的输出功率为0时,工厂菜单功率值(放大100倍)
|
|
static const int32 we_power_v[]=
|
|
{
|
|
-1129, -1077, -1074, -1065, -1053, -850, -834, -852, -816, -817,
|
|
-776, -803
|
|
};
|
|
/*7.1{
|
|
-1130, -1130, -1125, -1085, -1075, -915, -905, -895, -880, -860,
|
|
-850, -840
|
|
};*/
|
|
|
|
|
|
static const int32 we_power[]=
|
|
{
|
|
-385, -358, -342, -322, -321, -297, -285, -268, -206, -239,
|
|
-235, -222, -198, -167, -151, -127, -116, -100, -80, -57,
|
|
-40, -29, -18, 4, 34, 31, 73, 85, 127, 143,
|
|
167, 182, 192, 191, 180, 190, 199, 211, 235, 247,
|
|
268, 281, 277, 281, 281, 299, 310, 306, 325, 345,
|
|
395, 447, 528, 602, 711, 788, 874, 946, 1000, 1000,
|
|
1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000
|
|
};
|
|
|
|
/*auto ver
|
|
{
|
|
-405, -361, -349, -314, -332, -303, -295, -285, -172, -257,
|
|
-259, -244, -215, -184, -166, -139, -116, -105, -79, -49,
|
|
-40, -42, -36, -13, 22, 7, 71, 80, 134, 150,
|
|
173, 188, 199, 182, 160, 174, 183, 191, 234, 253,
|
|
295, 326, 318, 326, 311, 332, 335, 306, 324, 339,
|
|
389, 443, 546, 618, 757, 835, 923, 992, 1000, 1000,
|
|
1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000
|
|
};*/
|
|
|
|
/*{7.1
|
|
-315, -315, -310, -300, -280, -255, -235, -225, -210, -200,
|
|
-190, -180, -170, -150, -130, -115, -115, -105, -90, -75,
|
|
-60, -50, -40, -15, 5, 15, 25, 30, 55, 70,
|
|
80, 105, 120, 155, 175, 185, 205, 235, 260, 280,
|
|
295, 320, 350, 370, 390, 410, 440, 480, 510, 525,
|
|
535, 560, 580, 610, 630, 650, 660, 680, 700, 710,
|
|
720, 740, 755, 770, 780, 790, 800, 810, 800, 800
|
|
};*/
|
|
|
|
|
|
static const int32 we_power_v_3x[]=
|
|
{
|
|
-1200,-1150,-1120,-1100,-1100,-950,-940,-940,-940,-922,-912,-915
|
|
};
|
|
|
|
//71个点
|
|
static const int32 we_power_3x[]=
|
|
{
|
|
-300,-300,-280,-280,-280,-240,-240,-240,-235,-210,-200,-200,-180,-190,-160,-105,-100,-95,-90,-80,
|
|
-75,-65,-50,-50,-40,-35,-35,-35,-25,-10,-0,25,60,65,65,60,60,75,90,105,
|
|
125,150,170,180,195,200,200,320,330,335,360,385,395,420,435,460,470,485,500,520,
|
|
535,575,585,595,600,640,640,640,650,650,650
|
|
};
|
|
|
|
static uint32 value_power(int32 value)
|
|
{
|
|
int32 wep = 0;
|
|
|
|
wep = WE_POWER_ZERO+value*20/100;
|
|
if(wep<0)
|
|
{
|
|
wep = 0;
|
|
}
|
|
|
|
if(wep>WE_POWER_MAX)
|
|
{
|
|
wep = WE_POWER_MAX;
|
|
}
|
|
return wep;
|
|
}
|
|
|
|
|
|
void e2rom_save_sys(S_SYSTEM_PARA *ppara)
|
|
{
|
|
uint32 i;
|
|
|
|
c256_bytewrite(EEPROM_DPD_ADDR,ppara->adpc);
|
|
c256_bytewrite(EEPROM_SYS_INPUT,ppara->input);
|
|
|
|
c256_bytewrite(EEPROM_OCXO_ADDR,ppara->ocxo);
|
|
|
|
c256_bytewrite(EEPROM_GPS_ADDR,ppara->gps);
|
|
//c256_bytewrite(EEPROM_NET_ADDR,ppara->net);
|
|
c256_bytewrite(EEPROM_MODE_ADDR,ppara->mode);
|
|
c256_bytewrite(EEPROM_CTRL_ADDR,ppara->ctrl);
|
|
|
|
log_printf(LOG_INFO, I_USER_CFG, "adpc=%d,input=%d,ocxo=%d,gps=%d,net=%d,mode=%d,ctrl=%d\n",
|
|
ppara->adpc,ppara->input,ppara->ocxo,ppara->gps,ppara->net,ppara->mode,ppara->ctrl);
|
|
|
|
//local 改为remote时
|
|
if(atsc_para.wh_para.func==0) //仅TX有效
|
|
{
|
|
log_printf(LOG_INFO, I_USER_CFG, "atsc_para.wh_para.func=0\n");
|
|
if((atsc_para.system_para.ctrl==CTRL_LOCAL)&&(ppara->ctrl==CTRL_REMOTE))
|
|
{
|
|
if(atsc_para.rf_para.tx==1) // AD3 func为TX RF的TX为ON 则RF->ON
|
|
{
|
|
atsc_para.rf_para.rf=1; //则打开RF
|
|
c256_bytewrite(EEPROM_RF_ADDR,atsc_para.rf_para.rf);
|
|
fpga_set_rf_output(atsc_para.rf_para.rf);
|
|
off_rf = 0;
|
|
log_printf(LOG_INFO, I_USER_CFG, "atsc_para.rf_para.rf=1 open rf\n");
|
|
}
|
|
if(atsc_para.rf_para.tx==0) // AD3 func为TX RF的TX为OFF 则RF->OFF
|
|
{
|
|
atsc_para.rf_para.rf=0; //则关闭RF
|
|
c256_bytewrite(EEPROM_RF_ADDR,atsc_para.rf_para.rf);
|
|
setbit(off_rf, _KEY_TX);
|
|
fpga_set_rf_output(atsc_para.rf_para.rf);
|
|
log_printf(LOG_INFO, I_USER_CFG, "atsc_para.rf_para.rf=0 off rf\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
for(i=0;i<ATSC_TITLE_LEN;i++)
|
|
{
|
|
c256_bytewrite(EEPROM_WEB_TITLE_ADDR+i,ppara->web_title[i]);
|
|
log_printf(LOG_INFO, I_USER_CFG, "ppara->web_title[%d]=0x%x\n", i, ppara->web_title[i]);
|
|
}
|
|
|
|
c256_bytewrite(EEPROM_ADRV9009_ATT_H, (ppara->adrv9009_att>>8)&0xff);
|
|
c256_bytewrite(EEPROM_ADRV9009_ATT_L, ppara->adrv9009_att&0xff);
|
|
|
|
c256_bytewrite(EEPROM_ADRV9009_ORX_MANU_GAIN, ppara->orx_manu_gain&0xff);
|
|
c256_bytewrite(EEPROM_SPEC_ENABLE, ppara->spec_enable ? 1 : 0);
|
|
}
|
|
void e2rom_save_power(S_RF_PARA *ppara)
|
|
{
|
|
unsigned char UC_temp = 0 ;
|
|
uint16 power_now;
|
|
|
|
if(atsc_para.ad3_para.cor==0) //100W
|
|
{
|
|
power_now=c256_byteread(EEPROM_POWER_UIH_ADDR);
|
|
UC_temp=c256_byteread(EEPROM_POWER_UIL_ADDR);
|
|
power_now=(power_now<<8)| UC_temp;
|
|
// if((power_now!=atsc_para.rf_para.power) && (ppara->agc))
|
|
// c256_bytewrite(EEPROM_PWRVREF_VLDO_ADDR,0);
|
|
c256_bytewrite(EEPROM_POWER_UIH_ADDR,ppara->power>>8); //Power display high 8 bit
|
|
c256_bytewrite(EEPROM_POWER_UIL_ADDR,ppara->power); //Power display low 8 bit
|
|
c256_bytewrite(EEPROM_0DBFLAGH_ADDR,ppara->db>> 8); //Power command high 8 bit
|
|
c256_bytewrite(EEPROM_0DBFLAGL_ADDR,ppara->db);
|
|
|
|
#if BAK_PARA_CHECK
|
|
c256_bytewrite2(BAK_EEPROM_POWER_UIH_ADDR,ppara->power>>8); //Power display high 8 bit
|
|
c256_bytewrite2(BAK_EEPROM_POWER_UIL_ADDR,ppara->power); //Power display low 8 bit
|
|
c256_bytewrite2(BAK_EEPROM_0DBFLAGH_ADDR,ppara->db>> 8); //Power command high 8 bit
|
|
c256_bytewrite2(BAK_EEPROM_0DBFLAGL_ADDR,ppara->db);
|
|
#endif
|
|
//Power command low 8 bit
|
|
}
|
|
else //1000W
|
|
{
|
|
power_now=c256_byteread2(E2_POWER_UIH_ADDR);
|
|
UC_temp=c256_byteread2(E2_POWER_UIL_ADDR);
|
|
power_now=(power_now<<8)| UC_temp;
|
|
if((power_now!=atsc_para.rf_para.power) && (ppara->agc))
|
|
c256_bytewrite2(E2_PWRVREF_VLDO_ADDR,0);
|
|
|
|
c256_bytewrite2(E2_POWER_UIH_ADDR,ppara->power>>8); //Power display high 8 bit
|
|
c256_bytewrite2(E2_POWER_UIL_ADDR,ppara->power); //Power display low 8 bit
|
|
c256_bytewrite2(E2_0DBFLAGH_ADDR,ppara->db>> 8);
|
|
c256_bytewrite2(E2_0DBFLAGL_ADDR,ppara->db);
|
|
|
|
#if BAK_PARA_CHECK
|
|
c256_bytewrite2(BAK_E2_POWER_UIH_ADDR,ppara->power>>8); //Power display high 8 bit
|
|
c256_bytewrite2(BAK_E2_POWER_UIL_ADDR,ppara->power);
|
|
c256_bytewrite2(BAK_E2_0DBFLAGH_ADDR,ppara->db>> 8);
|
|
c256_bytewrite2(BAK_E2_0DBFLAGL_ADDR,ppara->db);
|
|
#endif
|
|
|
|
}
|
|
}
|
|
void e2rom_save_rf(S_RF_PARA *ppara)
|
|
{
|
|
log_printf(LOG_INFO, I_USER_CFG,"rf=%d, tx=%d, hz=%d\n", ppara->rf, ppara->tx, ppara->hz);
|
|
if((ppara->rf == 0) && (atsc_para.rf_para.rf == 1)) {
|
|
setbit(off_rf, _KEY_RF);
|
|
}
|
|
else if((ppara->rf == 1) && (atsc_para.rf_para.rf == 0)) {
|
|
off_rf = 0;
|
|
}
|
|
|
|
if((atsc_para.rf_para.tx==0)&&(ppara->tx==1)) {
|
|
//OFF->ON //要执行某些动作
|
|
|
|
//dryloop_write(DRYLOOP_I2C_RF_LED,1);
|
|
#if USE_DRY_LOOP
|
|
dryloop_amp_on(TRUE);
|
|
#endif
|
|
show_wait_info_with_sec(atsc_para.wj_para.rf_dly);
|
|
ppara->rf = 1;
|
|
off_rf = 0;
|
|
}
|
|
else if((atsc_para.rf_para.tx==1)&&(ppara->tx==0)) { //ON->OFF
|
|
ppara->rf = 0;
|
|
atsc_para.rf_para.rf = 0;
|
|
fpga_set_rf_output(ppara->rf);
|
|
show_wait_info_with_sec(atsc_para.wj_para.rf_dly);
|
|
#if USE_DRY_LOOP
|
|
dryloop_amp_on(FALSE);
|
|
#endif
|
|
atsc_para.latch_para.rf = 1;
|
|
off_rf = setbit(off_rf,_KEY_TX);
|
|
}
|
|
|
|
c256_bytewrite(EEPROM_CHANNEL_ADDR, ppara->txfreq);
|
|
c256_bytewrite(EEPROM_RXCHANNEL_ADDR, ppara->rxfreq);
|
|
|
|
#if BAK_PARA_CHECK
|
|
c256_bytewrite2(BAK_EEPROM_CHANNEL_ADDR,ppara->txfreq);
|
|
c256_bytewrite2(BAK_EEPROM_RXCHANNEL_ADDR,ppara->rxfreq);
|
|
#endif
|
|
e2rom_save_power(ppara);
|
|
|
|
c256_bytewrite(EEPROM_HZ_UIH_ADDR,ppara->hz>>16); //+ -
|
|
c256_bytewrite(EEPROM_HZ_UIM_ADDR,ppara->hz>>8); //Hz display high 8 bit
|
|
c256_bytewrite(EEPROM_HZ_UIL_ADDR,ppara->hz); //Hz display low 8 bit
|
|
|
|
c256_bytewrite(EEPROM_RF_ADDR,ppara->rf);
|
|
|
|
/*if(atsc_para.ad3_para.cor == 0)
|
|
c256_bytewrite(EEPROM_AGC_ADDR,ppara->agc);
|
|
else
|
|
c256_bytewrite2(E2_AGC_ADDR,ppara->agc);*/
|
|
c256_bytewrite(EEPROM_RF_TX,ppara->tx);
|
|
|
|
log_printf(LOG_INFO, I_USER_CFG,"rf=%d, tx=%d, cor=%d, txfreq=%d, rxfreq=%d, hz=%d\n",
|
|
ppara->rf, ppara->tx,atsc_para.ad3_para.cor,ppara->txfreq, ppara->rxfreq, ppara->hz);
|
|
}
|
|
void e2rom_save_wb(S_WB_PARA *ppara)
|
|
{
|
|
uint32 i;
|
|
uint8 *pchar = (uint8 *)ppara;
|
|
|
|
for(i=0; i<sizeof(S_WB_PARA)-1; i++) //rst 不用保存
|
|
{
|
|
c256_bytewrite(EEPROM_WB_ADDR+i,*pchar++);
|
|
}
|
|
}
|
|
void e2rom_save_wc(S_WC_PARA *ppara)
|
|
{
|
|
#if ADDR_CONFLICT_DISABLED
|
|
#else
|
|
|
|
#if !DEBUG_ERR_CHECK
|
|
uint32 i;
|
|
uint8 *pchar = (uint8 *)ppara;
|
|
#endif
|
|
|
|
#if DEBUG_ERR_CHECK
|
|
if(((atsc_para.wc_para.pr%2)==0))//改本身参数
|
|
{
|
|
c256_bytewrite(EEPROM_WC_ADDR+1,ppara->pr);
|
|
|
|
if(ppara->ch!=atsc_para.wc_para.ch)
|
|
{
|
|
c256_bytewrite(EEPROM_CHANNEL_ADDR,ppara->ch);
|
|
}
|
|
if(ppara->cl!=atsc_para.wc_para.cl)
|
|
{
|
|
c256_bytewrite(EEPROM_RXCHANNEL_ADDR,ppara->cl);
|
|
}
|
|
if(ppara->dh!=atsc_para.wc_para.dh) //cor 2
|
|
{
|
|
c256_bytewrite(EEPROM_POWER_UIH_ADDR,ppara->dh);
|
|
}
|
|
if(ppara->dl!=atsc_para.wc_para.dl)
|
|
{
|
|
c256_bytewrite(EEPROM_POWER_UIL_ADDR,ppara->dl);
|
|
}
|
|
|
|
if(ppara->til!=atsc_para.wc_para.til) //cor 2
|
|
{
|
|
c256_bytewrite2(E2_POWER_UIH_ADDR,ppara->til);
|
|
}
|
|
if(ppara->tfl!=atsc_para.wc_para.tfl)
|
|
{
|
|
c256_bytewrite2(E2_POWER_UIL_ADDR,ppara->tfl);
|
|
}
|
|
}
|
|
else//改备份值
|
|
{
|
|
c256_bytewrite(EEPROM_WC_ADDR+1,ppara->pr);
|
|
if(ppara->ch!=atsc_para.wc_para.ch)
|
|
{
|
|
c256_bytewrite2(BAK_EEPROM_CHANNEL_ADDR,ppara->ch);
|
|
}
|
|
if(ppara->cl!=atsc_para.wc_para.cl)
|
|
{
|
|
c256_bytewrite2(BAK_EEPROM_RXCHANNEL_ADDR,ppara->cl);
|
|
}
|
|
if(ppara->dh!=atsc_para.wc_para.dh)
|
|
{
|
|
c256_bytewrite2(BAK_EEPROM_POWER_UIH_ADDR,ppara->dh);
|
|
}
|
|
if(ppara->dl!=atsc_para.wc_para.dl)
|
|
{
|
|
c256_bytewrite2(BAK_EEPROM_POWER_UIL_ADDR,ppara->dl);
|
|
}
|
|
|
|
if(ppara->til!=atsc_para.wc_para.til)
|
|
{
|
|
c256_bytewrite2(BAK_E2_POWER_UIH_ADDR,ppara->til);
|
|
}
|
|
|
|
if(ppara->tfl!=atsc_para.wc_para.tfl)
|
|
{
|
|
c256_bytewrite2(BAK_E2_POWER_UIL_ADDR,ppara->tfl);
|
|
}
|
|
}
|
|
|
|
#else
|
|
for(i=0; i<sizeof(S_WC_PARA); i++)
|
|
{
|
|
c256_bytewrite(EEPROM_WC_ADDR+i,*pchar++);
|
|
}
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
void e2rom_save_wd(S_WD_PARA *ppara)
|
|
{
|
|
uint32 i;
|
|
uint8 *pchar = (uint8 *)ppara;
|
|
|
|
for(i=0; i<sizeof(S_WD_PARA); i++)
|
|
{
|
|
c256_bytewrite(EEPROM_WD_ADDR+i,*pchar++);
|
|
}
|
|
}
|
|
void e2rom_save_leak(uint32 ch, S_WE_PARA *ppara)
|
|
{
|
|
if(atsc_para.wl_para.exc_5x==0)
|
|
{
|
|
c256_bytewrite(EEPROM_CH2_POWER_ADDR+ch*2+0,ppara->power>>8);
|
|
c256_bytewrite(EEPROM_CH2_POWER_ADDR+ch*2+1,ppara->power);
|
|
}
|
|
else
|
|
{
|
|
c256_bytewrite(EEPROM_CH1_POWER_ADDR+ch*2+0,ppara->power>>8);
|
|
c256_bytewrite(EEPROM_CH1_POWER_ADDR+ch*2+1,ppara->power);
|
|
}
|
|
}
|
|
void e2rom_save_we(S_WE_PARA *ppara)
|
|
{
|
|
uint32 i;
|
|
uint8 *pchar = (uint8 *)ppara;
|
|
|
|
c256_bytewrite(EEPROM_CHANNEL_ADDR,ppara->ch);
|
|
atsc_para.rf_para.txfreq = ppara->ch;
|
|
|
|
#if BAK_PARA_CHECK
|
|
c256_bytewrite2(BAK_EEPROM_CHANNEL_ADDR,ppara->ch);
|
|
#endif
|
|
e2rom_save_leak(ppara->ch,ppara);
|
|
|
|
for(i=0;i<sizeof(S_WE_PARA); i++)
|
|
{
|
|
c256_bytewrite(EEPROM_WE_ADDR + i,*pchar++);
|
|
}
|
|
}
|
|
void e2rom_save_wf(S_WF_PARA *ppara)
|
|
{
|
|
#if ADDR_CONFLICT_DISABLED
|
|
#else
|
|
|
|
uint32 i;
|
|
uint8 *pchar = (uint8 *)ppara;
|
|
|
|
for(i=0; i<sizeof(S_WF_PARA); i++)
|
|
{
|
|
c256_bytewrite(EEPROM_WF_ADDR + i,*pchar++);
|
|
}
|
|
atsc_para.ad4_para.pdt = ppara->pdt;
|
|
#endif
|
|
}
|
|
void e2rom_save_wh(S_WH_PARA *ppara)
|
|
{
|
|
#if ADDR_CONFLICT_DISABLED
|
|
uint32 i;
|
|
uint8 *pchar = (uint8 *)ppara;
|
|
|
|
for(i=0; i<sizeof(S_WH_PARA); i++)
|
|
{
|
|
c256_bytewrite(EEPROM_WH_ADDR + i,*pchar++);
|
|
}
|
|
atsc_para.ad_para.swrt = ppara->balh;
|
|
|
|
#else
|
|
uint32 i;
|
|
uint8 *pchar = (uint8 *)ppara;
|
|
|
|
for(i=0; i<sizeof(S_WH_PARA); i++)
|
|
{
|
|
c256_bytewrite(EEPROM_WH_ADDR + i,*pchar++);
|
|
}
|
|
atsc_para.ad_para.swrt = ppara->balh;
|
|
|
|
|
|
/* if(atsc_para.wh_para.pac != ppara->pac)
|
|
{
|
|
if(atsc_para.ad3_para.cor==0)
|
|
{
|
|
c256_bytewrite(EEPROM_PWRVREF_VLDO_ADDR,0);
|
|
}
|
|
else
|
|
{
|
|
c256_bytewrite2(E2_PWRVREF_VLDO_ADDR,0);
|
|
}
|
|
}*/
|
|
|
|
#if USE_DRY_LOOP
|
|
if((atsc_para.wh_para.func==1)&&(ppara->func==0)) // EX->TX
|
|
{
|
|
atsc_para.rf_para.tx = 0;
|
|
atsc_para.rf_para.rf = 0;
|
|
dryloop_write(DRYLOOP_I2C_RF_LED,0); //AMP GND
|
|
atsc_para.latch_para.rf = 1;
|
|
c256_bytewrite(EEPROM_RF_ADDR,atsc_para.rf_para.rf); //RF 置为OFF
|
|
c256_bytewrite(EEPROM_RF_TX,atsc_para.rf_para.tx); //TX 置为OFF
|
|
fpga_set_rf_output(atsc_para.rf_para.rf);
|
|
setbit(off_rf, _KEY_WH);
|
|
}
|
|
#else
|
|
ppara->func = 1;
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
|
|
void e2rom_save_wj(S_WJ_PARA *ppara)
|
|
{
|
|
uint8 *pchar = (uint8 *)ppara;
|
|
uint32 i = 0;
|
|
|
|
for(i=0; i<sizeof(S_WJ_PARA); i++)
|
|
{
|
|
c256_bytewrite(EEPROM_WJ_ADDR + i,*pchar++);
|
|
}
|
|
}
|
|
|
|
void e2rom_save_wk(S_WK_PARA *ppara)
|
|
{
|
|
uint32 i = 0;
|
|
uint8 *pchar = (uint8 *)ppara;
|
|
|
|
for(i=0; i<sizeof(S_WK_PARA)-sizeof(ppara->mac); i++)
|
|
{
|
|
c256_bytewrite(EEPROM_WK_ADDR + i,*pchar++);
|
|
}
|
|
|
|
//ppara->mac &= 0xffffff;
|
|
c256_bytewrite(EEPROM_NET_MAC_H, ppara->mac[0] & 0xFF);
|
|
c256_bytewrite(EEPROM_NET_MAC_M, ppara->mac[1] & 0xFF);
|
|
c256_bytewrite(EEPROM_NET_MAC_L, ppara->mac[2] & 0xFF);
|
|
}
|
|
|
|
void e2rom_save_wl(S_WL_PARA *ppara)
|
|
{
|
|
uint8 *pchar = (uint8 *)ppara;
|
|
uint32 i;
|
|
|
|
for(i=0; i<sizeof(S_WL_PARA); i++)
|
|
{
|
|
c256_bytewrite(EEPROM_WL_ADDR+i,*pchar++);
|
|
}
|
|
c256_bytewrite(EEPROM_WL_ADDR+OFFSET_OF_STRUCT(S_WL_PARA,spe),0);
|
|
}
|
|
void e2rom_save_dpd_para(S_DPD_PARA *ppara)
|
|
{
|
|
uint32 i;
|
|
uint8 *pchar = (uint8 *)ppara;
|
|
|
|
c256_bytewrite(EEPROM_DPD_DISTORTION_SW,ppara->distortion_sw&0x07);
|
|
|
|
//h20201210固化
|
|
//c256_bytewrite(EEPROM_DPD_AGC_PWR_L,ppara->agc_pwr&0xff);
|
|
//c256_bytewrite(EEPROM_DPD_AGC_PWR_H,(ppara->agc_pwr>>8)&0xff);
|
|
|
|
c256_bytewrite(EEPROM_DPD_ERR_TH_L,ppara->err_th&0xff);
|
|
c256_bytewrite(EEPROM_DPD_ERR_TH_H,(ppara->err_th>>8)&0xff);
|
|
|
|
c256_bytewrite(EEPROM_DPD_ERR_CNT_TH,ppara->err_cnt_th&0xff);
|
|
|
|
if(ppara->amp_sat>FPGA_AMP_SAT_MAX){
|
|
ppara->amp_sat = FPGA_AMP_SAT_DEF;
|
|
}
|
|
c256_bytewrite(EEPROM_DPD_AMP_SAT_TH_L,ppara->amp_sat&0xff);
|
|
c256_bytewrite(EEPROM_DPD_AMP_SAT_TH_H,(ppara->amp_sat>>8)&0xff);
|
|
|
|
c256_bytewrite(EEPROM_DPD_TEST_L,ppara->dpd_test&0xff);
|
|
c256_bytewrite(EEPROM_DPD_TEST_H,(ppara->dpd_test>>8)&0xff);
|
|
|
|
c256_bytewrite(EEPROM_DPD_STEP,ppara->dpd_mode&0x01);
|
|
|
|
c256_bytewrite(EEPROM_DPD_PHASE6_MINUTE,ppara->phase6_minute);
|
|
|
|
c256_bytewrite(EEPROM_DPD_WPP_TH_L,ppara->wpp_th&0xff);
|
|
c256_bytewrite(EEPROM_DPD_WPP_TH_H,(ppara->wpp_th>>8)&0xff);
|
|
|
|
c256_bytewrite(EEPROM_DPD_GAIN_LIMIT_L, ppara->gl&0xFF);
|
|
c256_bytewrite(EEPROM_DPD_GAIN_LIMIT_H, (ppara->gl>>8)&0xFF);
|
|
|
|
c256_bytewrite(EEPROM_DPD_CTL_TST,ppara->dpd_ctl&0xff);
|
|
}
|
|
|
|
void e2rom_save_ad5(S_ADVANCE5_PARA *ppara)
|
|
{
|
|
c256_bytewrite(EEPROM_AD5_TIME_ADDR,ppara->time);
|
|
c256_bytewrite(EEPROM_AD5_TSNR_ADDR,ppara->a_snr);
|
|
c256_bytewrite(EEPROM_AD5_IMD_ADDR,ppara->a_imd);
|
|
c256_bytewrite(EEPROM_AD5_RSNR_ADDR,ppara->r_snr);
|
|
c256_bytewrite(EEPROM_AD5_RIMD_ADDR,ppara->r_imd);
|
|
ppara->c_t = ppara->time;
|
|
|
|
if(ppara->dpd==0) //当由DPD变为0时,清除本地ADPC数据
|
|
{
|
|
show_wait_info(" ");
|
|
erase_adpc_data();
|
|
c256_bytewrite(EEPROM_DPD_FLASH_VALID,0);
|
|
log_printf(LOG_DEBUG, I_USER_CFG, "clear dpd_data flash valid\n");
|
|
ppara->dpd=atsc_para.ad5_para.dpd;
|
|
} //EEPROM_WJ_DPD
|
|
c256_bytewrite(EEPROM_AD5_DPD_ADDR,ppara->dpd);
|
|
ppara->use_dpd = ppara->dpd;
|
|
|
|
printf("e2prom save a_snr=%d a_imd=%d r_snr=%d r_imd=%d dpd=%d c_t=%d\n",
|
|
ppara->a_snr, ppara->a_imd, ppara->r_snr, ppara->r_imd, ppara->dpd, ppara->c_t);
|
|
}
|
|
|
|
#if USE_PSTS
|
|
void e2rom_save_psts_ch(S_PSIP_PARA *psip,uint32 num)
|
|
{
|
|
uint32 address;
|
|
uint32 i;
|
|
uint8 *pchar = (uint8*)psip;
|
|
|
|
for(i=0;i<PSIP_SHT_NAME_LEN;i++)
|
|
{
|
|
if(psip->sht_name[i]=='"')
|
|
{
|
|
psip->sht_name[i]=' ';
|
|
}
|
|
}
|
|
|
|
address = EEPROM_PSTS_CH_START+num*PSIP_PER_E2_SIZE;
|
|
for(i=0;i<sizeof(S_PSIP_PARA);i++)
|
|
{
|
|
c256_bytewrite(address++,*pchar++);
|
|
}
|
|
}
|
|
void e2rom_read_psts_ch(S_PSIP_PARA *psip,uint32 num)
|
|
{
|
|
uint32 address;
|
|
uint32 i;
|
|
uint8 *pchar = (uint8*)psip;
|
|
|
|
address = EEPROM_PSTS_CH_START+num*PSIP_PER_E2_SIZE;
|
|
for(i=0;i<sizeof(S_PSIP_PARA);i++)
|
|
{
|
|
*pchar++ = c256_byteread(address++);
|
|
}
|
|
|
|
for(i=0;i<PSIP_SHT_NAME_LEN;i++)
|
|
{
|
|
if(psip->sht_name[i]=='"')
|
|
{
|
|
psip->sht_name[i]=' ';
|
|
}
|
|
}
|
|
}
|
|
|
|
void e2rom_save_psts(S_PSTS_PARA *ppara)
|
|
{
|
|
uint32 i = 0;
|
|
|
|
c256_bytewrite(EEPROM_PSTS_TS_EDIT,ppara->ts_ctrl);
|
|
c256_bytewrite(EEPROM_PSTS_TSIDH,ppara->tsid>>8);
|
|
c256_bytewrite(EEPROM_PSTS_TSIDL,ppara->tsid);
|
|
|
|
c256_bytewrite(EEPROM_PSTS_CHANEL,ppara->channel_max);
|
|
|
|
for(i=0;i<PSIP_MAX_CHANNLE_NUM;i++)
|
|
{
|
|
e2rom_save_psts_ch(&ppara->sip_para[i],i);
|
|
}
|
|
}
|
|
|
|
void e2rom_init_psts(S_PSTS_PARA *ppara)
|
|
{
|
|
uint32 i = 0;
|
|
|
|
memset(ppara,0,sizeof(S_PSTS_PARA));
|
|
|
|
c256_bytewrite(EEPROM_PSTS_TSIDH,ppara->tsid>>8);
|
|
c256_bytewrite(EEPROM_PSTS_TSIDL,ppara->tsid);
|
|
c256_bytewrite(EEPROM_PSTS_CHANEL,ppara->channel_max);
|
|
c256_bytewrite(EEPROM_PSTS_TS_EDIT,ppara->ts_ctrl);
|
|
|
|
for(i=0;i<PSIP_MAX_CHANNLE_NUM;i++)
|
|
{
|
|
ppara->sip_para[i].sht_name[0] = '0';
|
|
ppara->sip_para[i].sht_name[1] = '0';
|
|
ppara->sip_para[i].sht_name[2] = '0';
|
|
ppara->sip_para[i].sht_name[3] = '0';
|
|
ppara->sip_para[i].sht_name[4] = '0';
|
|
ppara->sip_para[i].sht_name[5] = '0';
|
|
ppara->sip_para[i].sht_name[6] = '0';
|
|
ppara->sip_para[i].sht_name[7] = 0;
|
|
|
|
e2rom_save_psts_ch(&ppara->sip_para[i],i);
|
|
}
|
|
}
|
|
|
|
void e2rom_read_psts(S_PSTS_PARA *ppara)
|
|
{
|
|
uint32 i = 0;
|
|
|
|
ppara->ts_ctrl=c256_byteread(EEPROM_PSTS_TS_EDIT);
|
|
|
|
ppara->tsid= (c256_byteread(EEPROM_PSTS_TSIDH)<<8) | c256_byteread(EEPROM_PSTS_TSIDL);
|
|
|
|
ppara->channel_max = c256_byteread(EEPROM_PSTS_CHANEL);
|
|
|
|
if(ppara->ts_ctrl>PSTS_CTRL_CLEAR)
|
|
{
|
|
e2rom_init_psts(ppara);
|
|
}
|
|
else
|
|
{
|
|
for(i=0;i<PSIP_MAX_CHANNLE_NUM;i++)
|
|
{
|
|
e2rom_read_psts_ch(&ppara->sip_para[i],i);
|
|
}
|
|
}
|
|
ppara->index = 0;
|
|
}
|
|
#endif
|
|
|
|
static void e2prom_read_ntp_server(u8 *ppara, uint8 *pswitch)
|
|
{
|
|
uint8 t_ip[4];
|
|
uint32 i;
|
|
uint8 ntp_switch;
|
|
|
|
ntp_switch = c256_byteread(EEPROM_NTP_SWITCH);
|
|
if(ntp_switch>1){
|
|
ntp_switch = 0;
|
|
}
|
|
*pswitch = ntp_switch;
|
|
|
|
for(i=0; i<sizeof(atsc_para.system_para.ntp_ip); i++)
|
|
{
|
|
t_ip[i] = c256_byteread(EEPROM_NTP_SERVER_IP+i);
|
|
}
|
|
|
|
if(t_ip[0]==0xff && t_ip[1]==0xff && t_ip[2]==0xff && t_ip[3]==0xff){
|
|
ppara[0] = 162;
|
|
ppara[1] = 159;
|
|
ppara[2] = 200;
|
|
ppara[3] = 123;
|
|
c256_bytewrite(EEPROM_NTP_SERVER_IP, ppara[0]);
|
|
c256_bytewrite(EEPROM_NTP_SERVER_IP+1, ppara[1]);
|
|
c256_bytewrite(EEPROM_NTP_SERVER_IP+2, ppara[2]);
|
|
c256_bytewrite(EEPROM_NTP_SERVER_IP+3, ppara[3]);
|
|
}
|
|
else{
|
|
memcpy(ppara, t_ip, 4);
|
|
}
|
|
|
|
set_ntp_server_ip_to_system(ppara, ntp_switch, 0);
|
|
printf("rd ntp_server_ip %d.%d.%d.%d sw=%d\n",
|
|
ppara[0],ppara[1],ppara[2],ppara[3], ntp_switch);
|
|
}
|
|
|
|
extern void save_sys_para(void *);
|
|
void e2rom_save_sn(S_SN_PARA *ppara)
|
|
{
|
|
#if 1//_USE_RVL_
|
|
uint32 glb_flag = 0;
|
|
uint32 temp=0;
|
|
|
|
if(((uint32)ppara)==(uint32)&atsc_para.sn_para)
|
|
{
|
|
glb_flag = 1;
|
|
}
|
|
#if USE_SPECT_DATA_TASK
|
|
if((atsc_para.sn_para.sn != ppara->sn)
|
|
||(atsc_para.sn_para.gui_key != ppara->gui_key)
|
|
||(glb_flag))
|
|
{
|
|
log_printf(LOG_INFO, I_USER_CFG, "sn=%llx,gui_key=%x\n",
|
|
ppara->sn,ppara->gui_key);
|
|
tcp_spect_calc_sn_licence(ppara->gui_key,&ppara->sn);
|
|
atsc_para.wl_para.spe = 0;
|
|
}
|
|
|
|
temp=(ppara->sn>>32);
|
|
c256_bytewrite(EEPROM_SN_H2,temp>>8);
|
|
c256_bytewrite(EEPROM_SN_H1,temp);
|
|
|
|
temp=ppara->sn&0xffffffff;
|
|
c256_bytewrite(EEPROM_SN_L4,temp>>24);
|
|
c256_bytewrite(EEPROM_SN_L3,temp>>16);
|
|
c256_bytewrite(EEPROM_SN_L2,temp>>8);
|
|
c256_bytewrite(EEPROM_SN_L1,temp);
|
|
|
|
temp = ppara->gui_key;
|
|
c256_bytewrite(EEPROM_KEY_H2,temp>>24);
|
|
c256_bytewrite(EEPROM_KEY_H1,temp>>16);
|
|
c256_bytewrite(EEPROM_KEY_L2,temp>>8);
|
|
c256_bytewrite(EEPROM_KEY_L1,temp);
|
|
#endif
|
|
|
|
if((atsc_para.sn_para.eas_key!=ppara->eas_key)||(glb_flag))
|
|
{
|
|
temp = ppara->eas_key;
|
|
c256_bytewrite(EEPROM_EAS_KEY1,temp>>24);
|
|
c256_bytewrite(EEPROM_EAS_KEY2,temp>>16);
|
|
c256_bytewrite(EEPROM_EAS_KEY3,temp>>8);
|
|
c256_bytewrite(EEPROM_EAS_KEY4,temp);
|
|
|
|
ppara->eas_key_valid = eas_calc_sn_licence(ppara->eas_key,&ppara->sn);
|
|
if(!ppara->eas_key_valid)
|
|
{
|
|
if(atsc_para.sn_para.eas_key!=ppara->eas_key)
|
|
{
|
|
if(atsc_para.system_para.input==ASI_INPUT_EAS)
|
|
{
|
|
atsc_para.system_para.input = ASI_INPUT_TS;
|
|
save_sys_para(&atsc_para.system_para);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if((atsc_para.sn_para.psip_key!=ppara->psip_key)||(glb_flag))
|
|
{
|
|
ppara->psip_key_valid = psip_calc_sn_licence(ppara->psip_key,&ppara->sn);
|
|
atsc_para.wl_para.spe = 0;
|
|
if(!ppara->psip_key_valid)
|
|
{
|
|
if(atsc_para.psts_para.ts_ctrl!=0)
|
|
{
|
|
atsc_para.psts_para.ts_ctrl = 0;
|
|
e2rom_save_psts(&atsc_para.psts_para);
|
|
fpga_save_psts(&atsc_para.psts_para);
|
|
}
|
|
}
|
|
}
|
|
temp = ppara->psip_key;
|
|
c256_bytewrite(EEPROM_PSIP_KEY_H2,temp>>24);
|
|
c256_bytewrite(EEPROM_PSIP_KEY_H1,temp>>16);
|
|
c256_bytewrite(EEPROM_PSIP_KEY_L2,temp>>8);
|
|
c256_bytewrite(EEPROM_PSIP_KEY_L1,temp);
|
|
log_printf(LOG_INFO, I_USER_CFG, "psip_key=%x,psip_key_valid=%x,eas_key=%x, eas_key_valid=%x\n",
|
|
ppara->psip_key,ppara->psip_key_valid, ppara->eas_key,ppara->eas_key_valid);
|
|
#endif
|
|
}
|
|
|
|
void e2rom_save_latch(S_LATCH_PARA *platch, S_SYSTEM_PARA *psys)
|
|
{
|
|
c256_bytewrite(EEPROM_CTRL_ADDR,psys->ctrl);
|
|
}
|
|
|
|
void e2rom_save_network(S_NETWORK_PARA *ppara)
|
|
{
|
|
if(ppara->delay>NET_MAX_DELAY)
|
|
{
|
|
ppara->delay = NET_MAX_DELAY;
|
|
}
|
|
c256_bytewrite(EEPROM_NET_DELAY_ADDR, ppara->delay>>16);
|
|
c256_bytewrite(EEPROM_NET_DELAY_ADDR+1,ppara->delay>>8);
|
|
c256_bytewrite(EEPROM_NET_DELAY_ADDR+2,ppara->delay);
|
|
}
|
|
|
|
void e2rom_save_mode(S_MODE_PARA *ppara)
|
|
{
|
|
c256_bytewrite(EEPROM_MODE_SYNC,ppara->sync);
|
|
c256_bytewrite(EEPROM_MODE_TCP_C,ppara->tcp_c);
|
|
c256_bytewrite(EEPROM_MODE_ZP1F,ppara->zp1f);
|
|
log_printf(LOG_INFO, I_USER_CFG,"sync=%d, tcp_c=%d, zp1f=%d\n", ppara->sync, ppara->tcp_c, ppara->zp1f);
|
|
}
|
|
void e2rom_save_ad(S_ADVANCE_PARA *ppara)
|
|
{
|
|
c256_bytewrite(EEPROM_PCR_ADDR,ppara->pcr);
|
|
c256_bytewrite(EEPROM_SLOW_UP_ADDR, ppara->slow_up);
|
|
c256_bytewrite(EEPROM_SLOW_DOWN_ADDR,ppara->slow_down);
|
|
|
|
#if ADDR_CONFLICT_DISABLED
|
|
atsc_para.wh_para.balh = ppara->swrt;
|
|
c256_bytewrite(EEPROM_WH_ADDR+OFFSET_OF_STRUCT(S_WH_PARA,balh),ppara->swrt);
|
|
#else
|
|
atsc_para.wh_para.balh = ppara->swrt;
|
|
c256_bytewrite(EEPROM_WH_ADDR+OFFSET_OF_STRUCT(S_WH_PARA,balh),ppara->swrt);
|
|
#endif
|
|
atsc_para.wh_para.pac = ppara->pac;
|
|
c256_bytewrite(EEPROM_WH_ADDR+OFFSET_OF_STRUCT(S_WH_PARA,pac),ppara->pac);
|
|
c256_bytewrite(EEPROM_ASIOUT_ADDR,ppara->asiout);
|
|
|
|
log_printf(LOG_INFO, I_USER_CFG, "pcr=%d,slow_up=%d,slow_down=%d\n", ppara->pcr,ppara->slow_up,ppara->slow_down);
|
|
log_printf(LOG_INFO, I_USER_CFG, "swrt=%d,pac=%d,asiout=%d\n",ppara->swrt,ppara->pac,ppara->asiout);
|
|
}
|
|
|
|
void e2rom_save_ad2(S_ADVANCE2_PARA *ppara)
|
|
{
|
|
c256_bytewrite(EEPROM_M_TS_ADDR,ppara->m_ts);
|
|
c256_bytewrite(EEPROM_M_10M_ADDR,ppara->m_10m);
|
|
c256_bytewrite(EEPROM_M_1PPS_ADDR,ppara->m_1pps);
|
|
|
|
if((ppara->m_dly_hh==0)&&(ppara->m_dly_mm==0)&&(ppara->m_dly_ss<4))
|
|
ppara->m_dly_ss = 4;
|
|
if(ppara->m_dly_hh>99)
|
|
ppara->m_dly_hh =99;
|
|
if(ppara->m_dly_mm>59)
|
|
ppara->m_dly_mm =59;
|
|
if(ppara->m_dly_ss>59)
|
|
ppara->m_dly_ss =59;
|
|
c256_bytewrite(EEPROM_M_DLY_ADDR,ppara->m_dly_hh);
|
|
c256_bytewrite(EEPROM_M_DLY_ADDR_MM,ppara->m_dly_mm);
|
|
c256_bytewrite(EEPROM_M_DLY_ADDR_SS,ppara->m_dly_ss);
|
|
|
|
log_printf(LOG_INFO, I_USER_CFG, "m_ts=%d,m_10m=%d,m_1pps=%d\n", ppara->m_ts,ppara->m_10m,ppara->m_1pps);
|
|
log_printf(LOG_INFO, I_USER_CFG, "m_dly_hh=%d,m_dly_mm=%d,m_dly_ss=%d\n",ppara->m_dly_hh,ppara->m_dly_mm,ppara->m_dly_ss);
|
|
}
|
|
void e2rom_save_ad4(S_ADVANCE4_PARA *ppara)
|
|
{
|
|
c256_bytewrite(EEPROM_WF_ADDR+OFFSET_OF_STRUCT(S_WF_PARA,pdt),ppara->pdt);
|
|
atsc_para.wf_para.pdt = ppara->pdt;
|
|
/*c256_bytewrite(EEPROM_WB_ADDR+OFFSET_OF_STRUCT(S_WB_PARA,cfr),ppara->cfr);
|
|
atsc_para.wb_para.cfr = ppara->cfr;*/
|
|
c256_bytewrite(EEPROM_DPD_ADDR, ppara->adpc);
|
|
}
|
|
void e2rom_save_config(S_CONFIG_PARA *ppara)
|
|
{
|
|
uint32 i = 0;
|
|
c256_bytewrite(EEPROM_BPS_ADDR,ppara->bps);
|
|
// c256_bytewrite(EEPROM_UPGRADE_ADDR,ppara->upgrade);
|
|
|
|
c256_bytewrite(EEPROM_ID_ADDR,ppara->id);
|
|
std_w[0] = std_r[0] = ppara->id;
|
|
|
|
for(i=0; i<4; i++)
|
|
{
|
|
c256_bytewrite(EEPROM_IP4_ADDR+i,ppara->ip[i]);
|
|
}
|
|
for(i=0; i<4; i++)
|
|
{
|
|
c256_bytewrite(EEPROM_GATEWAY_ADDR+i,ppara->gateway[i]);
|
|
}
|
|
for(i=0; i<4; i++)
|
|
{
|
|
c256_bytewrite(EEPROM_NETMASK_ADDR+i,ppara->mask[i]);
|
|
}
|
|
for(i=0; i<4; i++)
|
|
{
|
|
c256_bytewrite(EEPROM_DNS_ADDR+i,ppara->dns[i]);
|
|
}
|
|
|
|
//local_ip_change();
|
|
// eth0 admin interface
|
|
local_ip_change_admin(ppara);
|
|
|
|
if(ppara->bps != atsc_para.config_para.bps)
|
|
{
|
|
}
|
|
|
|
c256_bytewrite(EEPROM_PA_LINK_CTRL_RF_ADDR,ppara->pa_link_ctrl_rf);
|
|
|
|
log_printf(LOG_INFO, I_USER_CFG, "pa_link_ctrl_rf=%d, id=%d, bsp=%d\n", ppara->pa_link_ctrl_rf, ppara->id,ppara->bps);
|
|
log_printf(LOG_INFO, I_USER_CFG, "ip=%d.%d.%d,%d\n", ppara->ip[0],ppara->ip[1],ppara->ip[2],ppara->ip[3]);
|
|
log_printf(LOG_INFO, I_USER_CFG, "gw=%d.%d.%d,%d\n", ppara->gateway[0],ppara->gateway[1],ppara->gateway[2],ppara->gateway[3]);
|
|
log_printf(LOG_INFO, I_USER_CFG, "nm=%d.%d.%d,%d\n", ppara->mask[0],ppara->mask[1],ppara->mask[2],ppara->mask[3]);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#if ATSC_USA_AMP
|
|
void e2rom_save_pa_config(S_PA_CONFIG_PARA *ppara)
|
|
{
|
|
uint32 i = 0;
|
|
for(i=0; i<4; i++)
|
|
{
|
|
c256_bytewrite(EEPROM_PA_IP4_ADDR+i,ppara->ip[i]);
|
|
}
|
|
for(i=0; i<4; i++)
|
|
{
|
|
c256_bytewrite(EEPROM_PA_GATEWAY_ADDR+i,ppara->gateway[i]);
|
|
}
|
|
for(i=0; i<4; i++)
|
|
{
|
|
c256_bytewrite(EEPROM_PA_NETMASK_ADDR+i,ppara->mask[i]);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void e2rom_save_ad3(S_ADVANCE3_PARA *ppara)
|
|
{
|
|
uint16 ref = 0;
|
|
uint32 i;
|
|
uint32 ref_sum = 0;
|
|
|
|
if(ppara->fwd_cal==0)// cal
|
|
{
|
|
//do {
|
|
/* 校准点存的是额定功率处的 ORx 输入功率 p_db, 0.1 dB/LSB 定点。
|
|
ORx AGC 是闭环, ob_fb_rms_pwr 单独用恒被钉在设定点上, 必须把 FAGC
|
|
增益字(0x36/0x37)一起合成 —— 详见 orx_power.h 与
|
|
docs/superpowers/specs/2026-07-18-fssi-fwd-orx-power-design.md。
|
|
两对寄存器都用原子读: 0x03/0x04 共用 temp_reg 高字节锁存器。 */
|
|
{
|
|
uint16 cw[5], rms[5];
|
|
float p;
|
|
for(i=0;i<5;i++) {
|
|
rms[i] = fpga_word_read_lh(0x01, 0x03, 0x04);
|
|
cw[i] = fpga_word_read_hl(0x01, 0x36, 0x37);
|
|
}
|
|
p = orx_power_combine_db(orx_median5(cw), orx_median5(rms));
|
|
ppara->power_ref = (uint16)(p * 10.0f + 0.5f);
|
|
|
|
/* PR13: 分别记录两个原始量, 而不是只存合成标量 power_ref。 */
|
|
ppara->cal_fagc_cw = (uint8)((orx_median5(cw) >> 8) & 0xff);
|
|
ppara->cal_orx_pwr_hdb = (uint16)orx_pwr_halfdb(orx_median5(rms));
|
|
}
|
|
(void)ref; (void)ref_sum;
|
|
ppara->fwd_cal = 1;
|
|
ppara->fwd_cal_dly = 10;
|
|
|
|
#if USE_DRY_LOOP
|
|
if(ppara->cor==0) //100w
|
|
{
|
|
c256_bytewrite(EEPROM_AD3_POWER_REF_H,ppara->power_ref>>8);
|
|
c256_bytewrite(EEPROM_AD3_POWER_REF_L,ppara->power_ref);
|
|
} //1000w
|
|
else
|
|
{
|
|
c256_bytewrite2(E2_AD3_POWER_REF_H,ppara->power_ref>>8);
|
|
c256_bytewrite2(E2_AD3_POWER_REF_L,ppara->power_ref);
|
|
}
|
|
#else
|
|
ppara->cor = 0;
|
|
c256_bytewrite(EEPROM_AD3_POWER_REF_H,ppara->power_ref>>8);
|
|
c256_bytewrite(EEPROM_AD3_POWER_REF_L,ppara->power_ref);
|
|
log_printf(LOG_INFO, I_USER_CFG, "fwd_cal=%d, power_ref=%d\n", ppara->fwd_cal,ppara->power_ref);
|
|
#endif
|
|
/* PR13: cal_fagc_cw/cal_orx_pwr_hdb 按新枚举地址落盘, uint16 拆 H/L 两字节。 */
|
|
c256_bytewrite(EEPROM_AD3_CAL_FAGC_CW, ppara->cal_fagc_cw);
|
|
c256_bytewrite(EEPROM_AD3_CAL_ORX_PWR_H, ppara->cal_orx_pwr_hdb>>8);
|
|
c256_bytewrite(EEPROM_AD3_CAL_ORX_PWR_L, ppara->cal_orx_pwr_hdb);
|
|
}
|
|
//printf("ppara->rc_cmd=%d\n", ppara->rc_cmd);
|
|
c256_bytewrite(EEPROM_AD3_RC_CMD,ppara->rc_cmd);
|
|
c256_bytewrite(EEPROM_AD3_FWD_CAL,ppara->fwd_cal);
|
|
c256_bytewrite(EEPROM_AD3_TYPE,ppara->cor);
|
|
c256_bytewrite(EEPROM_PARA_CW_ADDR,ppara->cw); //CW
|
|
|
|
|
|
if(ppara->cor==0) //更新
|
|
{
|
|
ppara->power_ref = (c256_byteread(EEPROM_AD3_POWER_REF_H)<<8)|c256_byteread(EEPROM_AD3_POWER_REF_L);
|
|
}
|
|
else
|
|
{
|
|
ppara->power_ref = (c256_byteread2(E2_AD3_POWER_REF_H)<<8)|c256_byteread2(E2_AD3_POWER_REF_L);
|
|
}
|
|
|
|
// printf("ppara->power_ref =0x%x\n", ppara->power_ref );
|
|
#if USE_NEW_DIO_MODE
|
|
c256_bytewrite(EEPROM_AD3_MPTV,ppara->mptv);
|
|
#endif
|
|
|
|
c256_bytewrite(EEPROM_AD3_MAX_PWR_H,ppara->max_power>>8);
|
|
c256_bytewrite(EEPROM_AD3_MAX_PWR_L,ppara->max_power);
|
|
|
|
log_printf(LOG_INFO, I_USER_CFG, "rc_cmd=%d, cor=%d, cw=%d,power_ref=%d,max_power=%d\n", ppara->rc_cmd,ppara->cor,ppara->cw,ppara->power_ref,ppara->max_power);
|
|
}
|
|
|
|
|
|
void e2rom_save_user_info(S_USER_INFO *ppara)
|
|
{
|
|
uint32 i;
|
|
|
|
//暂时只有1个账户需要保存
|
|
c256_bytewrite(EEPROM_USER_INFO,ppara->user_type);
|
|
for(i=0;i<sizeof(ppara->name);i++)
|
|
{
|
|
c256_bytewrite(EEPROM_USER_INFO_NM+i,ppara->name[i]);
|
|
}
|
|
for(i=0;i<sizeof(ppara->password);i++)
|
|
{
|
|
c256_bytewrite(EEPROM_USER_INFO_PW+i,ppara->password[i]);
|
|
}
|
|
}
|
|
|
|
void e2rom_read_system(S_SYSTEM_PARA *ppara)
|
|
{
|
|
uint32 i;
|
|
uint8 *pchar;
|
|
uint8 ip_index;
|
|
|
|
|
|
ppara->input = c256_byteread(EEPROM_SYS_INPUT);
|
|
if(ppara->input>=ASI_INPUT_END)
|
|
ppara->input = ASI_INPUT_TS;
|
|
//PR04: input source is configurable via EEPROM(reg50)/web/uart; no longer forced.
|
|
// ASI_INPUT_TUNER=0(Sony tuner), ASI_INPUT_TS=1, ASI_INPUT_EAS=2, TSOIP_INPUT_IP=3
|
|
|
|
ppara->adpc = c256_byteread(EEPROM_DPD_ADDR);
|
|
if(ppara->adpc>ADPC_HOLD)
|
|
ppara->adpc = ADPC_OFF;
|
|
|
|
ppara->gps = c256_byteread(EEPROM_GPS_ADDR);
|
|
if(ppara->gps>2)
|
|
ppara->gps=0;
|
|
|
|
//ppara->net = c256_byteread(EEPROM_NET_ADDR);
|
|
//if(ppara->net>1)
|
|
// ppara->net = 0;
|
|
|
|
ppara->mode = c256_byteread(EEPROM_MODE_ADDR);
|
|
if(ppara->mode>2)
|
|
ppara->mode = 0;
|
|
|
|
ppara->ctrl = c256_byteread(EEPROM_CTRL_ADDR);
|
|
if(ppara->ctrl>CTRL_LOCAL)
|
|
ppara->ctrl = CTRL_REMOTE;
|
|
ppara->ocxo = c256_byteread(EEPROM_OCXO_ADDR);
|
|
if(math_abs(ppara->ocxo)>OCXO_MAX)
|
|
ppara->ocxo = 0;
|
|
|
|
for(i=0;i<ATSC_TITLE_LEN;i++)
|
|
{
|
|
ppara->web_title[i] = c256_byteread(EEPROM_WEB_TITLE_ADDR+i);
|
|
}
|
|
|
|
if(ppara->web_title[0]==0xff)
|
|
{
|
|
memcpy(ppara->web_title,ATSC_WEB_TITLE,strlen(ATSC_WEB_TITLE));
|
|
ppara->web_title[ATSC_TITLE_LEN-1] = 0;
|
|
for(i=0;i<ATSC_TITLE_LEN;i++)
|
|
{
|
|
c256_bytewrite(EEPROM_WEB_TITLE_ADDR+i,ppara->web_title[i]);
|
|
}
|
|
}
|
|
|
|
ppara->sntp_en = c256_byteread(EEPROM_SNTP_ENABLE);
|
|
if(ppara->sntp_en > 0x01)
|
|
ppara->sntp_en = 0x00;
|
|
|
|
|
|
|
|
pchar =(uint8 *)&ppara->sntp_sip;
|
|
for(ip_index=0; ip_index<4; ip_index++)
|
|
{
|
|
pchar[ip_index] = c256_byteread(EEPROM_SNTP_SIP1+ip_index) ;
|
|
}
|
|
memcpy(ppara->sntp_sip, pchar, 4);
|
|
|
|
|
|
ppara->agc_att = c256_byteread(EEPROM_AGC_ATT);
|
|
if(ppara->agc_att>0x3f)
|
|
ppara->agc_att = 0x3f;
|
|
|
|
ppara->adrv9009_att = (c256_byteread(EEPROM_ADRV9009_ATT_H)<<8) | c256_byteread(EEPROM_ADRV9009_ATT_L);
|
|
if(ppara->adrv9009_att>=65535)
|
|
ppara->adrv9009_att = 8000;
|
|
|
|
|
|
uint8 orx_gain_min, orx_gain_max;
|
|
get_adrv9009_c0_orx_range(&orx_gain_min, &orx_gain_max);
|
|
ppara->orx_manu_gain = c256_byteread(EEPROM_ADRV9009_ORX_MANU_GAIN);
|
|
if(ppara->orx_manu_gain<orx_gain_min||ppara->orx_manu_gain>orx_gain_max)
|
|
ppara->orx_manu_gain = orx_gain_max;
|
|
|
|
ppara->spec_enable = 1;
|
|
|
|
printf("load agc_att=%d %fdb adrv9009_att=%d orx_manu_gain=%d spec_enable=%d\n", ppara->agc_att, -0.5*ppara->agc_att, ppara->adrv9009_att, ppara->orx_manu_gain, ppara->spec_enable);
|
|
}
|
|
static void bak_e2rom_read_rf(S_RF_PARA *ppara)
|
|
{
|
|
uint8 UC_temp;
|
|
if(atsc_para.bak_check_flag)
|
|
{
|
|
if(E2PROM_MAGIC_WORD_BAK != c256_byteread(EEPROM_FQPW_CHECK_FLAG))
|
|
{
|
|
UC_temp=c256_byteread(EEPROM_CHANNEL_ADDR);
|
|
c256_bytewrite2(BAK_EEPROM_CHANNEL_ADDR,UC_temp);
|
|
|
|
UC_temp=c256_byteread(EEPROM_RXCHANNEL_ADDR);
|
|
c256_bytewrite2(BAK_EEPROM_RXCHANNEL_ADDR,UC_temp);
|
|
|
|
UC_temp=c256_byteread(EEPROM_POWER_UIH_ADDR);
|
|
c256_bytewrite2(BAK_EEPROM_POWER_UIH_ADDR,UC_temp);
|
|
|
|
UC_temp=c256_byteread(EEPROM_POWER_UIL_ADDR);
|
|
c256_bytewrite2(BAK_EEPROM_POWER_UIL_ADDR,UC_temp);
|
|
|
|
UC_temp=c256_byteread2(E2_POWER_UIH_ADDR);
|
|
c256_bytewrite2(BAK_E2_POWER_UIH_ADDR,UC_temp);
|
|
|
|
UC_temp=c256_byteread2(E2_POWER_UIL_ADDR);
|
|
c256_bytewrite2(BAK_E2_POWER_UIL_ADDR,UC_temp);
|
|
|
|
UC_temp=c256_byteread(EEPROM_0DBFLAGH_ADDR);
|
|
c256_bytewrite2(BAK_EEPROM_0DBFLAGH_ADDR,UC_temp);
|
|
|
|
UC_temp=c256_byteread(EEPROM_0DBFLAGL_ADDR);
|
|
c256_bytewrite2(BAK_EEPROM_0DBFLAGL_ADDR,UC_temp);
|
|
|
|
UC_temp=c256_byteread2(BAK_E2_0DBFLAGH_ADDR);
|
|
c256_bytewrite2(BAK_E2_0DBFLAGH_ADDR,UC_temp);
|
|
|
|
UC_temp=c256_byteread2(BAK_E2_0DBFLAGL_ADDR);
|
|
c256_bytewrite2(BAK_E2_0DBFLAGL_ADDR,UC_temp);
|
|
|
|
}
|
|
else
|
|
{
|
|
UC_temp = c256_byteread2(BAK_EEPROM_RXCHANNEL_ADDR);
|
|
if(UC_temp!=ppara->rxfreq)
|
|
atsc_para.bak_err_flag |= BAK_ERR_RXFREQ;
|
|
|
|
UC_temp = c256_byteread2(BAK_EEPROM_CHANNEL_ADDR);
|
|
if(UC_temp!=ppara->txfreq)
|
|
atsc_para.bak_err_flag |= BAK_ERR_TXFREQ;
|
|
|
|
if(atsc_para.ad3_para.cor == 0)
|
|
{
|
|
|
|
if( (((uint8)(ppara->power>>8))!=c256_byteread2(BAK_EEPROM_POWER_UIH_ADDR))
|
|
|| ( ((uint8)(ppara->power&0xff)) != c256_byteread2(BAK_EEPROM_POWER_UIL_ADDR)))
|
|
|
|
atsc_para.bak_err_flag |= BAK_ERR_POWER;
|
|
if( (((uint8)(ppara->db>>8))!=c256_byteread2(BAK_EEPROM_0DBFLAGH_ADDR))
|
|
|| ( ((uint8)(ppara->db&0xff)) != c256_byteread2(BAK_EEPROM_0DBFLAGL_ADDR)))
|
|
|
|
atsc_para.bak_err_flag |= BAK_ERR_DB;
|
|
}
|
|
else
|
|
{
|
|
if( (((uint8)(ppara->power>>8))!=c256_byteread2(BAK_E2_POWER_UIH_ADDR))
|
|
|| ( ((uint8)(ppara->power&0xff)) != c256_byteread2(BAK_E2_POWER_UIL_ADDR) ))
|
|
|
|
atsc_para.bak_err_flag |= BAK_ERR_POWER;
|
|
|
|
if( (((uint8)(ppara->db>>8))!=c256_byteread2(BAK_E2_0DBFLAGH_ADDR))
|
|
|| ( ((uint8)(ppara->db&0xff)) != c256_byteread2(BAK_E2_0DBFLAGL_ADDR) ))
|
|
|
|
atsc_para.bak_err_flag |= BAK_ERR_DB;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
}
|
|
|
|
if(atsc_para.bak_err_flag)
|
|
{
|
|
atsc_para.bak_err_flag |=1;
|
|
ppara->rf = 0; //不存E2，强制为0
|
|
}
|
|
}
|
|
|
|
|
|
void e2rom_read_rf(S_RF_PARA *ppara)
|
|
{
|
|
uint8 UC_temp;
|
|
|
|
ppara->rxfreq = c256_byteread(EEPROM_RXCHANNEL_ADDR);
|
|
if((ppara->rxfreq<FREQ_MIN_V1 ) || (ppara->rxfreq>FREQ_MAX_ALL)){
|
|
ppara->rxfreq = DEFAULT_FREQ_NUM;
|
|
}
|
|
|
|
ppara->txfreq = c256_byteread(EEPROM_CHANNEL_ADDR);
|
|
if((ppara->txfreq<FREQ_MIN_V1 )|| (ppara->txfreq>FREQ_MAX_ALL))
|
|
{
|
|
ppara->txfreq = DEFAULT_FREQ_NUM;
|
|
atsc_para.bak_err_flag |=BAK_ERR_TXFREQ;
|
|
}
|
|
printf("boot load tx=%d rx=%d\n", ppara->txfreq, ppara->rxfreq);
|
|
|
|
ppara->hz= c256_byteread(EEPROM_HZ_UIH_ADDR) ; //+ -
|
|
UC_temp = c256_byteread(EEPROM_HZ_UIM_ADDR) ; //Hz display : high 8 bit
|
|
ppara->hz = (ppara->hz<<8)|UC_temp ;
|
|
UC_temp = c256_byteread(EEPROM_HZ_UIL_ADDR) ; //Hz display : low 8 bit
|
|
ppara->hz = (ppara->hz<<8)|UC_temp ;
|
|
|
|
if((ppara->hz&0xffff)>RF_MAX_HZ)
|
|
ppara->hz = (ppara->hz&0xf0000)+RF_MAX_HZ;
|
|
|
|
if(atsc_para.ad3_para.cor == 0)
|
|
{
|
|
ppara->power = c256_byteread(EEPROM_POWER_UIH_ADDR) ;
|
|
UC_temp = c256_byteread(EEPROM_POWER_UIL_ADDR) ;
|
|
ppara->power = (ppara->power <<8)|UC_temp ;
|
|
|
|
ppara->db = c256_byteread(EEPROM_0DBFLAGH_ADDR);
|
|
UC_temp = c256_byteread(EEPROM_0DBFLAGL_ADDR);
|
|
ppara->db = (ppara->db<<8)|UC_temp;
|
|
|
|
ppara->agc = 0;//
|
|
//ppara->agc = c256_byteread(EEPROM_AGC_ADDR);
|
|
//if(ppara->agc >1)
|
|
// ppara->agc = 0;
|
|
|
|
// UC_temp = c256_byteread(EEPROM_PWRVREF_O_HADDR);
|
|
// ppara->ref = c256_byteread(EEPROM_PWRVREF_O_LADDR);
|
|
// ppara->ref = (UC_temp<<8)|ppara->ref;
|
|
}
|
|
else
|
|
{
|
|
ppara->power = c256_byteread2(E2_POWER_UIH_ADDR) ;
|
|
UC_temp = c256_byteread2(E2_POWER_UIL_ADDR) ;
|
|
ppara->power = (ppara->power <<8)|UC_temp ;
|
|
|
|
ppara->db = c256_byteread2(E2_0DBFLAGH_ADDR);
|
|
UC_temp = c256_byteread2(E2_0DBFLAGL_ADDR);
|
|
ppara->db = (ppara->db<<8)|UC_temp;
|
|
|
|
ppara->agc = 0;//
|
|
//ppara->agc = c256_byteread2(E2_AGC_ADDR);
|
|
//if(ppara->agc >1)
|
|
// ppara->agc = 0;
|
|
|
|
|
|
// UC_temp =c256_byteread2(E2_PWRVREF_O_HADDR);
|
|
// ppara->ref = c256_byteread2(E2_PWRVREF_O_LADDR);
|
|
// ppara->ref = (UC_temp<<8)|ppara->ref;
|
|
}
|
|
|
|
if(ppara->power >RF_POWER_P_C_ON)
|
|
{
|
|
ppara->power = RF_POWER_P_C_ON;
|
|
#if BAK_PARA_CHECK
|
|
atsc_para.bak_err_flag |= BAK_ERR_POWER;
|
|
#endif
|
|
}
|
|
if(ppara->power >atsc_para.ad3_para.max_power)
|
|
{
|
|
ppara->power = atsc_para.ad3_para.max_power;
|
|
|
|
#if BAK_PARA_CHECK
|
|
atsc_para.bak_err_flag |= BAK_ERR_POWER;
|
|
#endif
|
|
}
|
|
|
|
if(ppara->db>RF_POWER_DB_MAX) //65536/46=1424 -200~+100 1424-100=1324
|
|
{
|
|
if(atsc_para.wl_para.exc_5x==0)
|
|
{
|
|
ppara->db = DEFAULT_RF_POWER_DB_3X;
|
|
}
|
|
else
|
|
{
|
|
ppara->db = DEFAULT_RF_POWER_DB;
|
|
}
|
|
|
|
#if BAK_PARA_CHECK
|
|
atsc_para.bak_err_flag |= BAK_ERR_DB;
|
|
#endif
|
|
}
|
|
ppara->cw = c256_byteread(EEPROM_PARA_CW_ADDR);
|
|
ppara->rf = c256_byteread(EEPROM_RF_ADDR);
|
|
ppara->tx = c256_byteread(EEPROM_RF_TX);
|
|
if(ppara->tx>1)
|
|
{
|
|
ppara->tx = 0; //默认OFF
|
|
}
|
|
#if BAK_PARA_CHECK
|
|
bak_e2rom_read_rf(ppara);
|
|
#endif
|
|
}
|
|
void e2rom_read_network(S_NETWORK_PARA *ppara)
|
|
{
|
|
uint8 UC_temp;
|
|
|
|
UC_temp=c256_byteread(EEPROM_NET_DELAY_ADDR);
|
|
ppara->delay=(UC_temp<<16);
|
|
UC_temp =c256_byteread(EEPROM_NET_DELAY_ADDR+1);
|
|
ppara->delay+=(UC_temp<<8);
|
|
|
|
UC_temp =c256_byteread(EEPROM_NET_DELAY_ADDR+2);
|
|
ppara->delay+= UC_temp;
|
|
|
|
if(ppara->delay>NET_MAX_DELAY)
|
|
{
|
|
ppara->delay = 1;
|
|
c256_bytewrite(EEPROM_NET_DELAY_ADDR,0);
|
|
c256_bytewrite(EEPROM_NET_DELAY_ADDR+1,0);
|
|
c256_bytewrite(EEPROM_NET_DELAY_ADDR+2,1);
|
|
}
|
|
}
|
|
#if ATSC_USA_AMP
|
|
void e2rom_read_pa_config(S_PA_CONFIG_PARA *ppara)
|
|
{
|
|
uint8 *pchar;
|
|
uint8 UC_temp;
|
|
|
|
pchar =(uint8 *)&ppara->ip;
|
|
for(UC_temp=0; UC_temp<4; UC_temp++)
|
|
{
|
|
pchar[UC_temp] = c256_byteread(EEPROM_PA_IP4_ADDR+UC_temp) ;
|
|
}
|
|
|
|
pchar =(uint8 *)&ppara->gateway;
|
|
for(UC_temp=0; UC_temp<4; UC_temp++)
|
|
{
|
|
pchar[UC_temp] = c256_byteread(EEPROM_PA_GATEWAY_ADDR+UC_temp) ;
|
|
}
|
|
|
|
pchar =(uint8 *)&ppara->mask;
|
|
for(UC_temp=0; UC_temp<4; UC_temp++)
|
|
{
|
|
pchar[UC_temp] = c256_byteread(EEPROM_PA_NETMASK_ADDR+UC_temp) ;
|
|
}
|
|
|
|
if( (ppara->ip[1]==0xff)&&(ppara->ip[2]==0xff) ) //ldl 1-> (ppara->ip[1]==0xff)&&(ppara->ip[2]==0xff)
|
|
{
|
|
ppara->ip[0] = 192;
|
|
ppara->ip[1] = 168;
|
|
ppara->ip[2] = 1; //LDL 2->1 17-09-12
|
|
ppara->ip[3] = 210;
|
|
|
|
ppara->gateway[0] = 192;
|
|
ppara->gateway[1] = 168;
|
|
ppara->gateway[2] = 1;
|
|
ppara->gateway[3] = 1;
|
|
|
|
ppara->mask[0] = 255;
|
|
ppara->mask[1] = 255;
|
|
ppara->mask[2] = 255;
|
|
ppara->mask[3] = 0;
|
|
e2rom_save_pa_config(ppara);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
void e2rom_read_config(S_CONFIG_PARA *ppara)
|
|
{
|
|
uint8 *pchar;
|
|
uint8 UC_temp;
|
|
|
|
ppara->standard = STANDARD_ATSC;
|
|
|
|
ppara->bps = c256_byteread(EEPROM_BPS_ADDR) ;
|
|
if(ppara->bps>2)
|
|
{
|
|
ppara->bps = 2 ; //0:9600 1:19200 2:38400
|
|
c256_bytewrite(EEPROM_BPS_ADDR,2);
|
|
}
|
|
ppara->id = std_w[0] = std_r[0] = c256_byteread(EEPROM_ID_ADDR);
|
|
|
|
std_w[1]= std_r[1]= 0X46;
|
|
std_w[2]= 0X0A;
|
|
std_r[2]= 0X06;
|
|
|
|
pchar =(uint8 *)&ppara->ip;
|
|
for(UC_temp=0; UC_temp<4; UC_temp++)
|
|
{
|
|
pchar[UC_temp] = c256_byteread(EEPROM_IP4_ADDR+UC_temp);
|
|
}
|
|
|
|
pchar =(uint8 *)&ppara->gateway;
|
|
for(UC_temp=0; UC_temp<4; UC_temp++)
|
|
{
|
|
pchar[UC_temp] = c256_byteread(EEPROM_GATEWAY_ADDR+UC_temp);
|
|
}
|
|
|
|
pchar =(uint8 *)&ppara->mask;
|
|
for(UC_temp=0; UC_temp<4; UC_temp++)
|
|
{
|
|
pchar[UC_temp] = c256_byteread(EEPROM_NETMASK_ADDR+UC_temp);
|
|
}
|
|
|
|
pchar =(uint8 *)&ppara->dns;
|
|
for(UC_temp=0; UC_temp<4; UC_temp++)
|
|
{
|
|
//pchar[UC_temp] = c256_byteread(EEPROM_DNS_ADDR+UC_temp);
|
|
}
|
|
|
|
if((ppara->ip[1]==0xff)&&(ppara->ip[2]==0xff)) //ldl 1 -> (ppara->ip[1]==0xff)&&(ppara->ip[2]==0xff
|
|
{
|
|
ppara->ip[0] = 192;
|
|
ppara->ip[1] = 168;
|
|
ppara->ip[2] = 1; //LDL 2->1 17-09-12
|
|
ppara->ip[3] = 143;
|
|
|
|
ppara->gateway[0] = 192;
|
|
ppara->gateway[1] = 168;
|
|
ppara->gateway[2] = 1; //LDL 2->1 17-09-12
|
|
ppara->gateway[3] = 1;
|
|
|
|
ppara->dns[0] = 192;
|
|
ppara->dns[1] = 168;
|
|
ppara->dns[2] = 1; //
|
|
ppara->dns[3] = 1;
|
|
|
|
ppara->mask[0] = 255;
|
|
ppara->mask[1] = 255;
|
|
ppara->mask[2] = 255;
|
|
ppara->mask[3] = 0;
|
|
}
|
|
|
|
ppara->pa_link_ctrl_rf = c256_byteread(EEPROM_PA_LINK_CTRL_RF_ADDR) ;
|
|
if(ppara->pa_link_ctrl_rf>1){
|
|
ppara->pa_link_ctrl_rf = 0;
|
|
}
|
|
|
|
// eth0 admin interface
|
|
local_ip_change_admin(ppara);
|
|
|
|
}
|
|
|
|
void e2rom_read_mode(S_MODE_PARA *ppara)
|
|
{
|
|
ppara->sync = c256_byteread(EEPROM_MODE_SYNC);
|
|
ppara->sync &=1;
|
|
ppara->tcp_c= c256_byteread(EEPROM_MODE_TCP_C);
|
|
ppara->tcp_c&=1;
|
|
ppara->zp1f= c256_byteread(EEPROM_MODE_ZP1F);
|
|
ppara->zp1f&=1;
|
|
}
|
|
void e2rom_read_ad1(S_ADVANCE_PARA *ppara)
|
|
{
|
|
ppara->pcr = c256_byteread(EEPROM_PCR_ADDR);
|
|
ppara->slow_up = c256_byteread(EEPROM_SLOW_UP_ADDR);
|
|
ppara->slow_down= c256_byteread(EEPROM_SLOW_DOWN_ADDR);
|
|
ppara->swrt = c256_byteread_default(EEPROM_WH_ADDR+4, 0x03);
|
|
|
|
ppara->pcr = ppara->pcr>0x07 ?0:ppara->pcr; //默认值为0;
|
|
ppara->slow_up = ppara->slow_up>1 ?0:ppara->slow_up; //默认值为0;
|
|
ppara->slow_down = ppara->slow_down>1?0:ppara->slow_down; //默认值为0;
|
|
|
|
ppara->asiout= c256_byteread(EEPROM_ASIOUT_ADDR);
|
|
if(ppara->asiout>3)
|
|
{
|
|
ppara->asiout = 3; //默认auto
|
|
}
|
|
}
|
|
|
|
void e2rom_read_ad2(S_ADVANCE2_PARA *ppara)
|
|
{
|
|
ppara->m_ts = c256_byteread(EEPROM_M_TS_ADDR);
|
|
ppara->m_10m = c256_byteread(EEPROM_M_10M_ADDR);
|
|
ppara->m_1pps= c256_byteread(EEPROM_M_1PPS_ADDR);
|
|
ppara->m_dly_hh = c256_byteread(EEPROM_M_DLY_ADDR);
|
|
ppara->m_dly_mm = c256_byteread(EEPROM_M_DLY_ADDR_MM);
|
|
ppara->m_dly_ss = c256_byteread(EEPROM_M_DLY_ADDR_SS);
|
|
|
|
ppara->m_ts = ppara->m_ts>1 ?1:ppara->m_ts; //默认值为1;
|
|
ppara->m_10m = ppara->m_10m>1 ?1:ppara->m_10m; //默认值为1;
|
|
ppara->m_1pps = ppara->m_1pps>1 ?0:ppara->m_1pps; //默认值为0;
|
|
ppara->m_dly_hh = ppara->m_dly_hh>99 ?1:ppara->m_dly_hh; //默认值为1
|
|
ppara->m_dly_mm = ppara->m_dly_mm>59 ?0:ppara->m_dly_mm; //默认值0
|
|
ppara->m_dly_ss = ppara->m_dly_ss>59 ?0:ppara->m_dly_ss; //默认值0
|
|
if((ppara->m_dly_ss<4)&&(ppara->m_dly_hh==0)&&(ppara->m_dly_mm==0))
|
|
{
|
|
ppara->m_dly_ss=4;
|
|
}
|
|
}
|
|
|
|
//5000专用的功率归一化函数,客户菜单功率变为-25,同时,输出功率要相对于原先功率有一个差值降低
|
|
static void power_db_normalization_5000(void)
|
|
{
|
|
uint32 UI_temp = 0;
|
|
|
|
//客户菜单归一化为0,现在归一化为-25,同时db值减小相应的值
|
|
UI_temp = atsc_para.rf_para.power;
|
|
if(atsc_para.rf_para.db>UI_temp)
|
|
{
|
|
atsc_para.rf_para.db -= UI_temp;
|
|
}
|
|
else
|
|
{
|
|
atsc_para.rf_para.db = 0;
|
|
}
|
|
atsc_para.rf_para.power = 0;
|
|
}
|
|
|
|
|
|
void e2rom_read_ad3(S_ADVANCE3_PARA *ppara)
|
|
{
|
|
ppara->rc_cmd = c256_byteread(EEPROM_AD3_RC_CMD);
|
|
ppara->fwd_cal = c256_byteread(EEPROM_AD3_FWD_CAL);
|
|
ppara->cor = c256_byteread(EEPROM_AD3_TYPE);
|
|
ppara->fwd_cal_dly=0;
|
|
ppara->cw = c256_byteread(EEPROM_PARA_CW_ADDR);
|
|
|
|
if(ppara->rc_cmd > 1)
|
|
ppara->rc_cmd = 1;
|
|
|
|
if(ppara->fwd_cal > 1)
|
|
ppara->fwd_cal = 1;
|
|
|
|
if(ppara->cor > 1)
|
|
ppara->cor = 0;
|
|
|
|
#if AW_ATSC_5X
|
|
ppara->cor=0;
|
|
#endif
|
|
|
|
#if USE_DRY_LOOP
|
|
if(ppara->cor==0)
|
|
ppara->power_ref= (c256_byteread(EEPROM_AD3_POWER_REF_H)<<8)|c256_byteread(EEPROM_AD3_POWER_REF_L);
|
|
else
|
|
ppara->power_ref= (c256_byteread2(E2_AD3_POWER_REF_H)<<8)|c256_byteread2(E2_AD3_POWER_REF_L);
|
|
#else
|
|
ppara->cor =0;
|
|
ppara->power_ref= (c256_byteread(EEPROM_AD3_POWER_REF_H)<<8)|c256_byteread(EEPROM_AD3_POWER_REF_L);
|
|
#endif
|
|
|
|
ppara->max_power = (c256_byteread(EEPROM_AD3_MAX_PWR_H)<<8)|c256_byteread(EEPROM_AD3_MAX_PWR_L);
|
|
if(ppara->max_power>RF_POWER_P_C_ON)
|
|
{
|
|
ppara->max_power = AD_MAX_POWER_DEFAULT;
|
|
}
|
|
|
|
#if USE_NEW_DIO_MODE
|
|
ppara->mptv = c256_byteread(EEPROM_AD3_MPTV);
|
|
if(ppara->mptv>1)
|
|
ppara->mptv = 0;
|
|
#endif
|
|
|
|
/* PR13: 读回 FWD cal 分别记录的 FAGC 控制字与 ORx 数字功率(0.5dB步数)。
|
|
旧配置文件缺少这两个 reg 项时, c256_byteread 对应 ini_getl 缺省值
|
|
DEF_REG_PARA(0xff), 单字节/双字节缺省合成正好是 0xFF/0xFFFF, 与
|
|
未标定判据天然一致, 无需额外的迁移代码。 */
|
|
ppara->cal_fagc_cw = c256_byteread(EEPROM_AD3_CAL_FAGC_CW);
|
|
ppara->cal_orx_pwr_hdb = (c256_byteread(EEPROM_AD3_CAL_ORX_PWR_H)<<8)|c256_byteread(EEPROM_AD3_CAL_ORX_PWR_L);
|
|
}
|
|
|
|
void e2rom_read_ad4(S_ADVANCE4_PARA *ppara)
|
|
{
|
|
ppara->pdt=c256_byteread(EEPROM_WF_ADDR+OFFSET_OF_STRUCT(S_WF_PARA,pdt));
|
|
atsc_para.wf_para.pdt = ppara->pdt;
|
|
|
|
/*ppara->cfr=c256_byteread(EEPROM_WB_ADDR+OFFSET_OF_STRUCT(S_WB_PARA,cfr));
|
|
atsc_para.wb_para.cfr = ppara->cfr;*/
|
|
|
|
ppara->adpc=c256_byteread(EEPROM_DPD_ADDR);
|
|
}
|
|
void e2rom_read_ad5(S_ADVANCE5_PARA *ppara)
|
|
{
|
|
ppara->time=c256_byteread(EEPROM_AD5_TIME_ADDR);
|
|
ppara->a_snr=c256_byteread(EEPROM_AD5_TSNR_ADDR);
|
|
ppara->a_imd =c256_byteread(EEPROM_AD5_IMD_ADDR);
|
|
ppara->r_snr=c256_byteread(EEPROM_AD5_RSNR_ADDR);
|
|
ppara->r_imd =c256_byteread(EEPROM_AD5_RIMD_ADDR);
|
|
ppara->dpd= c256_byteread(EEPROM_AD5_DPD_ADDR);
|
|
|
|
ppara->time = ppara->time>MAX_AUTO_UPDATE_TIME?0:ppara->time;
|
|
ppara->a_snr = ppara->a_snr>99?A_SNR_DEFAUTL:ppara->a_snr;
|
|
ppara->a_imd = ppara->a_imd>99?A_IMD_DEFAULT:ppara->a_imd;
|
|
ppara->r_snr = ppara->r_snr>99?R_SNR_DEFAULT:ppara->r_snr;
|
|
ppara->r_imd = ppara->r_imd>99?R_IMD_DEFAULT:ppara->r_imd;
|
|
ppara->c_t = ppara->time;
|
|
|
|
if((ppara->dpd>3)||(ppara->dpd==0))
|
|
ppara->dpd= 1; //默认NEW
|
|
|
|
ppara->use_dpd = ppara->dpd;
|
|
|
|
printf("e2prom read a_snr=%d a_imd=%d r_snr=%d r_imd=%d dpd=%d c_t=%d\n",
|
|
ppara->a_snr, ppara->a_imd, ppara->r_snr, ppara->r_imd, ppara->dpd, ppara->c_t);
|
|
}
|
|
|
|
int check_and_restore_config(char *pname, char *ppasswd) {
|
|
|
|
FILE *fp = fopen(CFG_USR_NAME_PASSWD_FILE, "r");
|
|
char name[MAX_CFG_LEN + 1] = {0};
|
|
char pass[MAX_CFG_LEN + 1] = {0};
|
|
int match = 0;
|
|
|
|
if (fp != NULL) {
|
|
if (fscanf(fp, "%16[^:]:%16s", name, pass) == 2) {
|
|
if (strcmp(name, pname) == 0 && strcmp(pass, ppasswd) == 0) {
|
|
match = 1;
|
|
}
|
|
}
|
|
fclose(fp);
|
|
}
|
|
|
|
if (match) {
|
|
printf("check match usr_name&passwd\n");
|
|
return 0;
|
|
} else {
|
|
printf("force usr_name&passwd\n");
|
|
|
|
fp = fopen(CFG_USR_NAME_PASSWD_FILE, "w");
|
|
if (fp == NULL) {
|
|
perror("Failed to open file for writing");
|
|
return -1;
|
|
}
|
|
|
|
fprintf(fp, "%s:%s", pname, ppasswd);
|
|
fclose(fp);
|
|
|
|
system("sync");
|
|
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
void user_info_reset(void)
|
|
{
|
|
memset(atsc_para.reg_user_info,0,sizeof(atsc_para.reg_user_info));
|
|
#if USA_ATSC_5X
|
|
atsc_para.reg_user_info[0].user_type = LOGIN_ADMIN;
|
|
memcpy(atsc_para.reg_user_info[0].name,"root",sizeof("root"));
|
|
memcpy(atsc_para.reg_user_info[0].password,"adv314pi",sizeof("adv314pi")); //默认密码
|
|
|
|
atsc_para.reg_user_info[1].user_type = LOGIN_NORMAL;
|
|
memcpy(atsc_para.reg_user_info[1].name,"admin",sizeof("admin"));
|
|
memcpy(atsc_para.reg_user_info[1].password,"public",sizeof("public"));
|
|
#else
|
|
atsc_para.reg_user_info[0].user_type = LOGIN_ADMIN;
|
|
memcpy(atsc_para.reg_user_info[0].name,"anywavecom",sizeof("anywavecom"));
|
|
memcpy(atsc_para.reg_user_info[0].password,"anywavecom",sizeof("anywavecom"));
|
|
|
|
atsc_para.reg_user_info[1].user_type = LOGIN_NORMAL;
|
|
memcpy(atsc_para.reg_user_info[1].name,"guest",sizeof("guest"));
|
|
memcpy(atsc_para.reg_user_info[1].password,"guest",sizeof("guest"));
|
|
|
|
atsc_para.reg_user_info[2].user_type = LOGIN_ADMIN;
|
|
memcpy(atsc_para.reg_user_info[2].name,"AWCOM",sizeof("AWCOM"));
|
|
memcpy(atsc_para.reg_user_info[2].password,"Sh123456",sizeof("Sh123456"));
|
|
#endif
|
|
|
|
atsc_para.reg_user_info[3].user_type = LOGIN_ENGINEER;
|
|
memcpy(atsc_para.reg_user_info[3].name,"anywave_e",sizeof("anywave_e"));
|
|
memcpy(atsc_para.reg_user_info[3].password,"anywave_e",sizeof("anywave_e"));
|
|
|
|
e2rom_save_user_info(&atsc_para.reg_user_info[0]);
|
|
|
|
check_and_restore_config(atsc_para.reg_user_info[0].name, atsc_para.reg_user_info[0].password);
|
|
}
|
|
|
|
void e2rom_read_user_info(S_USER_INFO *ppara)
|
|
{
|
|
uint32 i;
|
|
uint32 rst_flag = 0;
|
|
uint8 data = c256_byteread(EEPROM_USER_INFO_MAGIC);
|
|
|
|
if(data!=0x79)
|
|
{
|
|
user_info_reset();
|
|
c256_bytewrite(EEPROM_USER_INFO_MAGIC,0x79);
|
|
return;
|
|
}
|
|
|
|
ppara->user_type = c256_byteread(EEPROM_USER_INFO);
|
|
for(i=0;i<sizeof(ppara->name);i++)
|
|
{
|
|
ppara->name[i] = c256_byteread(EEPROM_USER_INFO_NM+i);
|
|
}
|
|
for(i=0;i<sizeof(ppara->password);i++)
|
|
{
|
|
ppara->password[i] = c256_byteread(EEPROM_USER_INFO_PW+i);
|
|
}
|
|
|
|
#if USA_ATSC_5X
|
|
if(ppara[0].user_type!=LOGIN_ADMIN)
|
|
{
|
|
rst_flag = 1;
|
|
ppara[0].user_type = LOGIN_ADMIN;
|
|
memcpy(ppara[0].name,"root",sizeof("root"));
|
|
memcpy(ppara[0].password,"adv314pi",sizeof("adv314pi")); //默认密码
|
|
}
|
|
|
|
ppara[1].user_type = LOGIN_NORMAL;
|
|
memcpy(ppara[1].name,"admin",sizeof("admin"));
|
|
memcpy(ppara[1].password,"public",sizeof("public"));
|
|
|
|
#else
|
|
if(ppara[0].user_type!=LOGIN_ADMIN)
|
|
{
|
|
rst_flag = 1;
|
|
ppara[0].user_type = LOGIN_ADMIN;
|
|
memcpy(ppara[0].name,"anywavecom",sizeof("anywavecom"));
|
|
memcpy(ppara[0].password,"anywavecom",sizeof("anywavecom"));
|
|
}
|
|
|
|
ppara[1].user_type = LOGIN_NORMAL;
|
|
memcpy(ppara[1].name,"guest",sizeof("guest"));
|
|
memcpy(ppara[1].password,"guest",sizeof("guest"));
|
|
|
|
ppara[2].user_type = LOGIN_ADMIN;
|
|
memcpy(ppara[2].name,"AWCOM",sizeof("AWCOM"));
|
|
memcpy(ppara[2].password,"Sh123456",sizeof("Sh123456"));
|
|
#endif
|
|
|
|
//LOGIN_ENGINEER
|
|
ppara[3].user_type = LOGIN_ENGINEER;
|
|
memcpy(ppara[3].name,"anywave_e",sizeof("anywave_e"));
|
|
memcpy(ppara[3].password,"anywave_e",sizeof("anywave_e"));
|
|
|
|
//检查用户名和密码,正常字符最后是否有空格
|
|
if(!rst_flag)
|
|
{
|
|
#if 1//_USE_RVL_
|
|
str_trunc_space(ppara[0].name);
|
|
str_trunc_space(ppara[0].password);
|
|
#endif
|
|
}
|
|
|
|
check_and_restore_config(ppara[0].name, ppara[0].password);
|
|
}
|
|
|
|
|
|
|
|
void e2rom_read_latch(S_LATCH_PARA *ppara)
|
|
{
|
|
|
|
}
|
|
void e2rom_read_sn(S_SN_PARA *ppara)
|
|
{
|
|
#if 1//_USE_RVL_
|
|
|
|
uint64 temp1=0;
|
|
uint32 temp2=0;
|
|
|
|
#if USE_SPECT_DATA_TASK
|
|
|
|
temp1=c256_byteread(EEPROM_SN_H2);
|
|
if(temp1>=0x09)
|
|
temp1=0x09;
|
|
temp1 = temp1<<8;
|
|
temp1 |= c256_byteread(EEPROM_SN_H1);
|
|
temp1 = temp1<<8;
|
|
temp1 |= c256_byteread(EEPROM_SN_L4);
|
|
temp1 = temp1<<8;
|
|
temp1 |= c256_byteread(EEPROM_SN_L3);
|
|
temp1 = temp1<<8;
|
|
temp1 |= c256_byteread(EEPROM_SN_L2);
|
|
temp1 = temp1<<8;
|
|
temp1 |= c256_byteread(EEPROM_SN_L1);
|
|
ppara->sn = temp1;
|
|
|
|
if((ppara->sn&0x09ffffffffff) == (0x09ffffffffff))
|
|
{
|
|
ppara->sn= 0;
|
|
c256_bytewrite(EEPROM_SN_H2,0);
|
|
c256_bytewrite(EEPROM_SN_H1,0);
|
|
c256_bytewrite(EEPROM_SN_L4,0);
|
|
c256_bytewrite(EEPROM_SN_L3,0);
|
|
c256_bytewrite(EEPROM_SN_L2,0);
|
|
c256_bytewrite(EEPROM_SN_L1,0);
|
|
}
|
|
temp2=c256_byteread(EEPROM_KEY_H2);
|
|
temp2 = temp2<<8;
|
|
temp2 |= c256_byteread(EEPROM_KEY_H1);
|
|
temp2 = temp2<<8;
|
|
temp2 |= c256_byteread(EEPROM_KEY_L2);
|
|
temp2=temp2<<8;
|
|
temp2 |= c256_byteread(EEPROM_KEY_L1);
|
|
ppara->gui_key = temp2;
|
|
|
|
if(ppara->gui_key == 0xffffffff)
|
|
{
|
|
ppara->gui_key = 0;
|
|
c256_bytewrite(EEPROM_KEY_H2,0);
|
|
c256_bytewrite(EEPROM_KEY_H1,0);
|
|
c256_bytewrite(EEPROM_KEY_L2,0);
|
|
c256_bytewrite(EEPROM_KEY_L1,0);
|
|
}
|
|
|
|
tcp_spect_calc_sn_licence(ppara->gui_key,&ppara->sn);
|
|
#endif
|
|
|
|
temp2=c256_byteread(EEPROM_PSIP_KEY_H2);
|
|
temp2 = temp2<<8;
|
|
temp2 |= c256_byteread(EEPROM_PSIP_KEY_H1);
|
|
temp2 = temp2<<8;
|
|
temp2 |= c256_byteread(EEPROM_PSIP_KEY_L2);
|
|
temp2=temp2<<8;
|
|
temp2 |= c256_byteread(EEPROM_PSIP_KEY_L1);
|
|
ppara->psip_key = temp2;
|
|
|
|
temp2 = c256_byteread(EEPROM_PSIP_KEY_MAGIC);
|
|
if((ppara->psip_key == (uint32)-1)||(temp2!=0xa3))
|
|
{
|
|
ppara->psip_key = 0;
|
|
c256_bytewrite(EEPROM_PSIP_KEY_H2,0);
|
|
c256_bytewrite(EEPROM_PSIP_KEY_H1,0);
|
|
c256_bytewrite(EEPROM_PSIP_KEY_L2,0);
|
|
c256_bytewrite(EEPROM_PSIP_KEY_L1,0);
|
|
|
|
c256_bytewrite(EEPROM_PSIP_KEY_MAGIC,0xa3); //防止升级时,key未初始化
|
|
}
|
|
ppara->psip_key_valid = psip_calc_sn_licence(ppara->psip_key,&ppara->sn);
|
|
|
|
|
|
temp2=c256_byteread(EEPROM_EAS_KEY1);
|
|
temp2 = temp2<<8;
|
|
temp2 |= c256_byteread(EEPROM_EAS_KEY2);
|
|
temp2 = temp2<<8;
|
|
temp2 |= c256_byteread(EEPROM_EAS_KEY3);
|
|
temp2=temp2<<8;
|
|
temp2 |= c256_byteread(EEPROM_EAS_KEY4);
|
|
ppara->eas_key = temp2;
|
|
|
|
temp2 = c256_byteread(EEPROM_EAS_KEY_MAGIC);
|
|
if((ppara->eas_key == (uint32)-1)||(temp2!=0xa3))
|
|
{
|
|
ppara->eas_key = 0;
|
|
c256_bytewrite(EEPROM_EAS_KEY1,0);
|
|
c256_bytewrite(EEPROM_EAS_KEY2,0);
|
|
c256_bytewrite(EEPROM_EAS_KEY3,0);
|
|
c256_bytewrite(EEPROM_EAS_KEY4,0);
|
|
c256_bytewrite(EEPROM_EAS_KEY_MAGIC,0xa3); //防止升级时,key未初始化
|
|
}
|
|
ppara->eas_key_valid = eas_calc_sn_licence(ppara->eas_key,&ppara->sn);
|
|
#endif
|
|
}
|
|
|
|
void e2rom_read_wb(S_WB_PARA *ppara)
|
|
{
|
|
uint8 *pchar;
|
|
uint32 i;
|
|
|
|
pchar =(uint8 *)ppara;
|
|
for(i=0; i<sizeof(S_WB_PARA)-1; i++)
|
|
{
|
|
pchar[i] = c256_byteread(EEPROM_WB_ADDR+i);
|
|
}
|
|
|
|
if(ppara->alarm>3)
|
|
{
|
|
ppara->alarm = 0;
|
|
}
|
|
ppara->rst = 0;
|
|
}
|
|
void e2rom_read_wc(S_WC_PARA *ppara)
|
|
{
|
|
uint8 *pchar;
|
|
uint32 i;
|
|
|
|
pchar =(uint8 *)ppara;
|
|
for(i=0; i<sizeof(S_WC_PARA); i++)
|
|
{
|
|
pchar[i] = c256_byteread(EEPROM_WC_ADDR+i);
|
|
}
|
|
}
|
|
|
|
void e2rom_read_wd(S_WD_PARA *ppara)
|
|
{
|
|
uint8 *pchar;
|
|
uint32 i;
|
|
|
|
pchar =(uint8 *)ppara;
|
|
for(i=0; i<sizeof(S_WD_PARA); i++)
|
|
{
|
|
pchar[i] = c256_byteread(EEPROM_WD_ADDR+i);
|
|
}
|
|
|
|
if(ppara->cfr_work>1)
|
|
ppara->cfr_work = 0;
|
|
|
|
#if USE_SNR_ADJ
|
|
if(c256_byteread(EEPROM_WD_SPE_ADDR)!=KOREA_WD_SPE_VALUE)
|
|
{
|
|
atsc_para.wd_para.sa = 0;
|
|
atsc_para.wd_para.sb = 0;
|
|
atsc_para.wd_para.sc = 0;
|
|
atsc_para.wd_para.sd = 0;
|
|
pchar =(uint8 *)&atsc_para.wd_para;
|
|
for(i=0; i<sizeof(S_WD_PARA); i++)
|
|
{
|
|
c256_bytewrite(EEPROM_WD_ADDR+i,pchar[i]);
|
|
}
|
|
c256_bytewrite(EEPROM_WD_SPE_ADDR,KOREA_WD_SPE_VALUE);
|
|
}
|
|
else
|
|
{
|
|
if(abs(atsc_para.wd_para.sa)>KOREA_SNR_ADJ_MAX)
|
|
{
|
|
atsc_para.wd_para.sa = 0;
|
|
}
|
|
if(abs(atsc_para.wd_para.sb)>KOREA_SNR_ADJ_MAX)
|
|
{
|
|
atsc_para.wd_para.sb = 0;
|
|
}
|
|
if(abs(atsc_para.wd_para.sc)>KOREA_SNR_ADJ_MAX)
|
|
{
|
|
atsc_para.wd_para.sc = 0;
|
|
}
|
|
if(abs(atsc_para.wd_para.sd)>KOREA_SNR_ADJ_MAX)
|
|
{
|
|
atsc_para.wd_para.sd = 0;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
static void e2rom_fac_power_rst_5x(void)
|
|
{
|
|
uint32 i=0;
|
|
uint16 power;
|
|
|
|
for(i=FREQ_MIN_V1; i<=FREQ_MAX_V3; i++)
|
|
{
|
|
power = value_power(we_power_v[i-FREQ_MIN_V1]);
|
|
c256_bytewrite(EEPROM_CH1_POWER_ADDR+i*2+0,power>>8);
|
|
c256_bytewrite(EEPROM_CH1_POWER_ADDR+i*2+1,power);
|
|
}
|
|
|
|
for(i=FREQ_MIN_U; i<=FREQ_MAX_U; i++)
|
|
{
|
|
power = value_power(we_power[i-FREQ_MIN_U]);
|
|
c256_bytewrite(EEPROM_CH1_POWER_ADDR+i*2+0,power>>8);
|
|
c256_bytewrite(EEPROM_CH1_POWER_ADDR+i*2+1,power);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static void e2rom_fac_power_rst_3x(void)
|
|
{
|
|
uint32 i=0;
|
|
uint16 power;
|
|
|
|
for(i=FREQ_MIN_V1; i<=FREQ_MAX_V3; i++)
|
|
{
|
|
power = value_power(we_power_v_3x[i-FREQ_MIN_V1]);
|
|
c256_bytewrite(EEPROM_CH2_POWER_ADDR+i*2+0,power>>8);
|
|
c256_bytewrite(EEPROM_CH2_POWER_ADDR+i*2+1,power);
|
|
}
|
|
|
|
for(i=FREQ_MIN_U; i<=FREQ_MAX_U; i++)
|
|
{
|
|
power = value_power(we_power_3x[i-FREQ_MIN_U]);
|
|
c256_bytewrite(EEPROM_CH2_POWER_ADDR+i*2+0,power>>8);
|
|
c256_bytewrite(EEPROM_CH2_POWER_ADDR+i*2+1,power);
|
|
}
|
|
}
|
|
|
|
static uint16 e2rom_read_fac_power_default_3x(uint32 chn)
|
|
{
|
|
uint16 power;
|
|
|
|
if((chn>=FREQ_MIN_V1)&&(chn<=FREQ_MAX_V3))
|
|
{
|
|
power = value_power(we_power_v_3x[chn-FREQ_MIN_V1]);
|
|
|
|
c256_bytewrite(EEPROM_CH2_POWER_ADDR+chn*2+0,power>>8);
|
|
c256_bytewrite(EEPROM_CH2_POWER_ADDR+chn*2+1,power);
|
|
}
|
|
else if((chn>=FREQ_MIN_U)&&(chn<=FREQ_MAX_U))
|
|
{
|
|
power = value_power(we_power_3x[chn-FREQ_MIN_U]);
|
|
c256_bytewrite(EEPROM_CH2_POWER_ADDR+chn*2+0,power>>8);
|
|
c256_bytewrite(EEPROM_CH2_POWER_ADDR+chn*2+1,power);
|
|
}
|
|
else
|
|
{
|
|
power = WE_POWER_ZERO;
|
|
}
|
|
return power;
|
|
}
|
|
|
|
static uint16 e2rom_read_fac_power_default_5x(uint32 chn)
|
|
{
|
|
uint16 power;
|
|
|
|
if((chn>=FREQ_MIN_V1)&&(chn<=FREQ_MAX_V3))
|
|
{
|
|
power = value_power(we_power_v[chn-FREQ_MIN_V1]);
|
|
c256_bytewrite(EEPROM_CH1_POWER_ADDR+chn*2+0,power>>8);
|
|
c256_bytewrite(EEPROM_CH1_POWER_ADDR+chn*2+1,power);
|
|
}
|
|
else if((chn>=FREQ_MIN_U)&&(chn<=FREQ_MAX_U))
|
|
{
|
|
power = value_power(we_power[chn-FREQ_MIN_U]);
|
|
c256_bytewrite(EEPROM_CH1_POWER_ADDR+chn*2+0,power>>8);
|
|
c256_bytewrite(EEPROM_CH1_POWER_ADDR+chn*2+1,power);
|
|
}
|
|
else
|
|
{
|
|
power = WE_POWER_ZERO;
|
|
}
|
|
return power;
|
|
}
|
|
|
|
void e2rom_read_we(S_WE_PARA *ppara)
|
|
{
|
|
uint8 *pchar;
|
|
uint32 i;
|
|
pchar =(uint8 *)ppara;
|
|
|
|
for(i=0;i<sizeof(S_WE_PARA); i++)
|
|
{
|
|
*pchar++ = c256_byteread(EEPROM_WE_ADDR+i);
|
|
}
|
|
|
|
ppara->ch= atsc_para.rf_para.txfreq; //freq
|
|
e2rom_read_leak(ppara->ch,ppara); //power
|
|
|
|
if((ppara->snc>0xf) && (ppara->ltn>0xf) && (ppara->dsc>0xf))
|
|
{
|
|
//ppara->fsc = 0x80;
|
|
ppara->dpgh=40;
|
|
ppara->dpgm=30;
|
|
ppara->dpgl=80;
|
|
}
|
|
|
|
if(ppara->ltn>0xf)
|
|
ppara->ltn=0x1;
|
|
if(ppara->dsc>0xf)
|
|
ppara->dsc=0x7;
|
|
if(ppara->snc>0xf)
|
|
ppara->snc=0x5;
|
|
if(ppara->sp>4)
|
|
ppara->sp=0;
|
|
}
|
|
|
|
void e2rom_read_wf(S_WF_PARA *ppara)
|
|
{
|
|
uint8 *pchar;
|
|
uint32 i;
|
|
|
|
pchar =(uint8 *)ppara;
|
|
for(i=0; i<sizeof(S_WF_PARA); i++)
|
|
{
|
|
pchar[i] = c256_byteread(EEPROM_WF_ADDR + i);
|
|
}
|
|
}
|
|
void e2rom_read_wh(S_WH_PARA *ppara)
|
|
{
|
|
uint8 *pchar;
|
|
uint32 i;
|
|
|
|
pchar =(uint8 *)ppara;
|
|
for(i=0; i<sizeof(S_WH_PARA) ; i++)
|
|
{
|
|
pchar[i] = c256_byteread(EEPROM_WH_ADDR + i);
|
|
}
|
|
|
|
ppara->ball = c256_byteread_default(EEPROM_WH_ADDR+5, 0x80);
|
|
|
|
#if USE_DRY_LOOP
|
|
if(ppara->func > 1)
|
|
ppara->func = 1;
|
|
#else
|
|
ppara->func = 1;
|
|
#endif
|
|
|
|
#if AW_ATSC_5X //全波版本强制为EX模式
|
|
ppara->func = 1;
|
|
#endif
|
|
atsc_para.ad_para.pac = ppara->pac;
|
|
|
|
if(ppara->chip>1)
|
|
ppara->chip = 0;
|
|
|
|
printf("1.temp_unit=%d\n", ppara->temp_unit);
|
|
|
|
if(ppara->temp_unit>1)
|
|
ppara->temp_unit = 1;
|
|
|
|
printf("2.temp_unit=%d\n", ppara->temp_unit);
|
|
}
|
|
|
|
void e2rom_read_wk(S_WK_PARA *ppara)
|
|
{
|
|
uint32 i = 0;
|
|
uint32 ip = 0;
|
|
uint8 *pchar = (uint8 *)ppara;
|
|
|
|
for(i=0; i<sizeof(S_WK_PARA)-sizeof(ppara->mac); i++)
|
|
{
|
|
*pchar++ = c256_byteread(EEPROM_WK_ADDR + i);
|
|
}
|
|
|
|
IP_DATA(ip,ppara->alarm_ip[0],ppara->alarm_ip[1],ppara->alarm_ip[2],ppara->alarm_ip[3]);
|
|
if((ip==0)||(ip==(uint32)-1))
|
|
{
|
|
ppara->alarm_ip[0] = 192;
|
|
ppara->alarm_ip[1] = 168;
|
|
ppara->alarm_ip[2] = 1;
|
|
ppara->alarm_ip[3] = 100;
|
|
for(i=0;i<sizeof(ppara->alarm_ip);i++)
|
|
{
|
|
c256_bytewrite(EEPROM_WK_ADDR+OFFSET_OF_STRUCT(S_WK_PARA,alarm_ip[i]),ppara->alarm_ip[i]);
|
|
}
|
|
}
|
|
if(ppara->ss>1)
|
|
ppara->ss = 0;
|
|
#if AW_ATSC_5X
|
|
ppara->ss = 0;
|
|
#endif
|
|
|
|
|
|
// c256_bytewrite(EEPROM_NET_MAC_H, ppara->mac[0]&0xff);
|
|
// c256_bytewrite(EEPROM_NET_MAC_M, ppara->mac[1]&0xff);
|
|
// c256_bytewrite(EEPROM_NET_MAC_L, ppara->mac[2]&0xff);
|
|
|
|
getMacByName("eth0", &ppara->mac[0]);
|
|
|
|
}
|
|
|
|
void e2rom_read_wl(S_WL_PARA *ppara)
|
|
{
|
|
uint8 *pchar;
|
|
uint32 i;
|
|
|
|
pchar =(uint8 *)ppara;
|
|
for(i=0; i<sizeof(S_WL_PARA); i++)
|
|
{
|
|
pchar[i] = c256_byteread(EEPROM_WL_ADDR+i);
|
|
}
|
|
|
|
if(ppara->band >2)
|
|
ppara->band= 0;
|
|
|
|
if(ppara->exc_5x>1)
|
|
{
|
|
ppara->exc_5x = 1;
|
|
}
|
|
ppara->spe = 0;
|
|
ppara->s_p = 0;
|
|
ppara->l_p = 0;
|
|
|
|
//roll_off_sel
|
|
if(ppara->roll_off_sel>1)
|
|
{
|
|
ppara->roll_off_sel = 1;
|
|
}
|
|
|
|
//spec_shift
|
|
if(ppara->spec_shift>1)
|
|
{
|
|
ppara->spec_shift = 1;
|
|
}
|
|
}
|
|
|
|
extern uint16 amp_sat_th2sqr_th(uint16 sat);
|
|
|
|
static void e2rom_read_dpd_para(S_DPD_PARA *ppara)
|
|
{
|
|
ppara->distortion_sw = c256_byteread(EEPROM_DPD_DISTORTION_SW);
|
|
if(ppara->distortion_sw>INTER_DISTORTION_SW_MAX)
|
|
ppara->distortion_sw = 0;
|
|
|
|
ppara->agc_pwr = c256_byteread(EEPROM_DPD_AGC_PWR_L)|(c256_byteread(EEPROM_DPD_AGC_PWR_H)<<8);
|
|
if(ppara->agc_pwr !=256){//h20201210固化为256
|
|
ppara->agc_pwr = 256;
|
|
c256_bytewrite(EEPROM_DPD_AGC_PWR_L,ppara->agc_pwr&0xff);
|
|
c256_bytewrite(EEPROM_DPD_AGC_PWR_H,(ppara->agc_pwr>>8)&0xff);
|
|
}
|
|
|
|
ppara->err_th = c256_byteread(EEPROM_DPD_ERR_TH_L)|(c256_byteread(EEPROM_DPD_ERR_TH_H)<<8);
|
|
ppara->err_cnt_th = c256_byteread(EEPROM_DPD_ERR_CNT_TH);
|
|
|
|
ppara->amp_sat = c256_byteread(EEPROM_DPD_AMP_SAT_TH_L)|(c256_byteread(EEPROM_DPD_AMP_SAT_TH_H)<<8);
|
|
if(ppara->amp_sat>FPGA_AMP_SAT_MAX){
|
|
ppara->amp_sat = FPGA_AMP_SAT_DEF;
|
|
}
|
|
|
|
ppara->amp_sat_sqr= amp_sat_th2sqr_th(ppara->amp_sat);
|
|
|
|
ppara->dpd_test = c256_byteread(EEPROM_DPD_TEST_L)|(c256_byteread(EEPROM_DPD_TEST_H)<<8);
|
|
|
|
ppara->dpd_mode = c256_byteread(EEPROM_DPD_STEP);
|
|
ppara->dpd_mode = ppara->dpd_mode&0x01;
|
|
|
|
ppara->phase6_minute = c256_byteread(EEPROM_DPD_PHASE6_MINUTE);
|
|
if(ppara->phase6_minute > 20)
|
|
ppara->phase6_minute = 2;
|
|
|
|
ppara->wpp_th = c256_byteread(EEPROM_DPD_WPP_TH_L)|(c256_byteread(EEPROM_DPD_WPP_TH_H)<<8);
|
|
//gl default val 0x0370
|
|
ppara->gl = c256_byteread_default(EEPROM_DPD_GAIN_LIMIT_H, 0x03)<<8 | c256_byteread_default(EEPROM_DPD_GAIN_LIMIT_L, 0x70);
|
|
|
|
ppara->dpd_ctl = c256_byteread_default(EEPROM_DPD_CTL_TST, 0x03);
|
|
}
|
|
|
|
|
|
void e2rom_read_wj(S_WJ_PARA *ppara)
|
|
{
|
|
uint8 *pchar;
|
|
uint32 i;
|
|
|
|
pchar =(uint8 *)ppara;
|
|
for(i=0; i<sizeof(S_WJ_PARA); i++)
|
|
{
|
|
pchar[i] = c256_byteread(EEPROM_WJ_ADDR+i);
|
|
}
|
|
|
|
if(math_abs(ppara->gmt)>12)
|
|
ppara->gmt = 0;
|
|
if(ppara->p_c>1)
|
|
ppara->p_c= 1;
|
|
|
|
if(ppara->rf_dly>10)
|
|
ppara->rf_dly = 2;
|
|
|
|
if(ppara->picture>1)
|
|
ppara->picture = 0;
|
|
|
|
if(ppara->ctl_dpd!=E_DPD_SAVE_NFLITER && ppara->ctl_dpd!=E_DPD_SAVE_FLITER
|
|
&& ppara->ctl_dpd!=E_DPD_NSAVE_NFLITER && ppara->ctl_dpd!=E_DPD_NSAVE_FLITER )
|
|
ppara->ctl_dpd = E_DPD_SAVE_FLITER;
|
|
|
|
if(ppara->ph10_time>40 || ppara->ph10_time<1)
|
|
ppara->ph10_time = 5;
|
|
}
|
|
|
|
void e2rom_read_ri(S_RI_PARA *ppara)
|
|
{
|
|
uint8 *pchar = (uint8 *)ppara;
|
|
uint32 i = 0;
|
|
|
|
for(i=0; i<sizeof(S_RI_PARA); i++)
|
|
{
|
|
pchar[i] = c256_byteread(EEPROM_RI_ADDR + i);
|
|
}
|
|
|
|
if((ppara->m_snr==0)||(ppara->m_snr==0xff))
|
|
ppara->m_snr = atsc_para.ad5_para.a_snr;
|
|
if((ppara->m_imd==0)||(ppara->m_imd==0xff))
|
|
ppara->m_imd = atsc_para.ad5_para.a_imd;
|
|
#if 0//@TMP_NOT_USED cttb disable
|
|
ppara->rst_time = sys_get_rst_time();
|
|
#endif
|
|
}
|
|
|
|
void e2rom_read_power_db(uint32 cor)
|
|
{
|
|
uint8 UC_temp = 0;
|
|
|
|
atsc_para.rf_para.power = 0;
|
|
if(cor==0)
|
|
{
|
|
atsc_para.rf_para.power= c256_byteread(EEPROM_POWER_UIH_ADDR);
|
|
UC_temp=c256_byteread(EEPROM_POWER_UIL_ADDR);
|
|
atsc_para.rf_para.power = (atsc_para.rf_para.power << 8)| UC_temp;
|
|
|
|
atsc_para.rf_para.db = c256_byteread(EEPROM_0DBFLAGH_ADDR);
|
|
UC_temp = c256_byteread(EEPROM_0DBFLAGL_ADDR);
|
|
atsc_para.rf_para.db = (atsc_para.rf_para.db<<8)|UC_temp;
|
|
}
|
|
else
|
|
{
|
|
atsc_para.rf_para.power= c256_byteread2(E2_POWER_UIH_ADDR);
|
|
UC_temp=c256_byteread2(E2_POWER_UIL_ADDR);
|
|
atsc_para.rf_para.power = (atsc_para.rf_para.power << 8)| UC_temp;
|
|
|
|
atsc_para.rf_para.db = c256_byteread2(E2_0DBFLAGH_ADDR);
|
|
UC_temp = c256_byteread2(E2_0DBFLAGL_ADDR);
|
|
atsc_para.rf_para.db = (atsc_para.rf_para.db<<8)|UC_temp;
|
|
}
|
|
if(atsc_para.rf_para.power >RF_POWER_P_C_ON)
|
|
{
|
|
atsc_para.rf_para.power = RF_POWER_ZERO;
|
|
}
|
|
if(atsc_para.rf_para.db>RF_POWER_DB_MAX)
|
|
{
|
|
if(atsc_para.wl_para.exc_5x==0)
|
|
{
|
|
atsc_para.rf_para.db = DEFAULT_RF_POWER_DB_3X;
|
|
}
|
|
else
|
|
{
|
|
atsc_para.rf_para.db = DEFAULT_RF_POWER_DB;
|
|
}
|
|
}
|
|
}
|
|
|
|
void e2rom_read_tsoip(int tsoip_index, S_TSOIP_CONFIG_PARA *ppara)
|
|
{
|
|
tsoip_index = tsoip_index & 0x01;
|
|
uint32 i;
|
|
uint8 default_ip[4] = {192,168,2,200};
|
|
uint8 default_netmask[4] = {255,255,255,0};
|
|
uint8 default_gw[4] = {192,168,2,1};
|
|
uint8 default_muladdr[4] = {235,100,1,1};
|
|
|
|
|
|
if(TSOIP_1 == tsoip_index) {
|
|
|
|
|
|
// uint32 mac_ext = sys_get_dev_unique_id();
|
|
|
|
// ppara->id = c256_byteread(EEPROM_ID_ADDR);
|
|
//#if SELECT_MCU
|
|
// ppara->id = 0x90;
|
|
//#else
|
|
// ppara->id = 0x70;
|
|
// c256_bytewrite(EEPROM_ID_ADDR,ppara->id);
|
|
//#endif
|
|
|
|
for(i = 0; i< 4; i++)
|
|
{
|
|
ppara->ip[i] = c256_byteread(EEPROM_TSOIP_1_IP4_ADDR+i);
|
|
if(ppara->ip[i]==0xFF)
|
|
ppara->ip[i] = default_ip[i];
|
|
|
|
ppara->gateway[i] = c256_byteread(EEPROM_TSOIP_1_GATEWAY_ADDR+i);
|
|
if(ppara->gateway[i]==0xFF)
|
|
ppara->gateway[i] = default_gw[i];
|
|
|
|
ppara->mask[i] = c256_byteread(EEPROM_TSOIP_1_MASK_ADDR+i);
|
|
if(ppara->mask[i]==0xFF)
|
|
ppara->mask[i] = default_netmask[i];
|
|
|
|
ppara->multi_address[i] = c256_byteread(EEPROM_MULTI_ADDR+i);
|
|
if(ppara->multi_address[i]==0xFF)
|
|
ppara->multi_address[i] = default_muladdr[i];
|
|
|
|
ppara->dest_ip[i] = c256_byteread(EEPROM_DEST_IP_ADDR+i);
|
|
}
|
|
// ppara->mac[0] = mac_ext>>16;
|
|
// ppara->mac[1] = mac_ext>>8;
|
|
// ppara->mac[2] = mac_ext>>0;
|
|
|
|
// c256_bytewrite(EEPROM_TSOIP1_MAC_H, ppara->mac[0]);
|
|
// c256_bytewrite(EEPROM_TSOIP1_MAC_M, ppara->mac[1]);
|
|
// c256_bytewrite(EEPROM_TSOIP1_MAC_L, ppara->mac[2]); //保存只要供底层使用.
|
|
|
|
getMacByName("eth1", &ppara->mac[0]);
|
|
|
|
ppara->port = (c256_byteread(EEPROM_PORT_ADDR)<<8)|c256_byteread(EEPROM_PORT_ADDR+1);
|
|
ppara->ip_direct = c256_byteread(EEPROM_IP_DIRECT_ADDR);
|
|
ppara->udp_rtp= c256_byteread(EEPROM_UDP_RTP_ADDR);
|
|
ppara->packet_len= c256_byteread(EEPROM_PAK_LEN_ADDR);
|
|
ppara->receive_type= c256_byteread(EEPROM_RECE_TYPE_ADDR);
|
|
log_printf(LOG_DEBUG,I_NOUSED,"TSOIP_%d ppara->receive_type=%s\n", tsoip_index+1, ppara->receive_type==0?"multi":"singl" );
|
|
|
|
ppara->fec = (c256_byteread(EEPROM_FEC_ADDR)<<8)|c256_byteread(EEPROM_FEC_ADDR+1);
|
|
if(ppara->fec > 1) {
|
|
ppara->fec = 0;
|
|
}
|
|
|
|
ppara->delay = (c256_byteread(EEPROM_FEC_DLY_ADDR)<<8)|c256_byteread(EEPROM_FEC_DLY_ADDR+1);
|
|
ppara->row = (c256_byteread(EEPROM_ROW_ADDR)<<8)|c256_byteread(EEPROM_ROW_ADDR+1);
|
|
ppara->col = (c256_byteread(EEPROM_COL_ADDR)<<8)|c256_byteread(EEPROM_COL_ADDR+1);
|
|
ppara->sfn_mfn_sel = c256_byteread(EEPROM_SFN_MFN_SEL);
|
|
if(ppara->sfn_mfn_sel != NET_SFN && ppara->sfn_mfn_sel != NET_MFN) {
|
|
ppara->sfn_mfn_sel = NET_SFN;
|
|
}
|
|
|
|
ppara->phy_type = c256_byteread(EEPROM_PHY_TYPE);
|
|
if(ppara->phy_type>=PHY_TYPE_END) {
|
|
ppara->phy_type = PHY_TYPE_AUTO; //默认自动模式
|
|
}
|
|
ppara->dest_port = (c256_byteread(EEPROM_DEST_PORT_ADDR)<<8)|c256_byteread(EEPROM_DEST_PORT_ADDR+1);
|
|
ppara->ip12_sel = c256_byteread(EEPROM_IP2TS_SELECT_TO_FPGA);//h20190221
|
|
|
|
}else if(TSOIP_2==tsoip_index){
|
|
|
|
// uint32 mac_ext = sys_get_dev_unique_id();
|
|
|
|
// ppara->id = c256_byteread(EEPROM_ID_ADDR);
|
|
//#if SELECT_MCU
|
|
// ppara->id = 0x90;
|
|
//#else
|
|
// ppara->id = 0x70;
|
|
// c256_bytewrite(EEPROM_ID_ADDR,ppara->id);
|
|
//#endif
|
|
|
|
for(i = 0; i< 4; i++)
|
|
{
|
|
ppara->ip[i] = c256_byteread(EEPROM_TSOIP_2_IP4_ADDR+i);
|
|
ppara->gateway[i] = c256_byteread(EEPROM_TSOIP_2_GATEWAY_ADDR+i);
|
|
ppara->mask[i] = c256_byteread(EEPROM_TSOIP_2_MASK_ADDR+i);
|
|
ppara->multi_address[i] = c256_byteread(EEPROM_MULTI_2_ADDR+i);
|
|
ppara->dest_ip[i] = c256_byteread(EEPROM_DEST_IP_2_ADDR+i);
|
|
}
|
|
// ppara->mac[0] = mac_ext>>16;
|
|
// ppara->mac[1] = mac_ext>>8;
|
|
// ppara->mac[2] = mac_ext>>0;
|
|
|
|
// c256_bytewrite(EEPROM_ETH_MAC_H, ppara->mac[0]);
|
|
// c256_bytewrite(EEPROM_ETH_MAC_M, ppara->mac[1]);
|
|
// c256_bytewrite(EEPROM_ETH_MAC_L, ppara->mac[2]); //保存只要供底层使用.
|
|
|
|
ppara->port = (c256_byteread(EEPROM_PORT_2_ADDR)<<8)|c256_byteread(EEPROM_PORT_2_ADDR+1);
|
|
ppara->ip_direct = c256_byteread(EEPROM_IP_DIRECT_2_ADDR);
|
|
ppara->udp_rtp= c256_byteread(EEPROM_UDP_RTP_2_ADDR);
|
|
ppara->packet_len= c256_byteread(EEPROM_PAK_LEN_2_ADDR);
|
|
ppara->receive_type= c256_byteread(EEPROM_RECE_TYPE_2_ADDR);
|
|
log_printf(LOG_DEBUG,I_NOUSED,"TSOIP_%d ppara->receive_type=%s\n", tsoip_index+1, ppara->receive_type==0?"multi":"singl" );
|
|
|
|
ppara->fec = (c256_byteread(EEPROM_FEC_2_ADDR)<<8)|c256_byteread(EEPROM_FEC_2_ADDR+1);
|
|
if(ppara->fec >= 1) {
|
|
ppara->fec = 0;
|
|
}
|
|
|
|
ppara->delay = (c256_byteread(EEPROM_FEC_DLY_2_ADDR)<<8)|c256_byteread(EEPROM_FEC_DLY_2_ADDR+1);
|
|
ppara->sfn_mfn_sel = c256_byteread(EEPROM_SFN_MFN_SEL_2);
|
|
if(ppara->sfn_mfn_sel != NET_SFN && ppara->sfn_mfn_sel != NET_MFN){
|
|
ppara->sfn_mfn_sel = NET_SFN;
|
|
}
|
|
|
|
ppara->phy_type = c256_byteread(EEPROM_PHY_TYPE_2);
|
|
if(ppara->phy_type >= PHY_TYPE_END) {
|
|
ppara->phy_type = PHY_TYPE_AUTO; //默认自动模式
|
|
}
|
|
|
|
ppara->dest_port = (c256_byteread(EEPROM_DEST_PORT_2_ADDR)<<8)|c256_byteread(EEPROM_DEST_PORT_2_ADDR+1);
|
|
ppara->ip12_sel = c256_byteread(EEPROM_IP2TS_SELECT_TO_FPGA_2);//h20190221
|
|
|
|
}
|
|
ppara->para_reset = 0;
|
|
ppara->fpga_upgrade = 0;
|
|
ppara->upgrade = 0;
|
|
}
|
|
|
|
|
|
//将power归零,同时对db进行处理
|
|
void power_db_normalization(void)
|
|
{
|
|
uint32 UI_temp = 0;
|
|
|
|
UI_temp = math_abs(atsc_para.rf_para.power-RF_POWER_ZERO);
|
|
if(atsc_para.rf_para.power>RF_POWER_ZERO)
|
|
{
|
|
if((atsc_para.rf_para.db-UI_temp)>RF_POWER_ZERO )
|
|
{
|
|
atsc_para.rf_para.db -= UI_temp ;
|
|
}
|
|
else
|
|
{
|
|
atsc_para.rf_para.db = RF_POWER_ZERO;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if((atsc_para.rf_para.db+UI_temp)<1324)
|
|
{
|
|
atsc_para.rf_para.db += UI_temp;
|
|
}
|
|
else
|
|
{
|
|
atsc_para.rf_para.db = 1324;
|
|
}
|
|
}
|
|
atsc_para.rf_para.power = RF_POWER_ZERO;
|
|
}
|
|
|
|
extern S_IP2TS_PARA ip2ts[2];
|
|
void e2rom_load_default_param_t_tsoip(int tsoip_index, uint32 type)
|
|
{
|
|
tsoip_index = tsoip_index & 0x01;
|
|
|
|
switch(type) {
|
|
case 0:
|
|
|
|
ip2ts[tsoip_index].tsoip_config_para.ip12_sel = IP2TS_SEL_IP_AUTO;
|
|
ip2ts[tsoip_index].tsoip_config_para.fpga_upgrade = 0;
|
|
|
|
#if SPECIAL_VER_NO_WEB
|
|
// SET_IP_DATA(ip2ts.tsoip_config_para.ip, 192,168,1,143);//特殊版本默认IP
|
|
// SET_IP_DATA(ip2ts.tsoip_config_para.gateway,192,168,1,1);
|
|
// SET_IP_DATA(ip2ts.tsoip_config_para.mask, 255,255,255,0);
|
|
// SET_IP_DATA(ip2ts.tsoip_config_para.multi_address, 235,100,1,1);
|
|
// SET_IP_DATA(ip2ts.tsoip_config_para.dest_ip, 235,100,1,1);
|
|
// SET_IP_DATA(ip2ts.tsoip_config_para.multi_address, 235,100,1,1);
|
|
// SET_IP_DATA(ip2ts.tsoip_config_para.dest_ip, 235,100,1,1);
|
|
// ip2ts.tsoip_config_para.port = 4321;
|
|
// ip2ts.tsoip_config_para.udp_rtp = IP2TS_TYPE_UDP;
|
|
// ip2ts.tsoip_config_para.packet_len = IP2TS_PACKET_188;
|
|
// ip2ts.tsoip_config_para.receive_type= IP2TS_REC_TYPE_SINGLE;//特殊版本默认类型
|
|
// ip2ts.tsoip_config_para.dest_port = 4321;
|
|
#else
|
|
// work this way
|
|
if(tsoip_index==TSOIP_1){
|
|
SET_IP_DATA(ip2ts[tsoip_index].tsoip_config_para.ip, 192,168,2,200); // TSOIP_1 (U1/ETH1) TSoIP receiver (PR03)
|
|
SET_IP_DATA(ip2ts[tsoip_index].tsoip_config_para.gateway,192,168,2,1);
|
|
SET_IP_DATA(ip2ts[tsoip_index].tsoip_config_para.mask, 255,255,255,0);
|
|
|
|
SET_IP_DATA(ip2ts[tsoip_index].tsoip_config_para.multi_address, 235,100,1,1);
|
|
SET_IP_DATA(ip2ts[tsoip_index].tsoip_config_para.dest_ip, 235,100,1,1);
|
|
log_printf(LOG_DEBUG,I_NOUSED,"init cfg ip2ts[%d] multaddr=%d.%d.%d.%d\n",
|
|
tsoip_index,
|
|
ip2ts[tsoip_index].tsoip_config_para.multi_address[0],
|
|
ip2ts[tsoip_index].tsoip_config_para.multi_address[1],
|
|
ip2ts[tsoip_index].tsoip_config_para.multi_address[2],
|
|
ip2ts[tsoip_index].tsoip_config_para.multi_address[3]);
|
|
|
|
getMacByName("eth1", &ip2ts[TSOIP_1].tsoip_config_para.mac[0]);
|
|
}else{
|
|
SET_IP_DATA(ip2ts[tsoip_index].tsoip_config_para.ip, 192,168,2,200); // eth2 = TSoIP receive (PR03 unicast)
|
|
SET_IP_DATA(ip2ts[tsoip_index].tsoip_config_para.gateway,192,168,2,1);
|
|
SET_IP_DATA(ip2ts[tsoip_index].tsoip_config_para.mask, 255,255,255,0);
|
|
|
|
SET_IP_DATA(ip2ts[tsoip_index].tsoip_config_para.multi_address, 235,100,1,2);
|
|
SET_IP_DATA(ip2ts[tsoip_index].tsoip_config_para.dest_ip, 235,100,1,2);
|
|
log_printf(LOG_DEBUG,I_NOUSED,"init cfg ip2ts[%d] multaddr=%d.%d.%d.%d\n",
|
|
tsoip_index,
|
|
ip2ts[tsoip_index].tsoip_config_para.multi_address[0],
|
|
ip2ts[tsoip_index].tsoip_config_para.multi_address[1],
|
|
ip2ts[tsoip_index].tsoip_config_para.multi_address[2],
|
|
ip2ts[tsoip_index].tsoip_config_para.multi_address[3]);
|
|
}
|
|
|
|
|
|
ip2ts[tsoip_index].tsoip_config_para.port = 4321;
|
|
ip2ts[tsoip_index].tsoip_config_para.udp_rtp = IP2TS_TYPE_UDP;
|
|
ip2ts[tsoip_index].tsoip_config_para.packet_len = IP2TS_PACKET_188;
|
|
ip2ts[tsoip_index].tsoip_config_para.receive_type= IP2TS_REC_TYPE_SINGLE; // TSoIP unicast on both cores (PR03)
|
|
ip2ts[tsoip_index].tsoip_config_para.dest_port = 4321;
|
|
#endif
|
|
ip2ts[tsoip_index].tsoip_config_para.fec = 0;
|
|
ip2ts[tsoip_index].tsoip_config_para.delay = 0;
|
|
ip2ts[tsoip_index].tsoip_config_para.sfn_mfn_sel = NET_MFN;
|
|
|
|
ip2ts[tsoip_index].tsoip_config_para.para_reset = 0;
|
|
ip2ts[tsoip_index].tsoip_config_para.upgrade=0;
|
|
|
|
e2rom_save_config_tsoip(tsoip_index, &ip2ts[tsoip_index].tsoip_config_para); // need confirm by oneshu
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
void e2rom_save_config_tsoip(int tsoip_index,S_TSOIP_CONFIG_PARA *p_tsoip_para)
|
|
{
|
|
tsoip_index = tsoip_index & 0x01;
|
|
|
|
if(tsoip_index==TSOIP_1){
|
|
|
|
uint32 i = 0;
|
|
//uint32 mac_ext = sys_get_dev_unique_id();
|
|
//c256_bytewrite(EEPROM_ID_ADDR, p_tsoip_para->id);
|
|
|
|
for(i = 0; i < 4; i++)
|
|
{
|
|
c256_bytewrite(EEPROM_TSOIP_1_IP4_ADDR+i, p_tsoip_para->ip[i]);
|
|
c256_bytewrite(EEPROM_TSOIP_1_GATEWAY_ADDR+i, p_tsoip_para->gateway[i]);
|
|
c256_bytewrite(EEPROM_TSOIP_1_MASK_ADDR+i, p_tsoip_para->mask[i]);
|
|
|
|
c256_bytewrite(EEPROM_MULTI_ADDR+i, p_tsoip_para->multi_address[i]);
|
|
c256_bytewrite(EEPROM_DEST_IP_ADDR+i, p_tsoip_para->dest_ip[i]);
|
|
}
|
|
log_printf(LOG_DEBUG,I_NOUSED,"save data to TSOIP 1 cfg.ini ip:%d.%d.%d.%d gy=%d.%d.%d.%d mk:%d.%d.%d.%d muliaddr=%d.%d.%d.%d\n",
|
|
p_tsoip_para->ip[0],
|
|
p_tsoip_para->ip[1],
|
|
p_tsoip_para->ip[2],
|
|
p_tsoip_para->ip[3],
|
|
p_tsoip_para->gateway[0],
|
|
p_tsoip_para->gateway[1],
|
|
p_tsoip_para->gateway[2],
|
|
p_tsoip_para->gateway[3],
|
|
p_tsoip_para->mask[0],
|
|
p_tsoip_para->mask[1],
|
|
p_tsoip_para->mask[2],
|
|
p_tsoip_para->mask[3],
|
|
p_tsoip_para->multi_address[0],
|
|
p_tsoip_para->multi_address[1],
|
|
p_tsoip_para->multi_address[2],
|
|
p_tsoip_para->multi_address[3]);
|
|
|
|
c256_bytewrite(EEPROM_PORT_ADDR+0, p_tsoip_para->port>>8);
|
|
c256_bytewrite(EEPROM_PORT_ADDR+1, p_tsoip_para->port);
|
|
|
|
c256_bytewrite(EEPROM_UDP_RTP_ADDR, p_tsoip_para->udp_rtp);
|
|
c256_bytewrite(EEPROM_PAK_LEN_ADDR, p_tsoip_para->packet_len);
|
|
c256_bytewrite(EEPROM_RECE_TYPE_ADDR, p_tsoip_para->receive_type);
|
|
|
|
c256_bytewrite(EEPROM_FEC_ADDR, p_tsoip_para->fec>>8);
|
|
c256_bytewrite(EEPROM_FEC_ADDR+1, p_tsoip_para->fec);
|
|
|
|
c256_bytewrite(EEPROM_FEC_DLY_ADDR, p_tsoip_para->delay>>8);
|
|
c256_bytewrite(EEPROM_FEC_DLY_ADDR+1, p_tsoip_para->delay);
|
|
|
|
c256_bytewrite(EEPROM_ROW_ADDR, p_tsoip_para->row>>8);
|
|
c256_bytewrite(EEPROM_ROW_ADDR+1, p_tsoip_para->row);
|
|
|
|
c256_bytewrite(EEPROM_COL_ADDR, p_tsoip_para->col>>8);
|
|
c256_bytewrite(EEPROM_COL_ADDR+1, p_tsoip_para->col);
|
|
|
|
c256_bytewrite(EEPROM_SFN_MFN_SEL, p_tsoip_para->sfn_mfn_sel);
|
|
|
|
//#if NO_USE
|
|
// p_tsoip_para->mac[0] = mac_ext>>16;
|
|
// p_tsoip_para->mac[1] = mac_ext>>8;
|
|
// p_tsoip_para->mac[2] = mac_ext>>0;
|
|
//#endif
|
|
c256_bytewrite(EEPROM_TSOIP1_MAC_H,p_tsoip_para->mac[0]);
|
|
c256_bytewrite(EEPROM_TSOIP1_MAC_M,p_tsoip_para->mac[1]);
|
|
c256_bytewrite(EEPROM_TSOIP1_MAC_L,p_tsoip_para->mac[2]); //保存只要供底层使用.
|
|
|
|
c256_bytewrite(EEPROM_PHY_TYPE,p_tsoip_para->phy_type);
|
|
|
|
c256_bytewrite(EEPROM_DEST_PORT_ADDR+0, p_tsoip_para->dest_port>>8);
|
|
c256_bytewrite(EEPROM_DEST_PORT_ADDR+1, p_tsoip_para->dest_port);
|
|
|
|
c256_bytewrite(EEPROM_IP2TS_SELECT_TO_FPGA,p_tsoip_para->ip12_sel);//h20190221
|
|
|
|
//#if USE_HTTP
|
|
// //local_ip_change(TSOIP_1_ETH_INDEX);
|
|
//#endif
|
|
|
|
|
|
|
|
}
|
|
else if(tsoip_index==TSOIP_2) {
|
|
|
|
uint32 i = 0;
|
|
//uint32 mac_ext = sys_get_dev_unique_id();
|
|
//c256_bytewrite(EEPROM_ID_ADDR, p_tsoip_para->id);
|
|
|
|
for(i = 0; i < 4; i++)
|
|
{
|
|
c256_bytewrite(EEPROM_TSOIP_2_IP4_ADDR+i, p_tsoip_para->ip[i]);
|
|
c256_bytewrite(EEPROM_TSOIP_2_GATEWAY_ADDR+i, p_tsoip_para->gateway[i]);
|
|
c256_bytewrite(EEPROM_TSOIP_2_MASK_ADDR+i, p_tsoip_para->mask[i]);
|
|
|
|
c256_bytewrite(EEPROM_MULTI_2_ADDR+i, p_tsoip_para->multi_address[i]);
|
|
c256_bytewrite(EEPROM_DEST_IP_2_ADDR+i, p_tsoip_para->dest_ip[i]);
|
|
|
|
}
|
|
log_printf(LOG_DEBUG,I_NOUSED,"save data to TSOIP 2 cfg.ini [%s,%d] ip:%d.%d.%d.%d gy=%d.%d.%d.%d mk:%d.%d.%d.%d muliaddr=%d.%d.%d.%d\n", __FUNCTION__,__LINE__,
|
|
p_tsoip_para->ip[0],
|
|
p_tsoip_para->ip[1],
|
|
p_tsoip_para->ip[2],
|
|
p_tsoip_para->ip[3],
|
|
p_tsoip_para->gateway[0],
|
|
p_tsoip_para->gateway[1],
|
|
p_tsoip_para->gateway[2],
|
|
p_tsoip_para->gateway[3],
|
|
p_tsoip_para->mask[0],
|
|
p_tsoip_para->mask[1],
|
|
p_tsoip_para->mask[2],
|
|
p_tsoip_para->mask[3],
|
|
p_tsoip_para->multi_address[0],
|
|
p_tsoip_para->multi_address[1],
|
|
p_tsoip_para->multi_address[2],
|
|
p_tsoip_para->multi_address[3]);
|
|
|
|
c256_bytewrite(EEPROM_PORT_2_ADDR+0, p_tsoip_para->port>>8);
|
|
c256_bytewrite(EEPROM_PORT_2_ADDR+1, p_tsoip_para->port);
|
|
|
|
c256_bytewrite(EEPROM_UDP_RTP_2_ADDR, p_tsoip_para->udp_rtp);
|
|
c256_bytewrite(EEPROM_PAK_LEN_2_ADDR, p_tsoip_para->packet_len);
|
|
c256_bytewrite(EEPROM_RECE_TYPE_2_ADDR, p_tsoip_para->receive_type);
|
|
|
|
c256_bytewrite(EEPROM_FEC_2_ADDR, p_tsoip_para->fec>>8);
|
|
c256_bytewrite(EEPROM_FEC_2_ADDR+1, p_tsoip_para->fec);
|
|
|
|
c256_bytewrite(EEPROM_FEC_DLY_2_ADDR, p_tsoip_para->delay>>8);
|
|
c256_bytewrite(EEPROM_FEC_DLY_2_ADDR+1, p_tsoip_para->delay);
|
|
|
|
c256_bytewrite(EEPROM_ROW_2_ADDR, p_tsoip_para->row>>8);
|
|
c256_bytewrite(EEPROM_ROW_2_ADDR+1, p_tsoip_para->row);
|
|
|
|
c256_bytewrite(EEPROM_COL_2_ADDR, p_tsoip_para->col>>8);
|
|
c256_bytewrite(EEPROM_COL_2_ADDR+1, p_tsoip_para->col);
|
|
|
|
c256_bytewrite(EEPROM_SFN_MFN_SEL_2, p_tsoip_para->sfn_mfn_sel);
|
|
|
|
//#if NO_USE
|
|
// p_tsoip_para->mac[0] = mac_ext>>16;
|
|
// p_tsoip_para->mac[1] = mac_ext>>8;
|
|
// p_tsoip_para->mac[2] = mac_ext>>0;
|
|
//#endif
|
|
// c256_bytewrite(EEPROM_ETH_MAC_H,p_tsoip_para->mac[0]);
|
|
// c256_bytewrite(EEPROM_ETH_MAC_M,p_tsoip_para->mac[1]);
|
|
// c256_bytewrite(EEPROM_ETH_MAC_L,p_tsoip_para->mac[2]); //保存只要供底层使用.
|
|
|
|
c256_bytewrite(EEPROM_PHY_TYPE_2,p_tsoip_para->phy_type);
|
|
|
|
c256_bytewrite(EEPROM_DEST_PORT_2_ADDR+0, p_tsoip_para->dest_port>>8);
|
|
c256_bytewrite(EEPROM_DEST_PORT_2_ADDR+1, p_tsoip_para->dest_port);
|
|
|
|
c256_bytewrite(EEPROM_IP2TS_SELECT_TO_FPGA_2, p_tsoip_para->ip12_sel);//h20190221
|
|
|
|
#if USE_HTTP
|
|
//local_ip_change(TSOIP_1_ETH_INDEX);
|
|
#endif
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
#if 1//USE_TS2IP
|
|
void ts_load_default_para(int tsoip_index, S_TSOIP_CONFIG_PARA *p_tsoip_config_param)
|
|
{
|
|
//@RE-NEW
|
|
uint8 uchar = 0;
|
|
uint16 ustemp = 0;
|
|
int i = 0;
|
|
if(TSOIP_1 == tsoip_index){
|
|
for(i = 0; i< 4; i++){
|
|
ts_net_para.ip[i] = p_tsoip_config_param->ip[i];
|
|
ts_net_para.mask[i] = p_tsoip_config_param->mask[i];
|
|
ts_net_para.gateway[i] = p_tsoip_config_param->gateway[i];
|
|
ts_net_para.multi_address[i] = p_tsoip_config_param->multi_address[i];
|
|
}
|
|
|
|
ts_net_para.udp_rtp = p_tsoip_config_param->udp_rtp;//IP2TS_TYPE_UDP;
|
|
ts_net_para.packet_len = p_tsoip_config_param->packet_len;//IP2TS_PACKET_188;
|
|
ts_net_para.receive_type = p_tsoip_config_param->receive_type;//IP2TS_REC_TYPE_MULTI;
|
|
ts_net_para.port = p_tsoip_config_param->port; //4321;
|
|
|
|
|
|
// ip2ts_i2c_rw(ts_net_para.ip, IP2TS_I2C_ADD_IP, sizeof(ts_net_para.ip), TS_NET_I2C_WRITE); // TS NET IP
|
|
// ip2ts_i2c_rw(ts_net_para.mask, IP2TS_I2C_ADD_MASK, sizeof(ts_net_para.mask), TS_NET_I2C_WRITE); // TS NET MASK
|
|
// ip2ts_i2c_rw(ts_net_para.gateway, IP2TS_I2C_ADD_GATEWAY, sizeof(ts_net_para.gateway), TS_NET_I2C_WRITE); // TS NET GATEWAY
|
|
// ip2ts_i2c_rw(ts_net_para.multi_address,IP2TS_I2C_ADD_MULTI, sizeof(ts_net_para.multi_address), TS_NET_I2C_WRITE); // TS NET MUTIADDR
|
|
// ustemp = htons(ts_net_para.port);
|
|
// ip2ts_i2c_rw((uint8*)&ustemp, IP2TS_I2C_ADD_PORT, sizeof(ustemp), TS_NET_I2C_WRITE); // TS NET PORT
|
|
// ustemp = htons(ts_net_para.udp_rtp);
|
|
// ip2ts_i2c_rw((uint8*)&ustemp,IP2TS_I2C_ADD_UDP_RTP,sizeof(ustemp),TS_NET_I2C_WRITE);
|
|
// ustemp = htons(ts_net_para.packet_len);
|
|
// ip2ts_i2c_rw((uint8*)&ustemp,IP2TS_I2C_ADD_PACKET_LEN,sizeof(ustemp),TS_NET_I2C_WRITE);
|
|
// ustemp = htons(ts_net_para.receive_type);
|
|
// ip2ts_i2c_rw((uint8*)&ustemp,IP2TS_I2C_ADD_REC_TYPE,sizeof(ustemp),TS_NET_I2C_WRITE);
|
|
// uchar = 0x01;
|
|
// ip2ts_i2c_rw(&uchar,IP2TS_I2C_ADD_RESET, 1, TS_NET_I2C_WRITE); // RESET
|
|
ts_net_para.valid = 0;
|
|
}
|
|
|
|
/*uint8 uchar = 0;
|
|
uint16 ustemp = 0;
|
|
|
|
if(!atsc_para.wl_para.ip2ts)
|
|
{
|
|
memset(&ts_net_para,0,sizeof(TS_NET_STRUCT));
|
|
return;
|
|
}
|
|
|
|
SET_IP_DATA(ts_net_para.ip, 192,168,1,200);
|
|
SET_IP_DATA(ts_net_para.mask, 255,255,255,0);
|
|
SET_IP_DATA(ts_net_para.gateway, 192,168,1,1);
|
|
SET_IP_DATA(ts_net_para.multi_address,235,100,1,1);
|
|
SET_IP_DATA(ts_net_para.ip_bak, 235,100,1,2);
|
|
ts_net_para.udp_rtp = IP2TS_TYPE_UDP;
|
|
ts_net_para.packet_len = IP2TS_PACKET_188;
|
|
ts_net_para.receive_type = IP2TS_REC_TYPE_MULTI;
|
|
ts_net_para.port = 4321;
|
|
ts_net_para.port = 4331;
|
|
|
|
ip2ts_i2c_rw(ts_net_para.ip, IP2TS_I2C_ADD_IP, sizeof(ts_net_para.ip), TS_NET_I2C_WRITE); // TS NET IP
|
|
ip2ts_i2c_rw(ts_net_para.mask, IP2TS_I2C_ADD_MASK, sizeof(ts_net_para.mask), TS_NET_I2C_WRITE); // TS NET MASK
|
|
ip2ts_i2c_rw(ts_net_para.gateway, IP2TS_I2C_ADD_GATEWAY, sizeof(ts_net_para.gateway), TS_NET_I2C_WRITE); // TS NET GATEWAY
|
|
ip2ts_i2c_rw(ts_net_para.multi_address,IP2TS_I2C_ADD_MULTI, sizeof(ts_net_para.multi_address), TS_NET_I2C_WRITE); // TS NET MUTIADDR
|
|
ip2ts_i2c_rw(ts_net_para.ip_bak ,IP2TS_I2C_IP_BAK, sizeof(ts_net_para.ip_bak), TS_NET_I2C_WRITE);
|
|
|
|
ustemp = htons(ts_net_para.port);
|
|
ip2ts_i2c_rw((uint8*)&ustemp, IP2TS_I2C_ADD_PORT, sizeof(ustemp), TS_NET_I2C_WRITE); // TS NET PORT
|
|
|
|
ustemp = htons(ts_net_para.port_bak);
|
|
ip2ts_i2c_rw((uint8*)&ustemp, IP2TS_I2C_PORT_BAK, sizeof(ustemp), TS_NET_I2C_WRITE); // TS NET PORT
|
|
|
|
ustemp = htons(ts_net_para.udp_rtp);
|
|
ip2ts_i2c_rw((uint8*)&ustemp,IP2TS_I2C_ADD_UDP_RTP,sizeof(ustemp),TS_NET_I2C_WRITE);
|
|
|
|
ustemp = htons(ts_net_para.packet_len);
|
|
ip2ts_i2c_rw((uint8*)&ustemp,IP2TS_I2C_ADD_PACKET_LEN,sizeof(ustemp),TS_NET_I2C_WRITE);
|
|
|
|
ustemp = htons(ts_net_para.receive_type);
|
|
ip2ts_i2c_rw((uint8*)&ustemp,IP2TS_I2C_ADD_REC_TYPE,sizeof(ustemp),TS_NET_I2C_WRITE);
|
|
|
|
uchar = 0x01;
|
|
ip2ts_i2c_rw(&uchar,IP2TS_I2C_ADD_RESET, 1, TS_NET_I2C_WRITE); // RESET
|
|
ts_net_para.valid = 0;*/
|
|
}
|
|
#endif
|
|
|
|
void e2rom_load_default_param(unsigned char menu)
|
|
{
|
|
switch(menu)
|
|
{
|
|
case MENU_CUSTOM:
|
|
atsc_para.system_para.adpc = ADPC_OFF;
|
|
atsc_para.system_para.ocxo = 0;
|
|
atsc_para.system_para.mode = 0;
|
|
|
|
if(atsc_para.wj_para.mode)
|
|
{
|
|
atsc_para.system_para.input = ASI_INPUT_TUNER;
|
|
}
|
|
else
|
|
{
|
|
atsc_para.system_para.input = ASI_INPUT_TS;
|
|
}
|
|
atsc_para.system_para.final_stage = 0xff;
|
|
atsc_para.system_para.gps = 0;
|
|
atsc_para.system_para.test = TEST_OFF;
|
|
atsc_para.system_para.spec_enable = 1;
|
|
//atsc_para.system_para.net = 1; //MFN;
|
|
atsc_para.system_para.ctrl = CTRL_REMOTE; // remote
|
|
|
|
memcpy(atsc_para.system_para.web_title,ATSC_WEB_TITLE,strlen(ATSC_WEB_TITLE));
|
|
atsc_para.system_para.web_title[15] = 0;
|
|
|
|
atsc_para.system_para.sntp_en = 0; // sntp
|
|
atsc_para.system_para.sntp_sip[0] = 0; // sntp server ip
|
|
atsc_para.system_para.sntp_sip[1] = 0;
|
|
atsc_para.system_para.sntp_sip[2] = 0;
|
|
atsc_para.system_para.sntp_sip[3] = 0;
|
|
memcpy(atsc_para.system_para.sntp_date, "1970 01-01", SNTP_DATE_STRING_LEN);
|
|
memcpy(atsc_para.system_para.sntp_time, "00:00:00", SNTP_TIME_STRING_LEN);
|
|
|
|
atsc_para.rf_para.agc = 0;
|
|
atsc_para.rf_para.rxfreq = DEFAULT_FREQ_NUM;
|
|
atsc_para.rf_para.txfreq = DEFAULT_FREQ_NUM;
|
|
|
|
atsc_para.rf_para.hz = 0;
|
|
atsc_para.rf_para.cw = 0; //ST
|
|
atsc_para.rf_para.rf = 1; //RF 1:OFF
|
|
atsc_para.rf_para.ref = 0;
|
|
|
|
atsc_para.config_para.bps = 2;
|
|
/*atsc_para.config_para.ip[0] = 192;
|
|
atsc_para.config_para.ip[1] = 168;
|
|
atsc_para.config_para.ip[2] = 1;
|
|
atsc_para.config_para.ip[3] = 143;
|
|
|
|
atsc_para.config_para.gateway[0] = 192;
|
|
atsc_para.config_para.gateway[1] = 168;
|
|
atsc_para.config_para.gateway[2] = 1;
|
|
atsc_para.config_para.gateway[3] = 1;
|
|
|
|
atsc_para.config_para.mask[0] = 255;
|
|
atsc_para.config_para.mask[1] = 255;
|
|
atsc_para.config_para.mask[2] = 255;
|
|
atsc_para.config_para.mask[3] = 0;
|
|
|
|
atsc_para.config_para.dns[0] = 192;
|
|
atsc_para.config_para.dns[1] = 168;
|
|
atsc_para.config_para.dns[2] = 1;
|
|
atsc_para.config_para.dns[3] = 1;
|
|
*/
|
|
|
|
SET_IP_DATA(atsc_para.config_para.ip, 192,168,1,143); // eth0 ip
|
|
SET_IP_DATA(atsc_para.config_para.gateway,192,168,1,1);
|
|
SET_IP_DATA(atsc_para.config_para.mask, 255,255,255,0);
|
|
SET_IP_DATA(atsc_para.config_para.dns, 192,168,1,1);
|
|
|
|
|
|
atsc_para.config_para.pa_link_ctrl_rf = 0;
|
|
|
|
#if ATSC_USA_AMP
|
|
atsc_para.pa_config_para.ip[0] = 192;
|
|
atsc_para.pa_config_para.ip[1] = 168;
|
|
atsc_para.pa_config_para.ip[2] = 1;
|
|
atsc_para.pa_config_para.ip[3] = 210;
|
|
|
|
atsc_para.pa_config_para.gateway[0] = 192;
|
|
atsc_para.pa_config_para.gateway[1] = 168;
|
|
atsc_para.pa_config_para.gateway[2] = 1;
|
|
atsc_para.pa_config_para.gateway[3] = 1;
|
|
|
|
atsc_para.pa_config_para.mask[0] = 255;
|
|
atsc_para.pa_config_para.mask[1] = 255;
|
|
atsc_para.pa_config_para.mask[2] = 255;
|
|
atsc_para.pa_config_para.mask[3] = 0;
|
|
#endif
|
|
|
|
atsc_para.network_para.delay = 0;
|
|
atsc_para.config_para.id = 0x80;
|
|
|
|
atsc_para.mode_para.sync = 1;
|
|
atsc_para.mode_para.tcp_c= 0;
|
|
atsc_para.mode_para.zp1f = 0;
|
|
//atsc_para.mode_para.pid_det = 0;
|
|
|
|
atsc_para.ad_para.pcr = 0x1;
|
|
atsc_para.ad_para.slow_up = 1;
|
|
atsc_para.ad_para.slow_down = 0;
|
|
atsc_para.ad_para.swrt =0x03;
|
|
atsc_para.ad_para.asiout =3;
|
|
atsc_para.ad_para.pac =1;
|
|
|
|
atsc_para.ad2_para.m_ts = 0;
|
|
atsc_para.ad2_para.m_10m = 0;
|
|
atsc_para.ad2_para.m_1pps= 0;
|
|
atsc_para.ad2_para.m_dly_ss = 0;
|
|
atsc_para.ad2_para.m_dly_mm = 0;
|
|
atsc_para.ad2_para.m_dly_hh = 1;
|
|
|
|
atsc_para.ad3_para.rc_cmd= 1;
|
|
atsc_para.ad3_para.mptv= 0;
|
|
atsc_para.ad3_para.fwd_cal= 1;// 1:ok 0:cal
|
|
atsc_para.ad3_para.power_ref = 0x7FFF;//0
|
|
atsc_para.ad3_para.cal_fagc_cw = 0xFF; // PR13: 未标定
|
|
atsc_para.ad3_para.cal_orx_pwr_hdb = 0xFFFF; // PR13: 未标定
|
|
atsc_para.ad3_para.cw = 0;
|
|
atsc_para.ad3_para.rst = 0;
|
|
//atsc_para.ad3_para.max_power = AD_MAX_POWER_DEFAULT;
|
|
atsc_para.ad3_para.max_power = RF_POWER_P_C_ON;//h210816
|
|
|
|
atsc_para.ad4_para.pdt = 0x03;
|
|
atsc_para.ad4_para.adpc = ADPC_OFF;
|
|
//atsc_para.ad4_para.cfr = 0x0f;
|
|
|
|
atsc_para.ad5_para.time = 0;
|
|
atsc_para.ad5_para.a_imd = A_IMD_DEFAULT;
|
|
atsc_para.ad5_para.a_snr = A_SNR_DEFAUTL;
|
|
atsc_para.ad5_para.r_imd = R_IMD_DEFAULT;
|
|
atsc_para.ad5_para.r_snr = R_SNR_DEFAULT;
|
|
|
|
atsc_para.ri_para.m_snr = atsc_para.ad5_para.a_snr;
|
|
atsc_para.ri_para.m_imd = atsc_para.ad5_para.a_imd;
|
|
|
|
atsc_para.ad5_para.c_t =atsc_para.ad5_para.time;
|
|
atsc_para.ad5_para.dpd= 1; //默认为NEW
|
|
atsc_para.ad5_para.use_dpd =1; //AD4菜单与WK 菜单内容相同
|
|
|
|
#if USE_PSTS
|
|
atsc_para.psts_para.ts_ctrl=PSTS_CTRL_DISABLE;
|
|
atsc_para.psts_para.local_update_flag = 2;
|
|
psts_para_clear((S_PSTS_PARA*)&atsc_para.psts_para);
|
|
c256_bytewrite(EEPROM_PSTS_UP_FLAG,atsc_para.psts_para.local_update_flag);
|
|
e2rom_save_psts((S_PSTS_PARA *)&atsc_para.psts_para);
|
|
#endif
|
|
|
|
atsc_para.latch_para.reset = 0;
|
|
atsc_para.latch_para.u1 = 0 ;
|
|
atsc_para.rf_para.ssref = 0;
|
|
atsc_para.latch_para.u2 =0 ;
|
|
atsc_para.latch_para.rf =0 ;
|
|
atsc_para.latch_para.gps =0;
|
|
atsc_para.latch_para.ts =0 ;
|
|
atsc_para.latch_para.sys =0 ;
|
|
atsc_para.latch_para.m_1pps=0 ;
|
|
atsc_para.latch_para.sfn =0 ;
|
|
|
|
atsc_para.system_para.ntp_ip[0] = 162;
|
|
atsc_para.system_para.ntp_ip[1] = 159;
|
|
atsc_para.system_para.ntp_ip[2] = 200;
|
|
atsc_para.system_para.ntp_ip[3] = 123;
|
|
atsc_para.system_para.ntp_switch= 0;
|
|
c256_bytewrite(EEPROM_NTP_SERVER_IP, atsc_para.system_para.ntp_ip[0]);
|
|
c256_bytewrite(EEPROM_NTP_SERVER_IP+1, atsc_para.system_para.ntp_ip[1]);
|
|
c256_bytewrite(EEPROM_NTP_SERVER_IP+2, atsc_para.system_para.ntp_ip[2]);
|
|
c256_bytewrite(EEPROM_NTP_SERVER_IP+3, atsc_para.system_para.ntp_ip[3]);
|
|
set_ntp_server_ip_to_system(atsc_para.system_para.ntp_ip, atsc_para.system_para.ntp_switch, 0);
|
|
|
|
//80 46 0A 35 01 F0 F0 F0 D6 96
|
|
/********************************************************************
|
|
参数初始化时对功率以及cor的处理方法:
|
|
1.对两个COR所存储的POWR及AGC等参数均要进行初始化
|
|
2.初始化完成后要保持COR类型不变
|
|
*********************************************************************/
|
|
|
|
//atsc_para.ad3_para.cor = 0; //
|
|
|
|
#if USE_DRY_LOOP
|
|
atsc_para.ad3_para.cor = atsc_para.ad3_para.cor?0:1; //先初始化非当前类型的COR
|
|
e2rom_read_power_db(atsc_para.ad3_para.cor);
|
|
power_db_normalization_5000(); //归一化处理
|
|
e2rom_save_rf(&atsc_para.rf_para);
|
|
|
|
atsc_para.ad3_para.cor = atsc_para.ad3_para.cor?0:1; //再次翻转,COR为当前类型
|
|
e2rom_read_power_db(atsc_para.ad3_para.cor);
|
|
power_db_normalization_5000();
|
|
e2rom_save_rf(&atsc_para.rf_para);
|
|
|
|
c256_bytewrite(EEPROM_AD3_POWER_REF_H,atsc_para.ad3_para.power_ref>>8);
|
|
c256_bytewrite(EEPROM_AD3_POWER_REF_L,atsc_para.ad3_para.power_ref);
|
|
c256_bytewrite2(E2_AD3_POWER_REF_H,atsc_para.ad3_para.power_ref>>8);
|
|
c256_bytewrite2(E2_AD3_POWER_REF_L,atsc_para.ad3_para.power_ref);
|
|
#endif
|
|
|
|
e2rom_save_sys(&atsc_para.system_para);
|
|
e2rom_save_network(&atsc_para.network_para);
|
|
e2rom_save_config(&atsc_para.config_para);
|
|
#if ATSC_USA_AMP
|
|
e2rom_save_pa_config(&atsc_para.pa_config_para);
|
|
#endif
|
|
e2rom_save_mode(&atsc_para.mode_para);
|
|
e2rom_save_sn(&atsc_para.sn_para);
|
|
|
|
e2rom_save_ad(&atsc_para.ad_para);
|
|
e2rom_save_ad2(&atsc_para.ad2_para);
|
|
e2rom_save_ad3(&atsc_para.ad3_para);
|
|
e2rom_save_ad4(&atsc_para.ad4_para);
|
|
e2rom_save_ad5(&atsc_para.ad5_para);
|
|
|
|
e2rom_save_latch(&atsc_para.latch_para,&atsc_para.system_para);
|
|
|
|
e2rom_save_wh(&atsc_para.wh_para);
|
|
|
|
// c256_bytewrite(EEPROM_PWRVREF_O_HADDR,0x00);
|
|
// c256_bytewrite(EEPROM_PWRVREF_O_LADDR,0x00);
|
|
// c256_bytewrite(EEPROM_PWRVREF_VLDO_ADDR,0x00);
|
|
// c256_bytewrite(EEPROM_AD3_POWER_REF_H,0);
|
|
// c256_bytewrite(EEPROM_AD3_POWER_REF_L,0);
|
|
//c256_bytewrite(EEPROM_AGC_ADDR,atsc_para.rf_para.agc);
|
|
|
|
// c256_bytewrite2(E2_PWRVREF_O_HADDR,0x00);
|
|
// c256_bytewrite2(E2_PWRVREF_O_LADDR,0x00);
|
|
// c256_bytewrite2(E2_PWRVREF_VLDO_ADDR,0x00);
|
|
// c256_bytewrite2(E2_AD3_POWER_REF_H,0);
|
|
// c256_bytewrite2(E2_AD3_POWER_REF_L,0);
|
|
c256_bytewrite2(E2_AGC_ADDR,atsc_para.rf_para.agc); //两个COR中的参数归零
|
|
#if USE_TS2IP
|
|
//ts_load_default_para();
|
|
#endif
|
|
break;
|
|
|
|
case MENU_FACTORY:
|
|
atsc_para.fac_rst_flag = 1;
|
|
|
|
atsc_para.wb_para.b0 = 1;
|
|
atsc_para.wb_para.b1 = 1;
|
|
atsc_para.wb_para.b2 = 0x67;
|
|
|
|
atsc_para.wb_para.gpsc = 0x6106;;
|
|
|
|
/*#if USE_HW_REPT
|
|
atsc_para.wb_para.cfr = 0x05;
|
|
#else
|
|
atsc_para.wb_para.cfr = 0x0f;
|
|
#endif*/
|
|
|
|
|
|
atsc_para.wb_para.p0 = 0;
|
|
//atsc_para.wb_para.hz = 0x8000;
|
|
//atsc_para.wb_para.b8 = 0x10;
|
|
atsc_para.wb_para.alarm = 0;
|
|
atsc_para.wb_para.rst = 0;
|
|
|
|
atsc_para.wc_para.crg = 0x11;
|
|
atsc_para.wc_para.pr = 1;
|
|
atsc_para.wc_para.ch = 0x3d;
|
|
atsc_para.wc_para.cl = 0x09;
|
|
atsc_para.wc_para.dh = 0x0c;
|
|
atsc_para.wc_para.dl = 0x80;
|
|
atsc_para.wc_para.til = 0xcc;
|
|
atsc_para.wc_para.tfl = 0x11;
|
|
atsc_para.wc_para.tls = 0x04;
|
|
atsc_para.wc_para.pg = 0x08;
|
|
|
|
atsc_para.wd_para.cfr_work = 0;
|
|
atsc_para.wd_para.cfr_clip = 0x2300;//0x2C00
|
|
/*atsc_para.wd_para.twk = 0x01;
|
|
atsc_para.wd_para.pfg = 0x40;
|
|
atsc_para.wd_para.pdg = 0x20;
|
|
atsc_para.wd_para.feg = 0x20;
|
|
atsc_para.wd_para.deg = 0x10;
|
|
atsc_para.wd_para.lct = 0x75;
|
|
*/
|
|
atsc_para.wd_para.sa = 0;
|
|
atsc_para.wd_para.sb = 0;
|
|
atsc_para.wd_para.sc = 0;
|
|
atsc_para.wd_para.sd = 0;
|
|
/*#if USE_SNR_ADJ
|
|
atsc_para.wd_para.sa = 0;
|
|
atsc_para.wd_para.sb = 0;
|
|
atsc_para.wd_para.sc = 0;
|
|
atsc_para.wd_para.sd = 0;
|
|
#else
|
|
atsc_para.wd_para.sa = 0x0d;
|
|
atsc_para.wd_para.sb = 0x28;
|
|
atsc_para.wd_para.sc = 0x10;
|
|
atsc_para.wd_para.sd = 0x08;
|
|
#endif*/
|
|
atsc_para.we_para.ch = atsc_para.rf_para.txfreq;
|
|
atsc_para.we_para.ltn=0x1; //h-rpt 保持
|
|
|
|
atsc_para.we_para.snc=0x5; //h-rpt 保持
|
|
atsc_para.we_para.dpgh=0x50;//h-rpt 保持
|
|
atsc_para.we_para.dpgm=0x30;
|
|
atsc_para.we_para.dpgl=0x80;
|
|
//atsc_para.we_para.fsc=0x50; //h-rpt 保持
|
|
|
|
atsc_para.wf_para.l = 1;
|
|
atsc_para.wf_para.n = 1;
|
|
|
|
atsc_para.wf_para.pdt = 0x03; //h-rpt 保持
|
|
atsc_para.wf_para.m = 0; //h-rpt 保持
|
|
atsc_para.wf_para.ah = 0x01; //h-rpt 保持
|
|
atsc_para.wf_para.al = 0x80;
|
|
|
|
#if USE_HW_REPT
|
|
atsc_para.wf_para.equc = 0x3712;
|
|
atsc_para.wf_para.sp = 0;
|
|
atsc_para.we_para.dsc = 0x0e;
|
|
#else
|
|
atsc_para.wf_para.equc = 0x7712;
|
|
atsc_para.wf_para.sp = 0;
|
|
atsc_para.we_para.dsc = 0x7;
|
|
#endif
|
|
|
|
|
|
|
|
atsc_para.wf_para.agc = 0x01;
|
|
|
|
atsc_para.wf_para.g = 1; //默认为INT 和 EXT均可选
|
|
atsc_para.wf_para.th = 0x44;
|
|
|
|
atsc_para.wh_para.pd = 0;
|
|
atsc_para.wh_para.bw = 0x02;
|
|
atsc_para.wh_para.ralh = 0x38;
|
|
atsc_para.wh_para.rall = 0x3d;
|
|
atsc_para.wh_para.balh = 0x03;// == Sw_RT
|
|
atsc_para.wh_para.chip = 0;
|
|
atsc_para.ad_para.swrt = 0x03;
|
|
|
|
atsc_para.wh_para.ball = 0x80;
|
|
atsc_para.wh_para.pwrt = 0x14;
|
|
atsc_para.wh_para.pac = 1;
|
|
atsc_para.wh_para.func = 1;
|
|
|
|
atsc_para.wh_para.temp_unit = 1;
|
|
|
|
#if !TMP_UNUSE_LCD//@TMP_NOT_USED
|
|
sys_reset_rst_time();
|
|
#endif
|
|
|
|
atsc_para.wj_para.gmt = -4;
|
|
//atsc_para.wj_para.p_c = 0; //on
|
|
atsc_para.wj_para.p_c = 1;//h210816
|
|
atsc_para.wj_para.rf_dly = 2;
|
|
atsc_para.wj_para.mode = 0;
|
|
atsc_para.wj_para.picture = 0;
|
|
atsc_para.wj_para.ctl_dpd = E_DPD_SAVE_FLITER;
|
|
atsc_para.wj_para.ph10_time = 5;
|
|
|
|
atsc_para.wk_para.alarm_ip[0] = 192;
|
|
atsc_para.wk_para.alarm_ip[1] = 168;
|
|
atsc_para.wk_para.alarm_ip[2] = 1;
|
|
atsc_para.wk_para.alarm_ip[3] = 100;
|
|
atsc_para.wk_para.ss = 0;
|
|
getMacByName("eth0", &atsc_para.wk_para.mac[0]);
|
|
|
|
atsc_para.wl_para.band = 0;
|
|
atsc_para.wl_para.eebak= 1;
|
|
atsc_para.wl_para.roll_off_sel= 1;
|
|
atsc_para.wl_para.spec_shift = 1;
|
|
|
|
//[220524-f]-add
|
|
atsc_para.wl_para.exc_5x = 1;
|
|
|
|
//----------------------------
|
|
//e2rom_save_we(&cttb_para.we_para);
|
|
//dpd-para
|
|
atsc_para.dpd_para.distortion_sw=0;
|
|
atsc_para.dpd_para.dpd_test =0x0000;//0x0011
|
|
atsc_para.dpd_para.agc_pwr =256; //h20201210 需要固化
|
|
atsc_para.dpd_para.err_th =3000; //[220302-2327]
|
|
atsc_para.dpd_para.err_cnt_th =50;
|
|
atsc_para.dpd_para.amp_sat =FPGA_AMP_SAT_DEF; //h20201210 [16000-->23000]
|
|
atsc_para.dpd_para.dpd_mode =0;//ST
|
|
atsc_para.dpd_para.phase6_minute=3;//TM
|
|
atsc_para.dpd_para.wpp_th =3900;//6000
|
|
atsc_para.dpd_para.gl =0x0370;//0x0A00
|
|
atsc_para.dpd_para.dpd_ctl =3;
|
|
//cttb_para.dpd_para.amp_sat_sqr=0;//该值由amp_sat转换而成
|
|
e2rom_save_dpd_para(&atsc_para.dpd_para);
|
|
//----------------------------
|
|
|
|
e2rom_save_wb(&atsc_para.wb_para);
|
|
e2rom_save_wc(&atsc_para.wc_para);
|
|
e2rom_save_wd(&atsc_para.wd_para);
|
|
e2rom_save_we(&atsc_para.we_para);
|
|
e2rom_save_wf(&atsc_para.wf_para);
|
|
e2rom_save_wh(&atsc_para.wh_para);
|
|
e2rom_save_wj(&atsc_para.wj_para);
|
|
e2rom_save_wk(&atsc_para.wk_para);
|
|
e2rom_save_wl(&atsc_para.wl_para);
|
|
#if USE_SNR_ADJ
|
|
c256_bytewrite(EEPROM_WD_SPE_ADDR,KOREA_WD_SPE_VALUE);
|
|
#endif
|
|
user_info_reset();
|
|
|
|
break;
|
|
|
|
case MENU_POWER:
|
|
atsc_para.rf_para.power = RF_POWER_ZERO;
|
|
if(atsc_para.wl_para.exc_5x==0)
|
|
{
|
|
atsc_para.rf_para.db = DEFAULT_RF_POWER_DB_3X;
|
|
e2rom_fac_power_rst_3x(); //we power
|
|
}
|
|
else
|
|
{
|
|
atsc_para.rf_para.db = DEFAULT_RF_POWER_DB;
|
|
e2rom_fac_power_rst_5x(); //we power
|
|
}
|
|
e2rom_save_rf(&atsc_para.rf_para);
|
|
break;
|
|
#if USE_LOG_MODULE
|
|
case MENU_LOG:
|
|
#if 1//_USE_RVL_
|
|
log_record_reset();
|
|
#endif
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void e2rom_read_leak(uint32 chn,S_WE_PARA *ppara)
|
|
{
|
|
uint8 data = 0;
|
|
|
|
if(atsc_para.wl_para.exc_5x==0)
|
|
{
|
|
data = c256_byteread(EEPROM_CH2_POWER_ADDR+chn*2+0);
|
|
ppara->power = (data<<8)|c256_byteread(EEPROM_CH2_POWER_ADDR+chn*2+1);
|
|
|
|
if(ppara->power>WE_POWER_MAX)
|
|
{
|
|
ppara->power = e2rom_read_fac_power_default_3x(chn);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
data = c256_byteread(EEPROM_CH1_POWER_ADDR+chn*2+0);
|
|
ppara->power = (data<<8)|c256_byteread(EEPROM_CH1_POWER_ADDR+chn*2+1);
|
|
|
|
if(ppara->power>WE_POWER_MAX)
|
|
{
|
|
ppara->power = e2rom_read_fac_power_default_5x(chn);
|
|
}
|
|
}
|
|
}
|
|
extern void fpga_read_system(S_SYSTEM_PARA *ppara);
|
|
void e2rom_read_para_atsc(void)
|
|
{
|
|
#if BAK_PARA_CHECK
|
|
atsc_para.wl_para.eebak = c256_byteread(EEPROM_WL_ADDR+OFFSET_OF_STRUCT(S_WL_PARA, eebak));
|
|
|
|
if(atsc_para.wl_para.eebak>1)
|
|
{
|
|
atsc_para.wl_para.eebak=0;
|
|
c256_bytewrite(EEPROM_WL_ADDR+OFFSET_OF_STRUCT(S_WL_PARA, eebak),0);
|
|
}
|
|
|
|
if(atsc_para.wl_para.eebak)
|
|
{
|
|
if(E2PROM_MAGIC_WORD_BAK == c256_byteread2(BAK_E2_DEFAULT_PARAM_ADDR)) //已存
|
|
{
|
|
atsc_para.bak_check_flag = 1;
|
|
}
|
|
else
|
|
{
|
|
atsc_para.bak_check_flag = 0;
|
|
//判是否存在E2
|
|
//if(0xff == c256_byteread2(BAK_E2_DEFAULT_PARAM_ADDR))
|
|
{
|
|
c256_bytewrite2(BAK_E2_DEFAULT_PARAM_ADDR,E2PROM_MAGIC_WORD_BAK);
|
|
c256_bytewrite(EEPROM_FQPW_CHECK_FLAG,0xff);
|
|
delay_ms(10);
|
|
if(E2PROM_MAGIC_WORD_BAK == c256_byteread2(BAK_E2_DEFAULT_PARAM_ADDR)) //已存
|
|
{
|
|
atsc_para.bak_check_flag = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
e2rom_read_ad3(&atsc_para.ad3_para); //优先读取COR类型 后边读取AGC,power等用到此变量
|
|
e2rom_read_wh(&atsc_para.wh_para); //主要读取 FUNC
|
|
e2rom_read_wl(&atsc_para.wl_para);
|
|
e2rom_read_ad1(&atsc_para.ad_para);
|
|
|
|
e2rom_read_system(&atsc_para.system_para);
|
|
fpga_read_system(&atsc_para.system_para);
|
|
e2rom_read_rf(&atsc_para.rf_para);
|
|
|
|
e2rom_read_network(&atsc_para.network_para);
|
|
e2rom_read_mode(&atsc_para.mode_para);
|
|
e2rom_read_config(&atsc_para.config_para);
|
|
|
|
#if ATSC_USA_AMP
|
|
e2rom_read_pa_config(&atsc_para.pa_config_para);
|
|
#endif
|
|
e2rom_read_sn(&atsc_para.sn_para);
|
|
#if USE_PSTS
|
|
e2rom_read_psts(&atsc_para.psts_para);
|
|
if(!atsc_para.sn_para.psip_key_valid)
|
|
{
|
|
atsc_para.psts_para.ts_ctrl = 0;//若key无效,强制置为disable模式
|
|
}
|
|
#endif
|
|
if(!atsc_para.sn_para.eas_key_valid)
|
|
{
|
|
if(atsc_para.system_para.input==ASI_INPUT_EAS)
|
|
{
|
|
atsc_para.system_para.input = ASI_INPUT_TS;
|
|
}
|
|
}
|
|
e2rom_read_ad2(&atsc_para.ad2_para);
|
|
e2rom_read_ad3(&atsc_para.ad3_para);
|
|
e2rom_read_ad4(&atsc_para.ad4_para);
|
|
e2rom_read_ad5(&atsc_para.ad5_para);
|
|
e2rom_read_latch(&atsc_para.latch_para);
|
|
|
|
e2rom_read_user_info(atsc_para.reg_user_info);
|
|
|
|
e2rom_read_wb(&atsc_para.wb_para);
|
|
e2rom_read_wc(&atsc_para.wc_para);
|
|
e2rom_read_wd(&atsc_para.wd_para);
|
|
e2rom_read_we(&atsc_para.we_para);
|
|
e2rom_read_wf(&atsc_para.wf_para);
|
|
|
|
e2rom_read_wj(&atsc_para.wj_para);
|
|
|
|
e2rom_read_ri(&atsc_para.ri_para);
|
|
e2rom_read_wk(&atsc_para.wk_para);
|
|
|
|
e2rom_read_dpd_para(&atsc_para.dpd_para);
|
|
e2prom_read_ntp_server(atsc_para.system_para.ntp_ip, &atsc_para.system_para.ntp_switch);
|
|
|
|
e2rom_read_tsoip(TSOIP_1, &ip2ts[TSOIP_1].tsoip_config_para);
|
|
log_printf(LOG_DEBUG,I_NOUSED,"TSOIP 1 -- ip %d.%d.%d.%d mask:%d.%d.%d.%d gy:%d.%d.%d.%d mutli:%d.%d.%d.%d \n",
|
|
ip2ts[TSOIP_1].tsoip_config_para.ip[0],
|
|
ip2ts[TSOIP_1].tsoip_config_para.ip[1],
|
|
ip2ts[TSOIP_1].tsoip_config_para.ip[2],
|
|
ip2ts[TSOIP_1].tsoip_config_para.ip[3],
|
|
ip2ts[TSOIP_1].tsoip_config_para.mask[0],
|
|
ip2ts[TSOIP_1].tsoip_config_para.mask[1],
|
|
ip2ts[TSOIP_1].tsoip_config_para.mask[2],
|
|
ip2ts[TSOIP_1].tsoip_config_para.mask[3],
|
|
ip2ts[TSOIP_1].tsoip_config_para.gateway[0],
|
|
ip2ts[TSOIP_1].tsoip_config_para.gateway[1],
|
|
ip2ts[TSOIP_1].tsoip_config_para.gateway[2],
|
|
ip2ts[TSOIP_1].tsoip_config_para.gateway[3],
|
|
ip2ts[TSOIP_1].tsoip_config_para.multi_address[0],
|
|
ip2ts[TSOIP_1].tsoip_config_para.multi_address[1],
|
|
ip2ts[TSOIP_1].tsoip_config_para.multi_address[2],
|
|
ip2ts[TSOIP_1].tsoip_config_para.multi_address[3]);
|
|
|
|
if(atsc_para.wf_para.l==0)
|
|
{
|
|
atsc_para.system_para.mode = 0; //只能为legacy模式
|
|
c256_bytewrite(EEPROM_MODE_ADDR,0);
|
|
}
|
|
//if(atsc_para.wf_para.n==0)
|
|
///{
|
|
// atsc_para.system_para.net = 1; //只能为MFN模式
|
|
// c256_bytewrite(EEPROM_NET_ADDR,1);
|
|
//}
|
|
|
|
atsc_para.log_para.rxfreq = atsc_para.rf_para.rxfreq;
|
|
atsc_para.log_para.txfreq = atsc_para.rf_para.txfreq; //log屏幕初始化,可放在最后统一处理
|
|
atsc_para.log_para.adpc = atsc_para.system_para.adpc;
|
|
atsc_para.log_para.agc = atsc_para.rf_para.agc;
|
|
atsc_para.log_para.asi_input = atsc_para.system_para.input;
|
|
atsc_para.log_para.u_imd = 0;
|
|
atsc_para.log_para.l_imd = 0;
|
|
atsc_para.log_para.amp = 1;
|
|
atsc_para.system_para.final_stage = 0xff;
|
|
}
|
|
void e2rom_read_all_para(void)
|
|
{
|
|
if(E2PROM_MAGIC_WORD!=c256_byteread(EEPROM_DEFAULT_PARAM_ADDR)) //E2ROM信息未配置过!
|
|
{
|
|
log_printf(LOG_INFO, I_SYS_STATUS, "check magic word unvalid, try to load bkpfile.\n\n");
|
|
check_and_load_bkppara_to_cfgfile();
|
|
sleep(1);
|
|
}
|
|
|
|
if(E2PROM_MAGIC_WORD!=c256_byteread(EEPROM_DEFAULT_PARAM_ADDR)) //E2ROM信息未配置过!
|
|
{
|
|
#if USE_LOG_MODULE
|
|
MSG * plog_rst = alloc_msg();
|
|
#endif
|
|
log_printf(LOG_INFO, I_SYS_STATUS, "check magic word unvalid, now reset all system_para.\n\n");
|
|
|
|
atsc_para.wl_para.eebak = 1;
|
|
|
|
e2rom_load_default_param(1);
|
|
e2rom_load_default_param(2);
|
|
e2rom_load_default_param(3);
|
|
|
|
if(atsc_para.wl_para.exc_5x==0) //此处是将非当前标准的we功率也置为默认值.
|
|
{
|
|
e2rom_fac_power_rst_5x();
|
|
}
|
|
else
|
|
{
|
|
e2rom_fac_power_rst_3x();
|
|
}
|
|
|
|
e2rom_load_default_param_t_tsoip(TSOIP_1, 0);
|
|
|
|
#if USE_LOG_MODULE
|
|
if(plog_rst)
|
|
{
|
|
plog_rst->type = MSG_LOG_RECORD_RESET;
|
|
send_msg(LOG_TASK_ID,plog_rst);
|
|
}
|
|
#endif
|
|
|
|
atsc_para.wb_para.hz = 0x8000; //E2重配时,hz置为8000;
|
|
|
|
e2rom_save_wb(&atsc_para.wb_para);
|
|
|
|
c256_bytewrite(EEPROM_DEFAULT_PARAM_ADDR,E2PROM_MAGIC_WORD);
|
|
|
|
#if BAK_PARA_CHECK
|
|
if(atsc_para.wl_para.eebak)
|
|
{
|
|
c256_bytewrite2(BAK_E2_DEFAULT_PARAM_ADDR,E2PROM_MAGIC_WORD_BAK);
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
e2rom_read_para_atsc();
|
|
log_printf(LOG_DEBUG,I_NOUSED,"atsc_para.ad3_para.power_ref=0x%x\n", atsc_para.ad3_para.power_ref);
|
|
}
|
|
|
|
#if BAK_PARA_CHECK
|
|
if(atsc_para.wl_para.eebak)
|
|
{
|
|
c256_bytewrite(EEPROM_FQPW_CHECK_FLAG,E2PROM_MAGIC_WORD_BAK);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//备份系统当前的所有参数,返回值为保存的字节总长度
|
|
uint32 eeprom_backup_all_para_atsc(uint32 type)
|
|
{
|
|
uint32 save_len = 0;
|
|
uint8 *pchar = 0;
|
|
uint32 i = 0;
|
|
uint32 j = 0;
|
|
uint8 *ppower;
|
|
|
|
if((type==0)||(type>EEPROM_BACKUP_PARA_TYPE_CUST))
|
|
{
|
|
return save_len;
|
|
}
|
|
|
|
ppower = (uint8*)alloc_mem(EEPROM_CH1_POWER_ADDR+100-EEPROM_CH1_POWER_ADDR);
|
|
if(type==EEPROM_BACKUP_PARA_TYPE_PREF)
|
|
{
|
|
log_printf(LOG_DEBUG,I_NOUSED,"%s preferred settings start...\n",__FUNCTION__);
|
|
|
|
pchar = (uint8*)&atsc_para.system_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_SYSTEM,sizeof(S_SYSTEM_PARA));
|
|
save_len+=sizeof(S_SYSTEM_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.rf_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_RF,sizeof(S_RF_PARA));
|
|
save_len+=sizeof(S_RF_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.network_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_NET,sizeof(S_NETWORK_PARA));
|
|
save_len+=sizeof(S_NETWORK_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.mode_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_MODE,sizeof(S_MODE_PARA));
|
|
save_len+=sizeof(S_MODE_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.config_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_CONFIG,sizeof(S_CONFIG_PARA));
|
|
save_len+=sizeof(S_CONFIG_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_AD1,sizeof(S_ADVANCE_PARA));
|
|
save_len+=sizeof(S_ADVANCE_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad2_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_AD2,sizeof(S_ADVANCE2_PARA));
|
|
save_len+=sizeof(S_ADVANCE2_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad3_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_AD3,sizeof(S_ADVANCE3_PARA));
|
|
save_len+=sizeof(S_ADVANCE3_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad4_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_AD4,sizeof(S_ADVANCE4_PARA));
|
|
save_len+=sizeof(S_ADVANCE4_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad5_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_AD5,sizeof(S_ADVANCE5_PARA));
|
|
save_len+=sizeof(S_ADVANCE5_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wb_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_WB,sizeof(S_WB_PARA));
|
|
save_len+=sizeof(S_WB_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wc_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_WC,sizeof(S_WC_PARA));
|
|
save_len+=sizeof(S_WC_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wd_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_WD,sizeof(S_WD_PARA));
|
|
save_len+=sizeof(S_WD_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.we_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_WE,sizeof(S_WE_PARA));
|
|
save_len+=sizeof(S_WE_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wf_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_WF,sizeof(S_WF_PARA));
|
|
save_len+=sizeof(S_WF_PARA);
|
|
|
|
//pchar = (uint8*)&atsc_para.rg_para;
|
|
//atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_RG,sizeof(S_RG_PARA));
|
|
//save_len+=sizeof(S_RG_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wh_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_WH,sizeof(S_WH_PARA));
|
|
save_len+=sizeof(S_WH_PARA);
|
|
|
|
//pchar = (uint8*)&atsc_para.ri_para;
|
|
//atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_WI,sizeof(S_RI_PARA));
|
|
//save_len+=sizeof(S_RI_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wj_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_WJ,sizeof(S_WJ_PARA));
|
|
save_len+=sizeof(S_WJ_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wk_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_WK,sizeof(S_WK_PARA));
|
|
save_len+=sizeof(S_WK_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wl_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_PREF_WL,sizeof(S_WL_PARA));
|
|
save_len+=sizeof(S_WL_PARA);
|
|
|
|
if(ppower)
|
|
{
|
|
for(i=EEPROM_CH1_POWER_ADDR,j=0;i<EEPROM_CH1_POWER_ADDR+100;i++,j++)
|
|
{
|
|
ppower[j] = c256_byteread(i);
|
|
}
|
|
atmel_write_e3(ppower,E3_BACKUP_PARA_POWER_PREF_START,j);
|
|
}
|
|
else
|
|
{
|
|
for(i=EEPROM_CH1_POWER_ADDR,j=0;i<EEPROM_CH1_POWER_ADDR+100;i++,j++)
|
|
{
|
|
c256_bytewrite3(E3_BACKUP_PARA_POWER_PREF_START+j,c256_byteread(i));
|
|
}
|
|
}
|
|
save_len+=j;
|
|
c256_bytewrite3(E3_BACKUP_PARA_PREF_VALID, EEPROM_BACKUP_VALID_WORD);
|
|
log_printf(LOG_DEBUG,I_NOUSED,"preferred settings end,save data:%d\n",save_len);
|
|
}
|
|
else
|
|
{
|
|
log_printf(LOG_DEBUG,I_NOUSED,"custom settings start..\n");
|
|
pchar = (uint8*)&atsc_para.system_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_SYSTEM,sizeof(S_SYSTEM_PARA));
|
|
save_len+=sizeof(S_SYSTEM_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.rf_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_RF,sizeof(S_RF_PARA));
|
|
save_len+=sizeof(S_RF_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.network_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_NET,sizeof(S_NETWORK_PARA));
|
|
save_len+=sizeof(S_NETWORK_PARA);
|
|
|
|
|
|
pchar = (uint8*)&atsc_para.mode_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_MODE,sizeof(S_MODE_PARA));
|
|
save_len+=sizeof(S_MODE_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.config_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_CONFIG,sizeof(S_CONFIG_PARA));
|
|
save_len+=sizeof(S_CONFIG_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_AD1,sizeof(S_ADVANCE_PARA));
|
|
save_len+=sizeof(S_ADVANCE_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad2_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_AD2,sizeof(S_ADVANCE2_PARA));
|
|
save_len+=sizeof(S_ADVANCE2_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad3_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_AD3,sizeof(S_ADVANCE3_PARA));
|
|
save_len+=sizeof(S_ADVANCE3_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad4_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_AD4,sizeof(S_ADVANCE4_PARA));
|
|
save_len+=sizeof(S_ADVANCE4_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad5_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_AD5,sizeof(S_ADVANCE5_PARA));
|
|
save_len+=sizeof(S_ADVANCE5_PARA);
|
|
|
|
|
|
pchar = (uint8*)&atsc_para.wb_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_WB,sizeof(S_WB_PARA));
|
|
save_len+=sizeof(S_WB_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wc_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_WC,sizeof(S_WC_PARA));
|
|
save_len+=sizeof(S_WC_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wd_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_WD,sizeof(S_WD_PARA));
|
|
save_len+=sizeof(S_WD_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.we_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_WE,sizeof(S_WE_PARA));
|
|
save_len+=sizeof(S_WE_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wf_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_WF,sizeof(S_WF_PARA));
|
|
save_len+=sizeof(S_WF_PARA);
|
|
|
|
//pchar = (uint8*)&atsc_para.rg_para;
|
|
//atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_RG,sizeof(S_RG_PARA));
|
|
//save_len+=sizeof(S_RG_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wh_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_WH,sizeof(S_WH_PARA));
|
|
save_len+=sizeof(S_WH_PARA);
|
|
|
|
//pchar = (uint8*)&atsc_para.ri_para;
|
|
//atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_WI,sizeof(S_RI_PARA));
|
|
//save_len+=sizeof(S_RI_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wj_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_WJ,sizeof(S_WJ_PARA));
|
|
save_len+=sizeof(S_WJ_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wk_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_WK,sizeof(S_WK_PARA));
|
|
save_len+=sizeof(S_WK_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wl_para;
|
|
atmel_write_e3(pchar,E3_BACKUP_PARA_CUST_WL,sizeof(S_WL_PARA));
|
|
save_len+=sizeof(S_WL_PARA);
|
|
|
|
if(ppower)
|
|
{
|
|
for(i=EEPROM_CH1_POWER_ADDR,j=0;i<EEPROM_CH1_POWER_ADDR+100;i++,j++)
|
|
{
|
|
ppower[j] = c256_byteread(i);
|
|
}
|
|
atmel_write_e3(ppower,E3_BACKUP_PARA_POWER_CUST_START,j);
|
|
}
|
|
else
|
|
{
|
|
for(i=EEPROM_CH1_POWER_ADDR,j=0;i<EEPROM_CH1_POWER_ADDR+100;i++,j++)
|
|
{
|
|
c256_bytewrite3(E3_BACKUP_PARA_POWER_CUST_START+j,c256_byteread(i));
|
|
}
|
|
}
|
|
save_len+=j;
|
|
c256_bytewrite3(E3_BACKUP_PARA_CUST_VALID, EEPROM_BACKUP_VALID_WORD);
|
|
log_printf(LOG_DEBUG,I_NOUSED," custom settings end,save data:%d\n",save_len);
|
|
}
|
|
|
|
free_mem(ppower);
|
|
return save_len;
|
|
}
|
|
|
|
|
|
//读取后,参数错误检查还需同步更新.
|
|
uint32 eeprom_reload_all_para_atsc(uint32 type)
|
|
{
|
|
uint32 read_len = 0;
|
|
uint8 *pchar = 0;
|
|
uint32 i = 0;
|
|
uint32 j = 0;
|
|
uint8 *ppower;
|
|
|
|
if((type==0)||(type>EEPROM_BACKUP_PARA_TYPE_CUST))
|
|
{
|
|
return read_len;
|
|
}
|
|
|
|
log_printf(LOG_DEBUG,I_NOUSED,"start...\n");
|
|
|
|
ppower = (uint8*)alloc_mem(EEPROM_CH1_POWER_ADDR+100-EEPROM_CH1_POWER_ADDR);
|
|
|
|
if(type==EEPROM_BACKUP_PARA_TYPE_PREF)
|
|
{
|
|
if(c256_byteread3(E3_BACKUP_PARA_PREF_VALID)!= EEPROM_BACKUP_VALID_WORD)
|
|
{
|
|
log_printf(LOG_DEBUG,I_NOUSED,"end.load size:%d.\n",read_len);
|
|
free_mem(ppower);
|
|
return read_len;
|
|
}
|
|
|
|
pchar = (uint8*)&atsc_para.system_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_SYSTEM,sizeof(S_SYSTEM_PARA));
|
|
read_len+=sizeof(S_SYSTEM_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.rf_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_RF,sizeof(S_RF_PARA));
|
|
read_len+=sizeof(S_RF_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.network_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_NET,sizeof(S_NETWORK_PARA));
|
|
read_len+=sizeof(S_NETWORK_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.mode_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_MODE,sizeof(S_MODE_PARA));
|
|
read_len+=sizeof(S_MODE_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.config_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_CONFIG,sizeof(S_CONFIG_PARA));
|
|
read_len+=sizeof(S_CONFIG_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_AD1,sizeof(S_ADVANCE_PARA));
|
|
read_len+=sizeof(S_ADVANCE_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad2_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_AD2,sizeof(S_ADVANCE2_PARA));
|
|
read_len+=sizeof(S_ADVANCE2_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad3_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_AD3,sizeof(S_ADVANCE3_PARA));
|
|
read_len+=sizeof(S_ADVANCE3_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad4_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_AD4,sizeof(S_ADVANCE4_PARA));
|
|
read_len+=sizeof(S_ADVANCE4_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad5_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_AD5,sizeof(S_ADVANCE5_PARA));
|
|
read_len+=sizeof(S_ADVANCE5_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wb_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_WB,sizeof(S_WB_PARA));
|
|
read_len+=sizeof(S_WB_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wc_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_WC,sizeof(S_WC_PARA));
|
|
read_len+=sizeof(S_WC_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wd_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_WD,sizeof(S_WD_PARA));
|
|
read_len+=sizeof(S_WD_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.we_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_WE,sizeof(S_WE_PARA));
|
|
read_len+=sizeof(S_WE_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wf_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_WF,sizeof(S_WF_PARA));
|
|
read_len+=sizeof(S_WF_PARA);
|
|
|
|
//pchar = (uint8*)&atsc_para.rg_para;
|
|
//atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_RG,sizeof(S_RG_PARA));
|
|
//read_len+=sizeof(S_RG_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wh_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_WH,sizeof(S_WH_PARA));
|
|
read_len+=sizeof(S_WH_PARA);
|
|
|
|
//pchar = (uint8*)&atsc_para.wi_para;
|
|
//atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_WI,sizeof(S_WI_PARA));
|
|
//read_len+=sizeof(S_WI_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wj_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_WJ,sizeof(S_WJ_PARA));
|
|
read_len+=sizeof(S_WJ_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wk_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_WK,sizeof(S_WK_PARA));
|
|
read_len+=sizeof(S_WK_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wl_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_PREF_WL,sizeof(S_WL_PARA));
|
|
read_len+=sizeof(S_WL_PARA);
|
|
|
|
if(ppower)
|
|
{
|
|
atmel_read_e3(ppower,E3_BACKUP_PARA_POWER_PREF_START,EEPROM_CH1_POWER_ADDR+100-EEPROM_CH1_POWER_ADDR);
|
|
for(i=EEPROM_CH1_POWER_ADDR,j=0;i<EEPROM_CH1_POWER_ADDR+100;i++,j++)
|
|
{
|
|
c256_bytewrite(i,ppower[j]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(i=EEPROM_CH1_POWER_ADDR,j=0;i<EEPROM_CH1_POWER_ADDR+100;i++,j++)
|
|
{
|
|
c256_bytewrite(i,c256_byteread3(E3_BACKUP_PARA_POWER_PREF_START+j));
|
|
}
|
|
}
|
|
read_len+=j;
|
|
}
|
|
else
|
|
{
|
|
if(c256_byteread3(E3_BACKUP_PARA_CUST_VALID)!=EEPROM_BACKUP_VALID_WORD)
|
|
{
|
|
log_printf(LOG_DEBUG,I_NOUSED," end.load size:%d.\n",read_len);
|
|
free_mem(ppower);
|
|
return read_len;
|
|
}
|
|
|
|
pchar = (uint8*)&atsc_para.system_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_SYSTEM,sizeof(S_SYSTEM_PARA));
|
|
read_len+=sizeof(S_SYSTEM_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.rf_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_RF,sizeof(S_RF_PARA));
|
|
read_len+=sizeof(S_RF_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.network_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_NET,sizeof(S_NETWORK_PARA));
|
|
read_len+=sizeof(S_NETWORK_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.mode_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_MODE,sizeof(S_MODE_PARA));
|
|
read_len+=sizeof(S_MODE_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.config_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_CONFIG,sizeof(S_CONFIG_PARA));
|
|
read_len+=sizeof(S_CONFIG_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_AD1,sizeof(S_ADVANCE_PARA));
|
|
read_len+=sizeof(S_ADVANCE_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad2_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_AD2,sizeof(S_ADVANCE2_PARA));
|
|
read_len+=sizeof(S_ADVANCE2_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad3_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_AD3,sizeof(S_ADVANCE3_PARA));
|
|
read_len+=sizeof(S_ADVANCE3_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad4_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_AD4,sizeof(S_ADVANCE4_PARA));
|
|
read_len+=sizeof(S_ADVANCE4_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.ad5_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_AD5,sizeof(S_ADVANCE5_PARA));
|
|
read_len+=sizeof(S_ADVANCE5_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wb_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_WB,sizeof(S_WB_PARA));
|
|
read_len+=sizeof(S_WB_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wc_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_WC,sizeof(S_WC_PARA));
|
|
read_len+=sizeof(S_WC_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wd_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_WD,sizeof(S_WD_PARA));
|
|
read_len+=sizeof(S_WD_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.we_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_WE,sizeof(S_WE_PARA));
|
|
read_len+=sizeof(S_WE_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wf_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_WF,sizeof(S_WF_PARA));
|
|
read_len+=sizeof(S_WF_PARA);
|
|
|
|
//pchar = (uint8*)&atsc_para.rg_para;
|
|
//atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_RG,sizeof(S_RG_PARA));
|
|
//read_len+=sizeof(S_RG_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wh_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_WH,sizeof(S_WH_PARA));
|
|
read_len+=sizeof(S_WH_PARA);
|
|
|
|
//pchar = (uint8*)&atsc_para.wi_para;
|
|
//atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_WI,sizeof(S_WI_PARA));
|
|
//read_len+=sizeof(S_WI_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wj_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_WJ,sizeof(S_WJ_PARA));
|
|
read_len+=sizeof(S_WJ_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wk_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_WK,sizeof(S_WK_PARA));
|
|
read_len+=sizeof(S_WK_PARA);
|
|
|
|
pchar = (uint8*)&atsc_para.wl_para;
|
|
atmel_read_e3(pchar,E3_BACKUP_PARA_CUST_WL,sizeof(S_WL_PARA));
|
|
read_len+=sizeof(S_WL_PARA);
|
|
|
|
if(ppower)
|
|
{
|
|
atmel_read_e3(ppower,E3_BACKUP_PARA_POWER_CUST_START,EEPROM_CH1_POWER_ADDR+100-EEPROM_CH1_POWER_ADDR);
|
|
for(i=EEPROM_CH1_POWER_ADDR,j=0;i<EEPROM_CH1_POWER_ADDR+100;i++,j++)
|
|
{
|
|
c256_bytewrite(i,ppower[j]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(i=EEPROM_CH1_POWER_ADDR,j=0;i<EEPROM_CH1_POWER_ADDR+100;i++,j++)
|
|
{
|
|
c256_bytewrite(i,c256_byteread3(E3_BACKUP_PARA_POWER_CUST_START+j));
|
|
}
|
|
}
|
|
read_len+=j;
|
|
}
|
|
|
|
e2rom_save_rf(&atsc_para.rf_para);
|
|
e2rom_save_sys(&atsc_para.system_para);//保存 系统参数 至E2ROM
|
|
e2rom_save_rf(&atsc_para.rf_para);
|
|
e2rom_save_config(&atsc_para.config_para);
|
|
e2rom_save_network(&atsc_para.network_para);
|
|
e2rom_save_mode(&atsc_para.mode_para);
|
|
|
|
e2rom_save_ad(&atsc_para.ad_para);
|
|
e2rom_save_ad2(&atsc_para.ad2_para);
|
|
e2rom_save_ad3(&atsc_para.ad3_para);
|
|
e2rom_save_ad4(&atsc_para.ad4_para);
|
|
e2rom_save_ad5(&atsc_para.ad5_para);
|
|
|
|
e2rom_save_wb(&atsc_para.wb_para);
|
|
e2rom_save_wc(&atsc_para.wc_para);
|
|
e2rom_save_wd(&atsc_para.wd_para);
|
|
e2rom_save_we(&atsc_para.we_para);
|
|
e2rom_save_wf(&atsc_para.wf_para);
|
|
e2rom_save_wh(&atsc_para.wh_para);
|
|
e2rom_save_wj(&atsc_para.wj_para);
|
|
e2rom_save_wk(&atsc_para.wk_para);
|
|
e2rom_save_wl(&atsc_para.wl_para);
|
|
|
|
fpga_save_all_para(TRUE);
|
|
|
|
|
|
log_printf(LOG_DEBUG,I_NOUSED," end.load size:%d.\n",read_len);
|
|
free_mem(ppower);
|
|
return read_len;
|
|
}
|
|
|
|
|
|
/*******************************************END****************************************************/
|