partion.c

基于dsp的软驱控制源程序

#include "gm82c765b.h"
#include "partion.h"
#include "global.h"
/************************************************************/
int ReadFileFromFloppy(int number_of_file)
{
	int filecounts;
	int startcluster;
	int i,temp,logAddr;
	long filesize;
	CHS  chsaddr;
	char cluster[6];
	ReadDataFromFlash(0,0,&filecounts,1);
	if(number_of_file>filecounts)
		return -1;
	ReadDataFromFlash(0,1+(number_of_file-1)*16,databuffer,16);
	startcluster=(databuffer[13]<<8)+(databuffer[13]>>8);
	temp=(databuffer[15]<<8)+(databuffer[15]>>8);
	filesize=temp<<16;
	temp=((databuffer[14]<<8)+(databuffer[14]>>8));
	filesize+=temp;
	while(filesize>512)
	{	
	    temp=GetClusterChainOfFile(startcluster,cluster);
	    if(temp>=0)
	    {
	    	for(i=0;i<temp&&filesize>512;++i)
	    	{
	    		logAddr=(startcluster-2)+GetDataLogicBlockAddr();
				if(!ReadDataFromFloppy(logAddr,databuffer,512))
				{
					++filecounts;
				}
				else
				{
					return -1;
				}
	    		filesize-=512;
	    	    startcluster=cluster[i];
	    	}	    	
	    }
	    else
	    {
	    	return temp;
	    }
	}
	logAddr=(startcluster-2)+GetDataLogicBlockAddr();
	if(!ReadDataFromFloppy(logAddr,databuffer,(int)filesize))
	{
		++filecounts;
	}
	else
	{
		return -1;
	}	
	return 0;	
}
/************************************************************/
int GetClusterChainOfFile(int startcluster,char *cluster)
{
    int clustercount=0;
    int maxcluster=0;
    int logAddr=0;
    CHS chsaddr;
    logAddr=GetFat1LogicBlockAddr();		
    while(1)
    {
    	maxcluster+=512;
       	if((clustercount?cluster[clustercount-1]:startcluster)>maxcluster)
       	{
       		logAddr+=3;       		    		
       	}
       	else
    	{       		
        	if(!ReadDataFromFloppy(logAddr,databuffer,1536))
        	{           	
           	 	while(1)
            	{	
            		cluster[clustercount]=GetNextCluster(clustercount?cluster[clustercount-1]:startcluster,databuffer);         
            		if(cluster[clustercount]==0x0fff)
            		{  
            			++clustercount;
            			return clustercount; 
            		}
            		if(cluster[clustercount]>maxcluster)
       				{
       					++clustercount;
       					logAddr+=3;
       					break;
       				}
       				if(cluster[clustercount]==0)
       				{
       					return -2;
       				}
            		++clustercount;
            		if(clustercount==6)
            		{
            			return clustercount;
            		}	
            	}
   		 	}
   		 	 else
        	{
        		return -1;
        	}
   		}
    }
}
/************************************************************/ 
int GetNextCluster(int currentcluster,char *data,int logicAddr)
{
    int offset=currentcluster%512;
    int nextcluster=0;
    switch(offset%4)
    {
    	case 0:
    		nextcluster=((data[offset*3/4]&0xff00)>>8)+((data[offset*3/4]&0x000f)<<12);
    	    break;
    	case 1:
    		nextcluster=((data[offset*3/4]&0x00f0)>>4)+((data[offset*3/4+1]&0xff00)>>4);
    		break;
    	case 2:
    		nextcluster=(data[offset*3/4]&0x00ff)+(data[offset*3/4+1]&0x0f00);
    		break;
    	case 3:
    		nextcluster=((data[offset*3/4]&0xf000)>>12)+((data[offset*3/4]&0x00ff)<<4);
    		break;
    }
    return nextcluster;
    
}
/************************************************************/
int ListFileInRootDir()
{
	int i,j,fileCounts;
	CHS chsaddr;
	fileCounts=0;
	for(i=GetRootDirLogicBlockAddr();i<GetDataLogicBlockAddr()-4;i+=4)
    {	
    	if(!ReadDataFromFloppy(i,databuffer,2048))
    	{
           	for(j=0;j<64;++j)
           	{           		
           		if(((databuffer[j*16]&0xff00)!=0xe500)&&(databuffer[j*16+13]!=0))
           		{           			
           		    WriteDataInFlash(0,1+fileCounts*16,(databuffer+j*16),16);
           		    ++fileCounts;
           		}	
           	}
    		
        }
        else
        {
         	return -1;
        }
        
    }
    WriteDataInFlash(0,0,&fileCounts,1); 
    return fileCounts;    
}