progflash.c

mx21 Nor flash Bootloader 源代码

    		pWalkSrc++;
    	}
    	
    	// Cancel unlock bypass mode
        // ************************************************
        *(pBase + 0x000) = 0x00900090;
       	*(pBase + 0x000) = 0x00000000;


        // Reset flash devices
        // *******************
        *(pBase + 0x000) = 0x00f000f0;
        //printf("\nFlash Write Complete\n");
        EUARTputString("\nFlash Write Complete\n");
        
//        return bFailTotal ? 0 : nDone;
}


///@brief	This function erases all flash memory sectors 
///
///@param	sAddress	start address for erase
///@return	BOOL		chip erase success?
BOOL FlashChipErase(U32 sAddress)
{
    volatile U32*       pBase;
    BOOL               	bDone;
    BOOL                bFail;
    U32                 nPoll;
    U32					i = 0;

        // Check the Flash Starting Address
        pBase = (volatile U32*)(sAddress & 0xFE000000);
    			
		// Reset flash devices before chip erase
		// ***************************************
		*(pBase + 0x000) = 0x00f000f0;

        // Execute "normal" chip erase algorithm
        // ***************************************
        *(pBase + 0x555) = 0x00aa00aa;
        *(pBase + 0x2aa) = 0x00550055;
        *(pBase + 0x555) = 0x00800080;
        *(pBase + 0x555) = 0x00aa00aa;
        *(pBase + 0x2aa) = 0x00550055;
        *(pBase + 0x555) = 0x00100010;

		//printf("Chip Erasing...\n");
		EUARTputString("Chip Erasing...\n");
		
        // Data polling algorithm for erase operation
        // ******************************************
        bDone = FALSE;
        bFail = FALSE;

        while ((!bDone) && (!bFail))
        {
        	i++;
        	if ((i & 0xFFFF) == 0)
        	{
        		//printf(".");
        		EUARTputString(".\n");
        	}
            nPoll = *(pBase);
            if (((~nPoll) & FLASH_DQ7_2X16) == 0)
            {
                bDone = TRUE;
            }
            else if ((nPoll & FLASH_DQ5_2X16) == FLASH_DQ5_2X16)
            {
                nPoll = *(pBase);
                if (((~nPoll) & FLASH_DQ7_2X16) == 0)
                {
                    bDone = TRUE;
                }
                else
                {
                    bFail      = TRUE;
                }
            }

        }


        // Reset flash evices
        // *******************
        *(pBase + 0x000) = 0x00f000f0;
        
        //printf("\nChip Erase Complete\n");
        EUARTputString("\nChip Erase Complete\n");

    return bFail;
}


///@brief	This function erases all flash memory sectors overlapping
///             the address range specified in the parameters.
///
///@param	sAddress	start address for erase
///@param	nAddress	end address for erase
///
///@return	U32		number of bytes erased (rounded up to
///                                  next sector limit), or zero on error
U32 FlashSectorErase(U32 sAddress, U32 nAddress)
{
    volatile U32*       pBase;
    volatile U32*       pWalk;
    BOOL                bFailTotal;
    BOOL                bDone;
    BOOL                bFail;
    U32                 nWalk;
    U32                 nSize;
    U32                 nPoll;
    U32                 nDone;
    U32                 nSec;
    U32					SA;
    U32					i = 0;


        // Check the Flash Starting Address
        pBase = (volatile U32*)(sAddress & 0xFE000000);


        // Reset flash devices before starting erase sequences
        // ***************************************************
        *(pBase + 0x000) = 0x00f000f0;
		
		nSec = (U32)pBase;
		nDone = 0;
		nWalk = sAddress;
		//printf("Sector Erase at [0x%08X - 0x%08X]...\n",sAddress, nAddress);
 		EUARTputString("\nFlash Sector Erase at [0x");
 		EUARTputHex((sAddress>>24)&0xff);
 		EUARTputHex((sAddress>>16)&0xff);
 		EUARTputHex((sAddress>>8)&0xff);
 		EUARTputHex(sAddress&0xff);
 		EUARTputString(" - 0x");
 		EUARTputHex((nAddress>>24)&0xff);
 		EUARTputHex((nAddress>>16)&0xff);
 		EUARTputHex((nAddress>>8)&0xff);
 		EUARTputHex(nAddress&0xff);
 		EUARTputString("]\n");
				
		
		for (SA = 1; SA <= 270; SA++)
		{
			if ((SA >= 1 && SA <= 8) || (SA >= 262 && SA <= 270))
			{	
				nSize = 0x1000*4;
			}
			else
			{
				nSize = 0x8000*4;
			}
			
			if ((nSec <= nWalk) && (nSec + nSize > nWalk) && (nSec <= nAddress))
			{
				
				// This sector overlaps the address range. Erase it
				// ************************************************
				pWalk = (volatile U32*) nWalk;

				// Execute "normal" sector erase algorithm
				// ***************************************
				*(pBase + 0x555) = 0x00aa00aa;
				*(pBase + 0x2aa) = 0x00550055;
				*(pBase + 0x555) = 0x00800080;
				*(pBase + 0x555) = 0x00aa00aa;
				*(pBase + 0x2aa) = 0x00550055;
				*(pWalk)         = 0x00300030;


				// Data polling algorithm for erase operation
				// ******************************************
				bDone = FALSE;
				bFail = FALSE;

				while ((!bDone) && (!bFail))
				{
					nPoll = *(pWalk);
					if (((~nPoll) & FLASH_DQ7_2X16) == 0)
					{  
						bDone = TRUE;
					}
					else if ((nPoll & FLASH_DQ5_2X16) == FLASH_DQ5_2X16)
					{
						nPoll = *(pWalk);
						if (((~nPoll) & FLASH_DQ7_2X16) == 0)
						{
							bDone = TRUE;
						}
						else
						{
							bFail      = TRUE;
							bFailTotal = TRUE;
						}
					}
					if ( (i &= 0xFFFF) ==0)
					{
						//printf(".");
						EUARTputString(".");
					}
					i++;
                }
                nDone += nSize;
                nWalk += nSize;
            }
            nSec += nSize;
        }


        // Reset flash devices
        // *******************
        *(pBase + 0x000) = 0x00f000f0;
        EUARTputString("\n");

    return bFailTotal ? 0 : nDone;
}

///@brief	This function read data from flash memory
///
///@param	sAddress	start address for read
///@param	pData		data to read
///@param	nData		number of bytes to read
///
///@return	U32             start address for read
U32* FlashRead(U32 sAddress, U32* pData, U32 nData)
{
    U32					nWalk;
    U32					nAddress;
    U32*				dWalk;
    U32*				sWalk;
    U32					i;
    
    nWalk = sAddress;
    nAddress = sAddress + nData;
    dWalk = (U32*)sAddress;
    sWalk = pData;

    //printf("Flash Reading at [0x%08X - 0x%08X]...\n", sAddress, nAddress);
    // Data Read
    // *******************
    //pData=memcpy(pData, (U32*) nAddress, nData);
    //nDone = nData;
    
    while (nWalk < nAddress)
    {
    	i++;
    	if ((i & 0xFFFF) == 0)
    	{
    		//printf("R");
    		EUARTputString("R\n");
    	}
    	*dWalk = *sWalk;
    	dWalk++;
    	sWalk++;
    	nWalk +=sizeof(*dWalk);
    }
    //printf("\nFlash Read Complete\n");
    EUARTputString("\nFlash Read Complete\n");
	return (U32*)sAddress;

}

///@brief	Verify after programming
///
///@param	fAddress	RAM starting address 
///@param	rAddress	Flash starting address to be verified
///@param	nWords		number of words to check
///
///@return	U32		number of programming errors in word
U32	FlashVerify(U32 fAddress, U32 rAddress, U32 nWords)
{
	U32		i;
	U32		Errors = 0;
	U32*	fWalk;
	U32*	rWalk;
	U32		nAddress;
	
	fWalk = (U32*)fAddress;
	rWalk = (U32*)rAddress;
	nAddress = fAddress + (nWords - 1) * sizeof(*fWalk);
	//printf("Flash Verifing at [0x%08X - 0x%08X]...\n", fAddress, nAddress);
 		EUARTputString("\nFlash Verifying at [0x");
 		EUARTputHex((fAddress>>24)&0xff);
 		EUARTputHex((fAddress>>16)&0xff);
 		EUARTputHex((fAddress>>8)&0xff);
 		EUARTputHex(fAddress&0xff);
 		EUARTputString(" - 0x");
 		EUARTputHex((nAddress>>24)&0xff);
 		EUARTputHex((nAddress>>16)&0xff);
 		EUARTputHex((nAddress>>8)&0xff);
 		EUARTputHex(nAddress&0xff);
 		EUARTputString("]\n");
	
	for (i = 0; i < nWords;i++)
	{ 
		if (*fWalk != *rWalk)
		{
			//printf("Programming Error at 0x%08X\n", (U32)fWalk);
			Errors++;	
		}
		else
		{
			if ((i & 0xFFFF) == 0)
			{
				//printf("S");
				EUARTputString("S");
			}
		}
		fWalk++;
		rWalk++;
	}
	EUARTputString("\nVerify Done.\n");
	return Errors;
}



// ***************************************************************************
//
//  Function:       FlashLoader
//					 
//                  
//
//  Parameters:     U32             rAddress        RAM starting address
//		    U32		    fAddress	    Flash starting address to be programmmed
//                  U32		    nWords	    number of words to write
//
//  Return Value:   void              
//
// ***************************************************************************
void FlashLoader(U32 fAddress, U32 rAddress, U32 nWords)
{
		U32		nAddress;
		U32		Errors;
		
		EUARTputString("\nStarting Flash Programming\n");		
		nAddress = fAddress + (nWords - 1) * sizeof(U32);
		
		if (fAddress == 0xc8300000) {
			nAddress = 0xc9ffffff;
			FlashSectorErase(fAddress, nAddress);
		}
		else
			FlashSectorErase(fAddress,nAddress);
		
		FlashWrite(fAddress, (U32*)rAddress, nWords);
		Errors = FlashVerify(fAddress,rAddress,nWords);
		
		if (Errors)
		{
			EUARTputString("\nFlash Programming Error:\n Total no. of Errors:");
			EUARTputHex((Errors>>24)&0xff);
			EUARTputHex((Errors>>16)&0xff);
			EUARTputHex((Errors>>8)&0xff);
			EUARTputHex(Errors&0xff);
			EUARTputString("words(4 bytes)\n");
		}
		else
		{
			EUARTputString("\nFlash Programming Complete\n");
		}
		return;
}


void progFlash(U32 sourceAddr, U32 destinAddr, U32 byteCount)
{
	return FlashLoader(destinAddr, sourceAddr, (byteCount+4)/4);
}