smt_tmp.c

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

		if((ulSize + sizeof(SMT_C_DISCOD) - 1) <= (ulSctCnt * smt_stDevInf[smt_TmpDevIdx].ulSctSize)){
			smt_TmpMemTbl[ulTblIdx].bUseFlag = 1;
			smt_TmpMemTbl[ulTblIdx].bWrtFlag = 0;
			smt_TmpMemTbl[ulTblIdx].ulZone   = ulZone;
			smt_TmpMemTbl[ulTblIdx].ulPhyBlk = ulPhyBlk;
			smt_TmpMemTbl[ulTblIdx].ulPhySct = ulStartSct;
			smt_TmpMemTbl[ulTblIdx].ulSctNum = ulSctCnt;
			smt_TmpMemTbl[ulTblIdx].ulWrtSize = 0;
			break;
		}
	}
	if(!smt_TmpMemTbl[ulTblIdx].bUseFlag){
		return(0);					// A free territory isn't found
	}

	return(ulTblIdx);
}


/************************************************************************
 *  smtTmpRlsSector
 *      Type     : void
 *      Ret val  : None
 *      Argument : unsigned long ulSectorID ... Sector ID
 *                 [The return value of the smtTmpGetSector function]
 *      Function : This function release the territory which it got by
 *                 the smtTmpGetSector function.
 ************************************************************************/
int	smtTmpRlsSector(unsigned long ulSectorID)
{
	unsigned long	ulLogSect;				// Logic sector address.
	unsigned long	ulNumSect;				// Number of sectors.
	unsigned long	ulPage;					// Page address.
	static   char	bBuff[SMT_C_BLOCK - 1][SMT_C_SECT];	// Data buffer.

											// It gets a logic block address.
	ulPage = smtChgPgNum(smt_TmpMemTbl[ulSectorID].ulZone, smt_TmpMemTbl[ulSectorID].ulPhyBlk, 0x00);
	if(smtPageRead(0x50, 0x00, ulPage, bBuff[0]) == SMT_E_FAILURE){
		return(-1);
	}
	ulLogSect  = smt_TmpMemTbl[ulSectorID].ulZone;		// The calculation of logic sector address.
	ulLogSect *= SMT_C_VALID;
	ulLogSect += smtChgLogNum(bBuff[0][6], bBuff[0][7]);
	ulLogSect *= smt_stDevInf[smt_TmpDevIdx].ulBlkSize;
	ulNumSect  = smt_stDevInf[smt_TmpDevIdx].ulBlkSize;
	ulNumSect -= smt_TmpMemTbl[ulSectorID].ulSctNum;
	ulNumSect *= SMT_C_SECT;

	memset(bBuff, 0xFF, (SMT_C_BLOCK - 1) * SMT_C_SECT);	// Data are moved to another block.
	if(smtRdSect(0, ulLogSect, ulNumSect, bBuff) == SMT_E_FAILURE){
		return(-1);
	}
	ulNumSect = smt_stDevInf[smt_TmpDevIdx].ulBlkSize;
	ulNumSect *= SMT_C_SECT;
	if(smtWtSect(0, ulLogSect, ulNumSect, bBuff, 0) == SMT_E_FAILURE){
		return(-1);
	}

	smt_TmpMemTbl[ulSectorID].bUseFlag = 0;				// Resetting of temporary information table.
	smt_TmpMemTbl[ulSectorID].bWrtFlag = 0;
	smt_TmpMemTbl[ulSectorID].ulZone   = 0;
	smt_TmpMemTbl[ulSectorID].ulPhyBlk = 0;
	smt_TmpMemTbl[ulSectorID].ulPhySct = 0;
	smt_TmpMemTbl[ulSectorID].ulSctNum = 0;
	smt_TmpMemTbl[ulSectorID].ulWrtSize = 0;

	return(0);
}


/************************************************************************
 *  smtTmpWriteData
 *      Type     : unsigned long
 *      Ret val  : The number of the bytes of the data which were
 *                 actually written.
 *      Argument : unsigned long ulSectorID ... Sector ID
 *                 [The return value of the smtTmpGetSector function]
 *                 unsigned long ulDataSize ... Write data size
 *                 unsigned char *pDataBuff ... Write data buffer
 *                 unsigned char bVerify    ... Verify Enable/Disable flag
 *      Function : This function writes data in the free territory where
 *                 it was acquired.
 ************************************************************************/
unsigned long	smtTmpWriteData(unsigned long ulSectorID,
				unsigned long ulDataSize,
				unsigned char *pDataBuff)
{
	unsigned long	ulZone;					// Zone address.
	unsigned long	ulPhyBlk;				// Physics block address.
	unsigned long	ulPhySct;				// Physics sector address.
	unsigned long	ulSctNum;				// Number of sectors.
	unsigned long	ulCpySize;				// Copy data size.
	unsigned long	ulWrtSize;				// Write data size.
	unsigned long	ulPage;					// Page address.
	unsigned char	bFirst;					// The first writing flag.

	//------------------------------------------------------//
	// Physics address of a territory to write is acquired. //
	//------------------------------------------------------//
	if(!smt_TmpMemTbl[ulSectorID].bUseFlag){
		return(0);							// A free territory isn't taken.
	}
	if(smt_TmpMemTbl[ulSectorID].bWrtFlag){
		return(0);							// It has already been written.
	}
	if((!ulDataSize)						// The size of data to write is too big.
	||(ulDataSize > (smt_TmpMemTbl[ulSectorID].ulSctNum
	               * smt_stDevInf[smt_TmpDevIdx].ulSctSize))){
		return(0);
	}
	smt_TmpMemTbl[ulSectorID].bWrtFlag = 1;
	ulZone   = smt_TmpMemTbl[ulSectorID].ulZone;
	ulPhyBlk = smt_TmpMemTbl[ulSectorID].ulPhyBlk;
	ulPhySct = smt_TmpMemTbl[ulSectorID].ulPhySct;
	ulSctNum = smt_TmpMemTbl[ulSectorID].ulSctNum;

	//------------------------------------------//
	// Data for the specified size are written. //
	//------------------------------------------//
	ulWrtSize = 0;
	bFirst = 0;
	while(ulSctNum){
		// The initialization of the writing buffer.
		memset(smt_TmpBuff, 0xFF, smt_stDevInf[smt_TmpDevIdx].ulSctSize + 16);
		// Writing data size is acquired.
		if(ulDataSize > smt_stDevInf[smt_TmpDevIdx].ulSctSize){
			ulCpySize = smt_stDevInf[smt_TmpDevIdx].ulSctSize;
		}
		else{
			ulCpySize = ulDataSize;
		}
		// Writing data are acquired
		if(!bFirst){
			ulCpySize -= (sizeof(SMT_C_DISCOD) - 1);
			memcpy(smt_TmpBuff, SMT_C_DISCOD, sizeof(SMT_C_DISCOD) - 1);
			memcpy(&smt_TmpBuff[sizeof(SMT_C_DISCOD) - 1], pDataBuff, ulCpySize);
			bFirst = 1;
		}
		else{
			memcpy(smt_TmpBuff, pDataBuff, ulCpySize);
		}
		// Data are written.
		smtSetProlDat(-2, smt_TmpBuff);
		ulPage = smtChgPgNum(ulZone, ulPhyBlk, ulPhySct);
		if(smtPageProgram(0x00, ulPage, smt_TmpBuff, 0) == SMT_E_FAILURE){
			return(0);				// Writing error.
		}
		ulDataSize -= ulCpySize;
		pDataBuff += ulCpySize;
		ulWrtSize += ulCpySize;
		ulPhySct++;
		ulSctNum--;
	}
	smt_TmpMemTbl[ulSectorID].ulWrtSize = ulWrtSize;

	return(ulWrtSize);
}


/************************************************************************
 *  smtTmpReadData
 *      Type     : unsigned long
 *      Ret val  : The number of the bytes of the data which are
 *                 actually read.
 *      Argument : unsigned long ulSectorID ... Sector ID
 *                 [The return value of the smtTmpGetSector function]
 *                 unsigned long ulDataSize ... Read data size
 *                 unsigned char *pDataBuff ... Read data buffer
 *      Function : This function reads data from the territory where it
 *                 was acquired.
 ************************************************************************/
unsigned long	smtTmpReadData(unsigned long ulSectorID,
				unsigned long ulDataSize,
				unsigned char *pDataBuff)
{
	unsigned int	uiLoop;					// Loop counter.
	unsigned long	ulZone;					// Zone address.
	unsigned long	ulPhyBlk;				// Physics block address.
	unsigned long	ulPhySct;				// Physics sector address.
	unsigned long	ulSctNum;				// Number of sectors.
	unsigned long	ulCpySize;				// Copy data size.
	unsigned long	ulReadSize;				// Read data size.
	unsigned long	ulReadMax;				// Read max data size.
	unsigned long	ulPage;					// Page address.
	unsigned char	bFirst;					// The first writing flag.
	unsigned char	*pDistCode;				// Distinction code.

	//-----------------------------------------------------//
	// Physics address of a territory to read is acquired. //
	//-----------------------------------------------------//
	if(!smt_TmpMemTbl[ulSectorID].bUseFlag){
		return(0);					// These data break or it is release.
	}
	if(!smt_TmpMemTbl[ulSectorID].bWrtFlag){
		return(0);					// Data haven't been written yet.
	}
	ulZone   = smt_TmpMemTbl[ulSectorID].ulZone;
	ulPhyBlk = smt_TmpMemTbl[ulSectorID].ulPhyBlk;
	ulPhySct = smt_TmpMemTbl[ulSectorID].ulPhySct;
	ulSctNum = smt_TmpMemTbl[ulSectorID].ulSctNum;
	if((!ulDataSize)||(ulDataSize > smt_TmpMemTbl[ulSectorID].ulWrtSize)){
		ulReadMax = smt_TmpMemTbl[ulSectorID].ulWrtSize;
	}
	else{
		ulReadMax = ulDataSize;
	}

	//---------------------------------------//
	// Data for the specified size are read. //
	//---------------------------------------//
	ulReadSize = 0;
	bFirst = 0;
	while(ulSctNum){
		// Data are read.
		ulPage = smtChgPgNum(ulZone, ulPhyBlk, ulPhySct);
		if(smtPageRead(SMT_C_DREAD_1, 0x00, ulPage, smt_TmpBuff) == SMT_E_FAILURE){
			return(0);				// Read error.
		}
		// Reading data are copied on the buffer.
		if(ulReadMax > smt_stDevInf[smt_TmpDevIdx].ulSctSize){
			ulCpySize = smt_stDevInf[smt_TmpDevIdx].ulSctSize;
		}
		else{
			ulCpySize = ulReadMax;
		}
		if(!bFirst){
			// A distinction code is examined.
			pDistCode = SMT_C_DISCOD;
			for(uiLoop = 0; uiLoop < (sizeof(SMT_C_DISCOD) - 1); uiLoop++){
				if(*(pDistCode + uiLoop) != smt_TmpBuff[uiLoop]){
									// Resetting of temporary information table.
					smt_TmpMemTbl[ulSectorID].bUseFlag = 0;
					smt_TmpMemTbl[ulSectorID].bWrtFlag = 0;
					smt_TmpMemTbl[ulSectorID].ulZone   = 0;
					smt_TmpMemTbl[ulSectorID].ulPhyBlk = 0;
					smt_TmpMemTbl[ulSectorID].ulPhySct = 0;
					smt_TmpMemTbl[ulSectorID].ulSctNum = 0;
					return(0);		// Distinction code recognition error.
				}
			}
			ulCpySize -= (sizeof(SMT_C_DISCOD) - 1);
			memcpy(pDataBuff, &smt_TmpBuff[sizeof(SMT_C_DISCOD) - 1], ulCpySize);
			bFirst = 1;
		}
		else{
			memcpy(pDataBuff, smt_TmpBuff, ulCpySize);
		}
		pDataBuff += ulCpySize;
		ulReadSize += ulCpySize;
		ulReadMax -= ulCpySize;
		if(!ulReadMax){
			break;
		}
		ulPhySct++;
		ulSctNum--;
	}

	return(ulReadSize);
}


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