hpi.c

檔案系統FAT讀寫USB pen driver sample code

	    }
	/////////////////////////////////////////////
	//pDirInfo=(PDIR_INFO)RspBlockOpenFile.item;
	//ThisFile.FatSectorPointer=ThisFatSecNum(ThisFile.StartCluster);
	ThisFile.StartCluster=SwapINT16(pDirInfo->startCluster);
	ThisFile.LengthInByte=0;
	ThisFile.ClusterPointer=ThisFile.StartCluster;
	ThisFile.SectorPointer=FirstSectorofCluster(ThisFile.StartCluster);
	ThisFile.OffsetofSector=0;
	ThisFile.SectorofCluster=0;
	ThisFile.bFileOpen=1;
	ThisFile.pointer=0;
	ThisFile.FatSectorPointer=0;
	//////////////////////////////////////////////
	FreeFat.SectorNum=DeviceInfo.FatStartSector;
	FreeFat.OldSectorNum=DeviceInfo.FatStartSector;
	FreeFat.OffsetofSector=2;

	return TRUE;
#undef RspBlockCreateFile
}

unsigned char WriteFile(unsigned int writeLength,unsigned char *pBuffer)
{
#define RspBlockWriteFile CHRspBlock.RspBlock.Rsp_WriteFile
	unsigned int len,sector,i;
	PDIR_INFO pDirInfo;
	unsigned char bSuccess,bStop,step;

	if(!bXXGFlags.bits.SLAVE_IS_ATTACHED)	//U盘是否已经连接
	{
	CHRspBlock.errcode=ERC_NODEVICE;
	return FALSE;
	}
	if(!ThisFile.bFileOpen)			//文件是否已经打开
	{
	CHRspBlock.errcode=ERC_FILENOTOPENED;
	return FALSE;
	}
	///////////////////////////////////////////////////////////
	//if(CHCmdBlock.CmdBlock.Cmd_WriteFile.writeLength>0)
	//	{
	//	for(i=CHCmdBlock.CmdBlock.Cmd_WriteFile.writeLength;i<MAX_WRITE_LENGTH;i++)
	//	CHBUF[i]=0;
	//	}

	///////////////////////////////////////////////////////////
	ThisFile.bFileOpen=0;
	bSuccess=1;
	bStop=0;

	CHRspBlock.len=0;
	//if(CHCmdBlock.CmdBlock.Cmd_WriteFile.writeLength)
	while(writeLength>0)
	{
		 //////////////////////////////////////////////////////
		 if(ThisFile.OffsetofSector>0)
		 	{
		 	if(writeLength+ThisFile.OffsetofSector>DeviceInfo.BPB_BytesPerSec)
		   		len=DeviceInfo.BPB_BytesPerSec;
			else
		   		len=writeLength+ThisFile.OffsetofSector;
			//////////////////////////////////////////////////
		 	if(!RBC_Read(ThisFile.SectorPointer,1,DBUF))
				{
		   		CHRspBlock.errcode=ERC_DEVICEERR;
				return FALSE;
		   		}
		   			//ThisFile.OffsetofSector=len;
			len=len-ThisFile.OffsetofSector;
		   	for(i=0;i<len;i++)
		   		//DBUF[ThisFile.OffsetofSector+i]=CHBUF[i];
		   		DBUF[ThisFile.OffsetofSector+i]=*(pBuffer+i);
		   	if(!RBC_Write(ThisFile.SectorPointer,1,DBUF))
		   			{
		   			CHRspBlock.errcode=ERC_DEVICEERR;
					return FALSE;
		   			}
		  	ThisFile.OffsetofSector=ThisFile.OffsetofSector+len;
		   	}
		 else
		 	{
		 	if(writeLength>DeviceInfo.BPB_BytesPerSec)
		   		{
		   		step=writeLength/DeviceInfo.BPB_BytesPerSec;
		   		//step=step-ThisFile.SectorofCluster;
		   		if(step>DeviceInfo.BPB_SecPerClus)
		   			{
		   			step=DeviceInfo.BPB_SecPerClus-ThisFile.SectorofCluster;
		   			len=step*DeviceInfo.BPB_BytesPerSec;
		   			}
		   		else
		   			{
		   			step=step-ThisFile.SectorofCluster;
		   			len=step*DeviceInfo.BPB_BytesPerSec;
		   			}
		   		}
			else
		   		{
		   		step=1;
		   		len=writeLength;
		   		}
		 	////////////////////////////////////////////
		 	if(!RBC_Write(ThisFile.SectorPointer,step,pBuffer+CHRspBlock.len))
		   		{
		   		CHRspBlock.errcode=ERC_DEVICEERR;
				return FALSE;
		   		}
		   	ThisFile.OffsetofSector=len;
		 	}
		 /////////////////////////////////////////////////////
		 //if(ThisFile.OffsetofSector>DeviceInfo.BPB_BytesPerSec-1)
		 //  	ThisFile.OffsetofSector-=DeviceInfo.BPB_BytesPerSec;
		   writeLength-=len;
		   CHRspBlock.len+=len;
		   //ThisFile.LengthInByte+=len;
		/////////////更新文件指针 //////////////////////////////
		//改变参数：OffsetofSector,SectorofCluster,SectorPointer,ClusterPointer
		  step=ThisFile.OffsetofSector/DeviceInfo.BPB_BytesPerSec;

		  if(step>0)
		   {
		   	ThisFile.OffsetofSector-=step*DeviceInfo.BPB_BytesPerSec;
		   	ThisFile.SectorofCluster+=step;
		   	if(ThisFile.SectorofCluster>DeviceInfo.BPB_SecPerClus-1)
		   	{
		   		ThisFile.SectorofCluster=0;
		   		if(ThisFile.pointer+CHRspBlock.len<ThisFile.LengthInByte)
		   			ThisFile.ClusterPointer=GetNextClusterNum(ThisFile.ClusterPointer);
		   		else
		 		 	ThisFile.ClusterPointer=CreateClusterLink(ThisFile.ClusterPointer);//GetNextClusterNum(ThisFile.ClusterPointer);
		 		 if(ThisFile.ClusterPointer==0x00)
		 		 	{
		 		 //	   RspBlockReadFile.errcode=ERC_REACHEND;
		   			//   RspBlockReadFile.result=0x0;
		   			CHRspBlock.errcode=ERC_DEVICEERR;
					return FALSE;
		 			}
		 		 ThisFile.SectorPointer=FirstSectorofCluster(ThisFile.ClusterPointer);
		   	}
		   	else
		   		ThisFile.SectorPointer=ThisFile.SectorPointer+step;
		    }


	}//end while
	ThisFile.pointer+=CHRspBlock.len;

	UpdateFat(FreeFat.SectorNum);
	///////////更新文件目录信息/////////////////////////////
	if(bSuccess==1)
	{

		for(sector=0;sector<DeviceInfo.BPB_RootEntCnt;sector++)
	    	{
		//////////////////////////////////////////////////
		if(!RBC_Read(DeviceInfo.RootStartSector+sector,1,DBUF))
			{
			CHRspBlock.errcode=ERC_DEVICEERR;
			return FALSE;
			}
		///////////////////////////////////////////////////
		for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
			{
			pDirInfo=(PDIR_INFO)(DBUF+i);

			if(pDirInfo->startCluster==SwapINT16(ThisFile.StartCluster))
				{
				if(ThisFile.pointer>ThisFile.LengthInByte)
					ThisFile.LengthInByte=ThisFile.pointer;
				//else
				//	ThisFile.pointer=;

				pDirInfo->length=SwapINT32(ThisFile.LengthInByte);
				if(!RBC_Write(DeviceInfo.RootStartSector+sector,1,DBUF))
		   		{
		   		CHRspBlock.errcode=ERC_DEVICEERR;
				return FALSE;
		   		}
				 bStop=1;
				 break;
				}
			}
		if(bStop==1)
			break;
		////////////////////////////////////////////////////
	       }

	}
	/*
	if(bSuccess==0)
	{
	RspBlockWriteFile.errcode=ERC_DEVICEERR;
	RspBlockWriteFile.result=0x0;
	}
	*/
	CHRspBlock.len=0;
	ThisFile.bFileOpen=1;
	//////////////////////////////////////////////
	return TRUE;
#undef RspBlockWriteFile
}

unsigned char RemoveFile(unsigned char *pBuffer)   //删除文件
{
#define RspBlockRemoveFile CHRspBlock.RspBlock.Rsp_RemoveFile
	unsigned int sector,i;
	unsigned char bStop,j;
	PDIR_INFO pDirInfo;

	if(!bXXGFlags.bits.SLAVE_IS_ATTACHED)
	{
	CHRspBlock.errcode=ERC_NODEVICE;
	return FALSE;
	}
	///////////////////////////////////////////////////////////
	//RspBlockRemoveFile.result=0x1;
	////////////// 清除目录/////////////////////////////////////
	for(sector=0;sector<DeviceInfo.BPB_RootEntCnt;sector++)
	    	{
		//////////////////////////////////////////////////
		if(!RBC_Read(DeviceInfo.RootStartSector+sector,1,DBUF))
			{
			CHRspBlock.errcode=ERC_DEVICEERR;
			return FALSE;
			}
		///////////////////////////////////////////////////
		for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
			{
			if(DBUF[i]==0x00)
				{
				CHRspBlock.errcode=ERC_FILENOTFOUND;
				return FALSE;
				}
			///////////////////////////////////////////
			j=0;
			while(DBUF[i+j]==*(pBuffer+j))
				{
				 j=j+1;
				 if(j>10) break;
				 }//end while

			if(j>10)
			 	{
			 	DBUF[i]=0xE5;
			 	pDirInfo=(PDIR_INFO)(DBUF+i);
			 	ThisFile.StartCluster=SwapINT16(pDirInfo->startCluster);
			 	//DelayMs(15);
			 	if(!RBC_Write(DeviceInfo.RootStartSector+sector,1,DBUF))
					{
					CHRspBlock.errcode=ERC_DEVICEERR;
					return FALSE;
					}
				//////////////////// 清除FAT中的纪录////////////////////////
				//DelayMs(10);
				if(!DeleteClusterLink(ThisFile.StartCluster))
						{
						CHRspBlock.errcode=ERC_DEVICEERR;
						return FALSE;
						}
			 	bStop=1;
			 	break;
			 	}

			}//end for
		if(bStop==1)
			break;

	       }//end search
	if(sector>=DeviceInfo.BPB_RootEntCnt)
		{
		CHRspBlock.errcode=ERC_FILENOTFOUND;
			return FALSE;
		}
	//////////////////////////////////////////////
	return TRUE;
#undef RspBlockRemoveFile
}

unsigned char GetCapacity(void)
{
	unsigned int sectorNum,freesectorcnt,i;

#define RspBlockGetCapacity CHRspBlock.RspBlock.Rsp_GetCapacity
	PREAD_CAPACITY_RSP pBuf;

	if(!bXXGFlags.bits.SLAVE_IS_ATTACHED)
	{
	CHRspBlock.errcode=ERC_NODEVICE;
	return FALSE;
	}
	///////////////////////////////////////////////////////////
	if(!ReadCapacity())
	{
	CHRspBlock.errcode=ERC_DEVICEERR;
	return FALSE;
	}

	pBuf=(PREAD_CAPACITY_RSP)DBUF;
	RspBlockGetCapacity.disksize=SwapINT32((pBuf->LastLBA+1)*pBuf->BlockSize);
	////////////////////////////////////////////////////////////////////////
	sectorNum=DeviceInfo.FatStartSector;
	freesectorcnt=0;
	while(sectorNum<DeviceInfo.BPB_FATSz16+DeviceInfo.FatStartSector)
	{

		if(RBC_Read(sectorNum,1,DBUF))
		{
		  for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+2)
		  	{
		  	 //clusterNum++;

		  	 if((DBUF[i]==0xff)&&(DBUF[i+1]==0xff))
		  	 	{
		  	 	freesectorcnt++;
		  	 	}
		  	// clusterNum++;
		  	}
		}
		else
			{
			CHRspBlock.errcode=ERC_DEVICEERR;
			return FALSE;
			}
		sectorNum++;
	}

	////////////////////////////////////////////////////////////////////////
	RspBlockGetCapacity.freedisksize=DeviceInfo.BPB_BytesPerSec*DeviceInfo.BPB_SecPerClus;
	RspBlockGetCapacity.freedisksize=freesectorcnt*RspBlockGetCapacity.freedisksize;
	RspBlockGetCapacity.freedisksize=SwapINT32(RspBlockGetCapacity.disksize)-RspBlockGetCapacity.freedisksize;
	RspBlockGetCapacity.freedisksize=SwapINT32(RspBlockGetCapacity.freedisksize);

	return TRUE;
#undef RspBlockGetCapacity
}

unsigned char GetFreeCapacity(void)
{
#define RspBlockGetCapacity CHRspBlock.RspBlock.Rsp_GetFreeCapacity
	if(!bXXGFlags.bits.SLAVE_IS_ATTACHED)
	{
	CHRspBlock.errcode=ERC_NODEVICE;
	return FALSE;
	}
	//////////////////////////////////////////////


	return TRUE;
#undef RspBlockGetFreeCapacity
}

unsigned char SetFilePointer(unsigned long pointer)
{
#define RspBlockSetFilePointer CHRspBlock.RspBlock.Rsp_SetFilePointer

	//ThisFile.FilePointer=CHCmdBlock.CmdBlock.Cmd_SetFilePointer.pointer;
	if(!bXXGFlags.bits.SLAVE_IS_ATTACHED)
	{
	CHRspBlock.errcode=ERC_NODEVICE;
	return FALSE;
	}
	if(!ThisFile.bFileOpen)
	{
	CHRspBlock.errcode=ERC_FILENOTOPENED;
	return FALSE;
	}
	///////////////////////////////////////////////////////////
	ThisFile.pointer=pointer;
	if(ThisFile.pointer>ThisFile.LengthInByte)
	{
	CHRspBlock.errcode=ERC_LENGTHEXCEED;
	return FALSE;
	}

	if(!GoToPointer(ThisFile.pointer))
	{
	ThisFile.bFileOpen=0;
	CHRspBlock.errcode=ERC_DEVICEERR;
	return FALSE;
	}
	//////////////////////////////////////////////
	return TRUE;

#undef RspBlockSetFilePointer
}

unsigned char GetFirmwareVersion(void)
{
   #define RspBlockGetVersion CHRspBlock.RspBlock.Rsp_GetVersion
   ////////////////////////////////////////////////////////////
   RspBlockGetVersion.version=0x0100;
   return TRUE;
   #undef RspBlockGetVersion
}