syncflash.c

基于dragon_MX1_ads的装载启动代码armboot

#include "../../Include/type.h"

/* 4Mx16x2 IAM=0 CSD1 */

#define SDCTL0     0x00221000
#define SDCTL1     (SDCTL0+4)

// Following Setting is for CSD1
#define SDCTL      SDCTL1
#define SYNCFLASH_BASE (0x0C000000)

#define SYNCFLASH_A10  (0x00100000)

#define CMD_NORMAL     (0x81020300)            /* Normal Mode                */
#define CMD_PREC       (CMD_NORMAL+0x10000000) /* Precharge Command          */
#define CMD_AUTO       (CMD_NORMAL+0x20000000) /* Auto Refresh Command       */
#define CMD_LMR        (CMD_NORMAL+0x30000000) /* Load Mode Register Command */
#define CMD_LCR        (CMD_NORMAL+0x60000000) /* LCR Command                */
#define CMD_PROGRAM    (CMD_NORMAL+0x70000000)

#define MODE_REG_VAL   (SYNCFLASH_BASE+0x0008CC00) // Cas Latency 3

/* LCR Command */
#define LCR_READSTATUS    (0x0001C000) // 0x70
#define LCR_ERASE_CONFIRM (0x00008000) // 0x20
#define LCR_ERASE_NVMODE  (0x0000C000) // 0x30
#define LCR_PROG_NVMODE   (0x00028000) // 0xA0
#define LCR_SR_CLEAR      (0x00014000)  //0x50

void SyncFlashErase(U32);

void Delay(U32 Time)
{
    while(Time--);
}

/*
U32 SyncFlashBlankCheck(U32 StartAddress, U32 ByteSize)
{
  U32 i;
  
  for(i=0; i<ByteSize; i++)
     if( (*(P_U8)(StartAddress+i)) != 0xFF )
       return 0;
  
  return 1;
}
*/
U32 SyncFlashError(U32 ErrorCheck)
{
    U32 Error;
    
    Error=ErrorCheck;
    
	return Error;
}

void SyncFlashSRClear(void)
{
	U32 tmp;
	
    *(P_U32)SDCTL=CMD_LCR;         // Active LCR Mode
    tmp=*(P_U32)(SYNCFLASH_BASE+LCR_SR_CLEAR);
}

U32 SyncFlashSR(void)
{
	U32 tmp;

	*(P_U32)SDCTL=CMD_PREC;                       // Set Precharge Command
	tmp=(*(P_U32)(SYNCFLASH_BASE+SYNCFLASH_A10)); // Issue Precharge All command

    *(P_U32)SDCTL=CMD_LCR;         // Active LCR Mode
    *(P_U32)(SYNCFLASH_BASE+LCR_READSTATUS)=0; // issue status read setup
//    tmp=*(P_U32)(SYNCFLASH_BASE+LCR_READSTATUS); // issue status read setup
    *(P_U32)SDCTL=CMD_NORMAL;         // Return to Normal Mode

    tmp=(*(P_U32)SYNCFLASH_BASE); // Read SR of SYNC Flash
    
    SyncFlashSRClear();
    
	return tmp;
}

U8  SyncFlashReady(void)
{
	U32 tmp;

	tmp=SyncFlashSR();

    if( (tmp&0x00800000) && (tmp&0x001C0000) )
      SyncFlashError(tmp);

    if( (tmp&0x00000080) && (tmp&0x0000001C) )
      SyncFlashError(tmp);
   
   	if(tmp==0x00800080) // Test Bit 7 of SR
   	  return 1;
   	else
   	  return 0;
}

/* Check the address is equal to the Block starting address or not */
/*
U8 SyncFlashBlockStartingAddress(U32 Address)
{
   U32 i;
   U32 NumberOfBlock = 16;
   U32 BlockTable[]  = {0x00000000,
                        0x00080000, 
                        0x00100000,
                        0x00180000,
                        0x00200000,
                        0x00280000,
                        0x00300000,
                        0x00380000,
                        0x00400000,
                        0x00480000,
                        0x00500000,
                        0x00580000,
                        0x00600000,
                        0x00680000,
                        0x00700000,
                        0x00780000 }; 
   for(i=0; i<NumberOfBlock; i++)
     if( (SYNCFLASH_BASE+BlockTable[i]) == Address )
       return 1;
   return 0;
}
*/
void SyncFlashPrechargeAll(void)
{
	U32 tmp;
	
	*(P_U32)SDCTL=CMD_PREC;                       // Set Precharge Command
	tmp=(*(P_U32)(SYNCFLASH_BASE+SYNCFLASH_A10)); // Issue Precharge All command

}

void SyncFlashNormal(void)
{
    SyncFlashPrechargeAll();

	*(P_U32)SDCTL=CMD_NORMAL;       // Set Normal Mode
}

void SyncFlashInit(void)
{
    U32 tmp;

    /* Turn on CSD1 for negating RESETSF of SyncFLash */
	*(P_U32)SDCTL1|=0x80000000;
	*(P_U32)SDCTL0|=0x80000000;
	Delay(1000);
	
	
	*(P_U32)SDCTL=CMD_LMR;          // Set Load Mode Register Command
	tmp=(*(P_U32)(MODE_REG_VAL));   // Issue Load Mode Register Command
}
/*
U32 error(U32 Address)
{
   return Address;
}
*/

void SyncFlashWrite(U32 SourceAddress, U32 TargetAddress, U32 ByteSize)
{
  U32 i;
  U32 StatusRegister;
  U32 Timer;
  U32 tmp;


  for(i=0; i<ByteSize; i+=4)
  {  
    SyncFlashPrechargeAll();

    *(P_U32)SDCTL=CMD_PROGRAM; // Enter Sync Flash Program Mode

    *(P_U32)(TargetAddress+i)=*(P_U32)(SourceAddress+i);

	while(!SyncFlashReady());

    SyncFlashNormal();
  }
}
/*
void SyncFlashSingleWrite(U32 FlashAddress, U32 Data)
{
	U32 tmp;

    SyncFlashPrechargeAll();

    *(P_U32)SDCTL=CMD_PROGRAM; // Enter Sync Flash Program Mode

    *(P_U32)(FlashAddress)=Data;

    while(!SyncFlashReady());

    SyncFlashNormal();
}

void SyncFlashAutoWrite(U32 SourceAddress, U32 TargetAddress, U32 ByteSize)
{
  U32 i;
  U32 StatusRegister;
  U32 Timer;
  U32 tmp;


  for(i=0; i<ByteSize; i+=4)
  {  
    SyncFlashNormal();
	if(SyncFlashBlockStartingAddress(TargetAddress+i)) {
	   SyncFlashErase(TargetAddress+i);
	   Delay(0x02000000);
	   SyncFlashNormal();
	   Delay(0x02000000);
	}
    SyncFlashPrechargeAll();

    *(P_U32)SDCTL=CMD_PROGRAM; // Enter Sync Flash Program Mode

    *(P_U32)(TargetAddress+i)=*(P_U32)(SourceAddress+i);

//////////////////////
//    while(1) // Poll SR7
//     {
//    	*(P_U32)SDCTL=CMD_PREC;      // Active Termination Mode
//    	*(P_U32)(SYNCFLASH_BASE)=0;          // issue Active Termination Mode
//    	*(P_U32)SDCTL=CMD_LCR;         // Active LCR Mode
//    	*(P_U32)(SYNCFLASH_BASE+LCR_READSTATUS)=0; // issue status read setup
//    	*(P_U32)SDCTL=CMD_NORMAL;      // Return to Normal Mode
//    	tmp=(*(P_U32)(SYNCFLASH_BASE+i));    // Read SR of SYNC Flash
//    	if((tmp&0x00800080)==0x00800080) // Test Bit 7 of SR
//    	  break;
//     }
///////////////////

    SyncFlashNormal();
    
    Timer=0;
    while(1)
    {
       if( *(P_U32)(TargetAddress+i)==*(P_U32)(SourceAddress+i) )
         break;
       if(Timer>1000000){
         //error(TargetAddress+i);
         break;
       }  
       Timer++;
    }
    
  }
}

U32 CompareError(U32 Address)
{
	return Address;
}

U32 Compare(U32 SourceAddress, U32 TargetAddress, U32 ByteSize)
{
   U32 i;
   U32 _error=0;
   
   for(i=0; i<ByteSize; i++)
     if(*(P_U8)(SourceAddress+i) != *(P_U8)(TargetAddress+i) )
     {
       _error=1;
       CompareError(TargetAddress+i);
     }
  
  if(_error)
    return 1;
  
  return 0;
}
*/

void SyncFlashErase(U32 RowAddress)
{
        U32 i;
        U32 tmp;

    *(P_U32)SDCTL=CMD_NORMAL;       // Set Normal Mode

    i = (*(volatile unsigned int *)RowAddress);     // read the row before the LCD/ACT/WRIT

    // precharge only one bank!!!
    *(P_U32)SDCTL=CMD_PREC;         // Set Precharge Command
    tmp=(*(P_U32)(RowAddress));             // A10 is not explicitly high

    *(P_U32)SDCTL=CMD_LCR;                        // Set to LCR Mode
    *(P_U32)(RowAddress+LCR_ERASE_CONFIRM)=0; // Issue Erase Setup Command

    *(P_U32)SDCTL=CMD_NORMAL;                     // return to normal mode
    *(P_U32)(RowAddress)=0xD0D0D0D0; // Confirm

    while(!SyncFlashReady());

    SyncFlashNormal();
}
/*
void SyncFlashEraseAll(void)
{

    SyncFlashNormal();
    SyncFlashErase(SYNCFLASH_BASE+0x0000000);
    SyncFlashErase(SYNCFLASH_BASE+0x0080000);
    SyncFlashErase(SYNCFLASH_BASE+0x0100000);
    SyncFlashErase(SYNCFLASH_BASE+0x0180000);
    SyncFlashErase(SYNCFLASH_BASE+0x0200000);
    SyncFlashErase(SYNCFLASH_BASE+0x0280000);
    SyncFlashErase(SYNCFLASH_BASE+0x0300000);
    SyncFlashErase(SYNCFLASH_BASE+0x0380000);
    SyncFlashErase(SYNCFLASH_BASE+0x0400000);
    SyncFlashErase(SYNCFLASH_BASE+0x0480000);
    SyncFlashErase(SYNCFLASH_BASE+0x0500000);
    SyncFlashErase(SYNCFLASH_BASE+0x0580000);
    SyncFlashErase(SYNCFLASH_BASE+0x0600000);
    SyncFlashErase(SYNCFLASH_BASE+0x0680000);
    SyncFlashErase(SYNCFLASH_BASE+0x0700000);
    SyncFlashErase(SYNCFLASH_BASE+0x0780000);
    
    SyncFlashNormal();
*/
/*
    SyncFlashPrechargeAll();

//	*(P_U32)SDCTL=CMD_PREC;                   // Set Precharge Command
//	*(P_U16)(SYNCFLASH_BASE+SYNCFLASH_A10)=0; // Issue Precharge All command


    *(P_U32)SDCTL=CMD_LCR;                        // Set to LCR Mode
    *(P_U32)(SYNCFLASH_BASE+LCR_ERASE_CONFIRM)=0; // Issue Erase Setup Command

    *(P_U32)SDCTL=CMD_NORMAL;                     // return to normal mode
    *(P_U32)(SYNCFLASH_BASE+LCR_ERASE_CONFIRM)=0xD0D0D0D0; // Confirm
*/ 
//}

void SyncFlashNvmodeErase(void)
{
    SyncFlashPrechargeAll();

    *(P_U32)SDCTL=CMD_LCR;                        // Set to LCR Mode
    *(P_U32)(SYNCFLASH_BASE+LCR_ERASE_NVMODE)=0; // Issue Erase Nvmode Reg. Command

    *(P_U32)SDCTL=CMD_NORMAL;                     // return to normal mode
    *(P_U32)(SYNCFLASH_BASE+LCR_ERASE_NVMODE)=0xC0C0C0C0; // Confirm
}

void SyncFlashNvmodeWrite(void)
{
    SyncFlashPrechargeAll();

    *(P_U32)SDCTL=CMD_LCR;                      // Set to LCR Mode
    *(P_U32)(SYNCFLASH_BASE+LCR_PROG_NVMODE)=0; // Issue Program Nvmode Reg. Command

    *(P_U32)SDCTL=CMD_NORMAL;                     // return to normal mode
    *(P_U32)(SYNCFLASH_BASE+LCR_PROG_NVMODE)=0xC0C0C0C0; // Confirm not needed
}