/***********************************************************************/
/*                                                                     */
/* 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 "flash32.h"

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

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

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

static void Flash32Init(void *pDataBuf, Flash32CfgStruct *cfg){
    Flash32CfgStruct*  pCfg =(Flash32CfgStruct *)(pDataBuf);
    memmove(pCfg,cfg,sizeof(*cfg));
}

static int read_flash(void *pDataBuf,void *pBuf, int MaxLen)
{
    Flash32CfgStruct *pCfg=(Flash32CfgStruct *)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_flash(void *pDataBuf,void *pBuf, int MaxLen)
{
    Flash32CfgStruct *pCfg=(Flash32CfgStruct *)pDataBuf;
    SDCFlashAccessStruct *mas=(SDCFlashAccessStruct *)pBuf;
    int i,end;
    UCHAR *start,*BufAddr;
    ULONG data,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)&(~3L));
    i=((BaseAddr+Offset)&3L);
    BufAddr=mas->Base-i; DataLen+=i;

    data=0xffffffff;
    end=(DataLen>4)?4:DataLen; 
    memmove(((UCHAR *)&data)+i,BufAddr+i,end-i);
    i=0;
    while(1)
    {
        if(data!=0xffffffff)
        {
                ULONG ii,rc;
                WriteReg((ULONG)start,0x00400040);
                *(ULONG *)start=data;
                for(ii=0;ii<FLASH_WRITE_LOOP;ii++){
                        if((ReadReg((ULONG)start)&0x00800080)==0x00800080)break;
                        }
                if(ii==FLASH_WRITE_LOOP)break;
		rc=ReadReg((ULONG)start)&0x00380038;
		WriteReg((ULONG)start,0x00ff00ff); 
                if(rc!=0)break;
        }
        i+=4; start+=4;
        if(i>=DataLen)break; else data=0xffffffff;
        if((i+4)>DataLen)memmove((UCHAR *)&data,BufAddr+i,DataLen-i);
        else data=*(ULONG *)(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 Flash32Cntrl(void *pDataBuf, int cmd, void *pParam, int maxlen)
{
    Flash32CfgStruct *pCfg=(Flash32CfgStruct *)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_flash(pDataBuf,pParam,maxlen);
        case SDC_READ_FLASH:
            return read_flash(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,0x00300030);
            WriteReg(BaseAddr,0x00d000d0); 
            for(i=0;i<FLASH_ERASE_CHIP_LOOP;i++){
                if((ReadReg(BaseAddr)&0x00800080)==0x00800080)break;
                }
            if(i==FLASH_ERASE_CHIP_LOOP)ret=SDE_FLASH_FAIL;
            if((ReadReg(BaseAddr)&0x00380038) != 0)ret=SDE_FLASH_FAIL;
            WriteReg(BaseAddr,0x00ff00ff);
	    }
            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,0x00200020);
            WriteReg(BaseAddr+offset,0x00D000D0); 
            for(i=0;i<FLASH_ERASE_SECTOR_LOOP;i++){
                if((ReadReg(BaseAddr)&0x00800080)==0x00800080)break;
                }
            if(i==FLASH_ERASE_SECTOR_LOOP)ret=SDE_FLASH_FAIL;
            if((ReadReg(BaseAddr)&0x00380038) != 0)ret=SDE_FLASH_FAIL;
            WriteReg(BaseAddr,0x00ff00ff);
            return ret; 
        }
        default:
            return SDE_UNKNOW_CMD;
    }
    /* return SDE_OK; */
}

char *Flash32BspInit(int DEV, char *FreeMemPtr, Flash32CfgStruct *cfg)
{
    InstallSD(DEV,NULL,NULL,Flash32Cntrl,FreeMemPtr);
    if(cfg->CSRange[0][1]==0)cfg->CSRange[0][1]=cfg->MaxSize;
    Flash32Init(FreeMemPtr, cfg); 
    FreeMemPtr += sizeof(Flash32CfgStruct);
    memcpy(FreeMemPtr,"*Flsh32Dat",8);
    FreeMemPtr += 8;
    return FreeMemPtr;
}