ramdsk.c

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

/****************************************************************************
	ramdskMakeDriveImage()
 ----------------------------------------------------------------------------
	description:
		RAM 

	argument:	(none)
	return:		(none)
	input:		(none)
	output:		(none)
	flag:		(none)
	global:		(none)
	comment:
		
 ****************************************************************************/
void ramdskMakeDriveImage()
{
	int				iCnt0;
	int				iCnt1;
	unsigned long	ulRootDirSecCnt;
	unsigned long	ulFatSecCnt;
	unsigned long	ulDrvSecCnt;
	unsigned char	*pCurSecTop;


	///////////////////////////
	/// Set Global Variable ///
	///////////////////////////
	RAMDSK_Area = (void*)RAMDSK_STRADR;
	RAMDSK_SecSize = (unsigned long)RAMDSK_SEC_SIZE;
	RAMDSK_MaxSec = (unsigned long)RAMDSK_SIZE / RAMDSK_SecSize;


	////////////////////////////
	/// Calculate parameter  ///
	////////////////////////////
	ulDrvSecCnt = (unsigned long)RAMDSK_SIZE / RAMDSK_SEC_SIZE;

	/*** This code mean ... ***/
	/* RootDirSecCnt = Revalue(RootEntCnt * 32, ByteParSec)							*/
	/* FatSecCnt = Revalue(TotalSec32 - RsvSecCnt - RootDirSecCnt + (2 * SecParClus),	*/
	/*				FatCnt + (SecParClus * ByteParSec / 2));						*/
	ulRootDirSecCnt = Revalue(RAMDSK_ROOT_ENT_CNT * 32, RAMDSK_SEC_SIZE);
	ulFatSecCnt = Revalue(
			(ulDrvSecCnt - 1) - RAMDSK_RSV_SEC_CNT - ulRootDirSecCnt + (2 * RAMDSK_SEC_PAR_CLUS),
			RAMDSK_FAT_CNT + (RAMDSK_SEC_PAR_CLUS * RAMDSK_SEC_SIZE / 2)
		);

	////////////////////////////////
	/// WRITE MASTER BOOT RECORD ///
	////////////////////////////////
	pCurSecTop = (unsigned char*)RAMDSK_STRADR;

	memset((void*)pCurSecTop, 0, RAMDSK_SEC_SIZE);

	*((unsigned char*)(pCurSecTop + MBR_BOOT_CODE + 0)) = 0xeb;
	*((unsigned char*)(pCurSecTop + MBR_BOOT_CODE + 1)) = 0x40;
	*((unsigned char*)(pCurSecTop + MBR_BOOT_CODE + 2)) = 0x90;

	strcpy(((char*)(pCurSecTop + MBR_BOOT_CODE + 0x03)), OemName);
	strcpy(((char*)(pCurSecTop + MBR_BOOT_CODE + 0x10)), Copyright);

	*((unsigned char*)(pCurSecTop + MBR_PAT0_BOOT_FLAG)) = PAT_ACTIVE;
	*((unsigned char*)(pCurSecTop + MBR_PAT0_CHS_STR + 0)) = 0x01;		/* C=0, H=1, S=1 */
	*((unsigned char*)(pCurSecTop + MBR_PAT0_CHS_STR + 1)) = 0x01;
	*((unsigned char*)(pCurSecTop + MBR_PAT0_CHS_STR + 2)) = 0x00;
	*((unsigned char*)(pCurSecTop + MBR_PAT0_TYPE)) = PAT_TYPE_FAT16_LBA;
	*((unsigned char*)(pCurSecTop + MBR_PAT0_CHS_END + 0)) = 0xfe;		/* C=1023, H=254, S=63 */
	*((unsigned char*)(pCurSecTop + MBR_PAT0_CHS_END + 1)) = 0xff;
	*((unsigned char*)(pCurSecTop + MBR_PAT0_CHS_END + 2)) = 0xff;
	*((unsigned short*)(pCurSecTop + MBR_PAT0_LBA_ADR_L)) = (unsigned short)0x0001;
	*((unsigned short*)(pCurSecTop + MBR_PAT0_LBA_ADR_H)) = (unsigned short)0x0000;
	*((unsigned short*)(pCurSecTop + MBR_PAT0_LBA_SIZE_L)) = (unsigned short)((ulDrvSecCnt - 1) & 0xffff);
	*((unsigned short*)(pCurSecTop + MBR_PAT0_LBA_SIZE_H)) = (unsigned short)((ulDrvSecCnt - 1) >> 16);

	*((unsigned short*)(pCurSecTop + MBR_SIGNATURE)) = 0xaa55;


	///////////////////////////////////
	/// WRITE PARTITION BOOT RECORD ///
	///////////////////////////////////
	pCurSecTop += RAMDSK_HIDDEN_SEC_CNT * RAMDSK_SEC_SIZE;

	memset((void*)pCurSecTop, 0, RAMDSK_SEC_SIZE);

	*((unsigned char*)(pCurSecTop + PBR5_JUMP_CODE + 0)) = 0xeb;
	*((unsigned char*)(pCurSecTop + PBR5_JUMP_CODE + 1)) = 0x3e;
	*((unsigned char*)(pCurSecTop + PBR5_JUMP_CODE + 2)) = 0x90;

	memcpy(((char*)(pCurSecTop + PBR5_OEM_NAME)), "MSDOS5.0", 8);
	*((unsigned char*)(pCurSecTop + PBR5_BYTE_PAR_SEC_L)) = (unsigned char)(RAMDSK_SEC_SIZE & 0xff);
	*((unsigned char*)(pCurSecTop + PBR5_BYTE_PAR_SEC_H)) = (unsigned char)(RAMDSK_SEC_SIZE >> 8);
	*((unsigned char*)(pCurSecTop + PBR5_SEC_PAR_CLUS)) = RAMDSK_SEC_PAR_CLUS;
	*((unsigned short*)(pCurSecTop + PBR5_RSV_SEC_CNT)) = RAMDSK_RSV_SEC_CNT;
	*((unsigned char*)(pCurSecTop + PBR5_FAT_CNT)) = RAMDSK_FAT_CNT;
	*((unsigned char*)(pCurSecTop + PBR5_ROOT_ENT_CNT_L)) = (unsigned char)(RAMDSK_ROOT_ENT_CNT & 0xff);
	*((unsigned char*)(pCurSecTop + PBR5_ROOT_ENT_CNT_H)) = (unsigned char)(RAMDSK_ROOT_ENT_CNT >> 8);
	*((unsigned char*)(pCurSecTop + PBR5_TOTAL_SEC_L)) = 0;
	*((unsigned char*)(pCurSecTop + PBR5_TOTAL_SEC_H)) = 0;
	*((unsigned char*)(pCurSecTop + PBR5_MEDIA)) = 0xf8;
	*((unsigned short*)(pCurSecTop + PBR5_FAT_SIZE)) = ulFatSecCnt;
	*((unsigned short*)(pCurSecTop + PBR5_SEC_PAR_TRK)) = 63;
	*((unsigned short*)(pCurSecTop + PBR5_HEAD_CNT)) = 254;
	*((unsigned long*)(pCurSecTop + PBR5_HIDDEN_SEC_CNT)) = RAMDSK_HIDDEN_SEC_CNT;
	*((unsigned long*)(pCurSecTop + PBR5_TOTAL_SEC32)) = ulDrvSecCnt - 1;
	*((unsigned char*)(pCurSecTop + PBR5_DRV_NUM)) = 0x00;
	*((unsigned char*)(pCurSecTop + PBR5_BOOT_SIG)) = 0x29;
	*((unsigned char*)(pCurSecTop + PBR5_VOL_ID_L)) = 0x00;
	*((unsigned short*)(pCurSecTop + PBR5_VOL_ID_M)) = 0x0000;
	*((unsigned char*)(pCurSecTop + PBR5_VOL_ID_H)) = 0x00;
	memcpy((void*)((unsigned char*)(pCurSecTop + PBR5_VOL_LABEL)), "RAMDISK    ", 11);
	/*modified by david, if ramsize less than 1Mb, use FAT12 */
	if(RAMDSK_SIZE < 0x100000)
		memcpy((void*)((unsigned char*)(pCurSecTop + PBR5_FS_TYPE)), (void*)"FAT12   ", 8);
	else
		memcpy((void*)((unsigned char*)(pCurSecTop + PBR5_FS_TYPE)), (void*)"FAT16   ", 8);
	*((unsigned short*)(pCurSecTop + PBR5_SIGNATURE)) = 0xaa55;


	//////////////////////
	/// WRITE FAT AREA ///
	//////////////////////
	pCurSecTop += RAMDSK_RSV_SEC_CNT * RAMDSK_SEC_SIZE;

	for (iCnt0 = 0; iCnt0 < RAMDSK_FAT_CNT; iCnt0++){

		memset((void*)pCurSecTop, 0, RAMDSK_SEC_SIZE);
		pCurSecTop[0] = 0xf8;				// Cluster0
		pCurSecTop[1] = 0xff;				// Cluster0
		pCurSecTop[2] = 0xff;				// Cluster1
		pCurSecTop[3] = 0xff;				// Cluster1

		pCurSecTop += RAMDSK_SEC_SIZE;

		for (iCnt1 = 1; iCnt1 < ulFatSecCnt; iCnt1++){
			memset((void*)pCurSecTop, 0, RAMDSK_SEC_SIZE);
			pCurSecTop += RAMDSK_SEC_SIZE;
		}
	}

	///////////////////////////
	/// ROOT DIRECTORY AREA ///
	///////////////////////////
	memset((void*)pCurSecTop, 0, RAMDSK_SEC_SIZE);
	memcpy((void*)(pCurSecTop + 0), "RAMDISK    ", 11);
	*((unsigned char*)(pCurSecTop + 11)) = 0x08;
	pCurSecTop += RAMDSK_SEC_SIZE;

	for (iCnt0 = 1; iCnt0 < ulRootDirSecCnt; iCnt0++){
		memset((void*)pCurSecTop, 0, RAMDSK_SEC_SIZE);
		pCurSecTop += RAMDSK_SEC_SIZE;
	}
}
/**** End of function *******************************************************/


/****************************************************************************
	ramdskPhyFmtChk()
 ----------------------------------------------------------------------------
	description:
		RAMDSK 

	argument:	(none)
	return:
		int				iRetVal		<out>	RAMDSK_E_SUCCESS: 
											RAMDSK_E_FAILURE: 
	input:		(none)
	output:		(none)
	flag:		(none)
	global:		(none)
	comment:
		
 ****************************************************************************/
int ramdskPhyFmtChk()
{
	return RAMDSK_E_SUCCESS;
}
/**** End of function *******************************************************/


/****************************************************************************
	ramdskLogFmtChk()
 ----------------------------------------------------------------------------
	description:
		RAMDSK 

	argument:	(none)
	return:
		int				iRetVal		<out>	RAMDSK_E_SUCCESS: 
											RAMDSK_E_FAILURE: 
	input:		(none)
	output:		(none)
	flag:		(none)
	global:		(none)
	comment:	(none)
 ****************************************************************************/
int ramdskLogFmtChk()
{
	return RAMDSK_E_SUCCESS;
}
/**** End of function *******************************************************/


/****************************************************************************
	ramdskMediaReset()
 ----------------------------------------------------------------------------
	description:
		RAMDSK 

	argument:	(none)
	return:
		int				iRetVal		<out>	RAMDSK_E_SUCCESS: 
											RAMDSK_E_FAILURE: 
	input:		(none)
	output:		(none)
	flag:		(none)
	global:		(none)
	comment:	(none)
 ****************************************************************************/
int ramdskMediaReset()
{
	int		iRetVal;						// Driver return value

	return RAMDSK_E_SUCCESS;
}
/**** End of function *******************************************************/


/****************************************************************************
	ramdskRdSect()
 ----------------------------------------------------------------------------
	description:
		RAMDSK 

	argument:
		unsigned char	bDrvNum 		<in>	Drive number(dummy)
		unsigned long	ulLogSct		<in>	Logic sector address
		unsigned long	ulDatSiz		<in>	Read data size [byte]
		unsigned char	*pBuffer		<in>	Read data buffer

	return:
		long			iRetVal 		<out>	RAMDSK_E_SUCCESS: 
												RAMDSK_E_FAILURE: 
	flag:		(none)

	global:
		unsigned char	*RAMDSK_Area	<in>	RAM Disk area address
		unsigned long	RAMDSK_MaxSec	<in>	RAM Disk max sector [sector]
		unsigned long	RAMDSK_SecSize	<in>	RAM Disk sector size [byte]

	comment:
		 bDrvNum 
 ****************************************************************************/
int ramdskRdSect(unsigned char bDrvNum, unsigned long ulLogSct,
				unsigned long ulDatSiz, unsigned char *pBuffer)
{
	unsigned long	ulRemainSize;		/* RAM disk remain size [byte] */
	void			*pReadAdr;			/* Read start address */


	pReadAdr = RAMDSK_Area + ulLogSct * RAMDSK_SecSize;
	ulRemainSize = (RAMDSK_MaxSec - ulLogSct) * RAMDSK_SecSize;

	if (ulDatSiz <= ulRemainSize)
	{
		memcpy((void*)pBuffer, pReadAdr, ulDatSiz);
		return RAMDSK_E_SUCCESS;
	}
	else
	{
		memcpy((void*)pBuffer, pReadAdr, ulRemainSize);
		return RAMDSK_E_FAILURE;
	}
}
/**** End of function *******************************************************/


/****************************************************************************
	ramdskWtSect()
 ----------------------------------------------------------------------------
	description:
		RAMDSK 

	argument:
		unsigned char	bDrvNum 		<in>	Drive number(dummy)
		unsigned long	ulLogSct		<in>	Logic sector address
		unsigned long	ulDatSiz		<in>	Write data size [byte]
		unsigned char	*pBuffer		<out>	Wrire data buffer
		unsigned char	bVerify 		<in>	Verify option flag
													0: Verify off
													1: Verify on
	return:
		long			iRet			<out>	RAMDSK_E_SUCCESS: 
												RAMDSK_E_FAILURE: 
	flag:		(none)

	global:
		unsigned char	*RAMDSK_Area	<in>	RAM Disk area address
		unsigned long	RAMDSK_MaxSec	<in>	RAM Disk max sector [sector]
		unsigned long	RAMDSK_SecSize	<in>	RAM Disk sector size [byte]

	comment:
		 bDrvNum 
 ****************************************************************************/
int ramdskWtSect(unsigned char bDrvNum, unsigned long ulLogSct,
		unsigned long ulDatSiz, unsigned char *pBuffer, unsigned char bVerify)
{
	unsigned long	ulRemainSize;		/* RAM disk remain size [byte] */
	unsigned long	pWriteAdr; 		/* Write start address */
	int 			iRetVal;

	iRetVal = RAMDSK_E_SUCCESS;

	pWriteAdr = (unsigned long)RAMDSK_Area + ulLogSct * RAMDSK_SecSize;
	ulRemainSize = (RAMDSK_MaxSec - ulLogSct) * RAMDSK_SecSize;

	if (ulDatSiz <= ulRemainSize){

		memcpy((void*)pWriteAdr, (void*)pBuffer, ulDatSiz);
		if (ulDatSiz % RAMDSK_SecSize != 0){
			memset((void*)pWriteAdr + ulDatSiz, 0x0, RAMDSK_SecSize - (ulDatSiz % RAMDSK_SecSize));
		}

		if (bVerify == 1){
			iRetVal = memcmp((void*)pWriteAdr, (void*)pBuffer, ulDatSiz);
			if (iRetVal != 0){
				iRetVal = RAMDSK_E_FAILURE;
			}
		}
	}else{
		iRetVal = RAMDSK_E_FAILURE;
	}

	return iRetVal;
}
/**** End of function *******************************************************/


/****************************************************************************
	ramdskCacheRAMEntry()
 ----------------------------------------------------------------------------
	description:
		RAM 

	argument:
		unsigned char	*pCacheAddr	<in>	Cache area address

	return:
		int				iRet		<out>	RAMDSK_E_SUCCESS: 

	flag:		(none)
	global:		(none)

	comment:
		RAMDSK GDIC 
		
 ****************************************************************************/
int ramdskCacheRAMEntry(unsigned char *pCacheAddr)
{
	fatCacheRAMEntry(0);
	return RAMDSK_E_SUCCESS;
}
/**** End of function *******************************************************/

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