filesys.c

arm（s3c440b）读写u盘源程序

	DWORD FreeSpace;
	FreeSpace=0;
	if(USB_Control.bIsFat32==0)
	{
		*Total=(DiskInfo.BytesPerSec>>1)*DiskInfo.FATSz*DiskInfo.SecPerClus*DiskInfo.BytesPerSec   \
		-2*DiskInfo.SecPerClus*DiskInfo.BytesPerSec;
	///////////////////////////////////////////////////////////
		for(i=0;i<DiskInfo.FATSz;i++)
		{
			if(!Read(DiskInfo.FatStartSector+i,1,(BYTE *)Cache16))
			{
				printf("Getcapacity中1错误\n");
				return FALSE;
			}
			for(j=0;j<256;j++)
				if(Cache16[j]==0)
				 FreeSpace+=DiskInfo.SecPerClus*DiskInfo.BytesPerSec;
		}
		*Free=FreeSpace;
		return TRUE;
	////////////////////////////////////////////////////////////////////
	}else{
		*Total=(DiskInfo.BytesPerSec>>2)*(DiskInfo.FATSz)*DiskInfo.SecPerClus*DiskInfo.BytesPerSec   \
		-2*DiskInfo.SecPerClus*DiskInfo.BytesPerSec;
	////////////////////////////////////////////////////////////////
		for(i=0;i<DiskInfo.FATSz;i++)
		{
			if(!Read(DiskInfo.FatStartSector+i,1,(BYTE *)Cache32))
			{
				printf("Getcapacity中1错误\n");
				return FALSE;
			}
			for(j=0;j<128;j++)
				if(Cache32[j]==0)
				 FreeSpace+=DiskInfo.SecPerClus*DiskInfo.BytesPerSec;
		}
	//	*Free=DiskInfo.FSI_Free_Count*DiskInfo.SecPerClus*DiskInfo.BytesPerSec;
		*Free=FreeSpace;
		return TRUE;
	}	
	return FALSE;
}
BYTE Removefile(const char * filename)
{
	U16 i,sum;
	char bstop,sector,count,flag;
	BYTE BUF[512];
	U32 sectorToRead,clusterNum;
	PDIR_STRUCT pDir;
	U32 dirSectorPointer,dirClusterPointer;
	/////////////////////////////////////////////////////////////////
	ThisFile.bOpen=0;
	flag=0;
	sum=0;
	count=0;
	bstop=0;
	sector=0;
	dirClusterPointer=ThisDir.StartCluster;
	dirSectorPointer=ClusterToSec(ThisDir.StartCluster);
	for(;;)
	    {   
		/////////////////////////////////////////////////
		if(USB_Control.bIsFat32==0)	//Is fat16
		{
		
			if(ThisDir.bRootDir)	//Is Root directory
				{

					if(sector>DiskInfo.RootEntCnt>>4)
					{
						printf("removefile中的1错误\n");
						return FALSE;
					}
					sectorToRead=ThisDir.StartSector+sector++;
				}
			else					//Not Root directory
				{
				
				if(sector>DiskInfo.SecPerClus-1)
					{
					dirClusterPointer=GetNextCluster(dirClusterPointer);
					if(dirClusterPointer>0xfff8)
						{
						printf("removefile中的2错误\n");
						return FALSE;
						}
					dirSectorPointer=ClusterToSec(dirClusterPointer);
					sector=0;
					}
				sectorToRead=dirSectorPointer+sector++;
				}
		}
		else	//Is fat32
		{
			if(sector>DiskInfo.SecPerClus-1)
				{
					dirClusterPointer=GetNextCluster(dirClusterPointer);
					if(dirClusterPointer>0x0ffffff8)
						{
						printf("removefile中的3错误\n");
						return FALSE;
						}
					dirSectorPointer=ClusterToSec(dirClusterPointer);
					sector=0;
				}
			  sectorToRead=dirSectorPointer+sector++;
		}
		//////////////////////////////////////////////////
		if(!Read(sectorToRead,1,(BYTE *)BUF))
			{
				printf("removefile中的4错误,%d\n",sectorToRead);
				return FALSE;	
			}
		pDir=(PDIR_STRUCT)BUF;
		///////////////////////////////////////////////////
		for(i=0;i<DiskInfo.BytesPerSec;pDir++,i=i+32)
			{
			//	c=BUF[i];	
			if(BUF[i]==0x00)
				{
			//	printf("removefile中的1错误\n");
				return FALSE;				
				}
			///////////////////////////////////////////
			if(BUF[i]==0xE5||(BUF[i+11]==0x10))
				continue;
	
				if(memcmp(pDir->DIR_Name,filename,strlen(filename))==0)
				{
					pDir->DIR_Name[0]=0xE5;
					if(!Write(sectorToRead,1,BUF))
					{
						printf("removefile中的10错误,%d\n",sectorToRead);
						return FALSE;
					}
					/////////////////////////////////////////////
					//删除FAT链
					clusterNum=(pDir->DIR_FstClusHI<<16)|(pDir->DIR_FstClusLO);
						//MakeU32((pDir->DIR_FstClusHI>>8),(pDir->DIR_FstClusHI&0x00ff),(pDir->DIR_FstClusLO>>8),(pDir->DIR_FstClusLO&0xff));
					if(!DeleteClusterList(clusterNum))
					{
						printf("removefile中的11错误,%d\n",clusterNum);
						return FALSE;
					}else{
						bstop=1;
						break;
					}
					
				}
			
			
		}
		///////////////////////////////////////////////////////
		if(bstop==1)
			break;	
	    }
	return TRUE;
}
BYTE Cache[512];
#define NCLUSTER_COUNT 1
BYTE Writefile( char * pBuffer,DWORD dWlen,BYTE flag)
{
	//Test[1024]length,
	//WORD FatCache16[256];
	char bBuffer[ 32768 ];//64 个扇区的缓存
	U32 dTempSector,dLength,dTempCluster,nTempClusterCount;//t1,icluster,
	///////////////////////////////////////////////////////////
	if(!ThisFile.bOpen)
	{	
		printf("Writefile中0错误\n");
		return FALSE;
	}
	//////////////////////////////////////////////////////////
	//更新空文件
	
	if(ThisFile.StartCluster<2)
	{

		ThisFile.StartCluster=SeekEmptyCluster();
		if(USB_Control.bIsFat32==0)
		{	
			dTempSector=ThisFile.StartCluster*2/DiskInfo.BytesPerSec+DiskInfo.FatStartSector;
			if(!Read(dTempSector,1,Cache))
			{	printf("Writefile中1错误\n");
				return FALSE;
			}
			Cache[(ThisFile.StartCluster*2%DiskInfo.BytesPerSec)]=0xff;
			Cache[(ThisFile.StartCluster*2%DiskInfo.BytesPerSec)+1]=0xff;
			if(!Write(dTempSector,1,Cache))
			{	
				printf("Writefile中2错误\n");
				return FALSE;
			}
			//////////////////////////////////////////////////////////////////////////////////
		}else{// IS fat 32
			/////////////////////////////////////////////////////////////////////////////////
			dTempSector=ThisFile.StartCluster*4/DiskInfo.BytesPerSec+DiskInfo.FatStartSector;
			if(!Read(dTempSector,1,Cache))
			{	
				printf("Writefile中3错误,%d\n",dTempSector);
				return FALSE;
			}
			Cache[(ThisFile.StartCluster*4%DiskInfo.BytesPerSec)]=0xff;
			Cache[(ThisFile.StartCluster*4%DiskInfo.BytesPerSec)+1]=0xff;
			Cache[(ThisFile.StartCluster*4%DiskInfo.BytesPerSec)+2]=0xff;
			Cache[(ThisFile.StartCluster*4%DiskInfo.BytesPerSec)+3]=0x0f;
			if(!Write(dTempSector,1,Cache))
			{
				printf("Writefile中4错误,%d\n",dTempSector);
						return FALSE;
			}
			/////////////////////////////////////////////////////////////////////////////////
		}
		ThisFile.LengthInByte=0;
		ThisFile.ClusterPointer=ThisFile.StartCluster;
		ThisFile.SectorPointer=ClusterToSec(ThisFile.ClusterPointer);
		ThisFile.OffsetofSector=0;
	////////////////////////////////////////////////////////////
	}//end if
	////////////////////////////////////////////////////////////
	
	dTempCluster=ThisFile.StartCluster;

	if(ThisFile.OffsetofSector>0)
	{
		if(!Read(ThisFile.SectorPointer,DiskInfo.SecPerClus,(BYTE *)bBuffer))
		{
			printf("Writefile中5错误,%d\n",ThisFile.SectorPointer);
			return FALSE;
		}
		if(ThisFile.OffsetofSector+dWlen>(DiskInfo.BytesPerSec*DiskInfo.SecPerClus))
		{
			dLength=DiskInfo.BytesPerSec*DiskInfo.SecPerClus-ThisFile.OffsetofSector;
			memcpy(bBuffer+ThisFile.OffsetofSector,pBuffer,dLength);
//			printf("%d,%d/n",ThisFile.OffsetofSector,dLength);			
			ThisFile.OffsetofSector=0;
			dTempCluster=SecToCluster(ThisFile.SectorPointer);
			dTempCluster=LinkClusterNum(dTempCluster,1);

		}else{	
			dLength=dWlen;
			memcpy(bBuffer+ThisFile.OffsetofSector,pBuffer,dLength);
			ThisFile.OffsetofSector=(ThisFile.OffsetofSector+dLength)%  \
			(DiskInfo.BytesPerSec*DiskInfo.SecPerClus);
			dTempCluster=SecToCluster(ThisFile.SectorPointer);
		}
//		memcpy(bBuffer+ThisFile.OffsetofSector,pBuffer,dLength);
//		memcpy(Test,bBuffer,1024);
		pBuffer+=dLength;
		ThisFile.LengthInByte+=dLength;
//		printf("%d/n",ThisFile.SectorPointer);
		if(!Write(ThisFile.SectorPointer,DiskInfo.SecPerClus,(BYTE *)bBuffer))
		{	
			printf("Writefile中6错误,%d\n",ThisFile.SectorPointer);
			return FALSE;
		}	
		ThisFile.SectorPointer=ClusterToSec(dTempCluster);
		dWlen-=dLength;
	}else{
		if(ThisFile.LengthInByte!=0)
		{
			dTempCluster=LinkClusterNum(SecToCluster(ThisFile.SectorPointer),1);
			ThisFile.SectorPointer=ClusterToSec(dTempCluster);
		}
	}
	///////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////
	while(dWlen)
	{	
		nTempClusterCount=0;
		if(ThisFile.OffsetofSector+dWlen>(NCLUSTER_COUNT*DiskInfo.BytesPerSec*DiskInfo.SecPerClus))
		{
			dLength=NCLUSTER_COUNT*DiskInfo.BytesPerSec*DiskInfo.SecPerClus-ThisFile.OffsetofSector;
			ThisFile.OffsetofSector=0;
//			t1=SecToCluster(ThisFile.SectorPointer);
//			printf("%d\n",t1);
			dTempCluster=LinkClusterNum(SecToCluster(ThisFile.SectorPointer),NCLUSTER_COUNT);
			/////////////////////////////////////////////////////////////////////
		}else{	
			dLength=dWlen;
			nTempClusterCount=dWlen/(DiskInfo.BytesPerSec*DiskInfo.SecPerClus);
			if(((dWlen)%(DiskInfo.BytesPerSec*DiskInfo.SecPerClus))){
				nTempClusterCount+=1;
			}	
						
	            if(nTempClusterCount>1){
			dTempCluster=LinkClusterNum(SecToCluster(ThisFile.SectorPointer),(nTempClusterCount-1));	
	            	}		
			
			ThisFile.OffsetofSector=(ThisFile.OffsetofSector+dLength)%  \
			(1*DiskInfo.BytesPerSec*DiskInfo.SecPerClus);
			///////////////////////////////////////////////////////////////////////
		}
		memcpy(bBuffer,pBuffer,dLength);
//		memcpy(Test,bBuffer,1024);	
		pBuffer+=dLength;
		ThisFile.LengthInByte+=dLength;
//		printf("%d/t%d/n",dWlen,ThisFile.SectorPointer);
		if(!nTempClusterCount){
			if(!Write(ThisFile.SectorPointer,NCLUSTER_COUNT*DiskInfo.SecPerClus,(BYTE*)bBuffer))
			{	
			printf("Writefile中7错误,%d\n",ThisFile.SectorPointer);
			return FALSE;
			}
		}else{

		  if(!Write(ThisFile.SectorPointer,nTempClusterCount*DiskInfo.SecPerClus,(BYTE*)bBuffer))
			{	
			printf("Writefile中7错误,%d\n",ThisFile.SectorPointer);
			return FALSE;
			}
		
		}
		ThisFile.SectorPointer=ClusterToSec(dTempCluster);
		dWlen-=dLength;
	}//end for while
	if(ThisFile.LengthInByte>DiskInfo.BytesPerSec*DiskInfo.SecPerClus)
	{
		if(!UpdateFat())
		{	
			printf("Writefile中8错误\n");
			return FALSE;
		}
	 /////////////////////////////////////////////////////////////////////////
	}
	///////////////////////////////////////////////////////////////////////////
	if(flag)
	{	//更新文件目录信息
		if(!Read(ThisFile.DirSector,1,Cache))
		{	
			printf("Writefile中9错误,%d\n",ThisFile.DirSector);
			return FALSE;
		}
		Cache[ThisFile.DirNumOffSet*32+20]=(ThisFile.StartCluster&0x00ff0000)>>16;
		Cache[ThisFile.DirNumOffSet*32+21]=(ThisFile.StartCluster&0xff000000)>>24;
		Cache[ThisFile.DirNumOffSet*32+26]=ThisFile.StartCluster&0x000000ff;
		Cache[ThisFile.DirNumOffSet*32+27]=(ThisFile.StartCluster&0x0000ff00)>>8;
		////////////////////////////////////////////////////////////////////////
		Cache[ThisFile.DirNumOffSet*32+28]=(ThisFile.LengthInByte&0x000000ff);
		Cache[ThisFile.DirNumOffSet*32+29]=(ThisFile.LengthInByte&0x0000ff00)>>8;
		Cache[ThisFile.DirNumOffSet*32+30]=(ThisFile.LengthInByte&0x00ff0000)>>16;
		Cache[ThisFile.DirNumOffSet*32+31]=(ThisFile.LengthInByte&0xff000000)>>24;
		if(!Write(ThisFile.DirSector,1,Cache))
		{
			printf("Writefile中10错误,%d\n",ThisFile.DirSector);
				return FALSE;
		}
		ThisFile.bOpen=0;
		Fat16Cache[0][256]=0;
		Fat32Cache[0][128]=0;
	}
	return TRUE;
}
BYTE SetfilePointer(DWORD dFilePointer,BYTE bWrite)
{
	WORD wCount;
	DWORD dClusterNum;
	if(!ThisFile.bOpen)
	{
		printf("请先打开文件!\n");
			return FALSE;
	}
	if(dFilePointer>ThisFile.LengthInByte)
	{
		printf("指针超出了文件的最大长度!");
			return FALSE;
	}
	wCount=dFilePointer/(DiskInfo.BytesPerSec*DiskInfo.SecPerClus);
	ThisFile.OffsetofSector=(dFilePointer%(DiskInfo.BytesPerSec*DiskInfo.SecPerClus));
	wCount+=ThisFile.OffsetofSector?1:0;
	//////////////////////////////////////////////////////////////////////////////////
	if(ThisFile.StartCluster<2)
	{
		printf("空文件不用指针已经指向0处!\n");
		return FALSE;
	}
	dClusterNum=ThisFile.StartCluster;
	while(--wCount)
	{
		dClusterNum=GetNextCluster(dClusterNum);
	}
	ThisFile.SectorPointer=ClusterToSec(dClusterNum);
	if(bWrite)
	{
		ThisFile.LengthInByte=dFilePointer;
//	printf("%d,%d",ThisFile.LengthInByte,ThisFile.SectorPointer);
	}else{
		ThisFile.Readpointer=dFilePointer;
	}
//	printf("%d,%d",ThisFile.LengthInByte,ThisFile.OffsetofSector);
	return TRUE;
}
BYTE Readfile( char * pBuffer, WORD wLength)
{
	
	DWORD dClusterNum,dSectorNum,dClusterNum1;
	WORD wDataLength;
	BYTE bBuffer[ 32768 ];//Test[1024];,i
	char *ppBuffer;
	///////////////////////////////////////////////////////////////////////////
	if(!(ThisFile.bOpen)||(ThisFile.StartCluster<2)||(wLength>ThisFile.LengthInByte) \
	||(ThisFile.Readpointer+wLength)>ThisFile.LengthInByte)
	{
		
		return FALSE;
	}
	////////////////////////////////////////////////////////////////
	if((ThisFile.OffsetofSector==0))
	{
		
		dClusterNum1=GetNextCluster(SecToCluster(ThisFile.SectorPointer));
		ThisFile.SectorPointer=ClusterToSec(dClusterNum1);

	}
	ppBuffer=pBuffer;
	dSectorNum=ThisFile.SectorPointer;
	dClusterNum=SecToCluster(ThisFile.SectorPointer);
	while(wLength)
	{	
		dSectorNum=ClusterToSec(dClusterNum);
		if(!Read(dSectorNum,DiskInfo.SecPerClus,(BYTE *)bBuffer))
		{
			return FALSE;
		}
		if(ThisFile.OffsetofSector+wLength>(DiskInfo.BytesPerSec*DiskInfo.SecPerClus))
		{
			wDataLength=DiskInfo.BytesPerSec*DiskInfo.SecPerClus-ThisFile.OffsetofSector;
			dClusterNum=GetNextCluster(dClusterNum);
			memcpy(pBuffer,(char *)bBuffer+ThisFile.OffsetofSector,wDataLength);
			ThisFile.OffsetofSector=0;

		}else
		{
			wDataLength=wLength;
			memcpy(pBuffer,(char *)bBuffer+ThisFile.OffsetofSector,wDataLength);
			ThisFile.OffsetofSector=(ThisFile.OffsetofSector+wDataLength)% \
			(DiskInfo.BytesPerSec*DiskInfo.SecPerClus);
		}

		///////////////////////////////////////////////////////////////////////////	
//		memcpy(Test,bBuffer,1024);
//		for(i=900;i<1024;i++)
//		{
//			printf("%c,",Test[i]);
//		}
//		printf("读取扇区号为%d,%d,%d\n",dSectorNum,ThisFile.OffsetofSector,wDataLength);
		
		ThisFile.SectorPointer=dSectorNum;
		pBuffer+=wDataLength;
		wLength-=wDataLength;
	}//end while
	///////////////////////////////////////////////////////////////
	pBuffer=ppBuffer;
	return TRUE;
}
BYTE GetfilePointer(void)
{
	if(!ThisFile.bOpen)
	{
		return FALSE;
	}
	return TRUE;
}