backup_m04_c2.c

sircs decoder, for amplifier.. this is to decode

/* FUNCTION		:	IsBakSearchFinished																
/* PURPOSE		:	Check Whether Finished All Data Scaning							  							
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
unsigned char IsBakSearchFinished(void)
{
	unsigned char result;
	
	result = CLEAR;
	if (_scunt >= _SEARCH_ALL_LEN){	
		result = TRUE;
	}else{							
		result = FALSE;
	}
	return result;
}
/****************************************************************************************************/
/* FUNCTION		:	BR24xxWriteAll																
/* PURPOSE		:	BR24xx Fixed Data Write To All Address							  							
/* INPUT		:	data = Fixed Data Pattern																			
/* RETURN VALUE	:	TRUE = Success, NULL = Write Error																			
/****************************************************************************************************/
int BR24xxWriteAll(unsigned char data)
{
	unsigned int	i, j;
	unsigned char	buff[32];

	for (i = 0; i < 32; i++){
		buff[i] = data;
	}
	
/* warning : CIS 2CH only clear 32bytes (2 pages) instead of whole 2048bytes (128pages) EEPROM */
#if 0
	for (i = 0; i < _page_numb; i++) {
#endif

	for (i = 0; i < 2; i++) {
		for (j = 0;;) {
			if (BR24xxWrite(buff, i * _page_leng, _page_leng)){	
				break;
			}
			if (++j > _TIME_OVER){
				return NULL;
			}
		}
	}
	return TRUE;
}
/****************************************************************************************************/
/* FUNCTION		:	BR24xxForceRead																
/* PURPOSE		:	BR24xx Force Read							  							
/* INPUT		:	data = Ram Address						
/*					addr = EEPROM Address					
/*					cunt = Data Count						
/* RETURN VALUE	:	TRUE = Success							
/*					NULL = Read Error						
/****************************************************************************************************/
int BR24xxForceRead(unsigned char *data, unsigned int addr, unsigned int cunt)
{
	unsigned int i;

	for (i = 0; i < _TIME_OVER; i++) {
		if (BR24xxRead(data, addr, cunt)){
			return TRUE;
		}
	}
	return NULL;
}
/****************************************************************************************************/
/* FUNCTION		:	BR24xxRead																
/* PURPOSE		:	BR24xx Data Read						  							
/* INPUT		:	data = Ram Address						
/*					addr = EEPROM Address					
/*					cunt = Data Count						
/* RETURN VALUE	:	TRUE = Success							
/*					NULL = Read Error						
/****************************************************************************************************/
int	BR24xxRead(unsigned char *data, unsigned int addr, unsigned int cunt)
{
	unsigned int i;
	unsigned char slav,add1,add2,acko;

	if (cunt <= 0)	return NULL;
	slav = (unsigned char)(addr >> _sift_page);
	add1 = (unsigned char)(addr >> _sift_add1);
	add2 = (unsigned char)(addr >> _sift_add2);
	slav &= _mask_page;
	add1 &= _mask_add1;
	add2 &= _mask_add2;
	slav |= 0xa0;
	if (BR24xxSta() == NULL){			return NULL;	}
	if (BR24xxAcc(&slav,1,0) == NULL){	return NULL;	}
	if (BR24xxAcc(&add1,1,0) == NULL){	return NULL;	}
	if (_mask_add2) {
		if (BR24xxAcc(&add2,1,0) == NULL){	
			return NULL;	
		}
	}
	slav |= 0x01;
	if (BR24xxSta() == NULL){			return NULL;	}
	if (BR24xxAcc(&slav,1,0) == NULL){	return NULL;	}
	for (i = 0; i < cunt; i++, data++) {
		*data = 0xff;
		if (i == (cunt - 1)){	
			acko = 1;
		}else{					
			acko = 0;
		}
		if (BR24xxAcc(data, acko, acko) == NULL){
			return NULL;
		}
	}
	if (BR24xxStp() == NULL){
		return NULL;
	}
	return TRUE;
}
/****************************************************************************************************/
/* FUNCTION		:	BR24xxForceWrite																
/* PURPOSE		:	BR24xx Data Force Write						  							
/* INPUT		:	data = Ram Address						
/*					addr = EEPROM Address					
/*					cunt = Data Count						
/* RETURN VALUE	:	TRUE = Success							
/*					NULL = Read Error						
/****************************************************************************************************/
int	BR24xxForceWrite(unsigned char *data, unsigned int addr, unsigned int cunt)
{
	unsigned char 	i;
	int				result = 0;
	
	for (i = 0; i < _TIME_LOOP; i++) {
		if (BR24xxWrite(data, addr, cunt)) {
			result = TRUE;
			break;
		}
	}
	return result;
}
/****************************************************************************************************/
/* FUNCTION		:	BR24xxWrite																
/* PURPOSE		:	BR24xx Data Write							  							
/* INPUT		:	data = Ram Address						
/*					addr = EEPROM Address					
/*					cunt = Data Count						
/* RETURN VALUE	:	TRUE = Success							
/*					NULL = Read Error						
/****************************************************************************************************/
int	BR24xxWrite(unsigned char *data, unsigned int addr, unsigned int cunt)
{
	unsigned int i;
	unsigned char slav, add1, add2, buff;

	if (cunt <= 0){							return NULL;	}
	slav = (unsigned char)(addr >> _sift_page);
	add1 = (unsigned char)(addr >> _sift_add1);
	add2 = (unsigned char)(addr >> _sift_add2);
	slav &= _mask_page;
	add1 &= _mask_add1;
	add2 &= _mask_add2;
	slav |= 0xa0;
	if (BR24xxSta() == NULL){				return NULL;	}
	if (BR24xxAcc(&slav, 1, 0) == NULL){	return NULL;	}
	if (BR24xxAcc(&add1, 1, 0) == NULL){	return NULL;	}
	if (_mask_add2) {
		if (BR24xxAcc(&add2, 1, 0) == NULL){
			return NULL;	
		}
	}
	for (i = 0; i < cunt; i++, data++) {
		buff = *data;
		if (BR24xxAcc(&buff, 1, 0) == NULL){
			return NULL;
		}
		if (buff != *data) {
			BR24xxStp();
			return NULL;
		}
	}
	if (BR24xxStp() == NULL){				return NULL;	}
	
	return TRUE;
}
/****************************************************************************************************/
/* FUNCTION		:	BR24xxSta																
/* PURPOSE		:	BR24xx STA Condition						  							
/* INPUT		:	None																			
/* RETURN VALUE	:	TRUE = Success							
/*					NULL = Error							
/****************************************************************************************************/
int BR24xxSta(void)
{
	EEPCLK_0;
	EEPDIR_H;
	if (EEPDAT == 0) {
/*		EEPCLK_1;
*/		EEPCLK_1;
		EEPCLK_1;
		EEPCLK_0;
		return NULL;
	}
/*	EEPCLK_1;
*/	EEPCLK_1;
	EEPCLK_1;
	EEPDAT_0;
	EEPDIR_L;
/*	EEPDAT_0;
*/	EEPDAT_0;
	EEPCLK_0;
	return TRUE;
}
/****************************************************************************************************/
/* FUNCTION		:	BR24xxStp																
/* PURPOSE		:	BR24xx STP Condition							  							
/* RETURN VALUE	:	TRUE = Success							
/*					NULL = Error							
/****************************************************************************************************/
int BR24xxStp(void)
{
	int result;

	EEPCLK_0;
	EEPDAT_0;
	EEPDIR_L;
	EEPCLK_1;
	EEPCLK_1;
	EEPDIR_H;
	EEPCLK_1;
	if (EEPDAT) {
		result = TRUE;
	} else {
		result = NULL;
	}
	EEPCLK_0;
	return result;
}
/****************************************************************************************************/
/* FUNCTION		:	BR24xxAcc																
/* PURPOSE		:	BR24xx Data Access							  							
/* INPUT		:	data= Ram Address						
/*					addr= EEPROM Address					
/*					cunt= Data Count						
/* RETURN VALUE	:	TRUE= Success							
/*					NULL= Read Error						
/****************************************************************************************************/
int BR24xxAcc(unsigned char *data, unsigned char acko,unsigned char acki)
{
	unsigned char i, mask;

	for (i = 0, mask = 0x80; i < 8; i++, mask >>= 1) {
		EEPDAT_0;
		if ((*data) & mask){	
			EEPDIR_H;
		}else{
			EEPDIR_L;
		}
		EEPCLK_0;
		EEPCLK_1;
		if (EEPDAT){
			*data |= mask;
		}else{
			*data &= ~mask;
		}
		EEPCLK_1;
		EEPCLK_0;
	}
	
	EEPDAT_0;
	
	if (acko){
		EEPDIR_H;
	}else{
		EEPDIR_L;
	}
	
	EEPCLK_0;
	EEPCLK_1;
	
	if (EEPDAT == 0){
		i = 0;
	}else{
		i = 1;
	}
	
	EEPCLK_1;
	EEPCLK_0;
	EEPDIR_H;
	
	if (i) {
		if (acki){
			mask = 0;
		}else{
			mask = 1;
		}
	} else {
		if (acki){
			mask = 1;
		}else{
			mask = 0;
		}
	}
	
	if (mask) {
		BR24xxStp();
		return NULL;
	}
	
	return TRUE;
}
/****************************************************************************************************/
/* FUNCTION		:	_Wait																
/* PURPOSE		:	Make Wait Time Loop							  							
/* INPUT		:	n = Loop Counter																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void _Wait(unsigned int n)
{
	unsigned int i;

	for (i = 0;i < n;i++);
	return;
}

/******************************************************************************/
/* FUNCTION		:	RstBR24C16												  */
/* PURPOSE		:	Software Reset for BR24C16 (E2PROM )					  */
/* INPUT		:	None													  */
/* RETURN VALUE	:	None													  */
/******************************************************************************/
void RstBR24C16(void)
{
	unsigned int i;

	/* software reset a */
	P_SCL = HIGH;
	P_SDA = HIGH;
	_Wait(0);
	for (i = 0; i < 14; i++) {
		P_SCL = LOW;
		P_SDA = HIGH;
		_Wait(0);
		P_SCL = HIGH;
		_Wait(0);
	}
	for (i = 0; i < 2; i++) {
		P_SCL = HIGH;
		P_SDA = HIGH;
		_Wait(0);
		P_SDA = LOW;
		_Wait(0);
	}
	P_SDA = HIGH;

	return;
}