hfatfile.c

HaiBIOS 是为我的S3C2410开发板写的一个启动程序。 C盘是RAMDISK

				break;
		}
		else
		{
			Sec = (StartClust<<1)/DevInf_BytsPerSec(dev) + DevInf_RsvdSec(dev);
			if (Sec != BakSec)
			{
				BakSec = Sec;
				if (_hai_FatDevRead(dev, Sec, SecBuf))
					return 0xFFFFFFFF;
			}
			Offset = (StartClust<<1)%DevInf_BytsPerSec(dev);
			NxtClust = HAI_MAKEWORD(SecBuf+Offset);
			if (IS_FAT16_INUSE_CLUST(NxtClust))
				StartClust = NxtClust;
			else
				break;
		}
	}

	return StartClust;
}

int _hai_FileWriteOnFat(const void *buffer, size_t size, size_t count, S_DWORD CurOffset, size_t *RealCnt, SP_FATFILEINF pFileInf)
{
	int dev = pFileInf->dev;
	int err = FATERR_NO_ERROR;
	size_t tmpsize, writesize;
	const S_BYTE *pBuf = buffer;
	S_FILEBUF *pFileBuf, FileBuf;
	S_DWORD CurClust, OffInClust, OffInSec, NoClust;
	S_DWORD total, SecNum;

	if (pFileInf->attrib & FILE_ATTR_READ_ONLY)
		return FATERR_READONLY_FILE;

	if (CurOffset == 0xFFFFFFFF)
		CurOffset = pFileInf->FileSize;
	total = size*count+CurOffset;
	if (total > pFileInf->FileSize)
	{
		if (err = _hai_AllocDiskSpace4File(pFileInf, total))
			return err;
	}

	if (pFileInf->pSecbuf)
		pFileBuf = pFileInf->pSecbuf;
	else
	{
		pFileBuf = &FileBuf;
		hai_memset(pFileBuf, 0x00, sizeof(*pFileBuf));
	}

	NoClust = CurOffset/(DevInf_BytsPerSec(dev)*DevInf_SecPerClust(dev));
	if (pFileInf->CurWorkClust == 0)
		pFileInf->CurWorkClust = hai_FindSpecifyClust(dev, pFileInf->FirstClust, NoClust);
	else
	{
		if (NoClust >= pFileInf->WorkClu2FstClu)
			pFileInf->CurWorkClust = hai_FindSpecifyClust(dev, pFileInf->CurWorkClust, NoClust - pFileInf->WorkClu2FstClu);
		else
			pFileInf->CurWorkClust = hai_FindSpecifyClust(dev, pFileInf->FirstClust, NoClust);
	}
	pFileInf->WorkClu2FstClu = NoClust;

	if (pFileInf->CurWorkClust == 0x00)
		return FATERR_DEV_OPERATE_ERR;
	CurClust = pFileInf->CurWorkClust;
	OffInClust = CurOffset%(DevInf_BytsPerSec(dev)*DevInf_SecPerClust(dev));
	SecNum = OffInClust/DevInf_BytsPerSec(dev);
	OffInSec = OffInClust%DevInf_BytsPerSec(dev);
	
	if (err = _hai_Flush2ReadFileBuf(dev, CurClust, (S_BYTE)SecNum, pFileBuf))
		return err;

	for (*RealCnt = 0; *RealCnt < count; (*RealCnt)++)
	{
		for (tmpsize = size; tmpsize; )
		{
			if (tmpsize > DevInf_BytsPerSec(dev)-OffInSec)
				writesize = DevInf_BytsPerSec(dev)-OffInSec;
			else
				writesize = tmpsize;
			tmpsize -= writesize;
			pFileBuf->flush = 1;
			hai_memcpy(pFileBuf->SecBuf+OffInSec, pBuf, writesize);
			pBuf += writesize;
			if (OffInSec+writesize >= DevInf_BytsPerSec(dev))
			{
				if (SecNum+1 >= DevInf_SecPerClust(dev))
				{
					CurClust = hai_GetNextCluster(dev, CurClust);
					if (CurClust == 0xFFFFFFFF)
					{
						if (tmpsize == 0)//just complete
							break;
						err = FATERR_DEVOP_ABORT;
						goto FILEWRITE_ERR;
					}
					SecNum = 0;
				}
				else
					SecNum++;
				if (err = _hai_Flush2ReadFileBuf(dev, CurClust, (S_BYTE)SecNum, pFileBuf))
				{
					err = FATERR_DEVOP_ABORT;
					goto FILEWRITE_ERR;
				}
				OffInSec = 0;
			}
			else
			{
				OffInSec += writesize;
			}
		}
	}

	if (_hai_FlushFileBuf(dev, pFileBuf))
		err = FATERR_DEVOP_ABORT;
FILEWRITE_ERR:
	if (pFileInf->FileSize < CurOffset+*RealCnt*size)
		pFileInf->FileSize = CurOffset+*RealCnt*size;
	
	return err;
}

size_t _hai_fwriteOnFat(S_BYTE disk, const void *buffer, size_t size, size_t count, SH_FATFILEOP hFileOp)
{
	int err = FATERR_INVALID_DISK;
	size_t RealCnt = 0;
	S_DWORD CurOffset;

	if (hFileOp->dev != hai_GetDeviceNum(disk) || hFileOp->pfileinf == S_NULL)
		goto FWRITE_ERR;
	if (!hai_FatDevExist(hFileOp->dev))
		goto FWRITE_ERR;

	if (hFileOp->mode & _H_O_APPEND)
		CurOffset = 0xFFFFFFFF;
	else
		CurOffset = hFileOp->curoffset;

	if (hFileOp->mode & _H_O_WRONLY)
		err = _hai_FileWriteOnFat(buffer, size, count, CurOffset, &RealCnt, hFileOp->pfileinf);
	else
		err = FATERR_READONLY_MODE;

	if (err == FATERR_NO_ERROR || err == FATERR_DEVOP_ABORT)
		hFileOp->curoffset += size*RealCnt;

FWRITE_ERR:
	hFileOp->err = err;
	return RealCnt;
}

int _hai_FileReadOnFat(void *buffer, size_t size, size_t count, S_DWORD CurOffset, size_t *RealCnt, SP_FATFILEINF pFileInf)
{
	int dev = pFileInf->dev;
	int err = FATERR_NO_ERROR;
	size_t tmpsize, readsize;
	S_BYTE *pBuf = buffer;
	S_FILEBUF *pFileBuf, FileBuf;
	S_DWORD CurClust, OffInClust, OffInSec, NoClust;
	S_DWORD SecNum;

	if (pFileInf->pSecbuf)
		pFileBuf = pFileInf->pSecbuf;
	else
	{
		pFileBuf = &FileBuf;
		hai_memset(pFileBuf, 0x00, sizeof(*pFileBuf));
	}

	NoClust = (CurOffset+(DevInf_BytsPerSec(dev)*DevInf_SecPerClust(dev)-1))/(DevInf_BytsPerSec(dev)*DevInf_SecPerClust(dev));
	CurClust = hai_FindSpecifyClust(dev, pFileInf->FirstClust, NoClust);
	if (CurClust == 0x00)
		return FATERR_DEV_OPERATE_ERR;
	OffInClust = CurOffset%(DevInf_BytsPerSec(dev)*DevInf_SecPerClust(dev));
	SecNum = OffInClust/DevInf_BytsPerSec(dev);
	OffInSec = OffInClust%DevInf_BytsPerSec(dev);
	
	if (err = _hai_Flush2ReadFileBuf(dev, CurClust, (S_BYTE)SecNum, pFileBuf))
		return err;

	for (*RealCnt = 0; *RealCnt < count; (*RealCnt)++)
	{
		for (tmpsize = size; tmpsize; )
		{
			if (tmpsize > DevInf_BytsPerSec(dev)-OffInSec)
				readsize = DevInf_BytsPerSec(dev)-OffInSec;
			else
				readsize = tmpsize;
			tmpsize -= readsize;
			hai_memcpy(pBuf, pFileBuf->SecBuf+OffInSec, readsize);
			pBuf += readsize;
			if (OffInSec+readsize >= DevInf_BytsPerSec(dev))
			{
				if (SecNum+1 >= DevInf_SecPerClust(dev))
				{
					CurClust = hai_GetNextCluster(dev, CurClust);
					if (CurClust == 0xFFFFFFFF)
					{
						err = FATERR_DEVOP_ABORT;
						goto FILEREAD_ERR;
					}
					SecNum = 0;
				}
				else
					SecNum++;
				if (err = _hai_Flush2ReadFileBuf(dev, CurClust, (S_BYTE)SecNum, pFileBuf))
				{
					err = FATERR_DEVOP_ABORT;
					goto FILEREAD_ERR;
				}
				OffInSec = 0;
			}
			else
			{
				OffInSec += readsize;
			}
		}
	}

FILEREAD_ERR:
	
	return err;
}


size_t _hai_freadOnFat(S_BYTE disk, void *buffer, size_t size, size_t count, SH_FATFILEOP hFileOp)
{
	int err = FATERR_INVALID_DISK;
	size_t RealCnt = 0;

	if (hFileOp->dev != hai_GetDeviceNum(disk) || hFileOp->pfileinf == S_NULL)
		goto FREAD_ERR;
	if (!hai_FatDevExist(hFileOp->dev))
		goto FREAD_ERR;

	if (hFileOp->mode & _H_O_RDONLY)
	{
		if (hFileOp->pfileinf->FileSize-hFileOp->curoffset < size)
			err = FATERR_END_OF_FILE;
		else
		{
			if (hFileOp->pfileinf->FileSize-hFileOp->curoffset < size*count)
				count = (hFileOp->pfileinf->FileSize-hFileOp->curoffset)/size;
			err = _hai_FileReadOnFat(buffer, size, count, hFileOp->curoffset, &RealCnt, hFileOp->pfileinf);
		}
	}
	else
		err = FATERR_WRITEONLY_MODE;

	if (err == FATERR_NO_ERROR || err == FATERR_DEVOP_ABORT)
		hFileOp->curoffset += size*RealCnt;

FREAD_ERR:
	hFileOp->err = err;
	return RealCnt;
}

int _hai_rmfileOnFat(S_BYTE disk, const S_BYTE *filename)
{
	int err = -1;
	int dev = hai_GetDeviceNum(disk);
	S_BYTE DentBuf[FAT_DIRENT_SIZE];
	S_WORD DentNum, LDentNum;
	S_DWORD DSecNum, LDSecNum, clust;

	if (dev == -1)
		return FATERR_INVALID_DISK;
	if (!*filename||IS_FAT_CUR_DIR(filename)||IS_FAT_BACK_DIR(filename))
		return FATERR_INVALID_FILENAME;

	hai_DiskOperateLock(dev);

	clust = _hai_CwdOperate(CWDOPERATE_GETCLUS, S_NULL);
	err = hai_LocationDent(dev, clust, filename, &DSecNum, &DentNum, &LDSecNum, &LDentNum, DentBuf);
	if (err == FATERR_NO_ERROR)
	{
		if (_hai_CheckFileIsOpened(dev, DSecNum, DentNum, DentBuf))
		{
			err = FATERR_INUSE_FILE;
		}
		else if ((*pDIR_Attr(DentBuf)&(FILE_ATTR_DIRECTORY|FILE_ATTR_VOLUME_ID)) == 0x00)//is a file
		{
			err = hai_RemoveDent(dev, DSecNum, DentNum, LDSecNum, LDentNum, DentBuf);
			if (!err)
			{
				clust = GetDentClust(DentBuf);
				err = hai_UnlinkClust(dev, clust);
			}
		}
		else
		{
			err = FATERR_INVALID_FILENAME;
		}
	}

	hai_DiskOperateUnlock(dev);

	return err;
}

int _hai_fseekOnFat(S_BYTE disk, SH_FATFILEOP hFileOp, long offset, int origin)
{
	int err = FATERR_INVALID_DISK;
	SP_FATFILEINF pFileInf = hFileOp->pfileinf;

	if (hai_GetDeviceNum(disk)==hFileOp->dev && hai_FatDevExist(hFileOp->dev))
	{
		err = FATERR_NO_ERROR;
		if (origin == SEEK_SET)
		{
			if (offset < 0)
				err = FATERR_UNKNOWN_ERR2;
			else
				hFileOp->curoffset = offset;
		}
		else if (origin == SEEK_CUR)
		{
			if (offset<0 && offset+hFileOp->curoffset < 0)
				err = FATERR_UNKNOWN_ERR2;
			else
				hFileOp->curoffset += offset;
		}
		else if (origin == SEEK_END)
		{
			if (offset<0 && offset+pFileInf->FileSize < 0)
				err = FATERR_UNKNOWN_ERR2;
			else
				hFileOp->curoffset = (S_LONG)pFileInf->FileSize+offset;
		}
		else
			err = FATERR_UNKNOWN_ERR2;
	}

	hFileOp->err = err;
	return err;
}

long  _hai_ftellOnFat(S_BYTE disk, SH_FATFILEOP hFileOp)
{
	int err = FATERR_INVALID_DISK;
	long offset = 0;

	if (hai_GetDeviceNum(disk)==hFileOp->dev && hai_FatDevExist(hFileOp->dev))
	{
		offset = hFileOp->curoffset;
		err = FATERR_NO_ERROR;
	}

	hFileOp->err = err;
	return offset;
}

void  _hai_clearerrOnFat(S_BYTE disk, SH_FATFILEOP hFileOp)
{
	if (hai_GetDeviceNum(disk)==hFileOp->dev && hai_FatDevExist(hFileOp->dev))
		hFileOp->err = FATERR_NO_ERROR;
}

int  _hai_ferrorOnFat(S_BYTE disk, SH_FATFILEOP hFileOp)
{
	if (hai_GetDeviceNum(disk)==hFileOp->dev && hai_FatDevExist(hFileOp->dev))
		return hFileOp->err;
	return FATERR_UNKNOWN_ERR2;
}

int  _hai_feofOnFat(S_BYTE disk, SH_FATFILEOP hFileOp)
{
	int err = FATERR_UNKNOWN_ERR2;
	SP_FATFILEINF pFileInf;

	if (hai_GetDeviceNum(disk)==hFileOp->dev && hai_FatDevExist(hFileOp->dev))
	{
		pFileInf = hFileOp->pfileinf;
		if (pFileInf)
		{
			if (hFileOp->curoffset >= pFileInf->FileSize)
				err = FATERR_END_OF_FILE;
			else
				err = FATERR_NO_ERROR;
		}
	}

	return err;
}