comfs.c

The combined demo is dedicated for S1C33L05, so DMT33L05 should be used to load and run the demo. F

//--------------------------------------------------------------------------------- 
//
//      Copyright (C) SEIKO EPSON CORP. 2004 
//
//      GROUP					: SEE LSI
//      FILE                    : commFS.c
//      MODULE                  : storage module interface
//      Function description    : Driver 
//      Revision history        :                                                                                               
//                                Date            userName        	Description
//                                2004/06/8       David.Ji		      	start
//
//      Notes                   : 
//
//---------------------------------------------------------------------------------

#include "ros33.h"
#include "main.h"
#include "c33l11.h"
#include "comFS.h"

//---------------------------------------------------------------------------------
// global variables
//---------------------------------------------------------------------------------
T_IO0 * const g_Io0 = (T_IO0*)0x00040000;
T_MISC * const g_Misc = (T_MISC*)0x00300000;

FatFcs_t			g_StgFatFcs[FAT_MAX_FILES];
FatFile_t			g_StgFatFile[FAT_MAX_FILES];
FatFile_t *			g_StgFatfpFp[FAT_MAX_FILES];
FatSecBuf_t 		g_StgFatSecBuf[FAT_MAX_BUFFERS];
FatInitParams_t 	g_StgParm;

unsigned int		g_StgUseDrv;
STG_MEDIA_INFO  	g_StgMediaInfo;

T_FS_ERR			stFsErrinfo;

//---------------------------------------------------------------------------------
// static funciton declare
//---------------------------------------------------------------------------------
static int smtPhyStep(unsigned char);

int FS_ObtainSemaphore(void);
int FS_ReleaseSemaphore(void);

unsigned char *pVolNameRam = "Ram disk";
unsigned char *pVolNameSmt = "Smt disk";
/****************************************************************************
	ComFS_Init()
 ----------------------------------------------------------------------------
	description:

	argument:	(none)
	return:		(none)
	input:		(none)
	output:		(none)
	flag:		(none)
	global:		(none)
	comment:	(none)
 ****************************************************************************/
int ComFS_Init(void)
{
    int iRetVal;
    
    if(FS_ObtainSemaphore() != FS_SUCCESS)
    	return FS_FAILED;
    
	/* Initialize file system */
	g_StgParm.pstFcs	   = g_StgFatFcs;
	g_StgParm.pstFile	   = g_StgFatFile;
	g_StgParm.pstFp 	   = g_StgFatfpFp;
	g_StgParm.pstSecBuf    = g_StgFatSecBuf;
	g_StgParm.bMaxFiles    = FAT_MAX_FILES;
	g_StgParm.bMaxBuffers  = FAT_MAX_BUFFERS;
	g_StgParm.bVerify	   = FAT_VERIFY_ENA;

	g_StgUseDrv = DRV_MCP;
	
	bSmtType = SMT_T_MCP;
	mcp_PatInfo = PAT_USER;
	DrvFS_Init();
	
	iRetVal = FS_SUCCESS;
	fatCacheRAMClear();
	if (smtOpenLib(&g_StgParm) != SMT_E_SUCCESS)
	{
		iRetVal = smtPhyFormat( 0x12345, &pVolNameSmt,  ( FatInitParams_t * )&g_StgParm);
	}
	
	FS_ReleaseSemaphore();
	return iRetVal;
}

/****************************************************************************
	ComFS_GetDiskFree()
 ----------------------------------------------------------------------------
	description:

	argument:	diskfree_t*
	return:		FS_SUCCESS
				FS_FAILED
 ****************************************************************************/
int ComFS_GetDiskFree(struct diskfree_t *pstdiskfree)
{
	int iRetVal;
	
	// check fs semphore
	if(FS_ObtainSemaphore() != FS_SUCCESS)
		return FS_FAILED;
		
	iRetVal = fatDosGetDiskFree(0, pstdiskfree);
	
	FS_ReleaseSemaphore();
	
	return iRetVal;
	
}

/****************************************************************************
	ComFS_GetFilelist()
 ----------------------------------------------------------------------------
	description:

	argument:	Char*			 pPathName
				unsigned int 	 uiFileAttr
				T_FILELIST*		 pT_Filelist
	return:		FS_SUCCESS
				FS_FAILED
 ****************************************************************************/
int ComFS_GetFilelist(char* pPathName, unsigned long uiFileAttr, T_FS_FILELIST* pT_Filelist)
{
	int iRetValue;
	struct find_t stfind;
	unsigned short usLoopCnt = 0 ;

	if(FS_ObtainSemaphore() != FS_SUCCESS)
		return FS_FAILED;
		
	pT_Filelist->usFileCnt = 0;

	if( fatDosFindFirst( pPathName, uiFileAttr, &stfind) != FAT_OK)
	{	
		FS_ReleaseSemaphore();
		return FS_FAILED;
	}

	while(usLoopCnt < FS_FILELIST_CNT)
	{
		memcpy(&pT_Filelist->stFilelist[usLoopCnt], &stfind, sizeof (struct find_t));
		if(fatDosFindNext(&stfind )!= FAT_OK)
		{
			if(fat_stFatErr.bErrCode == FAT_NOMORE_FILES )
			{
				usLoopCnt++;
				break;
			}
			else
			{
				FS_ReleaseSemaphore();
				return FS_FAILED;
			}
		}
		usLoopCnt ++;
	}
	
	pT_Filelist->usFileCnt = usLoopCnt;
	FS_ReleaseSemaphore();
	return FS_SUCCESS;
}

/****************************************************************************
	ComFS_FindFirst()
 ----------------------------------------------------------------------------
	description:

	argument:	
	return:		FS_SUCCESS
				FS_FAILED
 ****************************************************************************/
int ComFS_FindFirst(char* pPathName, unsigned long uiFileAttr, struct find_t* pstFind)
{
	if(FS_ObtainSemaphore() != FS_SUCCESS)
		return FS_FAILED;
	
	if( fatDosFindFirst( pPathName, uiFileAttr, pstFind) != FAT_OK)
	{	
		FS_ReleaseSemaphore();
		return FS_FAILED;
	}
	
	FS_ReleaseSemaphore();
	return FS_SUCCESS;
	
}


/****************************************************************************
	ComFS_ChgDir()
 ----------------------------------------------------------------------------
	description:

	argument:	
	return:		FS_SUCCESS
				FS_FAILED
 ****************************************************************************/
int ComFS_ChgDir(const char *pcPathName)
{
	if(FS_ObtainSemaphore() != FS_SUCCESS)
		return FS_FAILED;
	
	if(fatChdir(pcPathName) != SMT_E_SUCCESS)
		return FS_FAILED;
	
	FS_ReleaseSemaphore();
		return FS_SUCCESS;
	
}


/****************************************************************************
	ComFS_FileRead()
 ----------------------------------------------------------------------------
	description:

	argument:	T_FS_FILECTL* pT_FILECTL
	return:		FS_SUCCESS
				FS_FAILED
 ****************************************************************************/
int ComFS_ReadFile(T_FS_FILECTL* pT_FileCtl)
{
	int iRetValue;
	FatFile_t	*pfilePnt;
	
	if(FS_ObtainSemaphore() != FS_SUCCESS)
		return FS_FAILED;
	
	/* file open */
	pfilePnt = fatFopen( pT_FileCtl->strFileName, "r" );
	if( pfilePnt == (FatFile_t *)0 )
	{
		pT_FileCtl->ulTranLen = 0;
		FS_ReleaseSemaphore();
		return FS_FAILED;
	}
	
	/* read file data */
	pT_FileCtl->ulTranLen = fatFread( pT_FileCtl->pFileData, 1, pT_FileCtl->ulReqLen, pfilePnt );
	
	/* close file */
	if( fatFclose( pfilePnt ) != FAT_OK )
	{
		pT_FileCtl->ulTranLen = 0;
		FS_ReleaseSemaphore();
		return FS_FAILED;
	}
	
	FS_ReleaseSemaphore();
	return FS_SUCCESS;
}

/****************************************************************************
	ComFS_FileWrite()
 ----------------------------------------------------------------------------
	description:

	argument:	T_FS_FILECTL* pT_FILECTL
	return:		FS_SUCCESS
				FS_FAILED
 ****************************************************************************/
int ComFS_WriteFile(T_FS_FILECTL* pT_FileCtl)
{
	int	iRetValue;
	FatFile_t	*pfilePnt;

	if(FS_ObtainSemaphore() != FS_SUCCESS)
		return FS_FAILED;

	/* file open */
	pfilePnt = fatFopen( pT_FileCtl->strFileName, "w" );
	if( pfilePnt == (FatFile_t *)0 )
	{
		pT_FileCtl->ulTranLen = 0;
		FS_ReleaseSemaphore();
		return FS_FAILED;
	}
	
	/* write file data */
	pT_FileCtl->ulTranLen = fatFwrite( pT_FileCtl->pFileData, 1, pT_FileCtl->ulReqLen, pfilePnt );
	
	/* close file */
	if( fatFclose( pfilePnt ) != FAT_OK )
	{
		pT_FileCtl->ulTranLen = 0;
		FS_ReleaseSemaphore();
		return FS_FAILED;
	}
	
	FS_ReleaseSemaphore();
	return FS_SUCCESS;
}


/****************************************************************************
	ComFS_FileWrite()
 ----------------------------------------------------------------------------
	description:

	argument:	T_FS_FILECTL* pT_FILECTL
	return:		FS_SUCCESS
				FS_FAILED
 ****************************************************************************/
char *ComFS_Loadfile(unsigned char* filename)
{
	FatFile_t			*pfilePnt;
	struct find_t		stFind;
	char*	pReadBuf;	
	
	if (fatDosFindFirst(filename,_A_NORMAL, &stFind) != SMT_E_SUCCESS)
		return 0;
	
	pReadBuf = (char *)malloc(stFind.size);
	if(pReadBuf == NULL)
		return 0;

	pfilePnt = fatFopen( filename, "r" );
	if( pfilePnt == (FatFile_t *)0 )
	{
		free(pReadBuf);
		return 0;
	}
	
	if(!fatFread(pReadBuf, 1,  stFind.size, pfilePnt))
	{
		fatFclose(pfilePnt);
		free(pReadBuf);
		return 0;
	}	
	fatFclose(pfilePnt);
	
	return pReadBuf;

}

/****************************************************************************
	ComFS_Formate()
 ----------------------------------------------------------------------------
	description:

	argument:	(none)
	return:		(none)
 ****************************************************************************/
int ComFS_Format(enDrvNum DrvNum, unsigned char bFormatStage)
{
	int iRetVal;
		
	if(bFormatStage > FMT_MAXSTAGE)
		return FS_FAILED;
	
	//check fs semphore
	if(FS_ObtainSemaphore() != FS_SUCCESS)
		return FS_FAILED;
	
	switch(DrvNum)
	{
		case DRV_RAM:
			iRetVal = ramdskPhyFormat(0x12345, &pVolNameRam,  ( FatInitParams_t * )&g_StgParm);
			FS_ReleaseSemaphore();
		break;
	
		case DRV_SMT:
		case DRV_MCP:
		case DRV_ADV:
		{
			if(bFormatStage == FMT_NOSTEP)
			{
				iRetVal = smtPhyFormat(0x12345, &pVolNameSmt,  ( FatInitParams_t * )&g_StgParm);
				FS_ReleaseSemaphore();
				break;
			}
			iRetVal = smtPhyStep(bFormatStage);
			FS_ReleaseSemaphore();
		}
		break;
	}
	return iRetVal;
}

/****************************************************************************
	ComFS_SelDsk()
 ----------------------------------------------------------------------------
	description:

	argument:	(none)
	return:		(none)
 ****************************************************************************/
int ComFS_SelDsk(enDrvNum DrvNum)
{
	if(g_StgUseDrv == DrvNum)					/* open current disk return */
		return FS_SUCCESS;
	
	//check fs semphore
	if(FS_ObtainSemaphore() != FS_SUCCESS)
		return FS_FAILED;
	
	/* close current driver */
	switch( g_StgUseDrv )
	{
		case DRV_RAM:
			break;								/* Ram disk no need close lib */
		case DRV_SMT:
		case DRV_MCP:
		case DRV_ADV:
			if(smtCloseLib() !=SMT_E_SUCCESS)
			{
				FS_ReleaseSemaphore();
				return FS_FAILED;
			}
			break;
		default:
			FS_ReleaseSemaphore();
			return FS_FAILED;				/* unsupported type */
	}

	/* Open device	*/
	switch(DrvNum)
	{
		case DRV_RAM:
		{
			fatCacheRAMEntry((unsigned char*)NULL);
			if (ramdskOpenLib(&g_StgParm) !=RAMDSK_E_SUCCESS)
			{
				FS_ReleaseSemaphore();
				return FS_FAILED;
			}
		}	
		break;
			
		case DRV_SMT:
		case DRV_MCP:
		case DRV_ADV:
		{
			if(DrvNum == DRV_SMT)
				bSmtType = SMT_T_CARD;
			else
				bSmtType = SMT_T_MCP;
			DrvFS_IO_SelSmt(DrvNum);
			
			if (smtOpenLib(&g_StgParm) !=SMT_E_SUCCESS)
			{
				FS_ReleaseSemaphore();
				return FS_FAILED;
			}
		}
		break;
		
		default:
			FS_ReleaseSemaphore();
			return FS_FAILED;				/* unsupported type */
	}
	
	g_StgUseDrv = DrvNum;
	
	FS_ReleaseSemaphore();
	
	return FS_SUCCESS;
}

/****************************************************************************
	smtPhyStep()
 ----------------------------------------------------------------------------
	description:

	argument:	(none)
	return:		(none)
 ****************************************************************************/
 static int smtPhyStep(unsigned char step)
 {
 	int iRetVal, iLoop;
 	unsigned char	bMaker;	
	unsigned char	bDevice;
	unsigned long	ulPageAddr;
	static unsigned char	*pCacheAddr;

 	switch(step)
	{
		case FMT_STAGE1	:		//get cache addr
		{
			pCacheAddr = fatGetCacheRAMAddr();
			return FS_SUCCESS;
		}
		break;
		
		case FMT_STAGE2 :		//inital dev
		{
			smtInitDev(&g_StgParm);
			return FS_SUCCESS;
		}
		break;
		
		case FMT_STAGE3 :		// media check
		{
			if((pSmt_CardDetect() == SMT_FALSE) | (pSmt_WriteProtect() == SMT_TRUE))
				return FS_FAILED;
			bMaker = bDevice = 0x00;
			pSmt_IdRead(&bMaker, &bDevice);
			if((bMaker == 0x00)||(bDevice == 0x00))
				return FS_FAILED;
			iRetVal = smtGetDevInfo(bDevice);
		}
		break;
		
		case FMT_STAGE4 :		// all block erase
		{
			iLoop = 0;
			while(iLoop < smt_pDevInf->pSizeInf->ulNumBlk)
		  	{
				ulPageAddr = smtChgPgNum(iLoop / SMT_ZON_MAX, iLoop % SMT_ZON_MAX, 0x00);
				iRetVal = pSmt_BlockErase(ulPageAddr);
				if(pSmt_EraseChk() != SMT_E_SUCCESS)
			  	{
					smtEntryBadBlk(iLoop / SMT_ZON_MAX, iLoop % SMT_ZON_MAX);
			  	}
				iLoop++;
		  	}
		}
		break;
		
		case FMT_STAGE5:		// cis data write	
			iRetVal = smtCisDataWrite();
		break;

		case FMT_STAGE6:		// phy format check
			iRetVal = smtPhyFmtChk(NULL);
		break;		
		
		case FMT_STAGE7:		// logical format
		{
			fatCacheRAMEntry(pCacheAddr);
			iRetVal = smtLogFormat(0x12345, &pVolNameSmt,  ( FatInitParams_t * )&g_StgParm);
		}
		break;
	}
	return iRetVal;	
 }
 
/***********************************************************
 * FUNCTION: FS_ObtainSemaphore
 *
 * PURPOSE:
 *    Obtain FS's Semaphore
 *
 * PARAMETERS
 *    Input: 
 *    Output:
 *    InOut: 
 * Return value:
 *					FS_SUCCESS
 *					Error code
 * Reentrant : Yes
 ***********************************************************/

int FS_ObtainSemaphore(void)
{

#ifdef FS_ROS33
	
	int iRetVal;

	iRetVal=preq_sem(ID_SEM_FS);
	
	if(iRetVal!=E_OK)
	{	
		stFsErrinfo.iErrType = FS_ERR_NOSEM;
		return FS_FAILED;
	}
	else
		return FS_SUCCESS;

#endif

	return FS_SUCCESS;
};

/***********************************************************
 * FUNCTION: FS_ReleaseSemaphore
 *
 * PURPOSE:
 *    Release FS's Semaphore
 *
 * PARAMETERS
 *    Input:  
 *    Output:
 *    InOut: 
 * Return value:
 * Reentrant : Yes
 ***********************************************************/

int FS_ReleaseSemaphore(void)
{

#ifdef FS_ROS33

	int iRetVal;

	iRetVal=sig_sem(ID_SEM_FS);

#endif

	return FS_SUCCESS;
};