flashdsk-080.cpp

一个29f800的flash驱动代码

            pNewEntry[i].dwMagic = 0;
            pNewEntry[i].dwOffset = pEntry->dwOffset;
            pNewEntry[i].dwLength = pEntry->dwLength;           

            //清除原来目录区入口
            memset(pEntry,0xFF,sizeof(TDirectory));

            //Update the Flash system sector.
            SetMapChangeFlag( pNewEntry );
            Map2Disk();
            return 0;
        }
    }                  
    return 3;
}

DWORD remove_f(char *fname)
{
    TDirectory *pEntry;
    DWORD hFile;
    TOpenFile *pFile;
    DWORD fat,tfat;
    DWORD len=0;

    // Not case sensitive. 
    ToLower(fname);       

    // Get Directory Entry
    pEntry = GetDirEntry(fname);
    if(pEntry == NULL)
        return 1;         
    
    // Get the first logic block
    fat = pEntry->dwOffset;
                                                  
    // Release the logic block of this file.
    len = 0;
    while((fat != FAT_FILEEND)&&(len*LOGIC_SECTOR_SIZE<pEntry->dwLength))
    {
        // Get the flag ( the flag maybe FAT_FILEEND or the number of next 
        // logic block ) in FAT table and clear it to FAT_REMOVE.
        tfat = pMapFat[fat];
        pMapFat[fat] = FAT_REMOVE;
        fat = tfat;
        len++;
    }                                       

    // Set changed flag in system sector map
    SetMapChangeFlag(pMapFat);   
           
    // Clear the directory entry.
    memset((BYTE*)pEntry,0xFF,sizeof(TDirectory));

    // Set changed flag in system sector map
    SetMapChangeFlag(pEntry);
    
    Map2Disk();	//added by zqz 2002/12/12
    return 0;
}

DWORD ftruncate_f(DWORD hFile,DWORD len)
{
    TOpenFile *pFile=(TOpenFile *)hFile;
    TDirectory *pEntry = pFile->pEntry;
    DWORD fat, fatold, size;

    if( pFile->dwMagic != OPEN_FILE )
        return 1;
    if( len==pEntry->dwLength )
        return 0;
    if( len>pEntry->dwLength ) 
        return 2;
    if( len>pFile->dwFileLength )
        return 3;
    
    fatold = pEntry->dwOffset;
    size = 0;
                              
    // Clear logic sector in FAT
    while((fatold != FAT_FILEEND)&&(size<pFile->dwFileLength))
    {
        fat = pMapFat[fatold];
        size += LOGIC_SECTOR_SIZE;

        if(size > len)      
        {
            pMapFat[fatold] = FAT_FILEEND;
            pMapFat[fat] = FAT_FREE;
        }                                 
        
        fatold = fat;
    } 
                                
    // Edit file length
    pEntry->dwLength = len;
    pFile->dwFileLength = len;

    // Set change flag of system sector.
    SetMapChangeFlag(pMapFat);
    
    return 0;
}

DWORD fstat_f(DWORD hFile,struct stat *pBuf)
{
    TDirectory *pEntry;
    TOpenFile *pFile;

    // Check parameter
    pFile = (TOpenFile*)hFile;
    if(pFile->dwMagic != OPEN_FILE)
        return 1;

    pEntry = (TDirectory*)pFile->pEntry;
    pBuf->st_mode = pEntry->dwMode;
    pBuf->st_size = pEntry->dwLength;
    pBuf->st_mtime=pEntry->stModify;
    return 0;
}

DWORD stat_f(char *fname ,struct stat* pBuf)
{
    TDirectory *pEntry;

    // Not case sensitive
    ToLower(fname);

    // Get file entry
    pEntry = GetDirEntry(fname);
    if(pEntry == NULL)
        return 1;    

    pBuf->st_mode = pEntry->dwMode;
    pBuf->st_size = pEntry->dwLength;
    pBuf->st_mtime = pEntry->stModify;
    return 0;
}

//创建文件目录
DWORD make_dir(char *szDirName,DWORD mode)
{
    TDirectory *pDir;

    //判断磁盘是否初始化
    if(DiskInit != TRUE)
        return 1;

    // Not case sensitive
    ToLower(szDirName);

    //分配目录入口
    DWORD dirFat=AllocDirEntry();   //？？从系统区FAT表中取一个空逻辑块？？
    if(dirFat == 0)
        return 2;

    for(int i=0;i<DIR_ENTRY_NUM;i++)
    {
        if(pCurrentDir[i].wType == 0xFFFF)
        {
            FillDir(pCurrentDir+i,szDirName,dirFat);
            pDir = (TDirectory*)((DWORD)pMapDir+dirFat*LOGIC_SECTOR_SIZE);
            FillDir(pDir,".",dirFat);
            pDir++;
            dirFat = GetDirFat(pCurrentDir);
            FillDir(pDir,"..",dirFat);
            break;
        }
    }
    
    //设置系统扇区变化标志
    SetMapChangeFlag(pCurrentDir);
    SetMapChangeFlag(pDir);

    //把镜像区内容写回磁盘
    //Map2Disk();
    return 0;
}

void ToLower( char * filename )
{
	WORD len = strlen(filename);
	for( int i=0;i<len;i++)
	{
		filename[i]=tolower(filename[i]);
	}
}

ULONG read_dir(XDIR *dir, struct dirent *buf)
{
    return 0;
}

ULONG close_dir(XDIR *dir)
{
    return 0;
}

ULONG open_dir(char *dirname, XDIR *dir)
{
    return 0;
}

//取该地址对应的物理扇区编号
DWORD GetPhysicalSector(void *pAddr)
{
    
    DWORD base = (DWORD)pAddr;
    TPhySector *pSector;
    for(int i=0;i<pMapDesp->nPhSector;i++)
    {
        pSector = &pMapDesp->phSector[i];
        if((base >= pSector->dwOffset)&&(base < pSector->dwOffset+pSector->dwSize))
            return i;
    }
}


//从目录分配表中分配空的目录项入口
DWORD AllocDirEntry()
{
    for(int i=1;i<DIR_FAT_NUM;i++)
    {
        if(pMapDesp->aDirFatTab[i] == FAT_FREE)
        {     
            //设置目录项使用标志
            pMapDesp->aDirFatTab[i] = FAT_FILEEND;
            //设置系统扇区变化标志
            SetMapChangeFlag(pMapDesp);
            //把FAT表信息写回磁盘
            //WriteWord2Disk(&pDiskDesp->aDirFatTab[i],FAT_FILEEND);
            return i;
        }
    }
    return 0;
}

//从全文件名称中分离出文件名称和文件后缀
DWORD FileName(char *const name,char *prev,char *sufix)
{
    DWORD len=strlen(name);
    DWORD num=0;
    BOOL isSuffix=FALSE;
    char *pChar;
    if(len>12) return 1;
    pChar = name;
    while(*pChar++ == '.')
    {
        prev[num++]='.';
    }
    if(num>0)
    {
        prev[num]=0;
        return 0;
    }
    num=0;
    pChar = prev;
    for(int i=0;i<len;i++)
    {
        if((name[i]=='*')||(name[i]=='\\')||(name[i]=='?')||(name[i]==',')||(name[i]=='/'))
            return 3;
        if(name[i] == '.')
        {
         pChar[num]='\0';
            pChar=sufix;
            num=0;
            isSuffix = TRUE;
            continue;
        }
        else pChar[num] = name[i];
        num++;
        if(num > 8)
            return 4;
    }
    pChar[num]=0;
    if(!isSuffix)
        sufix[0] = 0;
    return 0;
}


//填充目录区入口
void FillDir(TDirectory *pdir,char *fname,DWORD fat)
{
     FileName(fname,pdir->szName,pdir->szSuffix);
     pdir->wType = FT_SUBDIR;
     pdir->dwMagic = 0;
     pdir->dwLength = 0;
     pdir->dwOffset = fat;

}

//设置文件分配表信息,在首次初始化磁盘时调用
void SetFatInfo(DWORD off,DWORD size,DWORD mode)
{
    //计算该物理扇区在FAT表中的位置
    DWORD fat = off/LOGIC_SECTOR_SIZE;
    //计算该物理扇区在FAT表中个数
    DWORD num = size/LOGIC_SECTOR_SIZE;
    for(int i=0;i<num;i++)
    {
        switch(mode)
        {
        case PSM_SYSTEM:
            pMapFat[fat+i] = FAT_SYSTEM;
            break;
        case PSM_FILE:
            pMapFat[fat+i] = FAT_FREE;
            break;
        case PSM_RESERVED:
            pMapFat[fat+i] = FAT_RESERVED;
            break;
        case PSM_BAD:
            pMapFat[fat+i] = FAT_BAD;
            break;
        default:
            pMapFat[fat+i] = FAT_BAD;
            break;
        }
    }
}
//从全路径文件名称中分离出文件名称和文件路径
char *GetPath(char *file,char *name)
{
    int i;
    WORD len=strlen(file);

    //{{
    ToLower(file);
    //}}

    for(i=0;i<len;i++)
    {
        if((file[i] == '\\')||(file[i] == '/'))
        {
            name[i] = 0;
            return &file[i+1];
        }
        name[i] = file[i];
    }
    name[i]=0;
    return NULL;
}

void SeparatePath(const char * const file,char *path,char *fname)
{
    WORD len=strlen(file);
    while((file[len] != '\\')&&(file[len]!='/')&&(len != 0))
        len--;
    if(len != 0)
    {
        memcpy(path,file,len);
        path[len]=0;
        strcpy(fname,&file[len+1]);
    }
    else
    {
        *path='\0';
        strcpy(fname,file);
    }
}
//取文件或目录的目录区入口
TDirectory *GetDirEntry(char *name)
{
    char *str=name;
    char path[15];
    char fname[9];
    char suffix[4];
    DWORD fat;
    char filename[9];
    BOOL isFound=FALSE;
    TDirectory *pdir=pCurrentDir;

    //{{
    ToLower(name);
    //}}

    while(str!=NULL)
    {
        str = GetPath(str,path);

        //从根目录开始查找
        if(!strcmp(path,DIR_ROOT))
        {
            pdir = pMapDir;
            continue;
        }
        //从当前目录开始查找
        else
        {
            isFound = FALSE;
            FileName(path,fname,suffix);
            for(int i=0;i<DIR_ENTRY_NUM;i++)
            {
                memcpy(filename,pdir[i].szName,8);
                filename[8]=0;
//              if((!strcmp(pdir[i].szName,fname))&&(!strcmp(pdir[i].szSuffix,suffix)))
                if((!strcmp(filename,fname))&&(!strcmp(pdir[i].szSuffix,suffix)))
                {
                    fat = pdir[i].dwOffset;
                    if(pdir[i].wType == FT_SUBDIR)
                        pdir = (TDirectory*)(LOGIC_SECTOR_SIZE*fat+(DWORD)pMapDir);                                     
                    else pdir += i;
                    isFound = TRUE;
                    break;
                }
            }
            if(!isFound)
                return NULL;
        }
    }