fatfs_api.c

fs_lib,arm9的fat文件系统

/*
 * @(#)Api.c
 * @date 2005/12/25
 * @version 1.0
 * @author Zhou Shangpin.
 * Copyright 2005 Anyka corporation, Inc. All rights reserved.
 * ANYKA PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

#include	"global.h"
#include	"mem_port.h"
#include	"fatfs_api.h"

T_VOID FATFSAPI(Destroy)(T_VOID)
{
	Global_Destroy();
}

T_PSEARCH FATFSAPI(SearchInitial)()
{
	T_PSEARCH status;

	status = (T_PSEARCH)Fwl_Malloc(sizeof(T_SEARCH));
	if (status == AK_NULL)
	{
		return AK_NULL;
	}
	status->dot2 = AK_NULL;
	status->parent = AK_NULL;
	status->attr = AK_NULL;
	status->child = AK_NULL;
	status->ptr = AK_NULL;
	status->filter.filter = AK_NULL;	
	status->filter.type = 0;
	return status;
}

T_VOID FATFSAPI(SearchFree)(T_PSEARCH status)
{
	if (status == AK_NULL)
	{
		return;
	}	
	if (status->dot2 != AK_NULL)
	{
		Attr_Destroy(status->dot2);
	}
	if (status->parent != AK_NULL)
	{
		File_Close(status->parent);
	}
	if (status->attr != AK_NULL)
	{
		Attr_Destroy(status->attr);
	}
	if (status->child != AK_NULL)
	{
		Link_Destroy(status->child);
	}
	Fwl_Free(status);
}

T_VOID FATFSAPI(FindClose)(T_hFILESTAT stat)
{
	if (stat != FS_INVALID_STATHANDLE)
	{	
		FATFSAPI(SearchFree)((T_PSEARCH)stat);
	}
}

T_VOID	FATFSTAPI(Close)(T_hFILESTAT stat)
{
	if (stat != FS_INVALID_STATHANDLE)
	{	
		FATFSAPI(SearchFree)((T_PSEARCH)stat);
	}
}

T_BOOL FATFSAPI(FileClose)(T_hFILE hFile)
{
	if (hFile != FS_INVALID_HANDLE)
	{	
		File_Close((T_PFILE)hFile);
	}
	return AK_TRUE;
}

T_hFILESTAT FATFSAPI(HFileStat)(T_hFILE hFile)
{
	T_PSEARCH status;
	T_PFILE file;
	
	if (hFile == FS_INVALID_HANDLE)
	{
		return FS_INVALID_STATHANDLE;
	}
	status = FATFSAPI(SearchInitial)();
	if (status == AK_NULL)
	{
		return FS_INVALID_STATHANDLE;
	}
	file = File_Initial(((T_PFILE)hFile)->attr);
	if (file == AK_NULL)
	{
		Fwl_Free(status);
		return FS_INVALID_STATHANDLE;
	}
	status->attr = (T_PATTR)Fwl_Malloc(sizeof(T_ATTR));
	if (status->attr != AK_NULL)
	{
		
		Ram_Move(status->attr, file->attr, sizeof(T_ATTR));
		status->attr->msg = AK_NULL;
		status->attr->name = Str_Copy(file->attr->name);
	}
	File_Close(file);
	return (T_hFILESTAT)status;
}

T_hFILESTAT FATFSAPI(FileStat)(T_pCSTR path)
{
	T_PSEARCH status;
	T_hFILE file;	
	if (path == AK_NULL)
	{
		return FS_INVALID_STATHANDLE;
	}
	status = FATFSAPI(SearchInitial)();
	if (status == AK_NULL)
	{
		return FS_INVALID_STATHANDLE;
	}
	file = (T_hFILE)FS1_FileOpen(path, FILE_MODE_READ);
	if (file == FS_INVALID_HANDLE)
	{
		Fwl_Free(status);
		return FS_INVALID_STATHANDLE;
	}
	status->attr = (T_PATTR)Fwl_Malloc(sizeof(T_ATTR));
	if (status->attr != AK_NULL)
	{
		Ram_Move(status->attr, ((T_PFILE)file)->attr, sizeof(T_ATTR));
		status->attr->msg = AK_NULL;
		status->attr->name = Str_Copy(((T_PFILE)file)->attr->name);		
	}
	File_Close((T_PFILE)file);
	return (T_hFILESTAT)status;
}

T_U32	FATFSAPI(GetSize)(T_pCSTR device)
{	
	T_PDRIVER driver;
	T_U8 ch;
	if (device == AK_NULL)
	{
		return 0;
	}
	ch = (T_U8)Uni_ToUpper(*(T_U8*)device);
	ch -= 'A';
	driver = (T_PDRIVER)List_Get(fgb.DriverList, ch);
	if (driver == AK_NULL)
	{
		return 0;
	}
	return driver->capacity << driver->SecBit;
}

T_U32 FATFSAPI(GetUsedSize)(T_pCSTR device)
{
	T_U32 low, high;
	T_PDRIVER driver;
	T_U8 ch;
	if (device == AK_NULL)
	{
		return 0;
	}
	ch = (T_U8)Uni_ToUpper(*(T_U8*)device);
	ch -= 'A';
	driver = (T_PDRIVER)List_Get(fgb.DriverList, ch);
	if (driver == AK_NULL)
	{
		return 0;
	}
	low = Driver_GetUsedSize(driver, &high);
	return low;
}

T_U32 FATFSAPI(GetFreeSize)(T_pCSTR device)
{
	T_U32 low, high;
	T_PDRIVER driver;
	T_U8 ch;

	if (device == AK_NULL)
	{
		return 0;
	}
	ch = (T_U8)Uni_ToUpper(*(T_U8*)device);
	ch -= 'A';
	driver = (T_PDRIVER)List_Get(fgb.DriverList, ch);
	if (driver == AK_NULL)
	{
		return 0;
	}	
	low = Driver_GetFreeSize(driver, &high);
	return low;
}	

T_hFILE	FS1_FileOpen(T_pCSTR path, T_FILE_MODE mode)
{
	T_PFILE file;
	T_PSTRING name;
	T_PDRIVER driver;
	T_U8 dn;
	
	if (path == AK_NULL)
	{
		return FS_INVALID_HANDLE;
	}
	dn = fgb.CurDriver;
	if (path[1] == ':')
	{
		dn = Uni_ToUpper(path[0]) & 0xff;
		dn -= 'A';
	}
	driver = (T_PDRIVER)List_Get(fgb.DriverList, dn);
	if(driver == AK_NULL)
	{
		return FS_INVALID_HANDLE;
	}
	name = Str_AscCode((T_U8*)path, driver->code);	
	
	file = File_Open(AK_NULL, name, mode);
	Str_Destroy(name);
	if (file == AK_NULL)
	{
		return FS_INVALID_HANDLE;
	}
	if (File_IsFolder(file))
	{
		File_Close(file);
		return FS_INVALID_HANDLE;
	}
	if (!file->attr->exist)
	{
		if (mode == FS_MODE_READ)
		{
			File_Close(file);
			return FS_INVALID_HANDLE;
		}		
	}
	return (T_S32)file;
}

T_hFILE	FATFSAPI(FileOpen)(T_pCSTR path, T_FILE_FLAG flag,T_FILE_MODE mode)
{
	return FS1_FileOpen(path, mode);
}

T_U32 FATFSAPI(FileRead)(T_hFILE hFile, T_pVOID buffer, T_U32 count)
{
	T_PFILE pfile = (T_PFILE)hFile;
	
	if (hFile == FS_INVALID_HANDLE)
	{
		return 0;
	}

	return File_ReadBlock(pfile, (T_U8*)buffer, count);	
}

T_U32 FATFSAPI(FileWrite)(T_hFILE hFile, T_pCVOID buffer, T_U32 count)
{
	if (hFile == FS_INVALID_HANDLE)
	{
		return 0;
	}
	return File_WriteBlock((T_PFILE)hFile, (T_U8*)buffer, count);
}

T_U32 FATFSAPI(GetFileLen)(T_hFILE hFile)
{	
	T_U32 excess;
	if (hFile == FS_INVALID_HANDLE)
	{
		return 0;
	}
	return File_GetLength((T_PFILE)hFile, &excess);
}

T_U32 FATFSAPI(FileSeek)(T_hFILE hFile, T_S32 offset, T_U16 origin)
{
	T_PFILE	file;
	T_U32 point;
	if (hFile == FS_INVALID_HANDLE )
	{
		return 0;
	}
	file = (T_PFILE)hFile;	

	switch (origin)
	{
		case FS_SEEK_SET:			
			point = offset;
			break;
		case FS_SEEK_CUR:
			point = file->ptr + 1;
			point += offset;
			break;
		case FS_SEEK_END:
			point = file->attr->length;
			point += offset;
			break;
	}
	
	if (point >= 0x80000000)
		point = 0;

	return File_Seek(file, point);
}


T_BOOL FATFSAPI(FileDelete)(T_pCSTR path)
{
	T_PFILE file;
	T_hFILE handle;
	T_BOOL ret;
	if (path == AK_NULL)
	{
		return AK_FALSE;
	}
	handle = FS1_FileOpen(path, FILE_MODE_READ);
	file = (T_PFILE)handle;
	if (handle == FS_INVALID_HANDLE)
	{
		return AK_FALSE;
	}	
	if (File_IsFile(file))
	{
		ret = File_DeleteFile(file);
		File_Close(file);
		return ret;
	}
	File_Close(file);
	return AK_FALSE;
}

T_hFILESTAT FATFSAPI(FindFirst)(T_pCSTR pattern)
{
	T_PFILE parent, file;
	T_PSTRING name;	
	T_U32 len, i, j;
	T_STR_FILE ptr;
	T_PSEARCH status;
	T_U8 DeviceId;	
	T_PDRIVER driver;

	if (pattern == AK_NULL)
	{
		return -1;
	}
	status = FATFSAPI(SearchInitial)();
	if (status == AK_NULL)
	{
		return -1;
	}
	if (pattern == AK_NULL || pattern[0] == 0)
	{
		return AK_FALSE;
	}
	if (pattern[1] == ':')
	{
		DeviceId = Uni_ToUpper(pattern[0]) - 'A';		 
	}
	else
	{
		DeviceId = fgb.CurDriver;
	}
	driver = Driver_GetObject(DeviceId);
	

	if(driver == AK_NULL)
	{
		return -1;
	}
	Ram_Move(ptr, (T_U8*)pattern, MAX_FILENM_LEN);	
	i = Uni_AscSearch(ptr, '*', MAX_FILENM_LEN);	
	j = Uni_AscSearch(ptr, '?', MAX_FILENM_LEN);
	len = 0;
	if (i < MAX_FILENM_LEN  || j < MAX_FILENM_LEN)
	{
		len = Uni_AscSearch(ptr, 0, MAX_FILENM_LEN);
		j = len + 1;
		while (len > 0)
		{
			if (ptr[len] == '\\' || ptr[len] == '/')
			{
				break;
			}
			len--;
		}
		if (ptr[len] == '\\' || ptr[len] == '/')
		{			
			len++;
		}
		status->filter.type |= FILTER_CMP | FILTER_FOLDER;		
		Uni_AscZero(status->filter.pattern, ptr + len, driver->code);
		ptr[len] = 0;
		if (len > 1)
		{
			len--;
		}
		if (ptr[len] == '\\' || ptr[len] == '/')
		{
			if (len != 0 && !(len == 2  && ptr[1]== ':'))
			{
				ptr[len] = 0;
			}
		}
	}
	if(*ptr == 0)
	{
		parent = File_OpenId(driver, driver->DefaultPath);
	}
	else
	{
		name = Str_AscCode(ptr, driver->code);
		parent = File_Open(AK_NULL, name, FILE_MODE_READ);
		Str_Destroy(name);
	}
	status->parent = parent;
	if (parent == AK_NULL || File_IsFile(parent))
	{
		FATFSAPI(SearchFree)(status);
		return -1;
	}	
	status->child = File_Dirs1(parent, &status->filter);
	if (status->child == AK_NULL)
	{
		FATFSAPI(SearchFree)(status);
		return -1;
	}
	status->ptr = status->child->head;
	if (parent->attr->FileId == 0)
	{	
		status->ptr = status->ptr->next;
		if (status->ptr == AK_NULL)
		{
			FATFSAPI(SearchFree)(status);
			return -1;
		}
	}
	else
	{
		file = File_OpenId(parent->attr->driver, parent->attr->ParentId);
		status->dot2 = (T_PATTR)Fwl_Malloc(sizeof(T_ATTR));
		if (status->dot2 != AK_NULL)
		{		
			Ram_Move(status->dot2, file->attr, sizeof(T_ATTR));
			status->dot2->name = Str_Copy(file->attr->name);
			status->dot2->msg = AK_NULL;
		}
		else
		{
			File_Close(file);
			FATFSAPI(SearchFree)(status);