eeprom.c

TC35i收发短信的源代码

**	Initialization of EEPROM. Must specified wich one to be intializationed.
**
**  Parameters:
**	None
**
**  Returns:
**	None
**
****************************************************************************/
uchar ucEEPROMInitEx( uchar ucBlock )
{
	ushort usFlagAdr;        /* Effective/invalid flag address */
	uchar ucCount;           /* Elimination counter */
	uchar ucResult;          /* Processing result */

	/* Block elimination and effective block setting processing */
    /* loop for use block several minutes */
	if(ucBlock >= EEPROM_BLOCK_NO) return FALSE;

	/* Bank setting */
	SET_BANK(ucEEPROM_BANK[ucBlock]);

	/* The bank top address (a flag storage address) acquisition */
    usFlagAdr = BLOCK_TO_ADDRESS(ucEEPROM_BLOCK[ucBlock]);
 
	/* changes to a self-programming mode */
	SelfFlashModeOn();

    /* self-programming Initialization */
	if(ucSelfFlashInitialize() == FALSE) 
	{
		SelfFlashModeOff();              /* changes to a normal mode */
		return(ERRINIT);                 /* An initialization error */
	}

	/* An elimination counter minute loop */
	for(ucCount = ERASENUM + 1; ucCount > 0; ucCount--) 
	{
		/* Erases data in the block next used as EEPROM */
                                            /* Terminated normally? */
		if(ucSelfFlashBlockErase(ucEEPROM_BANK[ucBlock],ucEEPROM_BLOCK[ucBlock]) == TRUE) 
		{
			break;                        /* loop end */
		}
	}

	SelfFlashModeOff();                  /* changes to a normal mode */
                                          /* An elimination result judgment */
                                            /* Count <= 0 (re-try over) */
	if(ucCount <= 0) //erase fail
	{
		/* make a block the ban on use */
        /* Abnormal termination */
		return(ERRDEV);              /* device error */
	}

	/* only set the first block with 0x55,0xaa,0x55,0xaa. */
	SET_BANK(ucEEPROM_BANK[ucBlock]);         /* Bank setting */
                                            /* The bank top address (a flag storage address) acquisition */
	usFlagAdr = BLOCK_TO_ADDRESS(ucEEPROM_BLOCK[ucBlock]);
                                            /* A flag state judgment */
                                            /* A block is a state finished with elimination? */
	                                        /* Provids block validity setting data */
	ucDataBuf[0] = 0x55;
	ucDataBuf[1] = 0xAA;
	ucDataBuf[2] = 0x55;
	ucDataBuf[3] = 0xAA;
                                            /* changes to a self-programming mode */
	SelfFlashModeOn();
                                            /* self-programming Initialization */
	if(ucSelfFlashInitialize() == FALSE) 
	{
		SelfFlashModeOff();          /* changes to a normal mode */
		return(ERRINIT);             /* initialization error */
	}
                                            /* Sets block 0 as valid block */
	if(ucSelfFlashEEPROMWrite(ucEEPROM_BANK[ucBlock],usFlagAdr,DATALENGTH - 1) != TRUE) 
	{
		/* abnormal end */
		SelfFlashModeOff(); /* changes to a normal mode */
		return(ERRDEV); /* device error */
	}

	SelfFlashModeOff(); /* changes to a normal mode */

	return(TRUE); /* Normal end */
}


/****************************************************************************
**
**  Abstract:
**	read data from EEPROM.
**
**  Parameters:
**		usReadAdr -- 0~1024
**
**  Returns:
**	None
**
****************************************************************************/
uchar ucEEPROMReadEx(uchar ucBlock,ushort usReadAdr,ushort usReadLen,uchar *pDataAddress)
{
	uchar i;
	uchar *pReadAdr;
	ushort usTopAdr;

	if(usReadLen>BYTES1024) return (FALSE);

	/* Get top address */
	usTopAdr = BLOCK_TO_ADDRESS(ucEEPROM_BLOCK[ucBlock]);

	/* Reads data from specified address */
	pReadAdr = (uchar *)(usTopAdr+usReadAdr);

	for(i=0;i<usReadLen;i++) 
	{
		*pDataAddress++ = *pReadAdr++;
	}
 
	return(TRUE);
}

/****************************************************************************
**
**  Abstract:
**	read one byte from EEPROM.
**
**  Parameters:
**	None
**
**  Returns:
**	None
**
****************************************************************************/
uchar ucReadOneByte(uchar ucBlock,ushort usReadAdr)
{
	uchar *pReadAdr;
	ushort usTopAdr;

	/* Get top address */
	usTopAdr = BLOCK_TO_ADDRESS(ucEEPROM_BLOCK[ucBlock]);

	/* Reads data from specified address */
	pReadAdr = (uchar *)(usReadAdr+usTopAdr);

	return(*pReadAdr);
}

/****************************************************************************
**
**  Abstract:
**	Write data to EEPROM.
**
**  Parameters:
**		ucBlock -- 0~1
**		usWriteAdr -- 0~1024
**		usWriteLen -- max 16 bytes
**		pDataAddress -- data address
**  Returns:
**	None
**
****************************************************************************/
uchar ucEEPROMWriteEx(uchar ucBlock,ushort usWriteAdr,ushort usWriteLen,uchar *pDataAddress)
{
	uchar i,j;
	uchar ucResult;
	uchar ucTimes;
	ushort usTopAdr;


	/* Get top address */
	usTopAdr = BLOCK_TO_ADDRESS(ucEEPROM_BLOCK[ucBlock]);

	/* Calculate the write times */
	ucTimes = (uchar)(usWriteLen/DATALENGTH);
	if(usWriteLen%DATALENGTH!=0) ucTimes++;

	for(i=0;i<ucTimes;i++)
	{
	//	for(j=0;j<DATALENGTH;j++)
	//	{
	//		ucDataBuf[j] = 0xFF; /* Clear write buffer to 0xff */
	//	}

		for(j=0;j<DATALENGTH;j++)
		{
			ucDataBuf[j] = *pDataAddress++;          /* Setting of writing data */
		}

		/* Write to EEPROM! */
		//ucResult = ucEEPROMWriteDrv(ucEEPROM_BANK[ucBlock],usTopAdr+usWriteAdr,(uchar)usLength);
		ucResult = ucEEPROMWriteDrv(ucEEPROM_BANK[ucBlock],usTopAdr+usWriteAdr,DATALENGTH);

		usWriteAdr+=DATALENGTH;

		/* Write Error! */
		if(ucResult!=TRUE) return ucResult;
	}

	return(TRUE); //writting ok!
}

/****************************************************************************
**
**  Abstract:
**	write data into e2prom.
**
**  Parameters:
**	ucBlock -- which block writing into.
**  usWriteAdr -- writing address.
**  ucWriteLen -- writing length.
**  Returns:
**	None
**
****************************************************************************/
uchar ucEEPROMWriteDrv(uchar ucBlock,ushort usWriteAdr,uchar ucWriteLen)
{
	uchar ucCount;
	uchar ucResult;

	/* changes to a self-programming mode */
	SelfFlashModeOn();

	if(ucSelfFlashInitialize() == FALSE) 
	{                                           /* self-programming Initialization */
		SelfFlashModeOff();                      /* changes to a normal mode */
		return(ERRINIT);                         /* initialization error */
	}

	ucCount = WRITENUM + 1;                      /* Write-in counter initialization */		

	while(1)
	{

        /* Writes write data to EEPROM */
		ucResult = ucSelfFlashEEPROMWrite(ucBlock,usWriteAdr,ucWriteLen - 1);

		if(ucResult == TRUE) 
		{                                          /* Normal end? */
			break;
		}
		else if(ucResult != LIB_BLANK_ERR)
		{                                          /* Except a blank error */
			ucCount--;                              /* Counter - 1 */
			if(ucCount <= 0) 
			{                                      /* retry over */
				ucResult = ERRWRITE;                /* write error */
				break;
			}
		}
	}

	SelfFlashModeOff();                          /* changes to a normal mode */

	return ucResult;
}
/****************************************************************************
**
**  Abstract:
**	
**
**  Parameters:
**	None
**
**  Returns:
	>0x0--blank address
**	0x0-- no blank address
**
****************************************************************************/
ushort usEEPROMBlankAdrSearchEx( uchar ucBlock )
{
	uchar i;
	ushort usCurrAdr;
	ushort usTopAdr;

	usTopAdr = BLOCK_TO_ADDRESS(ucEEPROM_BLOCK[ucBlock]); // EEPROM's Top Address
	
	//Searching in current block 
	usCurrAdr = usTopAdr;
	while(usCurrAdr<(usCurrAdr+BYTES1024))
	{
		if(BLOCK_IS_BLANK((uchar *)usCurrAdr) == TRUE) // is blank 
		{
			return (usCurrAdr - usTopAdr); // return blank address 
		}
		
		usCurrAdr+=DATALENGTH;
	}

	return (0);
}