massop.c

可以实现44B0的底层所有通信

U8 RBC_Write(U32 lba,U8 len,U8 *pBuffer)
{
#define cdbWrite RBC_CDB.RbcCdb_Write
	TPBulk_CBW.dCBW_Signature=CBW_SIGNATURE;
	TPBulk_CBW.dCBW_Tag=0x60a624de;
	TPBulk_CBW.dCBW_DataXferLen=len*512;
	TPBulk_CBW.bCBW_Flag=0x0;
	TPBulk_CBW.bCBW_LUN=0;
	TPBulk_CBW.bCBW_CDBLen=12;
	TPBulk_CBW.OperationCode=RBC_CMD_WRITE10;
	cdbWrite.VendorSpecific=0;
	cdbWrite.LBA_0=lba;
	cdbWrite.LBA_1=lba>>8;
	cdbWrite.LBA_2=lba>>16;
	cdbWrite.LBA_3=lba>>24;
	cdbWrite.XferLength=WordSwap(len);
	cdbWrite.Reserved2=0;
	cdbWrite.Control=0;
	//////////////////////////////////////
	if(!epBulkSend((U8 *)&TPBulk_CBW,31))
		return FALSE;
	Delay1(10000);
	if(!epBulkSend(pBuffer,len*512))
		return FALSE;
	if(!epBulkRcv((U8 *)&TPBulk_CSW,13))
		return FALSE;

#undef cdbWrite

	return TRUE;
}





/*********************************************************************************/
//	FAT16/FAT32 Operation
/*********************************************************************************/

////////////////////////////////////////
U32 FirstSectorofCluster(U32 clusterNum)
{
	return (clusterNum-2)*DeviceInfo.BPB_SecPerClus+DeviceInfo.FirstDataSector;
}

U32 ThisFatSecNum(U32 clusterNum)
{

   U32 temp;
   if(bTJHFlags.bIsFat32==0)		
   	temp=DeviceInfo.BPB_BytesPerSec/2;		//Is FAT16
   else
   	temp=DeviceInfo.BPB_BytesPerSec/4;		//Is FAT32  temp--->128(0x80)
   
   temp=clusterNum/temp;
   
   temp=temp+DeviceInfo.FatStartSector;			
   return temp;
}

U16 ThisFatEntOffset(U32 clusterNum)
{
	U16 temp;
	U32 temp1;
	if(bTJHFlags.bIsFat32==0)		//IS  FAT16
		temp1=2*clusterNum;
	else
		temp1=4*clusterNum;			//IS FAT32
		
	temp=temp1/DeviceInfo.BPB_BytesPerSec;
	temp1=temp1-temp*DeviceInfo.BPB_BytesPerSec;
	//temp=temp1;
	return temp1;
}


U32 GetNextClusterNum(U32 clusterNum)
{
	
	U16 tjhFatEntOffset;
	U32 tjhFatSecNum;

	
	tjhFatSecNum=ThisFatSecNum(clusterNum);
	
	tjhFatEntOffset=ThisFatEntOffset(clusterNum);

	if(ThisFile.FatSectorPointer!=tjhFatSecNum)
	{	
		
		if(!RBC_Read(tjhFatSecNum,1,FATBUF))
			return 0x0;
		ThisFile.FatSectorPointer=tjhFatSecNum;
	}
	
	///////////////////////////////////////////////////
	if(bTJHFlags.bIsFat32==0)			//IS FAT16
		clusterNum=MakeU32(0,0,FATBUF[tjhFatEntOffset+1],FATBUF[tjhFatEntOffset]);

	else
		clusterNum=MakeU32(FATBUF[tjhFatEntOffset+3],FATBUF[tjhFatEntOffset+2],FATBUF[tjhFatEntOffset+1],FATBUF[tjhFatEntOffset]);
	return clusterNum;
}



U8 DeleteClusterLink(U32 clusterNum)
{
	
	U32 tjhFatSecNum,maxClusterNum;
	U16 tjhFatEntOffset;
	U8 BUF[512],bChanged;
	U32 ThisSector;
	////////////////////////////////////////////
	ThisSector=0;
	bChanged=0;
	
	if(bTJHFlags.bIsFat32==0)		//IS FAT16
		maxClusterNum=0xfff8;
	else
		maxClusterNum=0x0ffffff8;	//IS FAT32
	while((clusterNum>1)&&(clusterNum<maxClusterNum))
	{
	tjhFatSecNum=ThisFatSecNum(clusterNum);
	tjhFatEntOffset=ThisFatEntOffset(clusterNum);


	if(ThisSector!=tjhFatSecNum)
		{
		if(bChanged)
			{
			if(!RBC_Write(ThisSector,1,BUF))
				return FALSE;

			if(!RBC_Write(ThisSector+DeviceInfo.FATSz,1,BUF))
				return FALSE;
			bChanged=0;
			}
		
		if(!RBC_Read(tjhFatSecNum,1,BUF))
			{
			return FALSE;
			}
		ThisSector=tjhFatSecNum;
		}
	
	if(bTJHFlags.bIsFat32==0)				//IS FAT16
		{
		clusterNum=MakeU32(0,0,BUF[tjhFatEntOffset+1],BUF[tjhFatEntOffset]);

		BUF[tjhFatEntOffset]=0x00;
		BUF[tjhFatEntOffset+1]=0x00;

	
		bChanged=1;	
		}
	else			//IS FAT32
		{
		clusterNum=MakeU32(BUF[tjhFatEntOffset+3],BUF[tjhFatEntOffset+2],BUF[tjhFatEntOffset+1],BUF[tjhFatEntOffset]);
		
		
		BUF[tjhFatEntOffset]=0x00;
		BUF[tjhFatEntOffset+1]=0x00;	
		BUF[tjhFatEntOffset+2]=0x00;	
		BUF[tjhFatEntOffset+3]=0x00;	
		bChanged=1;
		}
	}
	
	
	if(bChanged)
			{
			if(!RBC_Write(ThisSector,1,BUF))
				return FALSE;

			if(!RBC_Write(ThisSector+DeviceInfo.FATSz,1,BUF))
				return FALSE;
			bChanged=0;
			}
	return TRUE;
}



U8 GoToPointer(U32 pointer)
{
	U16 clusterSize;
	clusterSize=DeviceInfo.BPB_SecPerClus*DeviceInfo.BPB_BytesPerSec;
	ThisFile.ClusterPointer=ThisFile.StartCluster;

	while(pointer+1>clusterSize)   
	{
		pointer-=clusterSize;	
		ThisFile.ClusterPointer=GetNextClusterNum(ThisFile.ClusterPointer);
		
	}
	ThisFile.SectorofCluster=pointer/DeviceInfo.BPB_BytesPerSec;
	ThisFile.SectorPointer=FirstSectorofCluster(ThisFile.ClusterPointer)+ThisFile.SectorofCluster;
	ThisFile.OffsetofSector=pointer-ThisFile.SectorofCluster*DeviceInfo.BPB_BytesPerSec;
	ThisFile.FatSectorPointer=0;
	return TRUE;
	
}



U32 CreateClusterLink(U32 currentCluster)
{
	U8 bFound;
	U16 tjhFatEntOffset;
	U32 tjhFatSecNum,maxClusterCnt;
	U8 BUF[512];
	
	bFound=0;
	if(bTJHFlags.bIsFat32==0)
		maxClusterCnt=DeviceInfo.FATSz*(DeviceInfo.BPB_BytesPerSec/2);
	else
		maxClusterCnt=DeviceInfo.FATSz*(DeviceInfo.BPB_BytesPerSec/4);;
	//////////////////////////////
	while(FreeClusterNum<maxClusterCnt)		
	{
		tjhFatSecNum=ThisFatSecNum(FreeClusterNum);
		tjhFatEntOffset=ThisFatEntOffset(FreeClusterNum);
		if(tjhFatSecNum!=FreeSecNum)
			{
			//UpdateFat(FreeSecNum);
			if(bTJHFlags.bFatChanged==1)
				{
				if(!RBC_Write(FreeSecNum,1,CurFatSector))
					return 0;
				if(!RBC_Write(FreeSecNum+DeviceInfo.FATSz,1,CurFatSector))
					return 0;
				bTJHFlags.bFatChanged=0;
				}
			FreeSecNum=tjhFatSecNum;
			if(!RBC_Read(FreeSecNum,1,CurFatSector))
				return 0x0;	
			}
		if(bTJHFlags.bIsFat32==0)
			{
			if((CurFatSector[tjhFatEntOffset]==0)&&(CurFatSector[tjhFatEntOffset+1]==0))
		  	{	
		  	CurFatSector[tjhFatEntOffset]=0xff;
		  	CurFatSector[tjhFatEntOffset+1]=0xff;
		  	 	
		  	 bTJHFlags.bFatChanged=1;
		  	 bFound=1;
		  	 }
		  	 }
		  else
		  	{
		  	if((CurFatSector[tjhFatEntOffset]==0)&&(CurFatSector[tjhFatEntOffset+1]==0)&&(CurFatSector[tjhFatEntOffset+2]==0)&&(CurFatSector[tjhFatEntOffset+3]==0))
		  	{	
		  	CurFatSector[tjhFatEntOffset]=0xff;
		  	CurFatSector[tjhFatEntOffset+1]=0xff;
		  	CurFatSector[tjhFatEntOffset+2]=0xff;
		  	CurFatSector[tjhFatEntOffset+3]=0x0f; 	
		  	
		  	 bTJHFlags.bFatChanged=1;
		  	 bFound=1;
		  	 }
		  	}
		 
		 if(bFound==1)
		 	break;
		 else
		 	FreeClusterNum++;
	
	}
	
	//////////////////////////////////////////////
	if(bFound==0)
		return 0x00;
	
	/////////////////////////////////////////////////////////////////////	
	//clusterNum=GetClusterNumFromPara(FreeFat.SectorNum,FreeFat.OffsetofSector);
	if(currentCluster==0x00)
		return FreeClusterNum++;
	
	tjhFatSecNum=ThisFatSecNum(currentCluster);
	tjhFatEntOffset=ThisFatEntOffset(currentCluster);
	
	if(tjhFatSecNum!=FreeSecNum)
	  {
		RBC_Read(tjhFatSecNum,1,BUF);
		if(bTJHFlags.bIsFat32==0)      
			{
			BUF[tjhFatEntOffset]=FreeClusterNum;
			BUF[tjhFatEntOffset+1]=FreeClusterNum>>8;
			}
		else							
			{
			BUF[tjhFatEntOffset]=FreeClusterNum;
			BUF[tjhFatEntOffset+1]=FreeClusterNum>>8;
			BUF[tjhFatEntOffset+2]=FreeClusterNum>>16;
			BUF[tjhFatEntOffset+3]=FreeClusterNum>>24;
			}
		
		if(!RBC_Write(tjhFatSecNum,1,BUF))
			return 0x00;
		if(!RBC_Write(tjhFatSecNum+DeviceInfo.FATSz,1,BUF))
			return 0x00;
	   }
	 else
	   {
	   	if(bTJHFlags.bIsFat32==0)		
	   		{
	   		CurFatSector[tjhFatEntOffset]=FreeClusterNum;
			CurFatSector[tjhFatEntOffset+1]=FreeClusterNum>>8;
	   		}
	   	else							
	   		{
	   		CurFatSector[tjhFatEntOffset]=FreeClusterNum;
			CurFatSector[tjhFatEntOffset+1]=FreeClusterNum>>8;
			CurFatSector[tjhFatEntOffset+2]=FreeClusterNum>>16;
			CurFatSector[tjhFatEntOffset+3]=FreeClusterNum>>24;
	   		}
	   			
		bTJHFlags.bFatChanged=1;
	   }	
	  //////////////////////////////////////////////////////////////////////////
	return FreeClusterNum++;
}