flash4tffs.c

MPC5200 BSP 支持ATA,USB, I2C,扩展网口

/* General Flash driver for TFFS */
#include <vxWorks.h>
#include <stdio.h>
#include <semLib.h>
#include <dosFsLib.h>
#include <taskLib.h>
#include "tffs/flflash.h"
#include "tffs/flsocket.h"
#include "tffs/flbase.h"
#include "tffs/backgrnd.h"
#include "tffs/tffsdrv.h"
#include "gflash.h"
#include "config.h"
#ifndef ERROR
	#define ERROR	-1
#endif

#ifndef OK
	#define OK		0
#endif
/* #define GFLASH_DEBUG 1 */

UINT32 g_tffs_DataBase;
UINT32 g_tffs_BlkSize;
UINT32 g_tffs_DataSize;

static UINT32 s_FlashBase;
static UINT32 s_tffs_ChipSize;
static UINT32 s_MacDataBase;
static UINT32 s_mac_BlkSize;

static FLStatus tffs_EraseBlock(UINT32 Addr);
static FLStatus tffs_FlashRead(FLFlash vol,CardAddress address,
            void FAR1 * buffer,int length,int modes);
static FLStatus tffs_FlashWrite(FLFlash vol,CardAddress address,
            const void * buffer,int dataLen,int modes);
static FLStatus tffs_FlashErase(FLFlash vol,int firstErasableBlock,
            int numOfErasableBlocks);
static UINT8 IsValidChipSize(UINT32 uiBlkSize,UINT32 uiChipSize,UINT32 *uiVCS);
int tffs_FlashInit(void);
extern int sysTffsFormat(void);
IMPORT STATUS dosFsDevInitOptionsSet(UINT);
#ifndef my_Assert
#define myAssert(p)    \
    {                   \
        if(!(p)) printf( "Assert Failed : File=%s Line=%d\n", __FILE__, __LINE__ );    \
    }
#endif

/* globals */
SEM_ID   mm_SemFlash;

static FlashConf s_tffsFlashConf =
{
    BaseAddr:           FLASH_BASE_ADRS,
    PortSizePerChip:    1,  /* x8 */
    ChipCount:          1,
    Options:            1   /* None */ 
};

static FL_DEV_ID	s_tffs_devid=0xff;
FL_PART_ID	s_tffs_partid=0xffff;
FL_PART_ID	s_mac_partid=0xffff;

/* #define LOGF_USED */
#ifdef LOGF_USED
static FL_PART_ID	s_logf_partid=0xffff;
#endif
static FlashInfo	s_tffsFlashInfo;
typedef struct tagFlashParams
{
	UINT8	bus;
	UINT8	ccnt;
} FlashParams;

static FlashParams s_flpa;

int tffs_FlashInit(void)
{
	UINT8		ucRetVal=0x00,ucRet;
    FlashConf   *pConf=&s_tffsFlashConf;
    FAST        UINT32 i;
    UINT32		uiBlkCnt=0;
    UINT32		uiSkipSize=0;
    UINT32		uiBlkSize=0;
    UINT8   	tffsBlkRegNo=0,ucRegCnt;    
    UINT32		uiOffset;
    FlashInfo	*pInfo=NULL;
	
    pInfo=&s_tffsFlashInfo;    
    s_tffs_devid=gFlash_OpenDevice(pConf,&ucRetVal);
    #ifdef GFLASH_DEBUG
    printf("devid=%d, handle=%d\n",s_tffs_devid,ucRetVal);
    #endif
    if((s_tffs_devid >= MAX_BANK_NO) || ucRetVal)
    {
    	myAssert(0);
        return ERROR;
    }

    ucRet=gFlash_GetDeviceInfo(s_tffs_devid,pInfo);
    if(ucRet)
    {
    	myAssert(0);
        return ERROR;
    }
    
    s_FlashBase=pInfo->BaseAddr;
    s_flpa.ccnt=pInfo->ChipCount;
    s_flpa.bus=(pInfo->PortSizePerChip)*8;
    
    ucRegCnt=pInfo->RegCnt;
    for(i=0;i<ucRegCnt;i++)
    {        
        if(pInfo->EBlk[i].Size > uiBlkSize)
        {
            tffsBlkRegNo=i;
            uiBlkSize=pInfo->EBlk[i].Size;            
            uiBlkCnt=pInfo->EBlk[i].Count;
        }
    }
    g_tffs_BlkSize = uiBlkSize * s_flpa.ccnt;
    s_tffs_ChipSize= uiBlkCnt * g_tffs_BlkSize;
   
    if(ucRegCnt>1)
    {
        if(tffsBlkRegNo>0)
        {
        	/* Bottom Boot memmory map */
            for(i=0;i<tffsBlkRegNo;i++)
            {
                uiSkipSize += pInfo->EBlk[i].Size * pInfo->EBlk[i].Count;
                #ifdef GFLASH_DEBUG
            			printf("bottom boot memmory map: g_tffs_DataBase=%d, skiping EBlk[%d].Size=%d EBlk[%d].Count=%d !\n",g_tffs_DataBase,i,pInfo->EBlk[i].Size,i, pInfo->EBlk[i].Count);
            		#endif
            }
            s_MacDataBase	= s_FlashBase;
            s_mac_BlkSize	= pInfo->EBlk[0].Size;
            g_tffs_DataBase	= s_FlashBase + uiSkipSize;
            #ifdef AMD_GFLASH_32M
            	s_tffs_ChipSize-= g_tffs_BlkSize;
            	s_MacDataBase	= g_tffs_DataBase + s_tffs_ChipSize;
        			s_mac_BlkSize	= g_tffs_BlkSize;
        		#endif
            #ifdef GFLASH_DEBUG
            	printf("bottom boot memmory map g_tffs_DataBase=%d !\n",g_tffs_DataBase);
            #endif
        }
        else
        {
        	/* Top Boot memmory map */
            g_tffs_DataBase = s_FlashBase;
            s_MacDataBase  	= g_tffs_DataBase + s_tffs_ChipSize;
            s_mac_BlkSize	= pInfo->EBlk[1].Size;
            #ifdef GFLASH_DEBUG
            	printf("Top boot memmory map!\n");
            #endif
        }
    }
    else /* Uniform sector flash */
    {
    	--uiBlkCnt;
#ifdef LOGF_USED
		--uiBlkCnt;
#endif

        g_tffs_DataBase = s_FlashBase;
        s_tffs_ChipSize-= g_tffs_BlkSize;
#ifdef LOGF_USED
		s_tffs_ChipSize-= g_tffs_BlkSize;
#endif
        s_MacDataBase	= g_tffs_DataBase + s_tffs_ChipSize;
        s_mac_BlkSize	= g_tffs_BlkSize;
    }
    
	/* Create a partition for TFFS FS */
	uiOffset = g_tffs_DataBase - s_FlashBase; 
	#ifdef GFLASH_DEBUG
     	printf("gFlash_CreatePart! g_tffs_DataBase=%d s_FlashBase=%d \n",g_tffs_DataBase,uiOffset);
   #endif
	
	IsValidChipSize(g_tffs_BlkSize,s_tffs_ChipSize,&g_tffs_DataSize);
	s_tffs_partid = gFlash_CreatePart(s_tffs_devid,uiOffset,g_tffs_BlkSize,uiBlkCnt,&ucRet);
	if(ucRet)
	{
		myAssert(0);
		return ERROR;
	}
	 #ifdef GFLASH_DEBUG
     	printf("gFlash_CreatePart! s_tffs_devid=%d uiOffset=%d g_tffs_BlkSize=%d  uiBlkCnt=%d \n",s_tffs_devid,uiOffset,g_tffs_BlkSize,uiBlkCnt);
   #endif

	/* Create a partition for saving Boot parameters */
	uiOffset = s_MacDataBase - s_FlashBase; 
	s_mac_partid = gFlash_CreatePart(s_tffs_devid,uiOffset,s_mac_BlkSize,1,&ucRet);
    if(ucRet)
    {
		myAssert(0);
		return ERROR;
	}
	 #ifdef GFLASH_DEBUG
     	printf("gFlash_CreatePart! s_tffs_devid=%d uiOffset=%d g_tffs_BlkSize=%d  uiBlkCnt=%d \n",s_tffs_devid,uiOffset,g_tffs_BlkSize,uiBlkCnt);
   #endif

#ifdef LOGF_USED
	/* Create a partition for saving log file */
	uiOffset += s_mac_BlkSize; 
	s_logf_partid = gFlash_CreatePart(s_tffs_devid,uiOffset,s_mac_BlkSize,1,&ucRet);
    if(ucRet)
    {
		myAssert(0);
		return ERROR;
	}
#endif
    return OK;    
}

FLStatus FlashIdentify( FLFlash vol )
{
    flSetWindowBusWidth(vol.socket,s_flpa.bus);
    flSetWindowSpeed(vol.socket,120);
    flSetWindowSize(vol.socket,g_tffs_DataSize >> 12);
    
    vol.type = 0x1122; /*0x88c4;  Just for cheating the system, do not change it. */
    vol.interleaving = s_flpa.ccnt;
    vol.noOfChips = s_flpa.ccnt;

    vol.erasableBlockSize = g_tffs_BlkSize;
    vol.chipSize = s_tffs_ChipSize/(vol.noOfChips);   

    vol.read  = tffs_FlashRead;
    vol.write = tffs_FlashWrite;
    vol.erase = tffs_FlashErase;
    #ifdef GFLASH_DEBUG
    printf("width=%d, windowSize =%x, eraseableBlockSize=%x,chipSize=%x\n ",s_flpa.bus,g_tffs_DataSize >> 12,vol.erasableBlockSize ,vol.chipSize);
     #endif   
    return (flOK);
}

/********************************************************************
 *
 * dataInit --  Data area Init.
 *                                  
 * This routine implement data area's  initialization function. 
 *
 * PARAMS:INPUT:   
 *        OUTPUT:   
 *
 * RETURNS:OK,or ERROR.
 *       .
 *
 * ERRNO:
 */
extern  MTDidentifyRoutine mtdTable[];
STATUS  FlashAndFsInit(void)
{      
    DOS_VOL_DESC    *pDosVolDesc;  
    BLK_DEV         *pBlkDev;
    STATUS          dwRet;

     if(tffs_FlashInit())
    {
        return (ERROR);
    }
     #ifdef GFLASH_DEBUG
     printf("noOfDrives =%d, noOfMTDs=%d\n",noOfDrives,noOfMTDs);
     #endif
     mtdTable[0] = FlashIdentify;
     #ifdef GFLASH_DEBUG
     printf("noOfDrives =%d, noOfMTDs=%d\n",noOfDrives,noOfMTDs);
     #endif
     mm_SemFlash = semBCreate(SEM_Q_FIFO,SEM_FULL);
    if (mm_SemFlash == NULL)
    {
        #ifdef  DEBUG_PRINT
            printf("semFlash create failure.");
        #endif
        return (flBadFunction);
    }
   /*first we assume tffs has been formatted,we directly create block device*/
   pBlkDev = (BLK_DEV *)tffsDevCreate(0,0);
   #ifdef GFLASH_DEBUG
     printf("noOfDrives =%d, noOfMTDs=%d\n",noOfDrives,noOfMTDs);
     #endif
   if (pBlkDev == NULL)/*create block device fail,possiblely flash hasn't been formatted*/
   {
       printf("TFFS device create failure!,ready to format tffs!......\n");

       dwRet = sysTffsFormat();
       if (dwRet == ERROR)
       {
           printf("TFFS device format failure,return to system control!......\n");
           return (ERROR);
       }
       else 
       {
           printf("TFFS device format success!\n");
      
           pBlkDev = (BLK_DEV *)tffsDevCreate(0,0);
           if (pBlkDev == NULL)
           {
               printf("TFFS device still create failure after tffs format success!\n");
               printf("return to system control!\n");
               return (ERROR);
           }
           else
           {   
               printf("TFFS device create success!\n");
           }
        }
    }
    else
    {   
        printf("TFFS device create success!\n");
    }

    dosFsInit (NUM_DOSFS_FILES);
    dosFsDevInitOptionsSet(DOS_OPT_AUTOSYNC);
    /*after block device create success,first assume dosfs has been formatted*/
    pDosVolDesc = dosFsDevInit("/tffs0",pBlkDev,NULL); 
    if (pDosVolDesc == NULL)
    {
        printf("DosFs device initial failure,ready to create a DosFs!......\n");
        pDosVolDesc = dosFsMkfs ("/tffs0", pBlkDev);