flash16b2.c

来自「这是单板上DPRAM的驱动程序」· C语言 代码 · 共 204 行

/***********************************************************************/
/*                                                                     */
/* 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 "flash16b2.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 SSTFlash16Init(void *pDataBuf, SSTFlash16CfgStruct *cfg){
    SSTFlash16CfgStruct*  pCfg =(SSTFlash16CfgStruct *)(pDataBuf);
    memmove(pCfg,cfg,sizeof(*cfg));        
}

/***********************************************************************/
/*   NOTE: The following are the sst39vf160 flash operation functions  */
/***********************************************************************/
static int read_sstflash(void *pDataBuf,void *pBuf, int MaxLen)
{
    SSTFlash16CfgStruct *pCfg=(SSTFlash16CfgStruct *)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)
{
    
    SSTFlash16CfgStruct *pCfg=(SSTFlash16CfgStruct *)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)
{
    SSTFlash16CfgStruct *pCfg=(SSTFlash16CfgStruct *)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 *SSTFlash16BspInit(int DEV, char *FreeMemPtr, SSTFlash16CfgStruct *cfg)
{
    InstallSD(DEV,NULL,NULL,SstFlash16Cntrl,FreeMemPtr);
	
    if(cfg->CSRange[0][1]==0)cfg->CSRange[0][1]=cfg->MaxSize;
    SSTFlash16Init(FreeMemPtr, cfg); 
    FreeMemPtr += sizeof(SSTFlash16CfgStruct);
    memcpy(FreeMemPtr,"*Flsh16Dat",8);
    FreeMemPtr += 8;
    return FreeMemPtr;
}