sdram.c

freescale mx21系列ARM芯片9328的WINCE5.0下的Nor Flash下载程序

// ***************************************************************************
//
//  Filename:       sdram.c
//
//  Created:        Louis Lai (6/20/2003)
//
//  Modified:       $Author: $ $Date: $
//
// ***************************************************************************


// ***************************************************************************
//  pragmas
// ***************************************************************************


// ***************************************************************************
//  includes
// ***************************************************************************
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "tht_memory_map_defines.h"
#include "common.h"


// ***************************************************************************
//  macros
// ***************************************************************************


// ***************************************************************************
//  definitions
// ***************************************************************************


	
// ***************************************************************************
//  types
// ***************************************************************************


// ***************************************************************************
//  structures
// ***************************************************************************


// ***************************************************************************
//  data
// ***************************************************************************
	

// ***************************************************************************
//  function implementations
// ***************************************************************************
// ***************************************************************************
//
//  Function:       walkingones
//
//                  This function configures the flash burst mode parameters.
//
//  Parameters:     U32		Start		Start RAM address under test
//					U32		End			End RAM address under test
//					U32		Mode		Byte/Half-Word/Word				
//
//  Return Value:   U32				
//					 
//
// ***************************************************************************			
				 
U32 walkingones(U32 Start, U32 End, U32 mode)
{
		
//		U8*		pData;
		U32		nWalk;
		U8		bWalk;
		U32		Error = 0;
		U32 	i = 0;
		U8*		bData;
		U16*	hData;
		U32*	wData;
		
		if (mode == 8)
		{
			bData = (U8*)Start;
			for	(nWalk = 1; nWalk <= (End - Start) + 1; nWalk++)
			{	 
				*bData = 1;
				bWalk = 1;
				for (i = 1; i <= 8; i++)
				{
					*bData = bWalk;
					if (*bData != bWalk)
					{
						printf("E");
						Error++;
						break;
					}
					else if ((i == 8) && (nWalk & 0xFFFF == 0))
					{
						printf("S");
					}
					*bData *= 2;
					bWalk *= 2;
				}
				bData++;
			}
		}
			
		if (mode == 16)
		{
			hData = (U16*)Start;
			for	(nWalk = 1; nWalk <= (End - Start) + 1; nWalk++)
			{	 
				*hData = 1;
				bWalk = 1;
				for (i = 1; i <= 16; i++)
				{
					*hData = bWalk;
					if (*hData != bWalk)
					{
						printf("E");
						Error++;
						break;
					}
					else if ((i == 16) && (nWalk & 0xFFFF == 0))
					{
						printf("S");
					}
					*hData *= 2;
					bWalk *= 2;
				}
				hData++;
			}
		}
			
		if (mode == 32)
		{
			wData = (U32*)Start;
			for	(nWalk = 1; nWalk <= (End - Start) + 1; nWalk++)
			{	 
				*wData = 1;
				bWalk = 1;
				for (i = 1; i <= 8; i++)
				{
					*wData = bWalk;
					if (*bData != bWalk)
					{
						printf("E");
						Error++;
						break;
					}
					else if ((i == 32) && (nWalk & 0xFFFF == 0))
					{
						printf("S");
					}
					*bData *= 2;
					bWalk *= 2;
				}
				bData++;
			}
		}
/*
				
		pData = (U8*)Start;
		for	(nWalk = 1; nWalk <= (End - Start) + 1; nWalk++)
		{	 
			*pData = 1;
			bWalk = 1;
			for (i = 1; i <= 8; i++)
			{
				*pData = bWalk;
				if (*pData != bWalk)
				{
					printf("E");
					Error++;
					break;
				}
//				else if((i == 8) && (nWalk % 102400 == 0))
				else if ((i == 8) && (nWalk & 0xFFFF == 0))
				{
					printf("S");
				}
				*pData *= 2;
				bWalk *= 2;
			}
			pData++;
			
			if (nWalk % (10*102400) == 0)
			{
				printf("\n");
			}
		}*/
		return Error;
}


							
// ***************************************************************************
//
//  Function:       sdram_test
//					Full test: Test the whole 64MBytes SDRAM at CSD0
//                  Quick test: Test 2Mbytes SDRAM at each bank
//
//  Parameters:     BOOL            FULL		Full test|Quick Test
//               							
//
//  Return Value:   void				
//					 
//
// ***************************************************************************
void sdram_test(BOOL FULL)
{
		U32		sAddress = 1;
		U32		nAddress = 2;
		U32		nError;
		U32		testsize;
		U32		BankSize;
		U32		nBank;
		U32		byte = 8;


		// **********************************************
		// Full Test - Test the whole 64MBytes SDRAM by
		// using the walking ones test pattern
		// **********************************************	
		if (FULL)					
		{
			sAddress = 0xC0300000;
			nAddress = 0xC1F40000;
			printf("\n");
			printf("RAM Full Test\n");
			nError = walkingones(sAddress, nAddress, byte);
			if (nError)
			{ 
				printf("\nRAM Full Test Fail");
				printf("\nTotal number of Error in bytes: %d", nError);
			}
			else
			{
				printf("\nRAM Full Test Pass");
			}
		}
		// **********************************************
		// Quick Test - There are four banks on each 
		// SDRAM. Quick test perform a 2kBytes walking 
		// ones test at each bank
		// **********************************************
		else
		{
			sAddress = 0xC0110000;
			testsize = 0x820;			// test 2kbyte in each bank
			BankSize = 0x7D0000;
			for (nBank = 1; nBank < 4; nBank++)
			{
				printf("\n");
    			printf("RAM Quick Test at [0x%08X - 0x%08X]...\n", sAddress, sAddress + testsize);
				nError = walkingones(sAddress, sAddress + testsize, byte);
				sAddress += BankSize;
			}
			if (nError)
			{ 
				printf("\nRAM Quick Test Fail");
				printf("\nTotal number of Error in bytes: %d", nError);
			}
			else
			{
				printf("\nRAM Quick Test Pass");
			}
		}
}

// ********************************************************************************
//
//  Function:       Memory_Fill
//					
//
//  Parameters:     U32		sAddress		Starting Address for memory fill	
//					U32		Size			Size in Byte
//					U32		tpat			test pattern to be filled (in word size)
//               							
//
//  Return Value:   void				
//					 
//
// *********************************************************************************
void Memory_Fill_U8(U32 sAddress, U32 Size, U8 tPat)
{
	U32		nWalk;
	U8*		rWalk;
	U32		nAddress;
	
	nAddress = sAddress + Size;
	nWalk = sAddress;
	rWalk = (U8*)sAddress;
	
	printf("8 bits Memory Fill at [0x%08X - 0x%08X]...\n", sAddress, nAddress);
	while (nWalk < nAddress)
	{
			if ((nWalk & 0xFFFF) == 0)
			{
				printf("P");
			}
	
			*rWalk = tPat;
			rWalk++;
			nWalk += sizeof(*rWalk);
	}
	printf("\nMemory Fill Complete\n");
}


// ********************************************************************************
//
//  Function:       Memory_Fill_U16
//					
//
//  Parameters:     U32		sAddress		Starting Address for memory fill	
//					U32		Size			Size in Half-Word
//					U32		tpat			test pattern to be filled (in word size)
//               							
//
//  Return Value:   void				
//					 
//
// *********************************************************************************
void Memory_Fill_U16(U32 sAddress, U32 Size, U16 tPat)
{
	U32		nWalk;
	U16*	rWalk;
	U32		nAddress;
	
	nAddress = sAddress + sizeof(*rWalk)*Size;
	nWalk = sAddress;
	rWalk = (U16*)sAddress;
	
	printf("16 bits Memory Fill at [0x%08X - 0x%08X]...\n", sAddress, nAddress);
	while (nWalk < nAddress)
	{
			if ((nWalk & 0xFFFF) == 0)
			{
				printf("P");
			}
	
			*rWalk = tPat;
			rWalk++;
			nWalk += sizeof(*rWalk);
	}
	printf("\nMemory Fill Complete\n");
}

	
		

// ********************************************************************************
//
//  Function:       Memory_Fill_U32
//					
//
//  Parameters:     U32		sAddress		Starting Address for memory fill	
//					U32		Size			Size in Word
//					U32		tpat			test pattern to be filled (in word size)
//               							
//
//  Return Value:   void				
//					 
//
// *********************************************************************************
void Memory_Fill_U32(U32 sAddress, U32 Size, U32 tPat)
{
	U32		nWalk;
	U32*	rWalk;
	U32		nAddress;
	
	nAddress = sAddress + sizeof(*rWalk)*Size;
	nWalk = sAddress;
	rWalk = (U32*)sAddress;
	
	printf("32 bits Memory Fill at [0x%08X - 0x%08X]...\n", sAddress, nAddress);
	while (nWalk < nAddress)
	{
			if ((nWalk & 0xFFFF) == 0)
			{
				printf("P");
			}
	
			*rWalk = tPat;
			rWalk++;
			nWalk += sizeof(*rWalk);
	}
	printf("\nMemory Fill Complete\n");
}

	

// ********************************************************************************
//
//  Function:       MemCheck_U32
//					
//
//  Parameters:     U32		sAddress		Starting Address for memory fill	
//					U32		Size			Size in Word
//					U32		tpat			test pattern to be filled (in word size)
//               							
//
//  Return Value:   void				
//					 
//
// *********************************************************************************
U32 MemCheck_U32(U32 sAddress, U32 Size, U32 tPat)
{
	U32		nWalk;
	U32*	rWalk;
	U32		nAddress;
	U32		nError = 0;
	
	nAddress = sAddress + sizeof(*rWalk)*Size;
	nWalk = sAddress;
	rWalk = (U32*)sAddress;
	
	printf("Memory Verify at [0x%08X - 0x%08X]...\n", sAddress, nAddress);
	while (nWalk < nAddress)
	{
		if (*rWalk != tPat)
		{
			printf("Memory Fail at 0x%08X...\n",nWalk);
			nError++;
		}
		else if ((nWalk & 0xFFFF) == 0)
		{
			printf("S");
		}
	
			rWalk++;
			nWalk += sizeof(*rWalk);
	}
	
	if (nError)
	{
		printf("\nMemory Check Fail\n");
		printf("Total number of Error is %d words", nError);
	}
	else
	{
		printf("\nMemory Check Complete\n");
	
	}
	return nError;
}