flashchk.c

MPC8241:本程序是freescale的824*系列的BSP源程序

	else if ((dwStartAddr >= FLASH32_BASE_ADDR) && (dwStartAddr < FLASH32_END_ADDR))
	{
		ret = Flash32Prg(ulAddress,offset,BufAddr,DataLen);
		return (ret);
	}
	else
	{
		return (ERROR);
	}
}
/****************************************************************
 *  FunctionName  :Flash16Prg									*
 *  Function      :program flash								*
 *  Parameters    :ulAddress--start address of flash programmed	*
 *		   		   offset--program address offset				*
 *			  	   BufAddr--pointer to buffer to be read		*
 *                 DataLen--length of data to be written		*
 *  Result        :if success,return OK,else return ERROR		*
 *  Global Vars   :												*
 *  Author/Date   :												*
 *  ModifiedRecord:												*
 ****************************************************************/
int	Flash16Prg(DWORD ulAddress,DWORD offset,DWORD *BufAddr,DWORD DataLen)
{
	char	bNum;
	DWORD	dwWriteAddr;
/*	DWORD	dwBlkAddr;*/
	char	bBuffer[8];
	unsigned long long int	cmd1=0x4040404040404040LL;
	unsigned long long int	cmd2=0x7070707070707070LL;
	unsigned long long int	cmd3=0x5050505050505050LL;
	unsigned long long int	cmd4=0xFFFFFFFFFFFFFFFFLL;
	unsigned long long int	content;
	int	ii;
	
	bNum = (char)((ulAddress + offset) % 8);
	dwWriteAddr = (ulAddress + offset) & 0xFFFFFFF8;

	ii = 0;
	while (1)
	{
		memset((char *)bBuffer,0xFF,8);
		if (DataLen < (8 - bNum))
			memcpy((char *)(bBuffer + bNum),(char *)((char *)BufAddr + ii),DataLen);
		else
			memcpy((char *)(bBuffer + bNum),(char *)((char *)BufAddr + ii),(8 - bNum));

		sysLongLongMove(dwWriteAddr,(UINT32)&cmd1);
		sysLongLongMove(dwWriteAddr,(UINT32)bBuffer);
		do
		{
			sysLongLongMove(dwWriteAddr,(UINT32)&cmd2);
			content = *((unsigned long long int *)dwWriteAddr);
		}while ((content & urs7) != urs7);
		
		content = *((unsigned long long int *)dwWriteAddr);
		if ((content & urs3) == urs3)
		{
			sysLongLongMove(dwWriteAddr,(UINT32)&cmd3);
			sysLongLongMove(dwWriteAddr,(UINT32)&cmd4);			
			return (ERROR);
		}
		
		content = *((unsigned long long int *)dwWriteAddr);
		if ((content & urs4) == urs4)
		{
			sysLongLongMove(dwWriteAddr,(UINT32)&cmd3);
			sysLongLongMove(dwWriteAddr,(UINT32)&cmd4);
			return (ERROR);
		}
		
		sysLongLongMove(dwWriteAddr,(UINT32)&cmd4);
		
		if (DataLen < (8 - bNum))
			break;
		else
		{
			DataLen = DataLen -(8 - bNum);
			if (DataLen <= 0)
				break;
			else
				ii = ii + (8 - bNum);
		}

		bNum = 0;
		dwWriteAddr = dwWriteAddr + 8;		
	}
	
	return	(OK);
}

/****************************************************************
 *  FunctionName  :Flash32Prg									*
 *  Function      :program flash								*
 *  Parameters    :ulAddress--start address of flash programmed	*
 *		   		   offset--program address offset				*
 *			  	   BufAddr--pointer to buffer to be read		*
 *                 DataLen--length of data to be written		*
 *  Result        :if success,return OK,else return ERROR		*
 *  Global Vars   :												*
 *  Author/Date   :												*
 *  ModifiedRecord:												*
 ****************************************************************/
int	Flash32Prg(DWORD ulAddress,DWORD offset,DWORD *BufAddr,DWORD DataLen)
{
	DWORD	dwAddr;
/*	STATUS	retval;*/
	DWORD	*ptr;
	char	bBuffer[4];
	char	bNum;
	int		ii;	

	bNum = (ulAddress + offset) % 4;
	dwAddr = (ulAddress + offset) & 0xFFFFFFFC;
	ii = 0;

	while (1)
	{
		memset((char *)bBuffer,0xFF,4);
		if (DataLen < (4 - bNum))
			memcpy((char *)(bBuffer + bNum),(char *)((char *)BufAddr + ii),DataLen);
		else
			memcpy((char *)(bBuffer + bNum),(char *)((char *)BufAddr + ii),(4 - bNum));

		ptr = (DWORD *)dwAddr;
		*ptr = 0x40404040;
		*ptr = *((DWORD *)bBuffer);

		do
		{
			*ptr = 0x70707070;
		}while ((*ptr & 0x00800080) != 0x00800080); 

		if ((*ptr & 0x00080008) == 0x00080008)
		{
			*ptr = 0x50505050;
			*ptr = 0xFFFFFFFF;
			return (ERROR);
		}

		if ((*ptr & 0x00100010) == 0x00100010)
		{
			*ptr = 0x50505050;
			*ptr = 0xFFFFFFFF;
			return (ERROR);
		}

		*ptr = 0xFFFFFFFF;		
		
		if (DataLen < (4 - bNum))
			break;
		else
		{
			DataLen = DataLen -(4 - bNum);
			if (DataLen <= 0)
				break;
			else
				ii = ii + (4 - bNum);
		}

		bNum = 0;
		dwAddr = dwAddr + 4;
	}
	return (OK);
}
/****************************************************************
 *  FunctionName  :FlashWrite									*
 *  Function      :program flash								*
 *  Parameters    :pAddr--start address of flash written		*
 *			  	   buf--pointer to buffer to be read			*
 *  Result        :if success,return OK,else return ERROR		*
 *  Global Vars   :												*
 *  Author/Date   :												*
 *  ModifiedRecord:												*
 ****************************************************************/
STATUS	FlashWrite(WORD *pAddr,WORD *buf)
{
	STATUS retval = OK;

	*pAddr = 0x4040;
	*pAddr = *buf;
	do{
		*pAddr = 0x7070;
	}while ((*pAddr & 0x0080) != 0x0080);
	
	if ((*pAddr & 0x0008) == 0x0008)
	{
		*pAddr = 0x5050;
		retval = ERROR;
	}
	
	if ((*pAddr & 0x0010) == 0x0010)
	{
		*pAddr = 0x5050;
		retval = ERROR;
	}
	
	*pAddr = 0xFFFF;
	taskDelay(10);
	return( retval );
}

/****************************************************************
 *  FunctionName  :EraseBlock									*
 *  Function      :erase flash block							*
 *  Parameters    :BaseAddr--start address of flash erased		*
 *  Result        :if success,return OK,else return ERROR		*
 *  Global Vars   :												*
 *  Author/Date   :												*
 *  ModifiedRecord:												*
 ****************************************************************/
int	EraseBlock(DWORD BaseAddr)
{
	unsigned long long int	cmd1=0x2020202020202020LL;
	unsigned long long int	cmd2=0xd0d0d0d0d0d0d0d0LL;
	unsigned long long int	cmd3=0x7070707070707070LL;
	unsigned long long int	cmd4=0x5050505050505050LL;	
	unsigned long long int	cmd5=0xFFFFFFFFFFFFFFFFLL;
	unsigned long long int	content;
	int	retval=OK;
	DWORD	*pBaseAddr;

	if ((BaseAddr >= FLASH16_BASE_ADDR) && (BaseAddr < FLASH16_END_ADDR))
	{
		sysLongLongMove(BaseAddr,(UINT32)&cmd1);
		sysLongLongMove(BaseAddr,(UINT32)&cmd2);
		do
		{
			sysLongLongMove(BaseAddr,(UINT32)&cmd3);
			content = *((unsigned long long int *)BaseAddr);
		}while ((content & urs7) != urs7);
		
		content = *((unsigned long long int *)BaseAddr);
		if ((content & urs3) == urs3)
		{
			sysLongLongMove(BaseAddr,(UINT32)&cmd4);
			retval = ERROR;
		}
		
		content = *((unsigned long long int *)BaseAddr);
		if ((content & urs45) == urs45)
		{
			sysLongLongMove(BaseAddr,(UINT32)&cmd4);
			retval = ERROR;
		}
		
		content = *((unsigned long long int *)BaseAddr);
		if ((content & urs5) == urs5)
		{
			sysLongLongMove(BaseAddr,(UINT32)&cmd4);
			retval = ERROR;
		}
		
		sysLongLongMove(BaseAddr,(UINT32)&cmd5);
		taskDelay(100);
		
		return (retval);
	}
	else if ((BaseAddr >= FLASH32_BASE_ADDR) && (BaseAddr < FLASH32_END_ADDR))
	{
		pBaseAddr = (DWORD *)BaseAddr;
		*pBaseAddr = 0x20202020;
		*pBaseAddr = 0xd0d0d0d0;
		
		do
		{
			*pBaseAddr = 0x70707070;
		}while ((*pBaseAddr & 0x00800080) != 0x00800080);
		
		if ((*pBaseAddr & 0x00080008) == 0x00080008)
		{
			*pBaseAddr = 0x50505050;
			retval = ERROR;
		}
		if	((*pBaseAddr & 0x00300030) == 0x00300030)
		{
			*pBaseAddr = 0x50505050;
			retval = ERROR;
		}
		if ((*pBaseAddr & 0x00200020) == 0x00200020)
		{
			*pBaseAddr = 0x50505050;
			retval = ERROR;
		}
		
		*pBaseAddr = 0xFFFFFFFF;
		taskDelay(100);
		return (retval);
	}
	else
		return (ERROR);
}

/****************************************************************
 *  FunctionName  :FlashRead									*
 *  Function      :Read data from flash							*
 *  Parameters    :pBuf--pointer to buffer for reading			*
 *		   		   dwStartAddr--reading address					*
 *			  	   dwSize--reading length						*
 *  Result        :												*
 *  Global Vars   :												*
 *  Author/Date   :												*
 *  ModifiedRecord:												*
 ****************************************************************/
void	FlashRead(UCHAR *pBuf,char *dwStartAddr,int dwSize)
{
/*	semTake(mm_SemFlash,WAIT_FOREVER); */
	memcpy(pBuf,dwStartAddr,dwSize);		
/*	semGive(mm_SemFlash); */
	return;
}
/****************************************************************
 *  FunctionName  :EraseSection									*
 *  Function      :Erase one section							*
 *  Parameters    :dwSecStartAddr--start address of section		*
 *                 dwLength--length of section					*
 *  Result        :												*
 *  Global Vars   :												*
 *  Author/Date   :												*
 *  ModifiedRecord:												*
 ****************************************************************/
void	EraseSection(DWORD dwSecStartAddr,DWORD	dwLength)
{
	UCHAR	ii;
	DWORD	jj;
	DWORD	dwEraseAddr;
	int		dwRet;
	
	if ((dwSecStartAddr >= FLASH16_BASE_ADDR) && (dwSecStartAddr < FLASH16_END_ADDR))
	{
		jj = dwLength / (DWORD)FLASH16_BLOCK_SIZE;
/*		semTake(mm_SemFlash,WAIT_FOREVER); */
		for (ii=0;ii<(UCHAR)jj;ii++)
		{
			dwEraseAddr = (DWORD)(dwSecStartAddr + ii*FLASH16_BLOCK_SIZE);
			dwRet = EraseBlock(dwEraseAddr);
		}
/*		semGive(mm_SemFlash); */
		return;
	}
	else if ((dwSecStartAddr >= FLASH32_BASE_ADDR) && (dwSecStartAddr < FLASH32_END_ADDR))
	{
		jj = dwLength / (DWORD)FLASH32_BLOCK_SIZE;
/*		semTake(mm_SemFlash,WAIT_FOREVER); */
		for (ii=0;ii<(UCHAR)jj;ii++)
		{
			dwEraseAddr = (DWORD)(dwSecStartAddr + ii*FLASH32_BLOCK_SIZE);
			dwRet = EraseBlock(dwEraseAddr);
		}
/*		semGive(mm_SemFlash); */
		return;
	}
	else
		return;
}