backup_m04_c2.c

sircs decoder, for amplifier.. this is to decode

					}
					_romaddr += _BlkAddr[_entry].len;
					_entry++;
					if (_entry >= _BLK_ENTRY_NUM) {
						_entry = 0;
						_romaddr = 0;
						_stat = _SYS_SRCH;
						break;
					}
				}
			}
		}
		
	} else if (_stat == _SYS_SRCH) {
		/* System data backup */
		for (i = 0; i < _TIME_LOOP; i++) {
			if (_romaddr + _len < _SYS_ALL_LEN) {
				if (SYS[_romaddr + _len] != _SysAddr[_entry].addr[_len]) {
					if (_screq){
						_scunt = CLEAR;	/* data search counter		 */	
					}
					Bak.Buzy = TRUE;			/* for power & display module		*/
					if (BR24xxWrite(&_SysAddr[_entry].addr[_len], _SYS_ADD + _romaddr + _len, 1)) {
						SYS[_romaddr + _len] = _SysAddr[_entry].addr[_len];
					} else {
						_fail = TRUE;
					}
					return;
				} else {
					if (_screq && (_scunt < _SEARCH_ALL_LEN)){
						_scunt++;	
					}
					_len++;
					if (_len >= _SysAddr[_entry].len) {
						_romaddr += _len;
						_len = 0;
						_entry++;
						if (_entry >= _SYS_ENTRY_NUM) {
							if (!_fail){
								Bak.Buzy = 0;	
							}
							_fail = FALSE;
							_romaddr = 0;
							_entry = 0;
							_stat = _BAC_SRCH;
							break;
						}
					}
				}
			}
		}
		
	} else if (_stat == _ALL_CLAR) {	/* ALL CLEAR */
		Bak.Buzy = TRUE;
		if ((_romaddr > _BLK_ALL_LEN) &&
		    (_romaddr < _MEM_ALL_LEN + _BLK_ALL_LEN)) {						/* write backup area */
			rest = _MEM_ALL_LEN + _BLK_ALL_LEN - _romaddr;
			if (rest >= _page_leng) {											/* page write */
				for (i = 0; i < _page_leng; i++){	
					CLR[i] = BUF[i + _romaddr - _BLK_ALL_LEN];	
				}
				if (BR24xxWrite(CLR, _BLK_ADD + _romaddr, _page_leng)){
					_romaddr += _page_leng;	
				}
			} else {
				for (i = 0; i < rest; i++){	
					CLR[i] = BUF[i + _romaddr - _BLK_ALL_LEN];	
				}
				if (BR24xxWrite(CLR, _BLK_ADD + _romaddr, rest)){
					_romaddr += rest;	
				}
			}
		} else if (_romaddr <= _BLK_ALL_LEN) {								/* write block area */
			if (_BLK_ALL_LEN - _romaddr >= _page_leng) {						/* no boundary adjustment */
				for (i = 0, k = 0; k < _page_leng; k += j, i++) {
					for (j = 0; j < _BlkAddr[i + _entry].len; j++){ 	
						CLR[k + j] = _BlkAddr[i + _entry].addr[j];	
					}
				}
				if (BR24xxWrite(CLR, _BLK_ADD + _romaddr, _page_leng)) {
					_romaddr += _page_leng;
					_entry   += i;
			    }
			} else { 															/* page boundary adjustment */
				rest = _page_leng - (_BLK_ALL_LEN - _romaddr);
				for (i = 0, k = 0; k < _BLK_ALL_LEN - _romaddr; k += j, i++) {	/* use block area */
					for (j = 0; j < _BlkAddr[_entry + i].len; j++){
						CLR[k + j] = _BlkAddr[_entry + i].addr[j];
					}
				}
				for (i = 0; i < rest; i++){
					CLR[k + i] = BUF[i];				/* use backup area */
				}
				if (BR24xxWrite(CLR, _BLK_ADD + _romaddr, _page_leng)) {
					_romaddr += (k + i);
					_entry = 0;
				}
			}
		} else {															/* write system area */
			if (BR24xxWrite(SYS, _SYS_ADD, _page_leng)) {
				_romaddr = 0;
				_stat = _BAC_SRCH;
				Bak.Buzy = CLEAR;
			}
		}
		
	}

/* CIS 2CH cannot read EEPROM */
#if 0
	if (_addr != Bak.Debg.Addr) {
		if (BR24xxRead(&Bak.Debg.Data, Bak.Debg.Addr, 1)) {
			_addr = Bak.Debg.Addr;
			Bak.Debg.Eror = 0;
		} else {
			_addr = ~Bak.Debg.Addr;
			Bak.Debg.Eror = 1;
		}
	}
#endif
	
	return;
}
/****************************************************************************************************/
/* FUNCTION		:	LoadAllBackupVariable																
/* PURPOSE		:	EEPROM Backup Variable Load						  									
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void LoadAllBackupVariable(void)
{
	unsigned int	i, j, k;

	if (BR24xxForceRead(SYS, _SYS_ADD, _SYS_ALL_LEN) == NULL){	Bak.Init |= _BACK_EROR;	}
	if (BR24xxForceRead(BUF, _MEM_ADD, _MEM_ALL_LEN) == NULL){	Bak.Init |= _BACK_EROR;	}
	
	if (SYS[VERS_ENT] < _ver1) 		{	Bak.Init |= _BACK_V_UP;		}
	else if (SYS[VERS_ENT] > _ver1)  	{	Bak.Init |= _BACK_V_DW;		}
	
	if (SYS[CLEAR_ENT] != _clar){	Bak.Init |= _BACK_CLAR;	}
	if (SYS[TEST_ENT] != _test){	Bak.Init |= _BACK_INIT;	}
	if (SYS[ENT1_ENT] != _ent1){	Bak.Init |= _BACK_CLAR;	}
	if (SYS[ENT2_ENT] != _ent2){	Bak.Init |= _BACK_CLAR;	}
	if (SYS[CLOF_ENT] != _clroff){	Bak.Init |= _BACK_CLOF;	}
	if (Bak.Init == NULL) {					/* normal boot?							*/
		for (i = 0, k = 0; i < _SYS_ENTRY_NUM; i++, k += j) {
			for (j = 0; j < _SysAddr[i].len; j++){
				_SysAddr[i].addr[j] = SYS[k + j];
			}
		}
		for (i = 0, k = 0; i < _BLK_ENTRY_NUM; i++) {
			if (BR24xxForceRead(_BlkAddr[i].addr, _BLK_ADD + k, _BlkAddr[i].len) == NULL) {
				Bak.Init |= _BACK_EROR;
				return;
			}
			k += _BlkAddr[i].len;
			if (BLK[i] != 0){
				BLK[i]	= 0;/* clear block write request data ('01.09.30) */
			}
		}
		for (i = 0, k = 0; i < _MEM_ENTRY_NUM; i++, k += j) {
			for (j = 0; j < _BacAddr[i].len; j++){
				_BacAddr[i].addr[j] = BUF[k + j];
			}
		}
	} else if (Bak.Init & _BACK_INIT) {		/* last reset factor super clear?		*/
		for (i = 0; i < _SYS_ALL_LEN; i++){		SYS[i] = _FILL_DATA;	}
		for (i = 0; i < _BLK_ENTRY_NUM; i++){	BLK[i] = 0xFF;			}
		for (i = 0; i < _MEM_ALL_LEN; i++){		BUF[i] = _FILL_DATA;	}
		if (BR24xxWriteAll(_FILL_DATA) == NULL){	Bak.Init |= _BACK_EROR;	}
	} else {								/* other(memory clear, version up or down	*/
		for (i = 0, k = 0; i < _SYS_ENTRY_NUM; i++, k += j) {
			for (j = 0; j < _SysAddr[i].len; j++){
				SYS[k + j] = _SysAddr[i].addr[j];
			}
		}
		for (i = 0; i < _BLK_ENTRY_NUM; i++){	BLK[i] = 0;	}
		for (i = 0, k = 0; i < _MEM_ENTRY_NUM; i++, k += j) {
			for (j = 0; j < _BacAddr[i].len; j++){
				BUF[k + j] = _BacAddr[i].addr[j];
			}
		}
		_stat = _ALL_CLAR;
	}
	return;
}
/****************************************************************************************************/
/* FUNCTION		:	LoadNonBackupVariable																
/* PURPOSE		:	EEPROM No-Backup Variable Load						  									
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void LoadNonBackupVariable(void)
{
	if (P_SEL_IR_IN != ON){
/*		Power.Flag.PowOnSel = ON;*/
		Power.Flag.PowOn = ON;
	} else {
		Power.Flag.PowOnSel = Power.Flag.PowOn;
	}		
/*	Power.Power = ON;	/*	for ICE debug	*/
	return;
}
/****************************************************************************************************/
/* FUNCTION		:	BakMemoryAllClear																
/* PURPOSE		:	Backup Variable Re-initialize						  							
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void BakMemoryAllClear(void)
{
	unsigned int	i, j;

	_clar = ~_clar;
	for (i = 0; i < _TIME_OVER / 2; i++) {
		if (BR24xxForceWrite(_SysAddr[CLEAR_ENT].addr, _SYS_ADD + CLEAR_ADD, _SysAddr[CLEAR_ENT].len)) {
			for (j = 0; j < _TIME_OVER / 2; j++) {
				if (BR24xxForceRead(&SYS[CLEAR_ENT], _SYS_ADD + CLEAR_ADD, _SysAddr[CLEAR_ENT].len)) {
					if (SYS[CLEAR_ENT] == _clar){
						return;
					}
				}
			}
		}
	}
	return;
}
/****************************************************************************************************/
/* FUNCTION		:	BakMemAllClrPowOff																
/* PURPOSE		:	Backup Variable Re-initialize & Power OFF							  							
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void BakMemAllClrPowOff(void)
{
	unsigned int	i, j, k;

	k = 0;
	for (i = 0; i < CLOF_ENT; i++){
		k += _SysAddr[i].len;
	}
	_clroff = ~_clroff;
	for (i = 0; i < _TIME_OVER / 2; i++) {
		if (BR24xxForceWrite(_SysAddr[CLOF_ENT].addr, k, _SysAddr[CLOF_ENT].len)) {
			for (j = 0; j < _TIME_OVER / 2; j++) {
				if (BR24xxForceRead(&SYS[CLOF_ENT], k, _SysAddr[CLOF_ENT].len)) {
					if (SYS[k] == _clroff){
						return;
					}
				}
			}
		}
	}	
	return;
}
/****************************************************************************************************/
/* FUNCTION		:	BakMemoryFactTest																
/* PURPOSE		:	EEPROM memory all clear for factory test							  							
/* INPUT		:	mode = Test Mode																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void BakMemoryFactTest(unsigned char mode)
{
	unsigned int	i, j;

	if (mode == _BACK_DISP){			
		_clar = _FACT_DISP;
	}else if (mode == _BACK_HARD){	
		_clar = _FACT_HARD;
	}else if (mode == _BACK_TUNR){
		_clar = _FACT_TUNR;
	}
	for (i = 0; i < _TIME_OVER / i; i++) {
		if (BR24xxForceWrite(_SysAddr[CLOF_ENT].addr, _SYS_ADD + CLOF_ADD, _SysAddr[CLOF_ENT].len)) {
			for (j = 0; j < _TIME_OVER / 2; j++) {
				if (BR24xxForceRead(&SYS[CLOF_ENT], _SYS_ADD + CLOF_ADD, _SysAddr[CLOF_ENT].len)) {
					if (SYS[_SysAddr[CLOF_ENT].len] == _clar){	
						return;
					}
				}
			}
		}
	}
	return;
}
/****************************************************************************************************/
/* FUNCTION		:	BakMemorySuperRes																
/* PURPOSE		:	EEPROM Memory All Clear With System Area						  							
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void BakMemorySuperRes(void)
{
	unsigned int	i, j ;

	_test = TRUE;
	for (i = 0; i < _TIME_OVER / 2; i++) {
		if (BR24xxForceWrite(_SysAddr[TEST_ENT].addr, _SYS_ADD + TEST_ADD, _SysAddr[TEST_ENT].len)) {
			for (j = 0; j < _TIME_OVER / 2; j++) {
				if (BR24xxForceRead(&SYS[TEST_ENT], _SYS_ADD + TEST_ADD, _SysAddr[TEST_ENT].len)) {
					if (SYS[TEST_ENT] == _test){
						return;
					}
				}
			}
		}
	}
	return;
}
/****************************************************************************************************/
/* FUNCTION		:	BakMemoryWriteReq																
/* PURPOSE		:	Block Memory Backup Request							  							
/* INPUT		:	addr = Pointer of Write Block Ram																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void BakMemoryWriteReq(unsigned char *addr)
{
	unsigned char i;

	for ( i = 0; i < _BLK_ENTRY_NUM; i++) {
		if (addr == _BlkAddr[i].addr) {
			BLK[i] = 0xFF;
			break;
		}
	}
	return;
}
/****************************************************************************************************/
/* FUNCTION		:	BakSearchStartReq																
/* PURPOSE		:	Start Searching Backup Data(from Backup Common data)						  							
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void BakSearchStartReq(void)
{
	_stat 	 = _BAC_SRCH;
	_len	 = 0;
	_entry	 = 0;
	_romaddr = 0;
	
	_scunt   = 0;
	_screq	 = 1;
	return;
}
/****************************************************************************************************/
/* FUNCTION		:	BakSearchReqCancel																
/* PURPOSE		:	Cancel Request on Searching Backup Data							  							
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void BakSearchReqCancel(void)
{
	_scunt   = 0;
	_screq   = 0;
	return;
}
/****************************************************************************************************/