brun_flash1.c

对于DSP自引导程序的一个实例

/*******************************************************************************
* FILENAME
*   test_flash.c
*
* DESCRIPTION
*   DSK Confidence test - DSP Code - No Host
*
*  Rev 2.16   17 Jul  2000  Z.Zhang, T.J.Dillon
*  
*----------------------------------------------------------------------
*  HISTORY
*  Rev 1.00  Created by Z.Zhang
*  Rev 1.10  Mods a) LEDS and CODEC parameter passing
*                 b) Removed FLASH checksum
*  Rev 1.20  Mods - Reorganized to be consistent with cnfDSP.c
*  Rev 1.30  Mods - Added board revision info
*  Rev 2.00  Mods - Updated for C6711 DSK
*  Rev 2.10  Mods - Updated for Larger SDRAMs
*  Rev 2.16  Mods - Added newer memory test for SDRAM      
*  
   Modified by Zhu Lei in 2005 7.13 - use new header files,optimize for C67xx
   
*******************************************************************************/

#include <stdio.h>
#include <c6x.h>
#include "flash_MT.h"
#include "interrupt.c"
#include "pll.c"



typedef unsigned short  datum;     /* Set the data bus width to 16 bits. */


#define NUM_BYTES      0x10000

datum memTestDataBus(volatile datum * address);
datum * memTestAddressBus(volatile datum * baseAddress, unsigned long nBytes);
datum * memTestDevice(volatile datum * baseAddress, unsigned long nBytes);

#pragma DATA_SECTION( BufWriteToFlash    ,"BUF" );

#define WRITE_SIZE  BLOCK_SIZE

#define BLOCK_SIZE               8192L    


char BufWriteToFlash[WRITE_SIZE];        
/* Input Buf which will be writed to flash */

//#define WRITE_TO_FLASH_FILENAME          "E:\\Working Space\\Out2Hex\\ProBody(good).hex"
//#define WRITE_TO_FLASH_FILENAME          "E:\\Working Space\\Out2Hex\\mcbsp_to_28.hex"
#define WRITE_TO_FLASH_FILENAME            "E:\\Working Space\\Out2Hex\\McBsp_to_64.hex"

int flag;
int err_cnt = 0;

/*-------------------------------------------------------------------------*/
/* main()                                                                  */
/*-------------------------------------------------------------------------*/
int main()
{



//	int src,dst,size; /* Used for QDMA */

	int BurnSize =0 ;
	
	/* dsp and peripheral initialization */ 
//	PLL_INI();
	
	EMIF_INI();
	SDRAM_SETUP();
	INTERRUPT_INITIAL();

    flag = Check_INTEL_28F016();
	if(flag == 1)
	   printf("The flash is INTEL_28F016!\n ");
	else
	   {  printf("ERROR: The flash is not INTEL_28F016!\n");
	   exit();
	   }
	    

	
	BurnSize= BurnFileToFlash(WRITE_TO_FLASH_FILENAME, BufWriteToFlash, FLASH_START_ADR );
	
	if( BurnSize == 0 )
//	  printf("Burn error!\n ");
	err_cnt = 1;
//	else
//	  printf("Burn %d byte to flash!\n", BurnSize);
	
  	
}


/**************************************************************************
                       File I/O
**************************************************************************/
int    BurnFileToFlash(const char* FileName, 
							char* pDataBuf,
							char* pFlashWriteAddr)
{
   FILE * pFile;
   int result,i=0;
   int EndFlag=0;
//   int j;
//   char* tempbuf;	  //for check use;
   
	unsigned int src, dst;

    if((pFile = fopen(FileName,"rb")) == NULL)
		{//perror("Can't open out file\n");
		return 0;}
	
	do{
//		memset(pDataBuf, 255, WRITE_SIZE);
        pDataBuf = (char*)malloc(WRITE_SIZE);
		result = fread(pDataBuf, 1, WRITE_SIZE, pFile);
		if(result != WRITE_SIZE)	
			EndFlag = 1;

		if(result != 0)
		{
			src = (unsigned int)pDataBuf;
			dst = (unsigned int)pFlashWriteAddr+ i*WRITE_SIZE;
			Program_One_Block((BYTE *)src,(BYTE *)dst);
			if(memcmp(src, dst) != 0 )  //error in burn page
			{	fclose( pFile );	return 0;}
			
			if(EndFlag == 0)
				i++;



		}
		
	}while(EndFlag ==0);
	
    fclose( pFile );
	return i*WRITE_SIZE + result;
}

///////////////////////////////////////////////////////////////////////////
#if 1

datum memTestDataBus(volatile datum * address)
{
    datum pattern;

    /*
     * Perform a walking 1's test at the given address.
     */
    for (pattern = 1; pattern != 0; pattern <<= 1)
    {
        /*
         * Write the test pattern.
         */
        *address = pattern;

        /*
         * Read it back (immediately is okay for this test).
         */
        if (*address != pattern) 
        {
            return (pattern);
        }
    }

    return (0);

}   /* memTestDataBus() */



datum * memTestAddressBus(volatile datum * baseAddress, unsigned long nBytes)
{
    unsigned long addressMask = (nBytes/sizeof(datum) - 1);
    unsigned long offset;
    unsigned long testOffset;

    datum pattern     = (datum) 0xAAAAAAAA;
    datum antipattern = (datum) 0x55555555;

    /*
     * Write the default pattern at each of the power-of-two offsets.
     */
    for (offset = 1; (offset & addressMask) != 0; offset <<= 1)
    {
        baseAddress[offset] = pattern;
    }

    /* 
     * Check for address bits stuck high.
     */
    testOffset = 0;
    baseAddress[testOffset] = antipattern;

    for (offset = 1; (offset & addressMask) != 0; offset <<= 1)
    {
        if (baseAddress[offset] != pattern)
        {
            return ((datum *) &baseAddress[offset]);
        }
    }

    baseAddress[testOffset] = pattern;

    /*
     * Check for address bits stuck low or shorted.
     */
    for (testOffset = 1; (testOffset & addressMask) != 0; testOffset <<= 1)
    {
        baseAddress[testOffset] = antipattern;

		if (baseAddress[0] != pattern)
		{
			return ((datum *) &baseAddress[testOffset]);
		}

        for (offset = 1; (offset & addressMask) != 0; offset <<= 1)
        {
            if ((baseAddress[offset] != pattern) && (offset != testOffset))
            {
                return ((datum *) &baseAddress[testOffset]);
            }
        }

        baseAddress[testOffset] = pattern;
    }

    return (NULL);

}   /* memTestAddressBus() */

datum * memTestDevice(volatile datum * baseAddress, unsigned long nBytes)	
{
    unsigned long offset;
    unsigned long nWords = nBytes / sizeof(datum);

    datum pattern;
    datum antipattern;

    /*
     * Fill memory with a known pattern.
     */
    for (pattern = 1, offset = 0; offset < nWords; pattern++, offset++)
    {
        baseAddress[offset] = pattern;
    }
	
//	baseAddress[offset] = pattern;
	
    /*
     * Check each location and invert it for the second pass.
     */
    for (pattern = 1, offset = 0; offset < nWords; pattern++, offset++)
    {
        if (baseAddress[offset] != pattern)
        {
            return ((datum *) &baseAddress[offset]);
        }

        antipattern = ~pattern;
        baseAddress[offset] = antipattern;
    }

    /*
     * Check each location for the inverted pattern and zero it.
     */
    for (pattern = 1, offset = 0; offset < nWords; pattern++, offset++)
    {
        antipattern = ~pattern;
        if (baseAddress[offset] != antipattern)
        {
            return ((datum *) &baseAddress[offset]);
        }
    }

    return (NULL);

}   /* memTestDevice() */
#endif