f_filesystem.c

S3C2410 USB Mass storage 源码.

		{
			pFile->currentSector = F_FAT_ClusterToSector(pFile->FatHdl, pFile->fileInfo.fileINF_start_cluster);
			pFile->buffer = prSectorBuf;
			pFile->bytePointer = 0;
			pFile->sectorHasChanged = 0;
			pFile->offsetsector = pFile->currentSector;
		}
	}
	else if(pFile->mode == w)
	{
		Error = F_FileSYS_GetFileInfo(pFile->FatHdl,filename, &pFile->fileInfo);
		if(Error != F_ERR_FILE_NOT_EXIST)
		{
			pFile->currentSector = F_FAT_ClusterToSector(pFile->FatHdl, pFile->fileInfo.fileINF_start_cluster);
			pFile->buffer = prSectorBuf;
			pFile->bytePointer = 0;
			pFile->sectorHasChanged = 0;
			pFile->offsetsector = 0;//pFile->currentSector;
		}
		else
		{
			//file create and open
			//mdt_printf("file is not exist and need to be created!\n");
			Error = F_FileSYS_fcreate(pFile, filename);
			if(Error == ERR_NONE || Error == F_ERR_FILE_EXIST)
			{
				pFile->buffer = prSectorBuf;
				pFile->bytePointer = 0;
				pFile->sectorHasChanged = 0;
				pFile->offsetsector = 0;//F_FAT_ClusterToSector(pFile->FatHdl, pFile->fileInfo.fileINF_start_cluster);
			}
			else
				return F_ERR_FILECREATE;
		}
	}
	return ERR_NONE;
}


/********************************************************************************/
/*Parameters: pFile-> handle of current file;											*/
/*			 buffer-> used to storage the read data									*/
/*			 readsize-> size wanted to be read										*/
/*			 realreadsize-> real read size											*/
/*Return Value: 0-> ok; or others-> file not exsit										*/
/********************************************************************************/
u8 F_FileSYS_fread(TFILE *pFile, u8 *buffer, u32 readsize, u32 *realreadsize)
{
	u32 sectorOffset = 0, OffsetSize = 0;//Offset < BytesPerSector
	u32 realsize = 0, tmpsize = 0;
	u32 nextCluster = 0, nextSector = 0;
	u8 readsector = 1, endflg = 0;
	
	if((readsize+pFile->bytePointer)>pFile->fileInfo.fileINF_size)
		tmpsize = pFile->fileInfo.fileINF_size - pFile->bytePointer;
	else
		tmpsize = readsize;

	if(tmpsize<=512)
		readsector = 1;
	else 
		readsector = 1;
	
	OffsetSize = pFile->bytePointer%pFile->FatHdl->BytesPerSector;
	if(OffsetSize)
	{
		F_ReadSector(hFile, pFile->currentSector, readsector, pFile->buffer);
		if(tmpsize>=(pFile->FatHdl->BytesPerSector - OffsetSize))
		{
			memcpy(buffer+realsize, pFile->buffer+OffsetSize, pFile->FatHdl->BytesPerSector - OffsetSize);
			realsize += pFile->FatHdl->BytesPerSector - OffsetSize;
			tmpsize -= pFile->FatHdl->BytesPerSector - OffsetSize;
			pFile->bytePointer += pFile->FatHdl->BytesPerSector - OffsetSize;

			endflg = 1;
		}
		else
		{
			memcpy(buffer+realsize, pFile->buffer+OffsetSize, tmpsize);
			realsize += tmpsize;
			pFile->bytePointer += tmpsize;
			tmpsize = 0;

			endflg = 0;
		}
		OffsetSize = 0;
		if(endflg)
		{
			if((pFile->currentSector - pFile->offsetsector + 1)%pFile->FatHdl->SectorsPerCluster == 0)
			{
				nextCluster = F_FAT_GetNextCluster(pFile->FatHdl, F_FAT_SectorToCluster(pFile->FatHdl, pFile->currentSector));
				if(nextCluster == 0)
					return EOF_FATCHAIN;
				nextSector = F_FAT_ClusterToSector(pFile->FatHdl, nextCluster);
				pFile->currentSector = nextSector;
			}
			else
			{
				pFile->currentSector ++;
			}
		}
	}
	
	while(tmpsize>0)
	{
		if(sectorOffset != 0)
		{
			if((pFile->currentSector - pFile->offsetsector + 1)%pFile->FatHdl->SectorsPerCluster == 0)
			{
				nextCluster = F_FAT_GetNextCluster(pFile->FatHdl, F_FAT_SectorToCluster(pFile->FatHdl, pFile->currentSector));
				if(nextCluster == 0)
					return EOF_FATCHAIN;
				nextSector = F_FAT_ClusterToSector(pFile->FatHdl, nextCluster);
				pFile->currentSector = nextSector;
			}
			else
			{
				pFile->currentSector ++;
			}
		}
		F_ReadSector(hFile, pFile->currentSector, readsector, pFile->buffer);
		if(tmpsize>=pFile->FatHdl->BytesPerSector)
		{
			memcpy(buffer+realsize, pFile->buffer, pFile->FatHdl->BytesPerSector);
			realsize += pFile->FatHdl->BytesPerSector;
			tmpsize -= pFile->FatHdl->BytesPerSector;
			pFile->bytePointer += pFile->FatHdl->BytesPerSector;

			endflg = 1;
		}
		else
		{
			memcpy(buffer+realsize, pFile->buffer, tmpsize);
			realsize += tmpsize;
			pFile->bytePointer += tmpsize;
			tmpsize = 0;

			endflg = 0;
		}
		sectorOffset++;
	}
	if(endflg)
	{
		if((pFile->currentSector - pFile->offsetsector + 1)%pFile->FatHdl->SectorsPerCluster == 0)
		{
			nextCluster = F_FAT_GetNextCluster(pFile->FatHdl, F_FAT_SectorToCluster(pFile->FatHdl, pFile->currentSector));
			if(nextCluster == 0)
				return EOF_FATCHAIN;
			nextSector = F_FAT_ClusterToSector(pFile->FatHdl, nextCluster);
			pFile->currentSector = nextSector;
		}
		else
		{
			pFile->currentSector ++;
		}
	}
	
	*realreadsize = realsize;
	return ERR_NONE;
}

u8 F_FileSYS_fseek(TFILE *pFile, s32 Offset, u8 seekPos)
{
	u32 OffsetCluster = 0, OffsetSector = 0, NextCluster = 0, FileSize = pFile->fileInfo.fileINF_size;
	u32 CurCluster = 0;
	
	switch (seekPos)
	{
		case SEEK_SET:
			if(Offset > FileSize)
				pFile->bytePointer = FileSize;
			else
				pFile->bytePointer = Offset;
			break;
		case SEEK_CUR:
			if((pFile->bytePointer + Offset)>FileSize)
				pFile->bytePointer = FileSize;
			else	
				pFile->bytePointer += Offset; 
			break;
		case SEEK_END:
			if(Offset > FileSize)
				pFile->bytePointer = 0;
			else
				pFile->bytePointer = pFile->fileInfo.fileINF_size - Offset;
			break;
		default:
			return F_ERR_SEEK_POSTION;
	}
/*
	OffsetSector = pFile->bytePointer/pFile->FatHdl->BytesPerSector;
	OffsetCluster = OffsetSector/pFile->FatHdl->SectorsPerCluster;
	pFile->offsetsector = OffsetSector;

	if(OffsetCluster)
	{
		while(OffsetCluster>0)
		{
			NextCluster = F_FAT_GetNextCluster(pFile->FatHdl, F_FAT_SectorToCluster(pFile->FatHdl, pFile->currentSector));
			if(NextCluster == 0)
				break;
			pFile->currentSector = F_FAT_ClusterToSector(pFile->FatHdl, NextCluster);
			OffsetCluster--;
			OffsetSector -=pFile->FatHdl->SectorsPerCluster;
		}
		if(OffsetSector)
			pFile->currentSector+=OffsetSector;
	}
	else
		pFile->currentSector+=OffsetSector;
*/
	CurCluster = pFile->fileInfo.fileINF_start_cluster;
	OffsetSector = (pFile->bytePointer/pFile->FatHdl->BytesPerSector)%pFile->FatHdl->SectorsPerCluster;
	OffsetCluster = pFile->bytePointer/(pFile->FatHdl->BytesPerSector*pFile->FatHdl->SectorsPerCluster);

	while (OffsetCluster > 0)
	{
		CurCluster=F_FAT_GetNextCluster(pFile->FatHdl, CurCluster);
		OffsetCluster--;
	}

	// calculate the Sector address of the new byte pointer
	pFile->currentSector=F_FAT_ClusterToSector(pFile->FatHdl, CurCluster) + OffsetSector;

	return ERR_NONE;
}

u8 F_FileSYS_fcreate(TFILE *pFile, c8 *filename)
{
	u8 Error = ERR_NONE;
	u8 fdbnum = 1, lfnflg = 0, fdbbuffer[32]={0};//*fdbbuffer = NULL;
	F_BrowsingCursor cursor;
	c8 shortname[13] = {0};
	F_direntry de;
	u32 freeCluster;
	
	Error = F_FileSYS_GetFileInfo(pFile->FatHdl, filename, &pFile->fileInfo);
	if(Error == F_ERR_FILE_NOT_EXIST)
	{
		///0. check if longname and get fdb number
		lfnflg = F_FAT_CheckIfLFN(filename, &fdbnum);
		if(lfnflg)
		{// create a short namen
			F_FAT_CreateShortName(pFile->FatHdl, filename, shortname,0);
		}
		//mdt_printf("lfnflg:%d, filename:%s\n",lfnflg, filename);
		///1. get free fdb entry
		F_FAT_BrowsingReset(pFile->FatHdl, &cursor);
		Error = F_FAT_GetFreeFDBEntry(pFile->FatHdl, fdbnum, &cursor);
		///2. filename,time -> fdb
		//fdbbuffer = (u8 *)malloc(fdbnum*32);
		if(lfnflg)
		{
			F_FAT_CreateLFNFDB(filename, shortname, fdbbuffer, fdbnum-1);
		}
		else
			strcpy(shortname, filename);
		F_FAT_CreateSFNFDB(&de, shortname, 1);
		memcpy((fdbbuffer+(fdbnum-1)*32), (u8 *)&de, 32);
		//DataPrint(32, 16, fdbbuffer);
		///3. create fdb
		#if 1
		F_FAT_CreateFDB(pFile->FatHdl, fdbbuffer, &cursor, fdbnum);


		pFile->de.deFileSize = 0;
		freeCluster = (u32)(de.deStartCluster&0xFFFF);
		freeCluster = freeCluster + (u32)(de.deHighClust<<16);
		pFile->currentSector = F_FAT_ClusterToSector(pFile->FatHdl, freeCluster);
		strcpy(pFile->fileInfo.fileINF_Name, shortname);
		#endif
		//free(fdbbuffer);
	}
	else
	{
		return F_ERR_FILE_EXIST;
	}
	return ERR_NONE;
}

u8 F_FileSYS_fwrite(TFILE *pFile, u8 *buffer, u32 writesize, u32 *realwritesize)
{
	u32 SectorsPerCluster = pFile->FatHdl->SectorsPerCluster;
	u32 CurrentCluster = F_FAT_SectorToCluster(pFile->FatHdl, pFile->currentSector);
	u32 NextCluster = 0;
	u16 i, lesssize = pFile->FatHdl->BytesPerSector - pFile->bytePointer%pFile->FatHdl->BytesPerSector;

	if(pFile->bytePointer!=0)
	{
		//mdt_printf("1..%d\n",pFile->currentSector);
		F_ReadSector(hFile, pFile->currentSector, 1, prSectorBuf);
		if(writesize>lesssize)
		{
			memcpy(prSectorBuf+pFile->FatHdl->BytesPerSector-lesssize, buffer, lesssize);
			F_WriteSector(hFile, pFile->currentSector, 1, prSectorBuf);
			
			writesize -= lesssize;
			buffer += lesssize;
			pFile->bytePointer += lesssize;
			//mdt_printf("o..%d\n",pFile->offsetsector);
			pFile->offsetsector++;
			
			if(pFile->offsetsector%SectorsPerCluster)
			{
				pFile->currentSector++;
			}
			else
			{
				NextCluster = F_FAT_GetNextFreeCluster(pFile->FatHdl, CurrentCluster);
				if(NextCluster==0)
					return 1;
				CurrentCluster = NextCluster;
				pFile->currentSector = F_FAT_ClusterToSector(pFile->FatHdl, CurrentCluster);
			}
		}
		else
		{	
			memcpy(prSectorBuf+pFile->FatHdl->BytesPerSector-lesssize, buffer, writesize);
			F_WriteSector(hFile, pFile->currentSector, 1, prSectorBuf);
			
			writesize = 0;
			pFile->bytePointer += writesize;
		}
		//mdt_printf("2..%d\n",pFile->currentSector);
	}

	while(writesize>0)
	{
		//mdt_printf("3..%d\n",pFile->currentSector);
		if(writesize>pFile->FatHdl->BytesPerSector)
		{
			F_WriteSector(hFile, pFile->currentSector, 1, buffer);  
			pFile->offsetsector++;
			if(pFile->offsetsector%SectorsPerCluster)
			{
				pFile->currentSector++;
			}
			else
			{
				NextCluster = F_FAT_GetNextFreeCluster(pFile->FatHdl, CurrentCluster);
				if(NextCluster==0)
					return 1;
				CurrentCluster = NextCluster;
				pFile->currentSector = F_FAT_ClusterToSector(pFile->FatHdl, CurrentCluster);
			}

			writesize -= pFile->FatHdl->BytesPerSector;
			buffer += pFile->FatHdl->BytesPerSector;
			pFile->bytePointer += pFile->FatHdl->BytesPerSector;
		}
		else
		{
			memcpy(pFile->buffer, buffer, writesize);
			memset(pFile->buffer+writesize, 0, (pFile->FatHdl->BytesPerSector - writesize));
			F_WriteSector(hFile, pFile->currentSector, 1, pFile->buffer);
			//pFile->offsetsector++;
			pFile->bytePointer += writesize;
			writesize = 0;
		}
		//mdt_printf("4..%d\n",pFile->currentSector);
	}
	//pFile->de.deFileSize = pFile->bytePointer;
	return ERR_NONE;
}

u8 F_FileSYS_fclose(TFILE *pFile)
{
	if(pFile->mode == r)
	{
		pFile->buffer = NULL;
		pFile->bytePointer = 0;
		pFile->currentSector = 0;
		pFile->offsetsector = 0;
		pFile->FatHdl = NULL;
		return ERR_NONE;
	}
	else if(pFile->mode == w)
	{
		if(pFile->de.deFileSize<pFile->bytePointer)
			pFile->de.deFileSize = pFile->bytePointer;
		F_FAT_ModifyFDB(pFile->FatHdl, &pFile->de, pFile->fileInfo.fileINF_Name);

		pFile->buffer = NULL;
		pFile->bytePointer = 0;
		pFile->currentSector = 0;
		pFile->offsetsector = 0;
		pFile->FatHdl = NULL;
	}
	return ERR_NONE;
}



/************************************************************************************/
/*****					Functions for File System Application							*****/
/************************************************************************************/
TFILE g_pFile;

void F_FileSYS_FileRead(c8 *filename, u8 *readdat, s32 Offset,u32 readsize)
{
	u32 realsize = 0;//i;
	static u8 flg = 0;

	//Uart_Printf("read one time open.. Offset:%d\n",Offset);
	g_pFile.FatHdl = F_FAT_GetCurrentFolder();
if(!flg)
{
	F_FileSYS_fopen(&g_pFile, "shh.mp3", r);
	flg = 1;
}
	F_FileSYS_fseek(&g_pFile, Offset, SEEK_SET);
	//Uart_Printf("offset:%d, g_pFile.bytepointer:%d\n", Offset, g_pFile.bytePointer);
	F_FileSYS_fread(&g_pFile, readdat, readsize, &realsize);
//	DataPrint(realsize, 32, readdat);
//	if(realsize<readsize)
//		for(i = realsize;i<readsize;i++)
//			readdat[i] = 0;
if(!flg)
{
	F_FileSYS_fclose(&g_pFile);
}
	//Uart_Printf("read one time Close..\n");
}

void F_FileSYS_FileSeekRead(u8 Item, char *readdat, s32 Offset,u32 readsize)
{
	u32 realsize = 0, i;

	if(Offset!=0)
	{
		F_FileSYS_fseek(&g_pFile, Offset, SEEK_CUR);
	}
	F_FileSYS_fread(&g_pFile, (u8 *)readdat, readsize, &realsize);
	if(realsize<readsize)
		for(i = realsize;i<readsize;i++)
			readdat[i] = 0;

	//F_FileSYS_fclose(&g_pFile);
}
#endif /* _READ_SD_ */