📄 flash16bsc.c

📁 这是单板上DPRAM的驱动程序
💻 C
字号:
/***********************************************************************/
/*                                                                     */
/* This module is the hardware-dependent flash programming module, the */
/* low-level routines to erase and program the flash are provided.     */
/*                                                                     */
/* History:                                                            */
/*    szg  6/22/98   create                                            */
/*                                                                     */
/*                                                                     */
/***********************************************************************/
#include <string.h>
#include "board.h"
#include "sdev.h"
#include "flash16.h"

#define SST_MANUFACTURER_CODE        0x00BF
#define SST_DEVICE_CODE              0x2782
#define SST_ID_READ_WAIT             0X20  


#define FLASH_ERASE_CHIP_LOOP        0X4000000
#define FLASH_ERASE_SECTOR_LOOP        0X4000000
#define FLASH_WRITE_LOOP                0X4000000


static USHORT ReadReg(ULONG Addr) {
 return (*(USHORT *)Addr);
}

static void WriteReg(ULONG Addr, USHORT val) {
 *(USHORT*)Addr = val;
 return;
}

static void Flash16Init(void *pDataBuf, Flash16CfgStruct *cfg){
    Flash16CfgStruct*  pCfg =(Flash16CfgStruct *)(pDataBuf);
    memmove(pCfg,cfg,sizeof(*cfg));        
}

static int block_erase_cmd(ULONG StartAddr)
{
	int i,ret;
	WriteReg((ULONG)StartAddr,0x0050); /*clear status reg*/
    WriteReg(StartAddr,0x0020);
    WriteReg(StartAddr,0x00D0); 
    for(i=0;i<FLASH_ERASE_SECTOR_LOOP;i++){
       if((ReadReg(StartAddr)&0x0080)==0x0080)break;
    }
    if(i==FLASH_ERASE_SECTOR_LOOP)ret=SDE_FLASH_FAIL;
    else if((ReadReg(StartAddr)&0x002) != 0) ret=SDE_FLASH_LOCK;
    else if ((ReadReg(StartAddr)&0x0038) != 0) ret=SDE_FLASH_FAIL;
    else ret=SDE_OK; 
    WriteReg(StartAddr,0x00ff);
    return ret;
}	

static int block_unlock_cmd(ULONG StartAddr)
{
	int i,ret;       
    WriteReg((ULONG)StartAddr,0x0050); /* clear the status register*/  
    WriteReg(StartAddr,0x0060);
    WriteReg(StartAddr,0x00d0); 
    for(i=0;i<FLASH_ERASE_CHIP_LOOP;i++){
      if((ReadReg(StartAddr)&0x0080)==0x0080) break;
    }
    if(i==FLASH_ERASE_SECTOR_LOOP)ret=SDE_FLASH_FAIL;
    else if((ReadReg(StartAddr)&0x0038)!= 0) ret=SDE_FLASH_FAIL;
    else ret=SDE_OK; 
    WriteReg(StartAddr,0x00ff);
    return ret;    
}	

static int write_flash_cmd(ULONG Start,USHORT Data)
{
	
   int  ii, rc;
   
   WriteReg((ULONG)Start,0x0050); /* clear status reg*/
   WriteReg((ULONG)Start,0x0040);
   *(USHORT*)Start=Data;
   for(ii=0;ii<FLASH_WRITE_LOOP;ii++){
     if((ReadReg((ULONG)Start)&0x0080)==0x0080)break;
   }
   if(ii==FLASH_WRITE_LOOP) rc=SDE_FLASH_FAIL;
   else if((ReadReg((ULONG)Start)&0x0002)!=0) rc=SDE_FLASH_LOCK; 
   else if((ReadReg((ULONG)Start)&0x0038)!=0) rc=SDE_FLASH_FAIL;
   else rc=SDE_OK;
   WriteReg((ULONG)Start,0x00ff);
   return rc;  	
}	
static int read_intelflash(void *pDataBuf,void *pBuf, int MaxLen)
{
    Flash16CfgStruct *pCfg=(Flash16CfgStruct *)pDataBuf;
    SDCFlashAccessStruct *mas=(SDCFlashAccessStruct *)pBuf;
    if(MaxLen!=sizeof(SDCFlashAccessStruct))return SDE_INVALID_ARG;
    if(mas->Size <= 0 ) return SDE_INVALID_ARG;
    if(mas->Size+mas->Offset > pCfg->MaxSize)return SDE_INVALID_ARG;
    memmove(mas->Base,(UCHAR *)pCfg->BaseAddr+mas->Offset,mas->Size);
    return SDE_OK;
}

static int write_intelflash(void *pDataBuf,void *pBuf, int MaxLen)
{
    Flash16CfgStruct *pCfg=(Flash16CfgStruct *)pDataBuf;
    SDCFlashAccessStruct *mas=(SDCFlashAccessStruct *)pBuf;
    int i,end;
    UCHAR *start,*BufAddr;
    USHORT data;
    ULONG Offset,DataLen,BaseAddr;

    if(MaxLen!=sizeof(SDCFlashAccessStruct))return SDE_INVALID_ARG;
    if(mas==NULL||(mas->Size+mas->Offset>pCfg->MaxSize))return SDE_INVALID_ARG;
    if(mas->Size==0)return SDE_OK;

    BaseAddr=pCfg->BaseAddr; Offset=mas->Offset;DataLen=mas->Size;
    start=(char *)((BaseAddr+Offset)&(~1L));
    i=((BaseAddr+Offset)&1L);
    BufAddr=mas->Base-i; DataLen+=i;

    data=0xffff;
    end=(DataLen>2)?2:DataLen; 
    memmove(((UCHAR *)&data)+i,BufAddr+i,end-i);
    i=0;
    while(1)
    {
        if(data!=0xffff)
        {
                int rc;
                rc=write_flash_cmd((ULONG)start,data);
                if(rc==SDE_FLASH_LOCK) 
                {
                   rc=block_unlock_cmd((ULONG)start);
                   if(rc==SDE_OK)
                     rc=write_flash_cmd((ULONG)start,data);
                }   
                if(rc!=SDE_OK) break;   
                   
        }
        i+=2; start+=2;
        if(i>=DataLen)break; else data=0xffff;
        if((i+2)>DataLen)memmove((UCHAR *)&data,BufAddr+i,DataLen-i);
        else data=*(USHORT*)(BufAddr+i);
    }
    WriteReg(BaseAddr,0x00ff);

    if(i<DataLen) return SDE_FLASH_FAIL;
    else
    {
        start = (UCHAR *)(BaseAddr + Offset);
        if(memcmp(start,mas->Base,mas->Size)!=0)return SDE_FLASH_FAIL;
        return SDE_OK;
    }
}

static int IntelFlash16Cntrl(void *pDataBuf, int cmd, void *pParam, int maxlen)
{
    Flash16CfgStruct *pCfg=(Flash16CfgStruct *)pDataBuf;
    switch(cmd)
    {
        case SDC_GET_UNIT_SIZE:
            if(maxlen!=sizeof(ULONG))return SDE_INVALID_ARG;
            *(ULONG *)pParam=pCfg->UnitSize;
            return SDE_OK;
        case SDC_GET_BASE_ADDR:
            if(maxlen!=sizeof(ULONG))return SDE_INVALID_ARG;
            *(ULONG *)pParam=pCfg->BaseAddr;
            return SDE_OK;
        case SDC_GET_MAX_SIZE:
            if(maxlen!=sizeof(ULONG))return SDE_INVALID_ARG;
            *(ULONG *)pParam=pCfg->MaxSize;
            return SDE_OK;
        case SDC_WRITE_FLASH:
            return write_intelflash(pDataBuf,pParam,maxlen);
        case SDC_READ_FLASH:
            return read_intelflash(pDataBuf,pParam,maxlen);
        case SDC_ERASE_CHIP:
        {
	  ULONG cs;
          int ret=SDE_OK;
	  for(cs=0;cs<8;cs++){
            ULONG i;
            ULONG BaseAddr=pCfg->CSRange[cs][0]+pCfg->BaseAddr;
	    if(pCfg->CSRange[cs][1]==0)break;

            WriteReg(BaseAddr,0x0030);
            WriteReg(BaseAddr,0x00d0); 
            for(i=0;i<FLASH_ERASE_CHIP_LOOP;i++){
                if((ReadReg(BaseAddr)&0x0080)==0x0080)break;
                }
            if(i==FLASH_ERASE_CHIP_LOOP)ret=SDE_FLASH_FAIL;
            if((ReadReg(BaseAddr)&0x0038) != 0)ret=SDE_FLASH_FAIL;
            WriteReg(BaseAddr,0x00ff);
	  }
          return ret;
        }
        case SDC_ERASE_SECTOR:
        {
            ULONG offset=*(ULONG *)pParam;
            int ret;
            ULONG i;
            ULONG BaseAddr=0xFFFFFFFF;
	        for(i=0;i<8 && pCfg->CSRange[i][1]!=0; i++)
	           if(pCfg->CSRange[i][0]<=offset && pCfg->CSRange[i][1]>offset){
		          BaseAddr=pCfg->CSRange[i][0]+pCfg->BaseAddr;
		          offset-=pCfg->CSRange[i][0];
		       }
	        if(BaseAddr==0xFFFFFFFF)return SDE_INVALID_ARG;
            if(maxlen!=sizeof(ULONG))return SDE_INVALID_ARG;
            ret=block_erase_cmd(BaseAddr+offset);
            if(ret==SDE_FLASH_LOCK) 
            {
               ret=block_unlock_cmd(BaseAddr+offset);
               if(ret==SDE_OK)
                 ret=block_erase_cmd(BaseAddr+offset);
            }   
            if(ret==SDE_FLASH_LOCK) 
               ret=SDE_FLASH_FAIL;   
            return ret; 
        }
        default:
            return SDE_UNKNOW_CMD;
    }
    /* return SDE_OK; */
}


/***********************************************************************/
/*   NOTE: The following are the sst39vf160 flash operation functions  */
/***********************************************************************/
static int read_sstflash(void *pDataBuf,void *pBuf, int MaxLen)
{
    Flash16CfgStruct *pCfg=(Flash16CfgStruct *)pDataBuf;
    SDCFlashAccessStruct *mas=(SDCFlashAccessStruct *)pBuf;
    if(MaxLen!=sizeof(SDCFlashAccessStruct))return SDE_INVALID_ARG;
    if(mas->Size <= 0 ) return SDE_INVALID_ARG;
    if(mas->Size+mas->Offset > pCfg->MaxSize)return SDE_INVALID_ARG;
    memmove(mas->Base,(UCHAR *)pCfg->BaseAddr+mas->Offset,mas->Size);
    return SDE_OK;

}

static int write_sstflash(void *pDataBuf,void *pBuf, int MaxLen)
{
    
    Flash16CfgStruct *pCfg=(Flash16CfgStruct *)pDataBuf;
    SDCFlashAccessStruct *mas=(SDCFlashAccessStruct *)pBuf;
    int i,end;
    UCHAR *start,*BufAddr;
    USHORT data;
    ULONG Offset,DataLen,BaseAddr;

    if(MaxLen!=sizeof(SDCFlashAccessStruct))return SDE_INVALID_ARG;
    if(mas==NULL||(mas->Size+mas->Offset>pCfg->MaxSize))return SDE_INVALID_ARG;
    if(mas->Size==0)return SDE_OK;

    BaseAddr=pCfg->BaseAddr; Offset=mas->Offset;DataLen=mas->Size;
    start=(char *)((BaseAddr+Offset)&(~1L));
    i=((BaseAddr+Offset)&1L);
    BufAddr=mas->Base-i; DataLen+=i;

    data=0xffff;
    end=(DataLen>2)?2:DataLen; 
    memmove(((UCHAR *)&data)+i,BufAddr+i,end-i);
    i=0;
    while(1)
    {
        if(data!=0xffff)
        {
                ULONG ii,rc;                
                WriteReg(BaseAddr+(ULONG)(0x5555<<1),0x00aa);
                WriteReg(BaseAddr+(ULONG)(0x2aaa<<1),0x0055);
                WriteReg(BaseAddr+(ULONG)(0x5555<<1),0x00a0);
                *(USHORT *)start=data;
                for(ii=0;ii<FLASH_WRITE_LOOP;ii++){
                	    /*Data# polling(DQ7)*/
                        if((ReadReg((ULONG)start)&0x0080)==(data&0x0080))break;
                        }
                if(ii==FLASH_WRITE_LOOP)break;
                   
        }
        i+=2; start+=2;
        if(i>=DataLen)break; else data=0xffff;
        if((i+2)>DataLen)memmove((UCHAR *)&data,BufAddr+i,DataLen-i);
        else data=*(USHORT*)(BufAddr+i);
    }

    if(i<DataLen) return SDE_FLASH_FAIL;
    else
    {
        start = (UCHAR *)(BaseAddr + Offset);
        if(memcmp(start,mas->Base,mas->Size)!=0)return SDE_FLASH_FAIL;
        return SDE_OK;
    }
   

}

static int SstFlash16Cntrl(void *pDataBuf, int cmd, void *pParam, int maxlen)
{
    Flash16CfgStruct *pCfg=(Flash16CfgStruct *)pDataBuf;
    switch(cmd)
    {
        case SDC_GET_UNIT_SIZE:
            if(maxlen!=sizeof(ULONG))return SDE_INVALID_ARG;
            *(ULONG *)pParam=pCfg->UnitSize;
            return SDE_OK;
        case SDC_GET_BASE_ADDR:
            if(maxlen!=sizeof(ULONG))return SDE_INVALID_ARG;
            *(ULONG *)pParam=pCfg->BaseAddr;
            return SDE_OK;
        case SDC_GET_MAX_SIZE:
            if(maxlen!=sizeof(ULONG))return SDE_INVALID_ARG;
            *(ULONG *)pParam=pCfg->MaxSize;
            return SDE_OK;
        case SDC_WRITE_FLASH:
            return write_sstflash(pDataBuf,pParam,maxlen);
        case SDC_READ_FLASH:
            return read_sstflash(pDataBuf,pParam,maxlen);
        case SDC_ERASE_CHIP:
        {
	  		ULONG cs;
          	int ret=SDE_OK;
	  		for(cs=0;cs<8;cs++)
	  		{
            	ULONG i;
            	ULONG BaseAddr=pCfg->CSRange[cs][0]+pCfg->BaseAddr;
	    		if(pCfg->CSRange[cs][1]==0)break;

                WriteReg(BaseAddr+(ULONG)(0x5555<<1),0x00aa);
                WriteReg(BaseAddr+(ULONG)(0x2aaa<<1),0x0055);
                WriteReg(BaseAddr+(ULONG)(0x5555<<1),0x0080);
                WriteReg(BaseAddr+(ULONG)(0x5555<<1),0x00aa);
                WriteReg(BaseAddr+(ULONG)(0x2aaa<<1),0x0055);
                WriteReg(BaseAddr+(ULONG)(0x5555<<1),0x0010);            	
           	
            	for(i=0;i<FLASH_ERASE_CHIP_LOOP;i++){
                	if((ReadReg(BaseAddr)&0x0080)==0x0080)break;
                }
            	if(i==FLASH_ERASE_CHIP_LOOP)ret=SDE_FLASH_FAIL;
	  		}
          	return ret;
        }
        case SDC_ERASE_SECTOR:
        {
            ULONG offset=*(ULONG *)pParam;
            int ret=SDE_OK;
            ULONG i;
            ULONG BaseAddr=0xFFFFFFFF;
	        for(i=0;i<8 && pCfg->CSRange[i][1]!=0; i++)
	           if(pCfg->CSRange[i][0]<=offset && pCfg->CSRange[i][1]>offset){
		          BaseAddr=pCfg->CSRange[i][0]+pCfg->BaseAddr;
		          offset-=pCfg->CSRange[i][0];
		       }
	        if(BaseAddr==0xFFFFFFFF)return SDE_INVALID_ARG;
            if(maxlen!=sizeof(ULONG))return SDE_INVALID_ARG;

            WriteReg(BaseAddr+(ULONG)(0x5555<<1),0x00aa);            
            WriteReg(BaseAddr+(ULONG)(0x2aaa<<1),0x0055);
            WriteReg(BaseAddr+(ULONG)(0x5555<<1),0x0080);
            WriteReg(BaseAddr+(ULONG)(0x5555<<1),0x00aa);
            WriteReg(BaseAddr+(ULONG)(0x2aaa<<1),0x0055);
            WriteReg(BaseAddr+offset,0x0050);            	

            for(i=0;i<FLASH_ERASE_SECTOR_LOOP;i++){
                if((ReadReg(BaseAddr+offset)&0x0080)==0x0080)break;
                }
            if(i==FLASH_ERASE_SECTOR_LOOP)ret=SDE_FLASH_FAIL;
            return ret; 
        }
        default:
            return SDE_UNKNOW_CMD;
    }
    /* return SDE_OK; */
}


char *Flash16BspInit(int DEV, char *FreeMemPtr, Flash16CfgStruct *cfg)
{
    Flash16CfgStruct *pCfg=cfg;   	
   	ULONG BaseAddr=pCfg->BaseAddr;
 	ULONG i,dwMCode,dwDCode;
   	
   	/*Now read sst Product Identification*/
    WriteReg(BaseAddr+(ULONG)(0x5555<<1),0x00aa);            
    WriteReg(BaseAddr+(ULONG)(0x2aaa<<1),0x0055);
    WriteReg(BaseAddr+(ULONG)(0x5555<<1),0x0090);
	for(i=0;i<SST_ID_READ_WAIT;i++);//wait Tida
	dwMCode=ReadReg(BaseAddr+(ULONG)(0x0<<1));
	dwDCode=ReadReg(BaseAddr+(ULONG)(0x1<<1));
    WriteReg(BaseAddr+(ULONG)(0x5555<<1),0x00aa);            
   	WriteReg(BaseAddr+(ULONG)(0x2aaa<<1),0x0055);
   	WriteReg(BaseAddr+(ULONG)(0x5555<<1),0x00F0);
    for(i=0;i<SST_ID_READ_WAIT;i++);//wait Tida
	if( (dwMCode==SST_MANUFACTURER_CODE) && (dwDCode==SST_DEVICE_CODE) )
	{
      	InstallSD(DEV,NULL,NULL,SstFlash16Cntrl,FreeMemPtr);
	}
	else//If not sst,sharp and intel have the same operation
	{
		InstallSD(DEV,NULL,NULL,IntelFlash16Cntrl,FreeMemPtr);
	}		

    if(cfg->CSRange[0][1]==0)cfg->CSRange[0][1]=cfg->MaxSize;
    Flash16Init(FreeMemPtr, cfg); 
    FreeMemPtr += sizeof(Flash16CfgStruct);
    memcpy(FreeMemPtr,"*Flsh16Dat",8);
    FreeMemPtr += 8;
    return FreeMemPtr;
}
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -