smt_fat.c

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

 *      Function : This function calls Library Initialization function
 ************************************************************************/
int	smtOpenLib(
	FatInitParams_t *pstParams
	)
  {
	unsigned char	*pCacheAddr;				// Cache area address
	long		lCacheSize;						// Cache area size
	int		iRetVal;							// Return value

	pCacheAddr = fatGetCacheRAMAddr();
	iRetVal = smtInitDev(pstParams);
	////////////////////////
	/// SYSTEM AREA READ ///
	////////////////////////
	if(pCacheAddr == NULL)
	  {
		return(iRetVal);
	  }

	lCacheSize = smtGetCacheRAMSize();
	if(lCacheSize == SMT_E_FAILURE)
	  {
		return(SMT_E_FAILURE);
	  }
	iRetVal = smtRdSect(0, smt_pDevInf->pSctInf->ulFatArea[0], lCacheSize, pCacheAddr);
	fatCacheRAMEntry(pCacheAddr);				// Cache RAM entry again because fatFatInit
												// initializes fat_CacheRAM.

	return(iRetVal);
  }

/************************************************************************
 *  smtCloseLib
 *      Type     : int
 *      Ret val  : Error code
 *                    SMT_SUCCESS ( 0) ... Successful
 *                    SMT_FAILURE (-1) ... Failure
 *      Argument : unsigned char *pCacheAddr
 *      Function : This function updates system area data on Cache RAM to
 *                 device
 ************************************************************************/
int	smtCloseLib(
	void
	)
  {
	unsigned long	ulSize;
	unsigned char	*pCacheAddr;
	int	 	iRetVal;
	int		iUpdateNum;
	int		iLoop;

	pCacheAddr = fatGetCacheRAMAddr();
	if (pCacheAddr == NULL)
	  {
		fatCacheRAMClear();
		return(SMT_E_SUCCESS);
	  }

	iUpdateNum =  smt_pDevInf->pSizeInf->uwBlkSize
	           - (smt_pDevInf->pSctInf->ulFatArea[0] % smt_pDevInf->pSizeInf->uwBlkSize);
	ulSize = smt_pDevInf->pSizeInf->uwDatSize * iUpdateNum;

	iRetVal = smtWtSect(0, smt_pDevInf->pSctInf->ulFatArea[0], ulSize, pCacheAddr, 1);
	if(iRetVal != SMT_E_SUCCESS)
	  {
		fatCacheRAMClear();
		return(iRetVal);
	  }
	pCacheAddr += ulSize;

	ulSize = smt_pDevInf->pSizeInf->uwDatSize * smt_pDevInf->pSizeInf->uwBlkSize;
	for(iLoop = smt_pDevInf->pSctInf->ulFatArea[0] + iUpdateNum;	// Update by cluster
	    iLoop + smt_pDevInf->pSizeInf->uwBlkSize - 1 < smt_pDevInf->pSctInf->ulDatArea[0];
	    iLoop += smt_pDevInf->pSizeInf->uwBlkSize)
	  {
		iRetVal = smtWtSect(0, iLoop, ulSize, pCacheAddr, 1);
		if(iRetVal != SMT_E_SUCCESS)
		  {
			fatCacheRAMClear();
			return(iRetVal);
		  }
		pCacheAddr += ulSize;
	  }

	iRetVal = pSmt_EraseChk();				// Block erase result check
	fatCacheRAMClear();
	return (iRetVal);						// iRetVal is only SMT_E_SUCCESS
  }											// of SMT_E_FAILURE


/************************************************************************
 *  smtGetCacheRAMSize
 *      Type     : long
 *      Ret val  : Error code
 *                    Cache RAM size  ... Successful
 *                    Error code      ... Failure
 *      Argument : unsigned char *pCacheAddr
 *      Function : This function returns necessary Cache Area Size
 ************************************************************************/
long	smtGetCacheRAMSize(
	)
  {
	unsigned char	bMaker;						// Maker code
	unsigned char	bDevice;					// Device code
	unsigned long	lCacheSize;					// Cache RAM size
	int		iIndex;								// Structure Index

	////////////////////////
	/// SMART MEDIA RESET //
	////////////////////////
	if(pSmt_MediaReset() != SMT_E_SUCCESS)		// A smart media is reset.
	  {
		smtErrInf.iSmtErr = SMT_E_MDRESET;
		return(SMT_E_FAILURE);
	  }

	//////////////////////////////
	/// GET DEVICE INFORMATION ///
	//////////////////////////////
	bMaker = bDevice = 0x00;					// A media ID and device information are
	pSmt_IdRead(&bMaker, &bDevice);				// - acquired.

	if((bMaker == 0x00)||(bDevice == 0x00))
	  {
		smtErrInf.iSmtErr = SMT_E_MIDREAD;
		return(SMT_E_FAILURE);
	  }

	if(bDevice == smtDevInf[0][0].bDevice || bDevice == smtDevInf[0][1].bDevice)
	  {
		iIndex = 0;					// 4MB
	  }
	else if(bDevice == smtDevInf[0][2].bDevice)
	  {
		iIndex = 1;					// 8MB
	  }
	else if(bDevice == smtDevInf[0][3].bDevice)
	  {
		iIndex = 2;					// 16MB
	  }
	else if(bDevice == smtDevInf[0][4].bDevice)
	  {
		iIndex = 3;					// 32MB
	  }
	else if(bDevice == smtDevInf[0][5].bDevice)
	  {
		iIndex = 4;					// 64MB
	  }
	else if(bDevice == smtDevInf[0][6].bDevice)
	  {
		iIndex = 5;					// 128MB
	  }
	else
	  {
		return(SMT_E_FAILURE);				// unknown device ID
	  }

	lCacheSize =  (smtSctInf[iIndex].ulDatArea[0] - smtSctInf[iIndex].ulFatArea[0])
		    * SMT_DAT_MAX;

	return (lCacheSize);
  }

/************************************************************************
 *  smtCacheRAMEntry
 *      Type     : int
 *      Ret val  : Error code
 *                    SMT_SUCCESS ( 0) ... Successful
 *                    SMT_FAILURE (-1) ... Failure
 *      Argument : unsigned char *pCacheAddr
 *      Function : This function registers Cache Area to the FAT library
 ************************************************************************/
int	smtCacheRAMEntry(
	unsigned char	*pCacheAddr
	)
  {
	fatCacheRAMEntry(pCacheAddr);
	return (SMT_E_SUCCESS);
  }

/************************************************************************
 *  smtVerifyCheck
 *      Type     : int
 *      Ret val  : Error code
 *                    SMT_SUCCESS ( 0) ... Normal
 *                    SMT_FAILURE (-1) ... abnormal
 *      Argument : unsigned long ulPage ... Page number for check page
 *                 unsigned char *bWrtData ... Written data
 *      Function : This function checks that written data is right or not
 ************************************************************************/
int	smtVerifyCheck(unsigned long ulPage, unsigned char *bWrtData)
{
	int	iLoop, iLoopLmt, iRetVal;
	unsigned char	bProlBak[SMT_PRL_MAX], *pbComp1, *pbComp2;

	memcpy(bProlBak, smtProlBuff.bFlatBuff, sizeof(bProlBak));	// Back up the current Prolix data

	if(smtPageReadWrap(SMT_C_DREAD_1, 0x00, ulPage, smtVerifyBuff) != SMT_E_SUCCESS)
	  {												// Read written data
		smtErrInf.iSmtErr = SMT_E_PAGREAD;
		return(SMT_E_FAILURE);
	  }

	iLoopLmt = smt_pDevInf->pSizeInf->uwDatSize;
	pbComp1 = smtVerifyBuff;
	pbComp2 = bWrtData;
	for(iLoop = 0 ; iLoop < iLoopLmt ; iLoop++)		// Compare Data area
	  {
		if(*pbComp1++ != *pbComp2++)
		  {
			break;
		  }
	  }
	if(iLoop < iLoopLmt)
	  {
		return(SMT_E_FAILURE);
	  }

	iLoopLmt = smt_pDevInf->pSizeInf->uwPrlSize;
	pbComp1 = smtProlBuff.bFlatBuff;
	pbComp2 = bProlBak;
	for(iLoop = 0 ; iLoop < iLoopLmt ; iLoop++)		// Compare Prolix area
	  {
		if(*pbComp1++ != *pbComp2++)
		  {
			break;
		  }
	  }
	if(iLoop < iLoopLmt)
	  {
		return(SMT_E_FAILURE);
	  }

	return(SMT_E_SUCCESS);							// Compare check OK
}

/************************************************************************
 *  smtPageReadWrap
 *      Type     : int
 *      Ret val  : Error code
 *                    SMT_SUCCESS ( 0) ... Successful
 *                    SMT_FAILURE (-1) ... Failure
 *      Argument : unsigned char bCommand ... Page read type
 *                 unsigned long ulColumn ... Clumun number
 *                 unsigned long ulPage   ... Page number
 *                 char          pBuffer  ... Pointer to buffer area
 *      Function : This function read data from SmartMedia by page.
 *                 if reading process exits abnormaly, do retrying
 ************************************************************************/
int	smtPageReadWrap(
	unsigned char bCommand,
	unsigned long ulColumn,
	unsigned long ulPage,
	char *pBuffer)
  {
	int	iLoop, iRetVal;							// Loop counter, return code

	for(iLoop = 0 ; iLoop <= SMT_BLKTRY_MAX ; iLoop++)
	  {
		if(pSmt_PageRead(bCommand, ulColumn, ulPage, pBuffer) != SMT_E_SUCCESS)
		  {										// Low revel function failure
			smtErrInf.iSmtErr = SMT_E_PAGREAD;
			return(SMT_E_FAILURE);
		  }

		if(bCommand == SMT_C_DREAD_1 && smtChkRdDat(pBuffer) != SMT_E_SUCCESS)	// Data check error
		  {
			continue;							// retrying
		  }

		break;
	  }

	if(iLoop > SMT_BLKTRY_MAX)
	  {
		smtErrInf.iSmtErr = SMT_E_PAGREAD;		// retry error
		return(SMT_E_FAILURE);
	  }

	return (SMT_E_SUCCESS);
  }

/************************************************************************
 *  smtBlockCopy
 *      Type     : int
 *      Ret val  : Error code
 *                    SMT_SUCCESS ( 0) ... Successful
 *                    SMT_FAILURE (-1) ... Failure
 *      Argument : unsigned long ulLogBlk ... Logical block number
 *                 unsigned long ulFirstBlk ... First half source block number
 *                 unsigned long ulLatterBlk ... Latter half source block number
 *                 unsigned long ulDestBlk ... New Block address
 *                 unsigned long ulExceptSct ... Physical Sector address except copying
 *                 char     bValidBlk    ... Valid source block
 *      Function : This function read data from SmartMedia by page.
 *                 if reading process exits abnormaly, do retrying
 ************************************************************************/
int	smtBlockCopy(
	struct SMT_BLKCOPY_PARAMS	*stBCParams)
  {
	int		iLoop, iRetVal;						// Loop counter, return code
	unsigned long	ulZone;						// Zone number
	unsigned long	ulNewPhyBlk;				// New Block address
	unsigned long	ulBtmSct;					// Bottom sector of copying sectors
	char		bIndex;							// Address management table index

	ulZone = stBCParams->ulLogBlk / SMT_LZN_MAX;
	if(!ulZone)
	  {
		bIndex = 0;
	  }
	else
	  {
		bIndex = 1;
	  }

	for(iLoop = 0 ; iLoop <= SMT_BLKTRY_MAX ; iLoop++)
	  {
		if(smtGetFreeBlk(ulZone, &ulNewPhyBlk) != SMT_E_SUCCESS)
		  {
			return(SMT_E_FAILURE);
		  }

		if((stBCParams->bValidBlkFlag & SMT_BLKMV_FIRST)		// First half moving
		    && ((stBCParams->bValidBlkFlag & SMT_BLKMV_RECOVER) || (stBCParams->ulExceptSct)))
		  {
			if(stBCParams->bValidBlkFlag & SMT_BLKMV_RECOVER)	// Recovery latter half moving
			  {
				ulBtmSct = stBCParams->ulExceptSct;
			  }
			else if(stBCParams->ulExceptSct)
			  {
				ulBtmSct = stBCParams->ulExceptSct - 1;
			  }
			if(smtDupliSect(ulZone, ulNewPhyBlk, stBCParams->ulFirstBlk,
					0x00, ulBtmSct, stBCParams->bVerify) != SMT_E_SUCCESS)
			  {
				if(smtErrInf.iSmtErr == SMT_E_BADBLCK)
				  {
					return(SMT_E_FAILURE);		// Bad Block limit over
				  }
				else
				  {
					continue;
				  }
			  }
		 }

		if((stBCParams->bValidBlkFlag & SMT_BLKMV_LATTER) &&
		   (stBCParams->ulExceptSct + 1 < smt_pDevInf->pSizeInf->uwBlkSize))
		  {										// latter half moving
			if(smtDupliSect(ulZone, ulNewPhyBlk, stBCParams->ulLatterBlk, stBCParams->ulExceptSct + 1,
			   smt_pDevInf->pSizeInf->uwBlkSize - 1, stBCParams->bVerify)
			   != SMT_E_SUCCESS)
			  {
				if(smtErrInf.iSmtErr == SMT_E_BADBLCK)
				  {
					return(SMT_E_FAILURE);		// Bad Block limit over
				  }
				else
				  {
					continue;
				  }
			  }
		  }
												// Address management table renewal
		if(smtWtBlkAddr(ulZone, ulNewPhyBlk, stBCParams->ulLogBlk) == SMT_E_SUCCESS)
		  {
			smtBlkTbl[bIndex].bBlkChkInf[(stBCParams->ulLogBlk % SMT_LZN_MAX) / 8]
				|= SMT_M_MASK(stBCParams->ulLogBlk % 8);
			smtBlkTbl[bIndex].bBlkCnvInf[stBCParams->ulLogBlk % SMT_LZN_MAX] = SMT_M_BYTE(ulNewPhyBlk, 0);
			break;
		  }
		else
		  {
			if(smtEntryBadBlk(ulZone, ulNewPhyBlk) != SMT_E_SUCCESS)
			  {
				return(SMT_E_FAILURE);
			  }
			continue;
		  }
	  }

	if(iLoop > SMT_BLKTRY_MAX)
	  {
		smtErrInf.iSmtErr = SMT_E_SCTWRTE;		// Set Sector Write error
		return(SMT_E_FAILURE);
	  }

	stBCParams->ulDestBlk = ulNewPhyBlk;
	return(SMT_E_SUCCESS);
  }


/***** End of file *****/