hfatutil.c

HFAT32是我依据FAT标准,按照自己的理解写出来的一个FAT文件系统 特性: 1.HFAT32 是一个小型的嵌入式FAT文件系统,可以方便地在nand flash,RAM和SD Card

	if (_hai_FatDevRead(dev, DevInf_FSInfo(dev), SecBuf))
		return FATERR_DEV_OPERATE_ERR;
	if (HAI_MAKEDWORD(pFSI_LeadSig(SecBuf))==FSI_LEADSIG
			&& HAI_MAKEDWORD(pFSI_StrucSig(SecBuf))==FSI_STRUCSIG
			&& HAI_MAKEDWORD(pFSI_TrailSig(SecBuf))==FSI_TRAILSIG)
	{
		if (*NxtFree==FSI_NXTFREE_INVALID&&*FreeCnt==FSI_FREECNT_INVALID)
		{
			*NxtFree = HAI_MAKEDWORD(pFSI_NextFree(SecBuf));
			*FreeCnt = HAI_MAKEDWORD(pFSI_FreeCount(SecBuf));
		}
		else
		{
			HAI_WRITEDWORD(pFSI_NextFree(SecBuf), *NxtFree);
			HAI_WRITEDWORD(pFSI_FreeCount(SecBuf), *FreeCnt);
			if (_hai_FatDevWrite(dev, DevInf_FSInfo(dev), SecBuf))
				return FATERR_DEV_OPERATE_ERR;
//			if (_hai_FatDevWrite(dev, DevInf_BkBootSec(dev)+DevInf_FSInfo(dev), SecBuf))
//				return FATERR_DEV_OPERATE_ERR;
		}
	}

	return 0;
}

S_DWORD hai_AllocIdleClust(int dev)
{
	S_WORD Offset;
	S_DWORD Sec, TmpClust, IdleClus = 0;
	S_DWORD NxtFree, FreeCnt; 
	S_BYTE SecBuf[FAT_SEC_BUF_MAX];

	if (DevInf_FatType(dev) == FAT_TYPE_32)
	{
		NxtFree=FSI_NXTFREE_INVALID, FreeCnt=FSI_FREECNT_INVALID;
		hai_FsInfoOperate(dev, &NxtFree, &FreeCnt);
		if (NxtFree==FSI_NXTFREE_INVALID) TmpClust = 0;
		else TmpClust = NxtFree & FAT32_CLUST_VALIDBIT_MASK;
		Sec = (TmpClust<<2)/DevInf_BytsPerSec(dev);
		Offset = DevInf_BytsPerSec(dev);
		for (; Sec < DevInf_FatSize(dev); Sec++)
		{
			if (_hai_FatDevRead(dev, DevInf_RsvdSec(dev)+Sec, SecBuf))
				break;
			for (Offset = 0; Offset < DevInf_BytsPerSec(dev); Offset += 4)
			{
				if ((HAI_MAKEDWORD(SecBuf+Offset)&FAT32_CLUST_VALIDBIT_MASK) == 0x00)
					break;
			}
			if (Offset < DevInf_BytsPerSec(dev))// find out
				break;
		}
		if (Offset < DevInf_BytsPerSec(dev))
		{
			TmpClust = Sec*(DevInf_BytsPerSec(dev)>>2) + (Offset>>2);
			if (TmpClust < ((DevInf_TotSec(dev)-DevInf_FirstDatSec(dev))/DevInf_SecPerClust(dev)+2))//is a valid cluster
			{
				HAI_WRITEDWORD(SecBuf+Offset, HAI_MAKEDWORD(SecBuf+Offset)|FAT32_EOF_CLUST);
				if (!_hai_FatDevWrite(dev, DevInf_RsvdSec(dev)+Sec, SecBuf))
				{
					if (DevInf_NumFats(dev) == 2)//write 2th FAT
						_hai_FatDevWrite(dev, DevInf_RsvdSec(dev)+DevInf_FatSize(dev)+Sec, SecBuf);	
					IdleClus = TmpClust;
				}
			}
		}
		if (IdleClus)
		{
			NxtFree = IdleClus;
			if (FreeCnt == FSI_FREECNT_INVALID)
				FreeCnt = hai_GetFat32FreeCnt(dev) - 1;
			else if (FreeCnt > 1)
				FreeCnt -= 1;
			hai_FsInfoOperate(dev, &NxtFree, &FreeCnt);
		}
	}
	else
	{
		Offset = DevInf_BytsPerSec(dev);
		for (Sec = 0; Sec < DevInf_FatSize(dev); Sec++)
		{
			if (_hai_FatDevRead(dev, DevInf_RsvdSec(dev)+Sec, SecBuf))
				break;
			for (Offset = 0; Offset < DevInf_BytsPerSec(dev); Offset += 2)
			{
				if (HAI_MAKEWORD(SecBuf+Offset) == 0x00)
					break;
			}
			if (Offset < DevInf_BytsPerSec(dev))// find out
				break;
		}
		if (Offset < DevInf_BytsPerSec(dev))
		{
			TmpClust = Sec*(DevInf_BytsPerSec(dev)>>1) + (Offset>>1);
			if (TmpClust < ((DevInf_TotSec(dev)-DevInf_FirstDatSec(dev))/DevInf_SecPerClust(dev)+2))//is a valid cluster
			{
				HAI_WRITEWORD(SecBuf+Offset, FAT16_EOF_CLUST);
				if (!_hai_FatDevWrite(dev, DevInf_RsvdSec(dev)+Sec, SecBuf))
				{
					if (DevInf_NumFats(dev) == 2)//write 2th FAT
						_hai_FatDevWrite(dev, DevInf_RsvdSec(dev)+DevInf_FatSize(dev)+Sec, SecBuf);	
					IdleClus = TmpClust;
				}
			}
		}
	}

	if (IdleClus)
	{//clear the space of IdleClus
		hai_memset(SecBuf, 0x00, sizeof(SecBuf));
		Sec = DevInf_FirstDatSec(dev) + (IdleClus-2)*DevInf_SecPerClust(dev);
		for (Offset = 0; Offset < DevInf_SecPerClust(dev); Offset++)
		{
			if (_hai_FatDevWrite(dev, Sec+Offset, SecBuf))
				return 0;
		}
	}

	return IdleClus;
}

int hai_LinkClust(int dev, S_DWORD CurClust, S_DWORD LinkClust)
{
	S_DWORD mask;
	S_DWORD Sec, Offset;
	S_BYTE SecBuf[FAT_SEC_BUF_MAX];

	if (DevInf_FatType(dev) == FAT_TYPE_32)
	{
		Sec = (CurClust<<2)/DevInf_BytsPerSec(dev);
		if (_hai_FatDevRead(dev, DevInf_RsvdSec(dev)+Sec, SecBuf))
			return FATERR_DEV_OPERATE_ERR;
		Offset = (CurClust<<2)%DevInf_BytsPerSec(dev);
		mask = HAI_MAKEDWORD(SecBuf+Offset)&~FAT32_CLUST_VALIDBIT_MASK;
		HAI_WRITEDWORD(SecBuf+Offset, mask|LinkClust);
	}
	else
	{
		Sec = (CurClust<<1)/DevInf_BytsPerSec(dev);
		if (_hai_FatDevRead(dev, DevInf_RsvdSec(dev)+Sec, SecBuf))
			return FATERR_DEV_OPERATE_ERR;
		Offset = (CurClust<<1)%DevInf_BytsPerSec(dev);
		HAI_WRITEWORD(SecBuf+Offset, LinkClust);
	}
	
	if (_hai_FatDevWrite(dev, DevInf_RsvdSec(dev)+Sec, SecBuf))
		return FATERR_DEV_OPERATE_ERR;
	if (DevInf_NumFats(dev) == 2)//write 2th FAT
		_hai_FatDevWrite(dev, DevInf_RsvdSec(dev)+DevInf_FatSize(dev)+Sec, SecBuf);	

	return 0;
}

int hai_UnlinkClust(int dev, S_DWORD clust)
{
	S_DWORD mask;
	S_DWORD Sec, Offset;
	S_DWORD curFreeCnt = 0, curFreeClust = 0xFFFFFFFF;
	S_BYTE SecBuf[FAT_SEC_BUF_MAX];

	while (DevInf_FatType(dev)==FAT_TYPE_16?IS_FAT16_INUSE_CLUST(clust):IS_FAT32_INUSE_CLUST(clust))
	{
		if (DevInf_FatType(dev) == FAT_TYPE_32)
		{
			curFreeCnt++;
			if (clust < curFreeClust)
				curFreeClust = clust;
			Sec = (clust<<2)/DevInf_BytsPerSec(dev);
			if (_hai_FatDevRead(dev, DevInf_RsvdSec(dev)+Sec, SecBuf))
				return FATERR_DEV_OPERATE_ERR;
			Offset = (clust<<2)%DevInf_BytsPerSec(dev);
			clust = HAI_MAKEDWORD(SecBuf+Offset);
			mask = clust&~FAT32_CLUST_VALIDBIT_MASK;
			clust &= FAT32_CLUST_VALIDBIT_MASK;
			HAI_WRITEDWORD(SecBuf+Offset, mask|FAT32_VALID_CLUST);
		}
		else
		{
			Sec = (clust<<1)/DevInf_BytsPerSec(dev);
			if (_hai_FatDevRead(dev, DevInf_RsvdSec(dev)+Sec, SecBuf))
				return FATERR_DEV_OPERATE_ERR;
			Offset = (clust<<1)%DevInf_BytsPerSec(dev);
			clust = HAI_MAKEWORD(SecBuf+Offset);
			HAI_WRITEWORD(SecBuf+Offset, FAT16_VALID_CLUST);
		}
		if (_hai_FatDevWrite(dev, DevInf_RsvdSec(dev)+Sec, SecBuf))
			return FATERR_DEV_OPERATE_ERR;
		if (DevInf_NumFats(dev) == 2)//write 2th FAT
			_hai_FatDevWrite(dev, DevInf_RsvdSec(dev)+DevInf_FatSize(dev)+Sec, SecBuf);	
	}
	if (DevInf_FatType(dev) == FAT_TYPE_32)
	{
		S_DWORD FreeCnt = FSI_FREECNT_INVALID, FreeClust = FSI_NXTFREE_INVALID;
		if (hai_FsInfoOperate(dev, &FreeClust, &FreeCnt) == 0)
		{
			if (FreeCnt == FSI_FREECNT_INVALID)
				FreeCnt = hai_GetFat32FreeCnt(dev);
			else if (FSI_FREECNT_INVALID-FreeCnt > curFreeCnt)
				FreeCnt += curFreeCnt;
				
			if (FreeClust == FSI_NXTFREE_INVALID || FreeClust > curFreeClust)
				FreeClust = curFreeClust;
			hai_FsInfoOperate(dev, &FreeClust, &FreeCnt);
		}
	}
	
	return 0;
}

S_BYTE hai_IsFATDisk(S_BYTE disk)
{
	int dev;

	if ((dev = hai_GetDeviceNum(disk)) == -1)
		return S_FALSE;
	return (DevInf_FatType(dev)==FAT_TYPE_32 || DevInf_FatType(dev)==FAT_TYPE_16);
}

/*
32-bit Windows Time/Date Formats
Remarks

The file time and the date are stored individually, using unsigned integers as bit fields. File time and date are packed as follows:

Time

Bit Position: 0   1   2   3   4 5   6   7   8   9   A B   C   D   E   F  
Length:       5                 6                     5 
Contents:     hours             minutes               2-second increments 
Value Range:  0–23              0-59                  0–29 in 2-second intervals 


Date

Bit Position: 0   1   2   3   4   5   6 7   8   9   A B   C   D   E   F 
Length:       7                         4             5 
Contents:     year                      month         day 
Value Range:  0–119                    1–12         1–31 
             (relative to 1980)     
*/
S_DWORD hai_GetDateTime32(S_VOID)
{
	S_DWORD DateTime = 0x13371337;

	return DateTime;
}

S_WORD hai_GetDate16(S_VOID)
{
	return 0x00;
}

S_WORD hai_GetTime16(S_VOID)
{
	return 0x00;
}

S_BYTE hai_GetTimeTenth8(S_VOID)
{
	return 0x00;
}