#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****************************************************/