f_filesystem.c

S3C2410 USB Mass storage 源码.

/***************************************************************/
/*
 * F_FileSystem.c, 20070206, denny
 *
 * A Marconix Software Product
 * Copyright(c) Marconix Co., Ltd. 2007
 * All Rights Reserved. Reproduction, adaption, or
 * translation without prior written permission is
 * prohibited, except as allowed under the copyright laws.
 */
/***************************************************************/
#include "F_system.h"
#ifdef _READ_SD_

//#include "inc.h" 
#include "F_driver.h"
#include "F_FAT.h"
#include "F_FileSystem.h"

#define SEEK_SET	0x00
#define SEEK_CUR	0x01
#define SEEK_END	0x02

u32 u32g_FtotalFoldernum = 0;
u32 u32g_Ftotalfilenum = 0;
F_FindFileInfo g_FileInfo[MAX_SHOW_NUM];
F_BrowsingCursor g_Cursor;


u8 F_FileSYS_Initial(u8 Index)
{
	u8 Error = ERR_NONE;
	Error = F_FAT_Init(Index);
	
	return Error;
}

/********************************************************************************/
/*Parameters: pHandle-> handle of current direntry;										*/
/*			 startnum-> reserved;													*/
/*			 Listnum -> wanted list num, and it return real list num						*/
/*			 Listtype -> extname, user can list files with this extname or list all just set it null	*/
/*Return Value: user can't use its return info.											*/
/*Global Variable: g_FileInfo -> it wiil be filled with file/folder info. 							*/
/********************************************************************************/
u8 F_FileSYS_Dir(FAT_HANDLE *pHandle, u32 startnum,u32 *Listnum, c8 *Listtype)
{
	u8 Error  = ERR_NONE, typeflg = 0;
	u32 num = 0, listIndex;
	F_FindFileInfo  ObjectInfo;
	c8 extName[4] = {0};

	listIndex = 0;

	Error = F_FileSYS_FindFirstFile(pHandle, &listIndex, &ObjectInfo);
	if(!Error)
	{
		if(ObjectInfo.ftype == FAT_FILE)
		{
			if(!F_FAT_GetExtName(ObjectInfo.fileInfo.fileINF_Name, extName))
			{
				{
					//fill info
					memcpy((u8 *)&g_FileInfo[num], (u8 *)&ObjectInfo, sizeof(F_FindFileInfo));
					num++;
				}
			}
		}
		else
		{
			//file info
			memcpy((u8 *)&g_FileInfo[num], (u8 *)&ObjectInfo, sizeof(F_FindFileInfo));
			num++;
		}
	}
	else
	{
		*Listnum = num;
		return Error;
	}

	while(num<*Listnum)
	{
		memset(extName,0,4);
		Error = F_FileSYS_FindNextFile(pHandle, &listIndex, &ObjectInfo);
		if(!Error)
		{
			if(ObjectInfo.ftype == FAT_FILE)
			{
				if(!F_FAT_GetExtName(ObjectInfo.fileInfo.fileINF_Name, extName))
				{
					{
						//fill info
						memcpy((u8 *)&g_FileInfo[num], (u8 *)&ObjectInfo, sizeof(F_FindFileInfo));
						num++;
					}
				}
			}
			else
			{
				//file info
				memcpy((u8 *)&g_FileInfo[num], (u8 *)&ObjectInfo, sizeof(F_FindFileInfo));
			num++;
			}
		}
		else
			break;
	}
	*Listnum = num;
	
	return Error;
}

/********************************************************************************/
/*Parameters: pHandle-> handle of current direntry;										*/
/*Description: This function used to get total file and folder number under current direntry		*/
/*			 User need to call it when necessary or when direntry modified.					*/
/*Global Variable: u32g_FtotalFoldernum -> get total folder number under current direntry.		*/
/*			       u32g_Ftotalfilenum -> get total file number under current direntry.			*/
/********************************************************************************/
u8 F_FileSYS_FolderScan(FAT_HANDLE *pHandle)
{
	u8 Error = ERR_NONE;
	F_direntry de;
	F_BrowsingCursor cursor;
	
	u32g_FtotalFoldernum = 0;
	u32g_Ftotalfilenum = 0;

	F_FAT_BrowsingReset(pHandle, &cursor);
	for(;F_FAT_GetNextDirEntry(pHandle, &de,  &cursor, 0, NULL) == 0;)
	{
		if((de.deAttributes&ATTR_DIRECTORY) == ATTR_DIRECTORY)
		{
			u32g_FtotalFoldernum++;
		}
		else if((de.deAttributes&ATTR_ARCHIVE) == ATTR_ARCHIVE)
		{
			u32g_Ftotalfilenum++;
		}
	}

	//printf("\n\tu32g_FtotalFoldernum = %d, u32g_Ftotalfilenum = %d\n",u32g_FtotalFoldernum,u32g_Ftotalfilenum);
	//printf("========================================================\n");
	return Error;
}

u32 F_FileSYS_GetTotalnum(void)
{
	return (F_FileSYS_GetTotalFilenum()+F_FileSYS_GetTotalFoldernum());
}

u32 F_FileSYS_GetTotalFoldernum(void)
{
	return u32g_FtotalFoldernum;
}

u32 F_FileSYS_GetTotalFilenum(void)
{
	return u32g_Ftotalfilenum;
}

/********************************************************************************/
/*Parameters: pHandle-> handle of current direntry;										*/
/*			 CurrentIndex-> must be "0"											*/
/*			 ObjectInfo-> storage object information									*/
/*Description: This function used to get the first item, file or folder							*/
/********************************************************************************/
u8 F_FileSYS_FindFirstFile(FAT_HANDLE *pHandle, u32 *CurrentIndex, F_FindFileInfo *ObjectInfo)
{
	F_direntry de;
	u16 unicode[MAX_LFN_BUF] = {0};

	if(*CurrentIndex != 0)
		return ERR_FILE_SEARCH;

	g_lfnflag = 0;
	memset((u8 *)g_longfilename, 0, MAX_LFN_BUF);
	F_FAT_BrowsingReset(pHandle, &g_Cursor);
	for(;F_FAT_GetNextDirEntry(pHandle, &de,  &g_Cursor, MAX_LFN_BUF, g_longfilename) == 0;)
	{
		if(de.deAttributes == ATTR_ARCHIVE)
		{
			if(g_lfnflag)
			{
				memcpy((u8 *)unicode, (u8 *)g_longfilename, MAX_LFN_BUF);
				F_UniStrToGB2312Str(unicode, (u8 *)ObjectInfo->fileInfo.fileINF_Name);
				g_lfnflag = 0;
			}
			else
				F_FAT_DirEntryToSFN(&de, ObjectInfo->fileInfo.fileINF_Name, 13);
			ObjectInfo->fileInfo.fileINF_size = de.deFileSize;
			ObjectInfo->fileInfo.fileINF_start_cluster = de.deStartCluster + (de.deHighClust<<16);
			ObjectInfo->ftype = FAT_FILE;

			(*CurrentIndex) ++;
			return ERR_NONE;
		}
		else if(de.deAttributes == ATTR_DIRECTORY)
		{
			if(g_lfnflag)
			{
				memcpy((u8 *)unicode, (u8 *)g_longfilename, MAX_LFN_BUF);
				F_UniStrToGB2312Str(unicode, (u8 *)ObjectInfo->folderInfo.folderINF_Name);
				g_lfnflag = 0;
			}
			else
				F_FAT_DirEntryToSFN(&de, ObjectInfo->folderInfo.folderINF_Name, 13);
			ObjectInfo->folderInfo.folderINF_start_cluster = de.deStartCluster + (de.deHighClust<<16);
			ObjectInfo->ftype = FAT_FOLDER;

			(*CurrentIndex) ++;
			return ERR_NONE;
		}
		g_lfnflag = 0;
		memset((u8 *)g_longfilename, 0, MAX_LFN_BUF);
	}
	return ERR_FILE_SEARCH;
}

/********************************************************************************/
/*Parameters: pHandle-> handle of current direntry;										*/
/*			 CurrentIndex-> must be more than "0"									*/
/*			 ObjectInfo-> storage object information									*/
/*Description: This function must be called after "F_FileSYS_FindFirstFile"						*/
/*			 and used to get the the next item, file or folder								*/
/********************************************************************************/
u8 F_FileSYS_FindNextFile(FAT_HANDLE *pHandle, u32 *CurrentIndex, F_FindFileInfo *ObjectInfo)
{
	F_direntry de;
	u16 unicode[MAX_LFN_BUF] = {0};

	if(*CurrentIndex<1)
		return ERR_FILE_SEARCH;

	g_lfnflag = 0;
	memset((u8 *)g_longfilename, 0, MAX_LFN_BUF);
	for(;F_FAT_GetNextDirEntry(pHandle, &de,  &g_Cursor, MAX_LFN_BUF, g_longfilename) == 0;)
	{
		if(de.deAttributes == ATTR_ARCHIVE)
		{
			if(g_lfnflag)
			{
				memcpy((u8 *)unicode, (u8 *)g_longfilename, MAX_LFN_BUF);
				F_UniStrToGB2312Str(unicode, (u8 *)ObjectInfo->fileInfo.fileINF_Name);
				g_lfnflag = 0;
			}
			else
				F_FAT_DirEntryToSFN(&de, ObjectInfo->fileInfo.fileINF_Name, 13);
			ObjectInfo->fileInfo.fileINF_size = de.deFileSize;
			ObjectInfo->fileInfo.fileINF_start_cluster = de.deStartCluster + (de.deHighClust<<16);
			ObjectInfo->ftype = FAT_FILE;

			(*CurrentIndex) ++;
			return ERR_NONE;
		}
		else if(de.deAttributes == ATTR_DIRECTORY)
		{
			if(g_lfnflag)
			{
				memcpy((u8 *)unicode, (u8 *)g_longfilename, MAX_LFN_BUF);
				F_UniStrToGB2312Str(unicode, (u8 *)ObjectInfo->folderInfo.folderINF_Name);
				g_lfnflag = 0;
			}
			else
				F_FAT_DirEntryToSFN(&de, ObjectInfo->folderInfo.folderINF_Name, 13);
			ObjectInfo->folderInfo.folderINF_start_cluster = de.deStartCluster + (de.deHighClust<<16);
			ObjectInfo->ftype = FAT_FOLDER;

			(*CurrentIndex) ++;
			return ERR_NONE;
		}
		g_lfnflag = 0;
		memset((u8 *)g_longfilename, 0, MAX_LFN_BUF);
	}
	return ERR_FILE_SEARCH;
}

/********************************************************************************/
/*Parameters: pHandle-> handle of current direntry;										*/
/*			 filename-> the file user want to get										*/
/*			 fileInfo-> storage object information										*/
/*Description: This function can be used as file search									*/
/*Return Value: 0->get the file; or others-> file is not exist								*/
/********************************************************************************/
u8 F_FileSYS_GetFileInfo(FAT_HANDLE *pHandle,c8 * filename, F_FileInfo *fileInfo)
{
	F_BrowsingCursor cursor;
	F_direntry de;
	u16 unicode[MAX_LFN_BUF] = {0};
	c8 tmpname[MAX_LFN_BUF] = {0};
	c8 tmpname1[MAX_LFN_BUF] = {0};

	strcpy(tmpname, filename);
	strupr(tmpname);

	g_lfnflag = 0;
	memset((u8 *)g_longfilename, 0, MAX_LFN_BUF);
	F_FAT_BrowsingReset(pHandle, &cursor);
	for(;F_FAT_GetNextDirEntry(pHandle, &de,  &cursor, MAX_LFN_BUF, g_longfilename) == 0;)
	{
		if(de.deAttributes == ATTR_ARCHIVE)
		{
			if(g_lfnflag)
			{
				memcpy((u8 *)unicode, (u8 *)g_longfilename, MAX_LFN_BUF);
				F_UniStrToGB2312Str(unicode, fileInfo->fileINF_Name);
				g_lfnflag = 0;

				strcpy(tmpname1, fileInfo->fileINF_Name);
				strupr(tmpname1);
				if(!strcmp(tmpname, tmpname1))
				{
					F_FAT_GetFileInfo(&de, fileInfo);
					
					return ERR_NONE;
				}
			}
			else
			{
				F_FAT_DirEntryToSFN(&de, fileInfo->fileINF_Name, 13);
				strcpy(tmpname1, fileInfo->fileINF_Name);
				strupr(tmpname1);
				if(!strcmp(tmpname, tmpname1))
				{
					F_FAT_GetFileInfo(&de, fileInfo);
					
					return ERR_NONE;
				}
			}
			
		}
		g_lfnflag = 0;
		memset((u8 *)g_longfilename, 0, MAX_LFN_BUF);
	}
	return F_ERR_FILE_NOT_EXIST;
}

u8 F_FileSYS_GetCurrentDir(c8 *CurrentDir)
{
	CurrentDir = g_CurrentDir;
	return ERR_NONE;
}

/********************************************************************************/
/*Parameters: pHandle-> handle of current direntry;										*/
/*			 tarDir-> the direntry user want to change									*/
/*Description: user can change current direntry with this function("\\","..","A:\..\..","foldername")	*/
/*Return Value: 0-> ok; or others-> error direntry										*/
/********************************************************************************/
u8 F_FileSYS_ChangeDir(FAT_HANDLE *pHandle, c8 *tarDir)
{
	u8 Error = ERR_NONE, Layer = 1, i;
	Error = F_FAT_GetDirLayer(tarDir, &Layer);
	if(!Error)
	{	
		F_FAT_DirInit(pHandle);
		for(i=1;i<Layer;i++)
		{
			Error = F_FAT_FolderChange(pHandle, g_direntry[i]);
			if(Error)
				return Error;
		}
	}
	else
	{
		Error = F_FAT_FolderChange(pHandle, tarDir);
		if(Error)
			return Error;
	}
	return Error;
}


u8 F_FileSYS_GetDiskSize(FAT_HANDLE *pHandle, u32 *totalsize,u32 *freesize, u32 *usedsize)
{
	u32 i = 0, j = 0,totalcluster = pHandle->NumClusters, usecluster = 0;
	u32 fatsector = pHandle->FatSectors;
	u32 readsector = pHandle->FirstFATSector, tmpsize = 0, fatmask = 0;
	u8 tmp = 0,fatoffset = 0;

	if(pHandle->PartType == PART_TYPE_FAT32)
	{
		fatoffset = 4;
		fatmask = FAT32_MASK;
	}
	else if(pHandle->PartType == PART_TYPE_FAT16)
	{
		fatoffset = 2;
		fatmask = FAT16_MASK;
	}

	for(j = 0;j< fatsector;j +=8)
	{
		if((fatsector-j)<8)
		{
			tmp = fatsector-j;
			tmpsize = pHandle->BytesPerSector* tmp;
		}
		else
		{
			tmp = 8;
			tmpsize = pHandle->BytesPerSector* 8;
		}
		F_ReadSector(hFile, readsector+j, tmp, prFATBuffer);
		for(i = 0;i<tmpsize;i+=fatoffset)
		{
			if(*((u32 *)(prFATBuffer+i))!=0)
				usecluster++;
		}
	}
	//printf("usecluster = %d, totalcluster = %d\n", usecluster, totalcluster);
	*usedsize = (usecluster-2)*pHandle->BytesPerSector*pHandle->SectorsPerCluster;
	*totalsize = totalcluster*pHandle->BytesPerSector*pHandle->SectorsPerCluster;
	*freesize = *totalsize - *usedsize;
	
}


/********************************************************************************/
/*Parameters: pFile-> handle of current file;											*/
/*			 filename-> which need to be opened										*/
/*			 mode-> open mode (r, w, wr)											*/
/*Return Value: 0-> ok; or others-> file not exsit										*/
/********************************************************************************/
//#include "mx_system.h"
u8 F_FileSYS_fopen(TFILE *pFile, c8 *filename, u8 mode)
{
	u8 Error = ERR_NONE;

	pFile->mode = mode;
	if(pFile->mode>wr)
		return F_ERR_OPENMODE;

	if(pFile->mode == r)
	{
		Error = F_FileSYS_GetFileInfo(pFile->FatHdl,filename, &pFile->fileInfo);
		if(Error == F_ERR_FILE_NOT_EXIST)
		{
			return F_ERR_FILE_NOT_EXIST;
		}
		else