fat.h File Reference

---

Detailed Description

FAT file system module C header file.

REVISION

• 10/07/2003 M.GAO
  Initial creation.
• 11/12/2003 M.GAO
  Added runtime file handle ID supprot.
• 02/01/2004 M.GAO
  Added oldFreeClusNum to monitor free cluster number change.
• 04/29/2004 M.GAO
  File flush macro definition.

Definition in file fat.h.

#include "../feature.h"
#include "../MESSAGE/message.h"
#include "../GENERIC/generic.h"
#include "../NAND/nand.h"
#include "../HDD/hdd.h"

Include dependency graph for fat.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	st_FATDISK
	FAT disk data structure. More...
struct	st_CURWORKDIR
	Current working directory. More...
struct	st_FATFILEINFO
	FAT file info. More...
struct	st_FATDIRENT
	FAT dir/file entry structure. More...
struct	st_FATDIRSEARCH
	FAT dir/file entry search control structure. More...
struct	st_FATFIND
	FAT find operation control structure. More...
struct	File
	File structure defintion. More...
Defines
#define	SET_DATETIME
	Enable date time support for file/dir creation.
#define	_FAT_REMOVE_FAT12_SUPPORT
	Enable this definition removes FAT12 support.
#define	_RECORD_CURWORKDIR_PATH
	Define to record current working directory path name.
#define	BOOTLOADER_SEC_LEN   256
	256 Sectors reserved for bootloader backup in NAND.
#define	MEDIA_RSV_SEC_LEN   64
	64 sectors reserved for parameters etc.
#define	FAT_MAX_FOPEN   16
	Number concurrently opened files.
#define	FAT_MAXLFN   (260)
	Maximum LFN length in bytes.
#define	FAT_INVALIDSEC   (0xFFFFFFFFL)
	Invalid FAT sector.
#define	FAT_FIRSTCLUS   (2)
	First data cluster.
Enumerations
enum	DISK_ID { DISK_C, DISK_D }
	Disk ID definition. More...
enum	FAT_MOUNT_MSG { FAT_MOUNT_SUCCESS, FAT_MOUNT_MEDIA_FAILURE, FAT_MOUNT_FAT_FAILURE, FAT_MOUNT_MEDIA_NOT_PRESENT }
	FAT mount disk returning message. More...
enum	FAT_TYPE
	FAT type enumeration.
enum	FAT_FORMAT_TYPE { FAT_HIGH_LEVEL_FORMAT, FAT_LOW_LEVEL_FORMAT, FAT_MEDIA_FORMAT }
	FAT format type enumeration. More...
enum	FOPEN_MODE { wb, rb, ab, r_b, w_b, a_b }
	File open mode defintion. More...
enum	SEEK_MODE { SEEK_HEAD, SEEK_MID, SEEK_TAIL }
	File seek mode flag. More...
enum	ENT_TYPE { ENT_FREE, ENT_DEL, ENT_DIR, ENT_FILE, ENT_VOL, ENT_LFN }
Functions
BOOL	FAT_format (DISK_ID, FAT_FORMAT_TYPE, unsigned long)
	Function will reformat the entire volume at given level.
FAT_MOUNT_MSG	FAT_mountDisk (DISK_ID)
	Function checks to mount specified disk and reports mount message.
void	FAT_releaseCurWorkDir (TSK_Handle)
	Function release the current working directory of given task.
long	FAT_findFirst (const char *, st_FATFILEINFO *)
	Function finds the first valid directory or file under current directory.
BOOL	FAT_finsert (File *, unsigned long, const unsigned short *, unsigned short, unsigned long)
	This function is used to insert data inside of file.
BOOL	FAT_attr (const char *, unsigned short)
	Function changes attribute of the specified file/directory.
File *	FAT_bfopen (const char *, FOPEN_MODE, File *)
	Function opens the file with supplied file object buffer.
BOOL	FAT_cd (const char *)
	Function changes current workding directory to specified path.
BOOL	FAT_delete (const char *)
	Function deletes file ONLY under current working directory.
BOOL	FAT_flushDisk (DISK_ID)
	Function flushes the FAT disk and makes all change final.
BOOL	FAT_mkdir (const char *)
	Function creates directory under current working directory if not exists already.
BOOL	FAT_rmdir (const char *)
	Function removes the given directory under current working directory and any subdirs or files.
File *	FAT_fopen (const char *, FOPEN_MODE)
	Function opens the file specified by pName in a mode specified by eMode under current working directory.
BOOL	FAT_fclose (File *)
	Function closes file and flushes disk.
BOOL	FAT_fseek (File *, long, SEEK_MODE)
	Function seeks in file.
short	FAT_fread (File *, unsigned short *, short)
	Function read file and return number of read words.
short	FAT_fwrite (File *, unsigned short *, short)
	Function writes to file and return number of written words.
BOOL	FAT_copyFile (const char *, const char *, USHORT *, USHORT)
	Copy srcFile to dstFile.
BOOL	FAT_copyDir (const char *, const char *, USHORT *, USHORT)
	Copy all files in srcDir to dstDir.
ULONG	FAT_freeSpace (DISK_ID)
	Function returns disk free space.
ULONG	FAT_totalSpace (DISK_ID)
	Function returns total disk space.
BOOL	FAT_frevive (const char *)
	Function checks to revive unclosed file.
unsigned long	FAT__calcPhySecOfClus (unsigned long, st_FATDISK *)
	Function returns starting physical sector of given cluster.
BOOL	FAT__cd (const char *, st_CURWORKDIR *)
	Function changes directory to specified path.
BOOL	FAT__chg2PathDir (const char *, char **, st_CURWORKDIR *)
	Function changes directory to directory part of a given path ignoring the last part, no matter it is a directory or file.
void	FAT__clearWorkDirReg (void)
	Function clears all workding directory registration.
unsigned long	FAT__clusEntry (unsigned long, st_FATDISK *)
	Function returns FAT cluster entry of specified cluster.
BOOL	FAT__createFile (const char *, unsigned short, unsigned long *, unsigned short *, st_CURWORKDIR *)
	Function creates directory/file under current working directory.
BOOL	FAT__delete (st_FATFILEINFO *, st_CURWORKDIR *)
	Function deletes specified file/dir under the given directory.
void	FAT__findClose (long)
	Function releases find cotrol objects.
long	FAT__findFirst (const char *, st_FATFILEINFO *, st_CURWORKDIR *)
	Function finds the first valid dir/file under given directory.
BOOL	FAT__findNext (long, st_FATFILEINFO *)
	Function finds next available directory or file under current workding directory.
unsigned short	FAT__findNxtAvlblClus (unsigned long *, unsigned short, st_FATDISK *)
	Function finds next available clusters.
unsigned short	FAT__findNxtOcupdClus (unsigned long, st_FATDISK *)
	Function finds next occupied clusters from FAT.
BOOL	FAT__flush (st_FATDISK *)
	Function flushes the specified disk.
File *	FAT__fopen (const char *pName, FOPEN_MODE eMode, st_CURWORKDIR *)
	Function opens the file specified by pName in a mode specified by eMode under given working directory.
File *	FAT__bfopen (const char *pName, FOPEN_MODE eMode, File *, st_CURWORKDIR *)
	Function opens the file specified by pName in a mode specified by eMode under given working directory.
BOOL	FAT__fflush (File *)
	Function flushes specified file.
unsigned long	FAT__freeClusNum (DISK_ID)
	Function returns the free cluster number of the specified disk.
BOOL	FAT__fseek (File *, long, SEEK_MODE)
	Function seeks in file, assuming file is seekable.
st_CURWORKDIR *	FAT__getCurWorkDir (void)
	Function returns the current working directory of current task.
void	FAT__getFinfo (st_FATFILEINFO *, st_FATDIRSEARCH *, st_FATDIRENT *)
	Function fetches detailed file info out of directory entry.
void	FAT__getFrstDirEnt (st_FATDIRSEARCH *, st_FATDIRENT *, st_CURWORKDIR *)
	Function fetches the first directory entry under current working directory.
BOOL	FAT__getNxtDirEnt (st_FATDIRSEARCH *, st_FATDIRENT *)
	Function fetches the next directory entry under current working directory.
void	FAT__intprtDirEnt (const unsigned short *, st_FATDIRENT *, st_FATDISK *)
	Function interpretes the directory entry.
BOOL	FAT__isSnameChar (char)
	Function checks to see if character is valid for short file name, following MS standard.
BOOL	FAT__mkdir (const char *, st_CURWORKDIR *)
	Function creates directory under given working directory if not exists already.
void	FAT__pathAppend (char *, const char *)
	Function appends a name string to path.
BOOL	FAT__readWord (unsigned long, unsigned short, unsigned short *, unsigned short, BOOL, st_FATDISK *)
	Function reads back words from data area.
BOOL	FAT__readFatWord (unsigned long, unsigned short, unsigned short *, unsigned short, BOOL, st_FATDISK *)
	Function reads back a word from FAT area.
BOOL	FAT__releaseClus (unsigned long, st_FATDISK *)
	Function releases the cluster linklist.
int	FAT__strcmp (const char *, const char *)
	Function carries out special FAT string comparation, it checks the '/' or NULL as the string terminator and compares at upper case.
void	FAT__pathTruncate (char *)
	Function truncate current path and go up once.
BOOL	FAT__unmountDisk (DISK_ID)
	Function unmounts disk to flush.
BOOL	FAT__updateCopyOfFAT (unsigned long, unsigned long, unsigned short, unsigned short, st_FATDISK *)
	Function updates specified copy of FAT.
BOOL	FAT__updateSecondCopyOfFAT (unsigned long, st_FATDISK *)
	Function updates the second copy of FAT based on FAT entry in first copy.
BOOL	FAT__updateFAT (unsigned long, unsigned long, unsigned short, st_FATDISK *)
	Function updates both copies of FAT.
BOOL	FAT__writeWord (unsigned long, unsigned short, unsigned short *, unsigned short, st_FATDISK *)
	Function writes a word to data area.
void	FAT_hdlInit (void)
	Function initializes file system handle objects.
Variables
st_FATDISK	DiskC
	GLOBAL DATA.

---

Enumeration Type Documentation

enum DISK_ID

Disk ID definition. Enumeration values: DISK_C  Hard disk. DISK_D  NAND disk. Definition at line 85 of file fat.h. { DISK_C, DISK_D } DISK_ID;

enum ENT_TYPE

Enumeration values: ENT_FREE  free entry. ENT_DEL  deleted entry. ENT_DIR  directory. ENT_FILE  file. ENT_VOL  volume entry. ENT_LFN  long file name entry. Definition at line 148 of file fat.h. Referenced by FAT__createFile(), FAT__findFirst(), and FAT__findNext(). { ENT_FREE, ENT_DEL, ENT_DIR, ENT_FILE, ENT_VOL, ENT_LFN, ENT_INVALID } ENT_TYPE;

enum FAT_FORMAT_TYPE

FAT format type enumeration. Enumeration values: FAT_HIGH_LEVEL_FORMAT  high-level format, rewrite FAT table. FAT_LOW_LEVEL_FORMAT  low-level format, rewrite MBR/BR. FAT_MEDIA_FORMAT  media level format. Definition at line 116 of file fat.h. { FAT_HIGH_LEVEL_FORMAT, FAT_LOW_LEVEL_FORMAT, FAT_MEDIA_FORMAT } FAT_FORMAT_TYPE;

enum FAT_MOUNT_MSG

FAT mount disk returning message. Enumeration values: FAT_MOUNT_SUCCESS  success. FAT_MOUNT_MEDIA_FAILURE  unable to mount media. FAT_MOUNT_FAT_FAILURE  unable to mount fat. FAT_MOUNT_MEDIA_NOT_PRESENT  media not present. Definition at line 94 of file fat.h. { FAT_MOUNT_SUCCESS, FAT_MOUNT_MEDIA_FAILURE, FAT_MOUNT_FAT_FAILURE, FAT_MOUNT_MEDIA_NOT_PRESENT, FAT_MOUNT_UNKNOWN_ERROR } FAT_MOUNT_MSG;

enum FOPEN_MODE

File open mode defintion. Use enumeration instead of string to save memeory. Enumeration values: wb  open(if exist) or create(if not exist) binary file to be written continuously only. rb  open binary file to be read only. ab  open(if exist) or create(if not exist) binary file to be appended continuously only. r_b  open(if exist) or create(if not exist) binary file to be read/written. w_b  create binary file to be read/written, not supported yet. a_b  append to binary read/write file, not supported yet. Definition at line 126 of file fat.h. Referenced by FAT_fclose(), FAT_fseek(), and FAT_fwrite(). { wb, rb, ab, r_b, w_b, a_b, fopen_invalid_mode } FOPEN_MODE;

enum SEEK_MODE

File seek mode flag. Enumeration values: SEEK_HEAD  From start. SEEK_MID  From current position. SEEK_TAIL  From end. Definition at line 139 of file fat.h. { SEEK_HEAD, SEEK_MID, SEEK_TAIL } SEEK_MODE;

---

Function Documentation

File* FAT__bfopen (  const char *  pName, FOPEN_MODE  eMode, File *  file, st_CURWORKDIR *  pDir )

Function opens the file specified by pName in a mode specified by eMode under given working directory. Functoin will NOT change the current working directory. Function will NOT open or create any directory. pName is NOT case sensitive. Parameters: pName  file name. eMode  file open mode. file  file object pointer. pDir  working directory. Returns: file pointer if successfully opened, other wise NULL. Definition at line 1532 of file fat.c. References ab, FAT__calcPhySecOfClus(), FAT__chg2PathDir(), FAT__createFile(), FAT__findFirst(), FAT__findNxtAvlblClus(), FAT__findNxtOcupdClus(), FAT__flush(), FAT__fseek(), FAT__releaseClus(), FAT__writeWord(), File::hdlID, st_FATDISK::maxFndClus, st_FATFILEINFO::phySec, r_b, rb, SEEK_TAIL, st_FATFILEINFO::size, st_FATFILEINFO::startClus, wb, st_FATFILEINFO::wordOffset, and st_FATDISK::wrFileNum. Referenced by FAT__fopen(), and FAT_bfopen(). { unsigned short usNum; unsigned short wordOffset; unsigned long phySec; unsigned long clus; long handle; char * pNext; st_FATDISK * pDisk; st_FATFILEINFO info; File * fcpy = file; if(FAT__chg2PathDir(pName, &pNext, pDir) == FALSE) return NULL; file->hdlID = FAT__getHdlID(); if(file->hdlID == 0) { return NULL; } handle = FAT__findFirst(pNext, &info, pDir ); if(handle != -1) FAT_findClose(handle); pDisk = pDir->pDisk; file->mode = eMode; file->pDisk = pDisk; file->flushedSize = 0; file->ptr = 0; if(rb == eMode) { if( (handle == -1) ||(info.size == 0) ) { file = NULL; } else { clus = info.startClus; usNum = FAT__findNxtOcupdClus(clus, pDisk); file->size = (info.size + 1)/2; file->startClus = clus; file->curClus = clus; file->preBroknClus = clus; file->nxtBroknClus = clus+usNum; file->curPhySec = FAT__calcPhySecOfClus(clus, pDisk); file->curSecOffsetInClus = 0; file->curWordOffsetInSec = 0; } } else if( (-1==handle)&&((wb==eMode)||(ab==eMode)||(r_b==eMode)) ) { if(FAT__createFile(pNext,0, &phySec, &wordOffset, pDir) == FALSE) { file = NULL; } else { usNum = FAT__findNxtAvlblClus(&clus, pDisk->maxFndClus, pDisk); if(usNum == 0) { file = NULL; } else { file->dirEntphySec = phySec; file->dirEntwordOffset = wordOffset; file->startUpdtClus = clus; file->startClus = clus; file->curClus = clus; file->preBroknClus = clus; file->nxtBroknClus = clus + usNum - 1; file->centClus = clus + usNum/2; file->curPhySec = FAT__calcPhySecOfClus(clus, pDisk); file->size = 0L; file->curSecOffsetInClus = 0; file->curWordOffsetInSec = 0; // Update the start cluster field of directory entry. { unsigned short tmpClusHi, tmpClusLo, wordOffset; unsigned long phySec; // Byte-swap to match "PC endian" tmpClusHi = (unsigned short)((file->startClus >>16) & 0x0000FFFF); tmpClusHi = ((tmpClusHi<<8) & 0xFF00) | ((tmpClusHi>>8) & 0x00FF); tmpClusLo = (unsigned short)(file->startClus & 0x0000FFFF); tmpClusLo = ((tmpClusLo<<8) & 0xFF00) | ((tmpClusLo>>8) & 0x00FF); // Update dir entry. phySec = file->dirEntphySec; wordOffset = file->dirEntwordOffset; // start cluster low. FAT__writeWord(phySec, (unsigned short)(wordOffset + 13), &tmpClusLo, 1, pDisk); // start cluster high. FAT__writeWord(phySec, (unsigned short)(wordOffset + 10), &tmpClusHi, 1, pDisk); FAT__flush(pDisk); } } } } else if( wb == eMode ) { FAT__releaseClus(info.startClus, pDisk); file->dirEntphySec = info.phySec; file->dirEntwordOffset = info.wordOffset; usNum = FAT__findNxtAvlblClus(&clus, pDisk->maxFndClus, pDisk); if(usNum == 0) { file = NULL; } else { file->startUpdtClus = clus; file->startClus = clus; file->curClus = clus; file->preBroknClus = clus; file->nxtBroknClus = clus + usNum - 1; file->centClus = clus + usNum/2; file->curPhySec = FAT__calcPhySecOfClus(clus, pDisk); file->size = 0L; file->curSecOffsetInClus = 0; file->curWordOffsetInSec = 0; } } else if( (ab == eMode)||(r_b == eMode) ) { file->size = (info.size + 1)>>1; file->flushedSize = file->size; file->dirEntphySec = info.phySec; file->dirEntwordOffset = info.wordOffset; clus = info.startClus; file->startClus = clus; FAT__fseek(file, 0, SEEK_TAIL); clus = file->curClus; file->startUpdtClus = clus; file->centClus = clus; } else { file = NULL; } if( (file)&&((wb==eMode)||(ab==eMode)||(r_b==eMode)) ) { pDisk->wrFileNum++; } if(NULL == file) { FAT__releaseHdlID(fcpy); } return file; }

Here is the call graph for this function:

unsigned long FAT__calcPhySecOfClus (  unsigned long  clus, st_FATDISK *  pDisk )

Function returns starting physical sector of given cluster. Parameters: clus  cluster number. pDisk  Disk structure pointer. Returns: Starting physical sector number. Definition at line 748 of file fat.c. References st_FATDISK::brPhySec, st_FATDISK::dataStartSec, and st_FATDISK::secPerClus. Referenced by FAT__bfopen(), FAT__createFile(), FAT__delete(), FAT__format(), FAT__fseek(), FAT__getFrstDirEnt(), FAT__getNxtDirEnt(), FAT_copyDir(), FAT_fread(), and FAT_fwrite(). { unsigned long sec; FAT_assert( clus <= pDisk->maxClus, FAT__CALCPHYSECOFCLUS ); sec = (unsigned long)(clus - 2)*pDisk->secPerClus + pDisk->dataStartSec + pDisk->brPhySec; return sec; }

BOOL FAT__cd (  const char *  pName, st_CURWORKDIR *  pDir )

Function changes directory to specified path. Parameters: pName  Path name, search for '/' or NULL terminator. pDir  working directory. Returns: TRUE if directory successfully changed, otherwise FALSE. Definition at line 5280 of file fat.c. References DISK_C, DISK_D, FAT__cdRoot(), FAT__findFirst(), FAT__pathAppend(), FAT__pathTruncate(), FAT__strcmp(), and st_FATFILEINFO::startClus. Referenced by FAT__chg2PathDir(), FAT_cd(), and FAT_copyDir(). { long handle; st_FATFILEINFO info; // Is this root? if( '/' == *pName ) { if (pDir->pDisk == &DiskD) return FAT__cdRoot(DISK_D, pDir); else if (pDir->pDisk == &DiskC) return FAT__cdRoot(DISK_C, pDir); else return FALSE; } // Is this root? if( (':' == *(pName+1))&& ('/' == *(pName+2)) ) { if (('D' == *pName)||('d' == *pName)) return FAT__cdRoot(DISK_D, pDir); else if (('C' == *pName)||('c' == *pName)) return FAT__cdRoot(DISK_C, pDir); else return FALSE; } if(FAT__strcmp(pName, ".") == 0 ) return TRUE; if( (FAT__strcmp(pName, "..") == 0) && (pDir->bIsRoot == TRUE) ) return TRUE; handle = FAT__findFirst(pName, &info, pDir); if(handle == -1 ) return FALSE; FAT_findClose(handle); // update the data cluster number of the current working directory pDir->startClus = info.startClus; // It is root directory when startClus turns to 0 here. if( pDir->startClus == 0 ) pDir->bIsRoot = TRUE; else pDir->bIsRoot = FALSE; #ifdef _RECORD_CURWORKDIR_PATH if ( FAT__strcmp((const char *)pName, "..") == 0 ) FAT__pathTruncate(pDir->path); else FAT__pathAppend(pDir->path, (const char *)pName); #endif return TRUE; }

Here is the call graph for this function:

BOOL FAT__chg2PathDir (  const char *  pName, char **  pNext, st_CURWORKDIR *  pDir )

Function changes directory to directory part of a given path ignoring the last part, no matter it is a directory or file. For example, function will do the same thing on "dir1/dir2/file" and "dir1/dir2/dir". Parameters: pName  Path name. pNext  last part path start. pDir  working directory. Returns: TRUE if directory successfully changed and pNext points to a valid path, otherwise FALSE. Definition at line 5233 of file fat.c. References FAT__cd(), and FAT_MAXLFN. Referenced by FAT__bfopen(), FAT__mkdir(), FAT_attr(), FAT_cd(), FAT_copyDir(), FAT_delete(), FAT_frevive(), and FAT_rmdir(). { unsigned short usNum = 1; char * pC = (char *)pName; unsigned short ii = 0; if ( *pC == 0 ) return FALSE; while( (*pC != 0) && (ii < FAT_MAXLFN ) ) { if(*pC++ == '/') usNum++; ii++; } if( FAT_MAXLFN <= ii) return FALSE; pC--; if( '/' == *pC ) usNum--; if( 1 == usNum ) { *pNext = (char *)pName; return TRUE; } pC = (char *)pName; while( --usNum ) { if( FALSE == FAT__cd(pC, pDir)) return FALSE; while( '/' != *pC++ ); } *pNext = pC; return TRUE; }

Here is the call graph for this function:

unsigned long FAT__clusEntry (  unsigned long  Clus, st_FATDISK *  pDisk )

Function returns FAT cluster entry of specified cluster. Parameters: Clus  cluster number. pDisk  undocumented. Returns: FAT cluster entry. Definition at line 5114 of file fat.c. References FAT__readFatWord(), FAT__readWord(), and SYS_die(). Referenced by FAT__delete(), FAT__findNxtAvlblClus(), FAT__findNxtOcupdClus(), FAT__fseek(), FAT__getNxtDirEnt(), FAT__updateSecondCopyOfFAT(), FAT_fread(), FAT_frevive(), and FAT_fwrite(). { unsigned long entry; unsigned long sector; #ifndef _FAT_REMOVE_FAT12_SUPPORT unsigned long jj, kk = 0; #endif unsigned short offset; unsigned short usTmp; switch(pDisk->fileSysType) { #ifndef _FAT_REMOVE_FAT12_SUPPORT case FAT_12: jj = Clus + (Clus/2); // bytes sector = pDisk->brPhySec + pDisk->rsvdSecCnt + (jj/(pDisk->wordsPerLogSec<<1)); // word offset within the sector offset = (unsigned short)((jj>>1)%pDisk->wordsPerLogSec); jj = FAT__readWord(sector, offset, FALSE, pDisk); // To see if cross-sector happens. if(offset == (pDisk->wordsPerLogSec-1) ) { kk = FAT__readWord(sector+1, 0, FALSE, pDisk); } else { kk = FAT__readWord(sector, (unsigned short)(offset+1), FALSE, pDisk); } switch(Clus % 4) { case 0: entry = jj >> 4; break; case 1: entry = ((jj&0xF)<<8) | (kk>>8); break; case 2: entry = ((jj&0xFF)<<4 ) | (kk >> 12); break; case 3: entry = jj & 0xFFF; break; } break; #endif // end of _FAT_REMOVE_FAT12_SUPPORT. case FAT_16: // For FAT16, there are (Clus) words (or 2*Clus bytes) in the FAT //sector = pDisk->brPhySec + pDisk->rsvdSecCnt + // (Clus/pDisk->wordsPerLogSec); //offset = (unsigned short)(Clus%pDisk->wordsPerLogSec); sector = pDisk->brPhySec + pDisk->rsvdSecCnt + (Clus >> 8); offset = (unsigned short)(Clus&0x00ff); // The AND mask here is for safe to work around CCS bug. FAT__readFatWord(sector, offset, &usTmp, 1, TRUE, pDisk); entry = (unsigned long)usTmp; break; case FAT_32: // For FAT32, there are (2*Clus) words (or 4*Clus bytes) in the FAT //sector = pDisk->brPhySec + pDisk->rsvdSecCnt + // (long)(2*Clus/pDisk->wordsPerLogSec); //offset = (unsigned short)((unsigned long)(2*Clus)%pDisk->wordsPerLogSec); sector = pDisk->brPhySec + pDisk->rsvdSecCnt + (Clus>>7); offset = (unsigned short)((unsigned long)(Clus<<1)&0x00ff); // read 1st 2-byte of the 32-bit entry FAT__readFatWord(sector, offset, (unsigned short *)&entry, 2, TRUE, pDisk ); entry = ((entry>>16)&0x0ffff)|((entry<<16)&0x0ffff0000); break; default: if(pDisk == &DiskC) { SYS_die(FAT__CLUSENTRY_HDD); } else { SYS_die(FAT__CLUSENTRY); } } return entry; }

Here is the call graph for this function:

BOOL FAT__createFile (  const char *  pName, unsigned short  attr, unsigned long *  pPhySec, unsigned short *  pWordOffset, st_CURWORKDIR *  pDir )

Function creates directory/file under current working directory. pName should NOT contain any invalid file name characters, pName should NOT contain any trailing/prefixing spaces either. Parameters: pName  Dir/file name to be created. attr  Dir/file attribute. pPhySec  Short name dir/file entry physical sector pointer. pWordOffset  Short name dir/file entry word offset. pDir  Current workding directory. Returns: TRUE if dir/file successfully created, otherwise FALSE. Definition at line 4437 of file fat.c. References st_FATDIRSEARCH::curClus, st_FATDIRSEARCH::curEnt, st_FATDIRENT::ent, ENT_TYPE, st_FATDISK::EOC, st_FATDIRENT::ext, FAT__calcPhySecOfClus(), FAT__findNxtAvlblClus(), FAT__flush(), FAT__getFrstDirEnt(), FAT__getNxtDirEnt(), FAT__updateFAT(), st_FATDISK::fileSysType, st_FATDIRENT::lname, st_FATDISK::newStartSrchClus, st_FATDIRSEARCH::phySec, st_FATDIRSEARCH::secOffset, st_FATDISK::secPerClus, st_FATDIRENT::sname, SYS_die(), and st_FATDIRSEARCH::wordOffset. Referenced by FAT__bfopen(), and FAT__mkdir(). { unsigned short ii; char sname[9]; char ext[4]; unsigned short * pEnt; unsigned long clus = 0L; unsigned long nextAvlblClus; st_FATDISK * pDisk = pDir->pDisk; BOOL isDir; BOOL bLFN; char * pC; unsigned short numEnt; ENT_TYPE entry; st_FATDIRENT ent; st_FATDIRSEARCH ctl; st_FATDIRSEARCH startCtl; BOOL bStarted; // To work with dir ent search. BOOL ret = TRUE; bLFN = _createSname(sname, ext, pName); _check2tailSname(sname, ext, pDir); // Calculate LFN numbers. pC = (char *)pName; while((*pC != 0)&&(*pC != '/')) pC++; // Num of LFN entries plus sname entry. // NULL is part of LFN!!! // But, when LFN is exactly a multiple of 13, no NULL or padded FFFF is needed. numEnt = 1; if(bLFN == TRUE) { ii = pC-pName; while(1) { numEnt++; if(ii <= 13) break; ii -= 13; } } isDir = (attr & FAT_ATTR_DIR)? TRUE:FALSE; if(isDir == TRUE) { // If creating dir, try to allocate a cluster first. // while creating a file, we hold to the caller to allocate this. if( FAT__findNxtAvlblClus(&clus, 1, pDisk) == 0) { // No cluster available, unable to create directory. return FALSE; } // update the starting search point // make the startSrchClus point to the end of the reserved cluster //pDisk->startSrchClus = clus; //pDisk->newStartSrchClus = clus + 1; } if( ((pDisk->fileSysType != FAT_32) && (pDir->bIsRoot == FALSE)) || (pDisk->fileSysType == FAT_32) ) { // If (FAT12/16 & Not root) OR FAT32, attempt to pre-allocate a cluster, // in case cross cluster happens while updating dir entries. // No error handling here since NO-CLUSTER does not mean // error if cross-cluster does not happen. FAT__findNxtAvlblClus(&nextAvlblClus, 1, pDisk); // Rare case, FAT rewind. //if(nextAvlblClus == clus) nextAvlblClus = 0; // should never happen. if(nextAvlblClus == clus) SYS_die(FAT__CREATEFILE); // update the starting search point, do not plus 1 since this cluster may // not be used. //else pDisk->startSrchClus = nextAvlblClus+1; if(nextAvlblClus) pDisk->newStartSrchClus = nextAvlblClus; } pEnt = (unsigned short *)malloc(16 * numEnt * sizeof(unsigned short)); if(pEnt == NULL) SYS_die(FAT__CREATEFILE2); if(bLFN == TRUE) _genrtDirEnt(clus, sname, ext, pName, attr, pEnt); else _genrtDirEnt(clus, sname, ext, NULL, attr, pEnt); // Try to locate numEnt of dir entries, make sure we have enough // DELETED entries if there is any. If reach the end of dir entry, we'll // leave and let __createDirEnt funtion to check if there are enough free // entries available. // Also be careful that FAT12/16 can only support limited number of entries. ent.sname = (char *)ent.lname; ent.ext = (char *)ent.lname+9; FAT__getFrstDirEnt(&ctl, &ent, pDir); entry = ent.ent; ii = 0; bStarted = FALSE; while(entry != ENT_FREE) { if( entry == ENT_DEL ) { if(bStarted == FALSE) { startCtl = ctl; bStarted = TRUE; } if(++ii == numEnt) { ctl = startCtl; break; } } else { bStarted = FALSE; ii = 0; } if(FAT__getNxtDirEnt(&ctl, &ent) == FALSE) { // Reached the end of dir entries. if( (nextAvlblClus == 0)||( (pDir->bIsRoot==TRUE)&&(pDisk->fileSysType != FAT_32) ) ) { //certainly ERROR! no cluster left or root is full. ret = FALSE; break; } else { // Update the FAT table here. FAT__updateFAT(ctl.curClus, nextAvlblClus, 1, pDisk); FAT__updateFAT(nextAvlblClus, pDisk->EOC, 1, pDisk); // Only update this varialb here if pre-allocated cluster is used. pDisk->newStartSrchClus = nextAvlblClus + 1; ctl.curClus = nextAvlblClus; ctl.curEnt++; ctl.phySec = FAT__calcPhySecOfClus(nextAvlblClus, pDisk); // Zero out the directory entries. _clearSec(ctl.phySec, 0, pDisk->secPerClus, pDisk ); ctl.secOffset = 0; ctl.wordOffset = 0; break; } } entry = ent.ent; } // Create dir/file entry. if(ret == TRUE) { ret = _createDirEnt(&ctl, pEnt, numEnt, nextAvlblClus); // record to return short name entry position. if(pPhySec) *pPhySec = ctl.phySec; if(pWordOffset) *pWordOffset = ctl.wordOffset; } free(pEnt); if(ret == FALSE) return FALSE; // Create '.', '..' entry. if(isDir == TRUE) { if(_createDotEnt(clus, sname, ext, pEnt, pDir) == FALSE) return FALSE; // Write FAT entry of dir cluster. FAT__updateFAT(clus, pDisk->EOC, 1, pDisk); } // Flush disk after creation to make sure all write happens. return ( FAT__flush(pDisk) ); }

Here is the call graph for this function:

BOOL FAT__delete (  st_FATFILEINFO *  pInfo, st_CURWORKDIR *  pOwnerDir )

Function deletes specified file/dir under the given directory. If a directory is chosen to be deleted, it is the caller's responsiblity to make sure that the directory is empty. Parameters: pInfo  Pointer to FAT information. pOwnerDir  Dir/file's Owner working directory. Returns: TRUE if entry is successfully deleted, otherwise FALSE. Definition at line 4349 of file fat.c. References FAT__calcPhySecOfClus(), FAT__clusEntry(), FAT__readWord(), FAT__releaseClus(), FAT__writeWord(), st_FATDIRENT::numLFN, and st_FATDISK::secPerClus. Referenced by FAT_delete(). { #if 0 unsigned long entry; short ii,jj; unsigned long entbuf[256]; unsigned long * pL; #endif unsigned long clus; unsigned long sec; unsigned long secOffset; unsigned short wordOffset; unsigned short word; unsigned short numLFN; st_FATDISK * pDisk = pOwnerDir->pDisk; numLFN = pInfo->numLFN; clus = pInfo->fstLFNclus; sec = pInfo->fstLFNphySec; secOffset = pInfo->fstLFNsecOffset; wordOffset = pInfo->fstLFNwordOffset; while(1) { // Delete LFN/sname entries. FAT__readWord(sec, wordOffset, &word, 1, FALSE, pDisk); word &= 0x00FF; word |= 0xE500; FAT__writeWord(sec, wordOffset, &word, 1, pDisk); if(numLFN) { numLFN--; wordOffset += 16; if(wordOffset >= 256) { // Cross sector. wordOffset -= 256; sec++; secOffset++; if(secOffset >= pDisk->secPerClus) { // Cross cluster. secOffset = 0; if( (pOwnerDir->bIsRoot != TRUE)||(pOwnerDir->pDisk->fileSysType == FAT_32) ) { // Only look up FAT if owner is NOT root or it is FAT-32. clus = FAT__clusEntry(clus, pDisk); sec = FAT__calcPhySecOfClus(clus, pDisk); } } } } else break; } // No cluster associated with '.' and '..' entry. if( (strcmp((const char *)pInfo->lname, strDOT) == 0) || (strcmp((const char *)pInfo->lname, strDOTDOT) == 0) ) return TRUE; // Release FAT table. return FAT__releaseClus(pInfo->startClus, pDisk); }

Here is the call graph for this function:

BOOL FAT__fflush (  File *  file  )

Function flushes specified file. Parameters: file  File to be flushed. Returns: TRUE if file successfully flushed, otherwise FALSE. Definition at line 4306 of file fat.c. References st_FATDISK::EOC, FAT__updateCopyOfFAT(), and st_FATDIRENT::size. Referenced by FAT_fclose(), FAT_fread(), and FAT_fseek(). { unsigned long ulTmp1, ulTmp2; st_FATDISK * pDisk = file->pDisk; if(file->flushedSize < file->ptr) { // Update FAT table. if(file->flag & FILE_FLUSH_BROKNCLUS_PENDING) { file->flag &= ~FILE_FLUSH_BROKNCLUS_PENDING; FAT__updateCopyOfFAT(file->nxtPreBroknClus, file->preBroknClus, 1, 0, pDisk); } ulTmp1 = file->preBroknClus; ulTmp2 = file->curClus; FAT__updateCopyOfFAT( ulTmp1, ulTmp1+1,(unsigned short)(ulTmp2-ulTmp1), 0, pDisk); FAT__updateCopyOfFAT( ulTmp2, pDisk->EOC, 1, 0, pDisk); file->nxtBroknClus = ulTmp2; file->preBroknClus = ulTmp2; file->flushedSize = file->size; } file->flag &= ~FILE_FAT_FLUSH_PENDING; return TRUE; }

Here is the call graph for this function:

void FAT__findClose (  long  handle  )

Function releases find cotrol objects. Parameters: handle  FAT find object handle. Definition at line 1924 of file fat.c. References st_FATFIND::_pCtl. Referenced by FAT__findFirst(), FAT_copyDir(), and FAT_delete(). { FATfindObj[handle]._pCtl = NULL; }

long FAT__findFirst (  const char *  pName, st_FATFILEINFO *  pInfo, st_CURWORKDIR *  pDir )

Function finds the first valid dir/file under given directory. Parameters: pName  name of dir/file to be found, if NULL, find all. pInfo  dir/file info buffer. pDir  working directory. Returns: find handle that can be used by findnext(...), -1 otherwise. Definition at line 4223 of file fat.c. References st_FATFIND::_pCtl, st_FATFIND::_pEnt, st_FATDIRENT::ent, ENT_TYPE, st_FATDIRENT::ext, FAT__findClose(), FAT__getFinfo(), FAT__getFrstDirEnt(), FAT__getNxtDirEnt(), FAT__strcmp(), st_FATDIRENT::lname, st_FATDIRENT::sname, and SYS_die(). Referenced by FAT__bfopen(), FAT__cd(), FAT__mkdir(), FAT_attr(), FAT_copyDir(), FAT_delete(), FAT_findFirst(), and FAT_frevive(). { long handle = 0; st_FATDIRSEARCH * pCtl; st_FATDIRENT * pEnt; ENT_TYPE ent; while(handle < MAX_CONCURRENT_FIND) { if( FATfindObj[handle]._pCtl == NULL) break; handle++; } if(handle >= MAX_CONCURRENT_FIND) SYS_die(FAT__FINDFIRST); pCtl = FATfindObj[handle]._pCtl = &FATcontrolObj[handle]; pEnt = FATfindObj[handle]._pEnt = &FATentryObj[handle]; pEnt->sname = (char *)pEnt->lname; pEnt->ext = (char *)pEnt->lname+9; FAT__getFrstDirEnt( pCtl, pEnt, pDir ); // By now, first valid entry found. if(pName == NULL) { // Act as wildcard '*.*', return whatever was found. // Search till the valid file info found. while(1) { ent = pEnt->ent; if(ent == ENT_FREE) break; if( (ent == ENT_DIR)||(ent == ENT_FILE)||(ent== ENT_LFN) ) { FAT__getFinfo(pInfo, pCtl, pEnt); ent = pEnt->ent; if( (ent == ENT_FILE)||(ent == ENT_DIR) ) return handle; } // Locate next entry. if(FAT__getNxtDirEnt(pCtl, pEnt) == FALSE ) break; } } else { // Search till the valid file info found. while(1) { ent = pEnt->ent; if(ent == ENT_FREE) break; if( (ent == ENT_DIR)||(ent == ENT_FILE)||(ent== ENT_LFN) ) { FAT__getFinfo(pInfo, pCtl, pEnt); ent = pEnt->ent; if( (ent == ENT_FILE)||(ent == ENT_DIR) ) { if(FAT__strcmp(pName, (const char*)pInfo->lname) == 0) return handle; } } // Locate next entry. if(FAT__getNxtDirEnt(pCtl, pEnt) == FALSE ) break; } } FAT__findClose(handle); return -1L; }

Here is the call graph for this function:

BOOL FAT__findNext (  long  handle, st_FATFILEINFO *  pInfo )

Function finds next available directory or file under current workding directory. Parameters: handle  FAT find handle. pInfo  Dir/file info buffer. Returns: TRUE if dir/file found, otherwise FALSE. Definition at line 1864 of file fat.c. References st_FATFIND::_pCtl, st_FATFIND::_pEnt, st_FATDIRENT::ent, ENT_TYPE, FAT__getFinfo(), and FAT__getNxtDirEnt(). Referenced by FAT_copyDir(). { st_FATDIRSEARCH * pCtl = FATfindObj[handle]._pCtl; st_FATDIRENT * pEnt = FATfindObj[handle]._pEnt; ENT_TYPE ent; if(handle < 0) return FALSE; while(1) { // Locate next entry. if(FAT__getNxtDirEnt(pCtl, pEnt) == FALSE ) break; ent = pEnt->ent; if(ent == ENT_FREE) break; if( (ent == ENT_DIR)||(ent == ENT_FILE)||(ent== ENT_LFN) ) { FAT__getFinfo(pInfo, pCtl, pEnt); ent = pEnt->ent; if( (ent == ENT_FILE)||(ent == ENT_DIR) ) return TRUE; } } return FALSE; }

Here is the call graph for this function:

unsigned short FAT__findNxtAvlblClus (  unsigned long *  pClus, unsigned short  count, st_FATDISK *  pDisk )

Function finds next available clusters. Parameters: pClus  the beginning cluster of free consecutive clusters that have been found. count  the max number of free consecutive cluster to be found. pDisk  pointer to FAT/disk structure? (undocumented). Returns: how many free consecutive clusters have found. Definition at line 4152 of file fat.c. References FAT__clusEntry(), st_FATDISK::flag, st_FATDISK::maxClus, st_FATDISK::newStartSrchClus, and st_FATDISK::oldStartSrchClus. Referenced by FAT__bfopen(), FAT__createFile(), and FAT_fwrite(). { unsigned short usNum = 0; BOOL bStartSet = FALSE; unsigned long startClus = pDisk->newStartSrchClus; unsigned long endClus; *pClus = 0; // if haven't rollover yet, find until last cluster (maxClus) // if already rollover, find until pStart. if ( pDisk->flag & DISK_CLUS_SEARCH_ROLLOVER ) endClus = pDisk->oldStartSrchClus; else endClus = pDisk->maxClus; while(usNum < count) { if(startClus >= endClus) { // has searched to the end, still no free entry found if( (bStartSet == FALSE) && (!(pDisk->flag & DISK_CLUS_SEARCH_ROLLOVER)) ) { startClus = FAT_FIRSTCLUS; endClus = pDisk->oldStartSrchClus; pDisk->flag |= DISK_CLUS_SEARCH_ROLLOVER; } else break; // no free ones or at least one found already. } if(FAT__clusEntry(startClus, pDisk) == 0) { // cluster FAT entry = 0, the cluster is free if(bStartSet == FALSE) { *pClus = startClus; bStartSet = TRUE; } startClus++; usNum++; // count the number of free entry found } else if(bStartSet == FALSE) { // keep searching the next free entry in FAT startClus++; } else break; // Cluster broken, return. } pDisk->newStartSrchClus = startClus; return usNum; }

Here is the call graph for this function:

unsigned short FAT__findNxtOcupdClus (  unsigned long  startClus, st_FATDISK *  pDisk )

Function finds next occupied clusters from FAT. Parameters: startClus  the beginning of cluster to start searching consecutive occupied cluster. pDisk  Active disk data pointer. Returns: The occupied clusters that have been found, excluding the startClus. Definition at line 4114 of file fat.c. References st_FATDISK::EOC, FAT__clusEntry(), and st_FATDISK::maxFndClus. Referenced by FAT__bfopen(), FAT__fseek(), FAT_copyDir(), FAT_fread(), and FAT_fwrite(). { unsigned short usNum = 0; unsigned short maxFndClus = pDisk->maxFndClus; unsigned long EOC = pDisk->EOC; unsigned long clus; while(1) { clus = FAT__clusEntry(startClus, pDisk); if( (clus == 0)||(clus>=EOC) ) break; startClus++; if(clus == startClus) { usNum++; if(usNum >= maxFndClus) break; } else break; } return usNum; }

Here is the call graph for this function:

BOOL FAT__flush (  st_FATDISK *  pDisk  )

Function flushes the specified disk. Parameters: pDisk  Disk structure pointer. Returns: TRUE if successfully flushed, otherwise FALSE. update freeClusNum to Fat table * Definition at line 4046 of file fat.c. References FAT__writeWord(), st_FATDISK::flag, st_FATDISK::freeClusNum, st_FATDISK::fsInfoSec, st_FATDISK::newStartSrchClus, st_FATDISK::oldFreeClusNum, and st_FATDISK::writeSec. Referenced by FAT__bfopen(), FAT__createFile(), FAT__unmountDisk(), FAT_attr(), FAT_delete(), FAT_fclose(), FAT_flushDisk(), FAT_frevive(), and FAT_rmdir(). { unsigned short usTmp; unsigned long sec, ulTmp; BOOL ret = TRUE; if ( (FAT_32 == pDisk->fileSysType)&&(pDisk->oldFreeClusNum != pDisk->freeClusNum) ) { sec = pDisk->fsInfoSec; ulTmp = pDisk->freeClusNum; usTmp = (unsigned short)(((ulTmp & 0x000000FF)<<8)| ((ulTmp>>8) & 0x000000FF)); FAT__writeWord( sec, 488>>1, &usTmp, 1, pDisk); usTmp = (unsigned short)(((ulTmp>>8)&0x0000FF00)| ((ulTmp>>24) & 0x000000FF)); FAT__writeWord( sec, 490>>1, &usTmp, 1, pDisk); /* FSI_Nxt_Free */ ulTmp = pDisk->newStartSrchClus; usTmp = (unsigned short)(((ulTmp & 0x000000FF)<<8)| ((ulTmp>>8) & 0x000000FF)); FAT__writeWord( sec, 492>>1, &usTmp, 1, pDisk); usTmp = (unsigned short)(((ulTmp>> 8) & 0x0000FF00) | ((ulTmp>>24) & 0x000000FF)); FAT__writeWord( sec, 494>>1, &usTmp, 1, pDisk); pDisk->oldFreeClusNum = pDisk->freeClusNum; } if( pDisk->flag & DISK_FATWRITE_PENDING ) { ret = pDisk->writeSec( pDisk->curActvFatPhySec, pDisk->fatSecBuf, FALSE); pDisk->flag &= ~DISK_FATWRITE_PENDING; } if( (pDisk->flag&DISK_WRITE_PENDING) && (ret == TRUE) ) { ret = pDisk->writeSec( pDisk->curActvPhySec, pDisk->secBuf, FALSE); pDisk->flag &= ~DISK_WRITE_PENDING; } return ret; }

Here is the call graph for this function:

File* FAT__fopen (  const char *  pName, FOPEN_MODE  eMode, st_CURWORKDIR *  pDir )

Function opens the file specified by pName in a mode specified by eMode under given working directory. Functoin will NOT change the current working directory. Function will NOT open or create any directory. pName is NOT case sensitive. Parameters: pName  file name. eMode  file open mode. pDir  working directory. Returns: file pointer if successfully opened, other wise NULL. Definition at line 1495 of file fat.c. References FAT__bfopen(), and File::flag. Referenced by FAT_bfopen(), FAT_copyDir(), and FAT_fopen(). { File * file; file = (File *)malloc(sizeof(File)); if(file) { if(NULL == FAT__bfopen(pName, eMode, file, pDir)) { free(file); file = NULL; } else file->flag = FILE_OBJ_ALLOCATED; } return file; }

Here is the call graph for this function:

unsigned long FAT__freeClusNum (  DISK_ID  disk  )

Function returns the free cluster number of the specified disk. Parameters: disk  Disk ID. Returns: Free cluster number. Definition at line 3863 of file fat.c. References st_FATDISK::brPhySec, st_FATDISK::curActvPhySec, DISK_C, DiskC, FAT__readWord(), st_FATDISK::FATsz16_32, st_FATDISK::fileSysType, st_FATDISK::fsInfoSec, st_FATDISK::maxClus, st_FATDISK::readSec, st_FATDISK::rsvdSecCnt, st_FATDISK::secBuf, SYS_die(), and st_FATDISK::wordsPerLogSec. Referenced by FAT_freeSpace(). { unsigned short ii, usTmp; unsigned short * pBuf, * pBufStart; unsigned long fatStartPhySec, fatEndPhySec; unsigned long fatCurrentPhySec; unsigned long usedClusCnt = 0; st_FATDISK * pDisk; unsigned long frClus; #ifndef _FAT_REMOVE_FAT12_SUPPORT unsigned long jj, kk, entry, savedLastWord, sector; unsigned short offset; unsigned long Clus = 2; BOOL bFourBitsSaved = FALSE; #endif pDisk = (DISK_C == disk)? &DiskC : &DiskD; if ( FAT_32 == pDisk->fileSysType ) { // lookup FSInfo Sector to get disk free space FAT__readWord( pDisk->fsInfoSec, 488>>1, &usTmp, 1, TRUE, pDisk); frClus = (unsigned long)usTmp; FAT__readWord( pDisk->fsInfoSec, 490>>1, &usTmp, 1, TRUE, pDisk); frClus |= (unsigned long)usTmp << 16; if ( frClus < pDisk->maxClus ) { // if it larger than maxClus, then it has to go thru whole fat table. return frClus; } } // Start sector number of FAT itself fatStartPhySec = pDisk->brPhySec + pDisk->rsvdSecCnt; fatEndPhySec = fatStartPhySec + (pDisk->FATsz16_32) - 1; fatCurrentPhySec = fatStartPhySec; // Assuming logical sector always has a size of 512bytes. if(pDisk->wordsPerLogSec != 256) return 0xffffffff; if ( (pBufStart = (unsigned short *)malloc(pDisk->wordsPerLogSec*sizeof(short))) == NULL ) // Out of memory, fatal error. SYS_die(FAT__FREECLUSNUM); while( (fatCurrentPhySec <= fatEndPhySec) && (usedClusCnt < pDisk->maxClus) ) { pBuf = pBufStart; if( fatCurrentPhySec == pDisk->curActvPhySec) { memcpy(pBuf, pDisk->secBuf, 256); } else pDisk->readSec(fatCurrentPhySec, pBuf, FALSE); fatCurrentPhySec++; switch ( pDisk->fileSysType ) { #ifndef _FAT_REMOVE_FAT12_SUPPORT case FAT_12: // 12-bit/entry, 340 or 341 entries/sector depending on the // bits alignment. The remaining 4 or 8 bits and the 8 or 4 // bits from the 1st byte of the next sector form the // following entry. jj = Clus + (Clus/2); // bytes // word offset within the sector offset = (unsigned short)((jj>>1)%pDisk->wordsPerLogSec); while ( offset <= (pDisk->wordsPerLogSec-1) ) { jj = Clus + (Clus/2); // bytes sector = pDisk->brPhySec + pDisk->rsvdSecCnt + (jj/(pDisk->wordsPerLogSec<<1)); // word offset within the sector offset = (unsigned short)((jj>>1)%pDisk->wordsPerLogSec); jj = pBuf[offset]; // To see if cross-sector happens. if(offset == (pDisk->wordsPerLogSec-1) ) { kk = FAT__readWord(sector+1, 0, FALSE, pDisk); } else { kk = pBuf[offset+1]; } switch(Clus % 4) { case 0: entry = jj >> 4; if ( offset == (pDisk->wordsPerLogSec-1) ) { // save 4 LSBs of the last word // of the current sector. savedLastWord = jj; bFourBitsSaved = TRUE; } break; case 1: if ( (offset == 0) && (bFourBitsSaved == TRUE) ) { entry = ((savedLastWord&0x000F)<<8) | (jj&0x00FF); bFourBitsSaved = FALSE; } else { entry = ((jj&0xF)<<8) | (kk>>8); } break; case 2: entry = ((jj&0xFF)<<4 ) | (kk >> 12); break; case 3: entry = jj & 0xFFF; break; } if ( entry != 0 ) usedClusCnt++; Clus++; } break; #endif // end of _FAT_REMOVE_FAT12_SUPPORT. case FAT_16: // One word (16-bit)/entry, 256 entries/sector for ( ii = 0; ii < 256; ii++ ) { if ( *pBuf++ != 0 ) usedClusCnt++; } break; case FAT_32: // Two words (32-bit)/entry, 128 entries/sector //for ( ii = 0; ii < 256; ii+=2 ) for ( ii = 0; ii < 128; ii++ ) { //if ( ( *(pBuf+ii) != 0 ) || ( *(pBuf+ii+1) != 0 ) ) if ( ((*pBuf++)|(*pBuf++)) != 0 ) { usedClusCnt++; } } break; default: break; } } free ( pBufStart ); if (usedClusCnt > pDisk->maxClus) { // should never happen usedClusCnt = pDisk->maxClus; } return ( pDisk->maxClus - usedClusCnt ); }

Here is the call graph for this function:

BOOL FAT__fseek (  File *  file, long  len, SEEK_MODE  eMod )

Function seeks in file, assuming file is seekable. Parameters: file  File pointer. len  Seek offset. eMod  Seek mode. Returns: TRUE if successfully reset file pointer, otherwise FALSE. Definition at line 5398 of file fat.c. References FAT__calcPhySecOfClus(), FAT__clusEntry(), FAT__findNxtOcupdClus(), st_FATDISK::secPerClus, SEEK_HEAD, SEEK_MID, and SEEK_TAIL. Referenced by FAT__bfopen(), and FAT_fseek(). { st_FATDISK * pDisk = file->pDisk; unsigned long size = file->size; unsigned long ptr = file->ptr; unsigned long length; unsigned long ulTmp; switch ( eMod ) { case SEEK_HEAD: if ( (len > (long)size) || (len < 0 ) ) return FALSE; length = len; break; case SEEK_MID: if ( (((long)ptr + len) > size) || (((long)ptr + len) < 0 ) ) return FALSE; length = ptr + len; break; case SEEK_TAIL: if ( ((len + (long)size) < 0)|| (len > 0 ) ) return FALSE; length = size + len; break; default: return FALSE; } ulTmp = file->startClus; file->curClus = ulTmp; file->preBroknClus = ulTmp; file->nxtBroknClus = ulTmp; //file->nxtBroknClus = ulTmp + FAT__findNxtOcupdClus(ulTmp, pDisk); file->curPhySec = FAT__calcPhySecOfClus(ulTmp, pDisk); file->curWordOffsetInSec = 0; file->curSecOffsetInClus = 0; file->ptr = length; while(1) { if(file->curSecOffsetInClus >= pDisk->secPerClus) { // Cross cluster boundary. file->curSecOffsetInClus = 0; if(file->curClus < file->nxtBroknClus ) file->curClus++; else { ulTmp = FAT__clusEntry(file->nxtBroknClus, pDisk); if(ulTmp == 0L) return FALSE; file->curClus = ulTmp; file->preBroknClus = ulTmp; file->nxtBroknClus = ulTmp + FAT__findNxtOcupdClus(ulTmp, pDisk); file->curPhySec = FAT__calcPhySecOfClus(ulTmp, pDisk); } } if(length >= 256) { length -= 256; file->curPhySec++; file->curSecOffsetInClus++; if(length == 0) return TRUE; } else { file->curWordOffsetInSec = (unsigned short)length; return TRUE; } } }

Here is the call graph for this function:

st_CURWORKDIR* FAT__getCurWorkDir (  void   )

Function returns the current working directory of current task. Returns: Current workding directory. Definition at line 3769 of file fat.c. References SYS_die(). Referenced by FAT_attr(), FAT_bfopen(), FAT_cd(), FAT_copyDir(), FAT_delete(), FAT_findFirst(), FAT_fopen(), FAT_frevive(), FAT_mkdir(), and FAT_rmdir(). { TSK_Handle task; st_WORKDIRREG * pAvailableReg = NULL; st_WORKDIRREG * pReg = &workdirREG[0]; unsigned short ii = MAX_CONCURRENT_WORKDIR; // Don't bother me at this time. TSK_disable(); task = TSK_self(); while(ii) { if(pReg->task == task) break; if(pReg->task == NULL) pAvailableReg = pReg; pReg++; ii--; } if( 0==ii ) { if( NULL==pAvailableReg ) SYS_die(FAT__GETCURWORKDIR); else { pAvailableReg->task = task; pReg = pAvailableReg; } } TSK_enable(); return pReg->pDir; }

Here is the call graph for this function:

void FAT__getFinfo (  st_FATFILEINFO *  pInfo, st_FATDIRSEARCH *  pCtl, st_FATDIRENT *  pEnt )

Function fetches detailed file info out of directory entry. On return, pEnt->ent will be set to ENT_FILE, ENT_DIR or ENT_INVALID. Parameters: pInfo  File info buffer. pCtl  File search control buffer. pEnt  Directory entry buffer. Definition at line 3370 of file fat.c. References FAT__getNxtDirEnt(), st_FATDIRSEARCH::phySec, and st_FATDIRSEARCH::wordOffset. Referenced by FAT__findFirst(), and FAT__findNext(). { unsigned short usNum; unsigned short usLen; unsigned short usAvlbl; unsigned short ii, jj; unsigned short* pS, *pD; st_FATDIRSEARCH ctl; // Set up LFN part of info if LFN available. pInfo->numLFN = 0; pInfo->fstLFNclus = pCtl->curClus; pInfo->fstLFNsecOffset = pCtl->secOffset; pInfo->fstLFNphySec = pCtl->phySec; pInfo->fstLFNwordOffset = pCtl->wordOffset; if(pEnt->ent == ENT_LFN) { pInfo->numLFN = pEnt->numLFN; usNum = pEnt->numLFN; usLen = 13 * usNum; usAvlbl = 13; ii = pEnt->lname[12]; if( (ii != 0)&&( ii != 0xFFFF) ) { // LFN just fits the entry, manually append NULL. pInfo->lname[usLen] = 0; } else { ii = 0; pS = &pEnt->lname[12]; while( *pS-- == 0x0ffff) { usLen--; usAvlbl--; } } pS = &pEnt->lname[0]; pD = &pInfo->lname[usLen-usAvlbl]; for(jj = 0; jj< usAvlbl; jj++) *pD++ = *pS++; usLen -= usAvlbl; // Get the rest of the LFN entries. Check sum needs to checked here??? for(ii = 0; ii < usNum -1 ; ii++) { usLen -= 13; ctl = *pCtl; FAT__getNxtDirEnt(pCtl, pEnt); if(pEnt->ent != ENT_LFN) { pEnt->ent = ENT_INVALID; *pCtl = ctl; return; } pS = &pEnt->lname[0]; pD = &pInfo->lname[usLen]; for(jj = 0; jj< 13; jj++) *pD++ = *pS++; } // Get the short name entry. ctl = *pCtl; FAT__getNxtDirEnt(pCtl, pEnt); if( (pEnt->ent != ENT_FILE)&&(pEnt->ent != ENT_DIR) ) { pEnt->ent = ENT_INVALID; *pCtl = ctl; return; } } // Precess the sname entry. pInfo->phySec = pCtl->phySec; pInfo->wordOffset = pCtl->wordOffset; strcpy(pInfo->sname, pEnt->sname); strcpy(pInfo->ext, pEnt->ext); if(pInfo->numLFN == 0) { _concatSnameExt((char *)pInfo->lname, pInfo->sname, pInfo->ext); } pInfo->attr = pEnt->attr; pInfo->size = pEnt->size; pInfo->startClus = pEnt->startClus; }

Here is the call graph for this function:

void FAT__getFrstDirEnt (  st_FATDIRSEARCH *  pCtl, st_FATDIRENT *  pEnt, st_CURWORKDIR *  pDir )

Function fetches the first directory entry under current working directory. Parameters: pCtl  Directory search control buffer. pEnt  Directory entry buffer. pDir  Current working directory. Definition at line 3502 of file fat.c. References st_FATDISK::brPhySec, FAT__calcPhySecOfClus(), FAT__intprtDirEnt(), FAT__readWord(), st_FATDISK::fileSysType, st_FATDIRSEARCH::pDisk, st_FATDISK::rootDirCluster, and st_FATDISK::rootDirSec. Referenced by FAT__createFile(), and FAT__findFirst(). { unsigned long sec; st_FATDISK * pDisk = pDir->pDisk; unsigned short buf[16]; // Dir entry buffer, 32 bytes. if ( TRUE == pDir->bIsRoot ) { if ( pDisk->fileSysType != FAT_32 ) { sec = pDisk->rootDirSec + pDisk->brPhySec; pCtl->curClus = 0; } else { sec = FAT__calcPhySecOfClus( pDisk->rootDirCluster, pDisk ); pCtl->curClus = pDisk->rootDirCluster; } } else { sec = FAT__calcPhySecOfClus(pDir->startClus, pDisk); pCtl->curClus = pDir->startClus; } pCtl->pDisk = pDisk; pCtl->curEnt = 1; pCtl->phySec = sec; pCtl->secOffset = 0; pCtl->wordOffset = 0; FAT__readWord(sec, 0, buf, 16, TRUE, pDisk); FAT__intprtDirEnt(buf, pEnt, pDisk); }

Here is the call graph for this function:

BOOL FAT__getNxtDirEnt (  st_FATDIRSEARCH *  pCtl, st_FATDIRENT *  pEnt )

Function fetches the next directory entry under current working directory. Parameters: pCtl  Directory search control buffer. pEnt  Directory entry buffer. Returns: TRUE if entry found, otherwise FALSE. Definition at line 3551 of file fat.c. References st_FATDISK::EOC, FAT__calcPhySecOfClus(), FAT__clusEntry(), FAT__intprtDirEnt(), FAT__readWord(), and st_FATDISK::secPerClus. Referenced by FAT__createFile(), FAT__findFirst(), FAT__findNext(), and FAT__getFinfo(). { unsigned long clus; st_FATDISK * pDisk = pCtl->pDisk; unsigned short buf[16]; pCtl->wordOffset += 16; pCtl->curEnt++; if(pCtl->wordOffset >= 256) { // Cross sector. pCtl->wordOffset = 0; pCtl->secOffset += 1; pCtl->phySec += 1; if(pCtl->secOffset >= pDisk->secPerClus) { pCtl->secOffset = 0; if(pCtl->curClus != 0) { // Cross cluster boundary. clus = FAT__clusEntry(pCtl->curClus, pDisk); if( clus >= pDisk->EOC) return FALSE; pCtl->curClus = clus; pCtl->phySec = FAT__calcPhySecOfClus(clus, pDisk); } else { // FAT12/16 support, rootclus = 0. if(pCtl->curEnt > pCtl->pDisk->rootEntCnt) return FALSE; } } } FAT__readWord( pCtl->phySec, pCtl->wordOffset, buf, 16, TRUE, pDisk); FAT__intprtDirEnt(buf, pEnt, pDisk); return TRUE; }

Here is the call graph for this function:

void FAT__intprtDirEnt (  const unsigned short *  pBuf, st_FATDIRENT *  pEnt, st_FATDISK *  pDisk )

Function interpretes the directory entry. NOTE: Robust code needs to be added here to automatically delete the invalid diretory entry. Parameters: pBuf  Directory entry data buffer. pEnt  Directory entry. pDisk  pointer to FAT/disk structure? (undocumented). Definition at line 3609 of file fat.c. References st_FATDIRENT::attr, st_FATDIRENT::ent, ENT_DIR, ENT_FILE, ENT_LFN, ENT_VOL, st_FATDIRENT::numLFN, and st_FATDIRENT::startClus. Referenced by FAT__getFrstDirEnt(), and FAT__getNxtDirEnt(). { unsigned short attr; switch( (*pBuf) & 0xFF) { case 0x00: // free entry. pEnt->ent = ENT_FREE; return; case 0xE5: // deleted entry. pEnt->ent = ENT_DEL; return; #if 0 case 0x05: // 0xE5 character. break; default: // not a free/deleted entry break; #endif } // found a none free entry, not deleted either, further process needed. attr = pBuf[5] >> 8;// little endian. pEnt->attr = attr; pEnt->numLFN = 0; if( (attr & FAT_LFN_MASK) == FAT_ATTR_LFN) { pEnt->ent = (TRUE == _fetchLFN(pBuf, pEnt))? ENT_LFN:ENT_INVALID; } else if( (attr & ( FAT_ATTR_DIR|FAT_ATTR_VOLUME)) == 0 ) { pEnt->ent = ( (TRUE == _fetchDir(pBuf, pEnt))&&(pEnt->startClus <= pDisk->maxClus))? ENT_FILE:ENT_INVALID; } else if( (attr & ( FAT_ATTR_DIR|FAT_ATTR_VOLUME)) == FAT_ATTR_DIR ) { pEnt->ent = ( (TRUE == _fetchDir(pBuf, pEnt))&&(pEnt->startClus <= pDisk->maxClus))? ENT_DIR:ENT_INVALID; } else if( (attr & ( FAT_ATTR_DIR|FAT_ATTR_VOLUME)) == FAT_ATTR_VOLUME ) { pEnt->ent = (TRUE == _fetchVolume(pBuf, pEnt))? ENT_VOL:ENT_INVALID; } else pEnt->ent = ENT_INVALID; }

BOOL FAT__isSnameChar (  char  Ch  )

Function checks to see if character is valid for short file name, following MS standard. Function is called to generate short name, thus ' ' and '.' are not counted as valid character. Parameters: Ch  character. Returns: TRUE if it is valid short name character, otherwise FALSE. Definition at line 3333 of file fat.c. { if( Ch & 0x80 ) return TRUE; /* > 127 */ if( (Ch < '#' )&&( Ch != '!') ) return FALSE; if( Ch < '*' ) return TRUE; if( (Ch <'0') && ( Ch != '-') ) return FALSE; if( Ch < ':' ) return TRUE; if( Ch < '@' ) return FALSE; if( Ch < '[' ) return TRUE; if( Ch < '^') return FALSE; if( Ch < '|' ) return TRUE; if( (Ch != '}')&&(Ch != '~') ) return FALSE; return TRUE; }

BOOL FAT__mkdir (  const char *  pDirName, st_CURWORKDIR *  pDir )

Function creates directory under given working directory if not exists already. Root directory can NOT be created by definition. Function does not translate path delimiters, which means only one directory can be created per call. No character validity function here, it is the caller's responsibility to make sure pDirName points to valid dir name. Parameters: pDirName  Directory name. pDir  Actual working directory? (undocumented). Returns: TRUE if directory successfully created, otherwise FALSE. Definition at line 522 of file fat.c. References FAT__chg2PathDir(), FAT__createFile(), and FAT__findFirst(). Referenced by FAT_copyDir(), and FAT_mkdir(). { long handle; char * pNext; st_FATFILEINFO info; if(FAT__chg2PathDir(pDirName, &pNext, pDir) == FALSE) return FALSE; handle = FAT__findFirst(pNext, &info, pDir); if(handle != -1) { FAT_findClose(handle); return TRUE; } return(FAT__createFile((const char *)pNext, FAT_ATTR_DIR, NULL, NULL, pDir)); }

Here is the call graph for this function:

void FAT__pathAppend (  char *  path, const char *  pName )

Function appends a name string to path. Parameters: path  working direcotry path. pName  name string. Definition at line 2495 of file fat.c. Referenced by FAT__cd(). { unsigned short usLen; usLen = strlen(path); path += usLen; while( (usLen < FAT_MAXLFN)&&(*pName != '/')&&(*pName != 0) ) { *path++ = *pName++; } *path++ = '/'; *path = 0; }

void FAT__pathTruncate (  char *  path  )

Function truncate current path and go up once. Parameters: path  working direcotry path. Definition at line 2468 of file fat.c. Referenced by FAT__cd(). { unsigned short usLen; usLen = strlen(path) - 1; path += usLen; while(usLen--) { path--; if(*path == '/') { *(path+1) = 0; break; } } }

BOOL FAT__readFatWord (  unsigned long  ulPhySec, unsigned short  usWordOffset, unsigned short *  pWord, unsigned short  wordNum, BOOL  bByteSwap, st_FATDISK *  pDisk )

Function reads back a word from FAT area. It is the caller's responsibility to make sure words do not cross sector boundary. Parameters: ulPhySec  physical sector number. usWordOffset  word offset in sector. pWord  Word buffer. wordNum  Number of words to read. bByteSwap  TRUE if high-low byte is swapped. pDisk  drive global data structure pointer. Returns: TRUE if words successuflly read, otherwise FALSE. Definition at line 3047 of file fat.c. References st_FATDISK::curActvFatPhySec, st_FATDISK::fatSecBuf, st_FATDISK::flag, st_FATDISK::readSec, and st_FATDISK::writeSec. Referenced by FAT__clusEntry(). { unsigned short * pBuf = (unsigned short *) &pDisk->fatSecBuf[0]; FAT_assert(ulPhySec < pDisk->totalSec16_32, FAT__READFATWORD); FAT_lock(pDisk->lock2); if(ulPhySec != pDisk->curActvFatPhySec) { if(pDisk->flag&DISK_FATWRITE_PENDING) { pDisk->writeSec(pDisk->curActvFatPhySec, pDisk->fatSecBuf, FALSE); pDisk->flag &= ~DISK_FATWRITE_PENDING; } pDisk->readSec(ulPhySec, pBuf, FALSE); pDisk->curActvFatPhySec = ulPhySec; } pBuf += usWordOffset; if( FALSE == bByteSwap) while(wordNum--) *pWord++ = *pBuf++; else { while(wordNum--) { *pWord = (*pBuf<<8) | ( ((*pBuf)>>8)&0x00ff ); pWord++; pBuf++; } } FAT_unlock(pDisk->lock2); return TRUE; }

BOOL FAT__readWord (  unsigned long  ulPhySec, unsigned short  usWordOffset, unsigned short *  pWord, unsigned short  wordNum, BOOL  bByteSwap, st_FATDISK *  pDisk )

Function reads back words from data area. It is the caller's responsibility to make sure words do not cross sector boundary. Parameters: ulPhySec  physical sector number. usWordOffset  word offset in sector. pWord  Word buffer. wordNum  Number of words to read. bByteSwap  TRUE if high-low byte is swapped. pDisk  drive global data structure pointer. Returns: TRUE if words successuflly read, otherwise FALSE. Definition at line 2935 of file fat.c. References st_FATDISK::curActvPhySec, st_FATDISK::flag, st_FATDISK::readSec, st_FATDISK::secBuf, and st_FATDISK::writeSec. Referenced by FAT__clusEntry(), FAT__delete(), FAT__freeClusNum(), FAT__getFrstDirEnt(), FAT__getNxtDirEnt(), FAT__globalsInit(), FAT_attr(), and FAT_fread(). { unsigned short * pBuf = (unsigned short *) &pDisk->secBuf[0]; //FAT_assert(ulPhySec < pDisk->totalSec16_32, FAT__READWORD); FAT_lock(pDisk->lock); if(ulPhySec != pDisk->curActvPhySec) { if(pDisk->flag&DISK_WRITE_PENDING) { pDisk->writeSec(pDisk->curActvPhySec, pDisk->secBuf, FALSE); pDisk->flag &= ~DISK_WRITE_PENDING; } pDisk->readSec(ulPhySec, pBuf, FALSE); pDisk->curActvPhySec = ulPhySec; } pBuf += usWordOffset; if( FALSE == bByteSwap) while(wordNum--) *pWord++ = *pBuf++; else { while(wordNum--) { *pWord = (*pBuf<<8) | ( ((*pBuf)>>8)&0x00ff ); pWord++; pBuf++; } } FAT_unlock(pDisk->lock); return TRUE; }

BOOL FAT__releaseClus (  unsigned long  startClus, st_FATDISK *  pDisk )

Function releases the cluster linklist. Parameters: startClus  Start cluster. pDisk  Disk data pointer. Returns: TRUE if list is successfully released, otherwise FALSE. Definition at line 3151 of file fat.c. References st_FATDISK::brPhySec, st_FATDISK::curActvFatPhySec, st_FATDISK::fatSecBuf, st_FATDISK::flag, st_FATDISK::freeClusNum, st_FATDISK::readSec, st_FATDISK::rsvdSecCnt, and st_FATDISK::writeSec. Referenced by FAT__bfopen(), and FAT__delete(). { unsigned short copy, offset; unsigned short* pD; unsigned short* pBuf; unsigned short* pEndBuf; unsigned long entry, clus = startClus; unsigned long actvFatSec; unsigned long sector; unsigned long fatSecOffset; FAT_lock(pDisk->lock2); pBuf = pDisk->fatSecBuf; pEndBuf = pBuf + 256; actvFatSec = pDisk->curActvFatPhySec; for( copy = 0; copy < pDisk->numFATs; copy++ ) { startClus = clus; fatSecOffset = (unsigned short)(copy*pDisk->FATsz16_32) + pDisk->brPhySec + pDisk->rsvdSecCnt; #ifndef _FAT_REMOVE_FAT12_SUPPORT if( FAT_12 == pDisk->fileSysType ) { } else #endif if( FAT_16 == pDisk->fileSysType ) { // For FAT16, there are (1*clus) words (or 2*clus bytes) in each FAT entry // sector += (FAT_curDir.pDisk->brPhySec + // FAT_curDir.pDisk->rsvdSecCnt + // (clus/FAT_curDir.pDisk->wordsPerLogSec) ); // Following to optimize, assuming sector size fixed to 512bytes. sector = fatSecOffset + (startClus>>8); //offset = (unsigned short)(clus%FAT_curDir.pDisk->wordsPerLogSec); offset = (unsigned short)(startClus & 0x00FF); if(sector != actvFatSec) { if(pDisk->flag&DISK_FATWRITE_PENDING) pDisk->writeSec(actvFatSec, pBuf, FALSE); pDisk->readSec(sector, pBuf, FALSE); } pD = pBuf + offset; entry = (*pD>>8)|(*pD<<8); while(1) { *pD++ = 0; // if ent is zero, meaning one cluster is free now, freeClusNum plus one. // otherwise, one cluster is taken, freeClusNum minus one. if ( copy == 0 ) { pDisk->freeClusNum++; } if( entry == startClus+1 ) { if(pD == pEndBuf) { pDisk->writeSec(sector++, pBuf, FALSE); pDisk->readSec(sector, pBuf, FALSE); pD = pBuf; } } else { if( (entry >= pDisk->EOC)||(entry == 0) ) { actvFatSec = sector; pDisk->curActvFatPhySec = sector; pDisk->flag |= DISK_FATWRITE_PENDING; break; } pDisk->writeSec(sector, pBuf, FALSE); actvFatSec = sector; sector = fatSecOffset + (entry>>8); offset = entry & 0x0ff; pD = pBuf + offset; if( sector != actvFatSec ) pDisk->readSec(sector, pBuf, FALSE); } startClus = entry; entry = (*pD>>8)|(*pD<<8); } } else if( FAT_32 == pDisk->fileSysType ) { // For FAT32, there are (2*clus) words (or 4*clus bytes) in each FAT entry // sector += (FAT_curDir.pDisk->brPhySec + // FAT_curDir.pDisk->rsvdSecCnt + // (2*clus/FAT_curDir.pDisk->wordsPerLogSec) ); sector = fatSecOffset + (startClus>>7); //offset = (unsigned short)(2*clus% // FAT_curDir.pDisk->wordsPerLogSec); offset = (unsigned short)((startClus<<1)&0x00FF); if(sector != actvFatSec) { if(pDisk->flag&DISK_FATWRITE_PENDING) pDisk->writeSec(actvFatSec, pBuf, FALSE); pDisk->readSec(sector, pBuf, FALSE); } pD = pBuf + offset; entry = (*pD>>8)|(*pD<<8); pD++; entry |= (unsigned long)((*pD>>8)|(*pD<<8))<<16; while(1) { *pD-- = 0; *pD = 0; pD += 2; // if ent is zero, meaning one cluster is free now, freeClusNum plus one. // otherwise, one cluster is taken, freeClusNum minus one. if ( copy == 0 ) { pDisk->freeClusNum++; } if( entry == startClus+1 ) { if(pD == pEndBuf) { pDisk->writeSec(sector++, pBuf, FALSE); pDisk->readSec(sector, pBuf, FALSE); pD = pBuf; } } else { if( (entry >= pDisk->EOC)||(entry == 0) ) { actvFatSec = sector; pDisk->curActvFatPhySec = sector; pDisk->flag |= DISK_FATWRITE_PENDING; break; } pDisk->writeSec(sector, pBuf, FALSE); actvFatSec = sector; sector = fatSecOffset + (entry>>7); offset = (unsigned short)((entry<<1)&0x00FF);; pD = pBuf + offset; if( sector != actvFatSec ) pDisk->readSec(sector, pBuf, FALSE); } startClus = entry; entry = (*pD>>8)|(*pD<<8); pD++; entry |= (unsigned long)((*pD>>8)|(*pD<<8))<<16; } } } FAT_unlock(pDisk->lock2); return TRUE; }

int FAT__strcmp (  const char *  str1, const char *  str2 )

Function carries out special FAT string comparation, it checks the '/' or NULL as the string terminator and compares at upper case. Parameters: str1  string 1. str2  string 2. Returns: 0 If str1 is equal to str2, nonzero otherwise. Definition at line 2899 of file fat.c. Referenced by FAT__cd(), and FAT__findFirst(). { FAT_assert((unsigned short)str1&&(unsigned short)str2, FAT__STRCMP); do { if( toupper(*str1) != toupper(*str2) ) return 1; str1++; str2++; } while( (*str1 != 0)&&(*str1 != '/') ); if( (*str2 != 0)&&(*str2 != '/') ) return 1; return 0; }

BOOL FAT__unmountDisk (  DISK_ID  disk  )

Function unmounts disk to flush. Parameters: disk  Disk specifier. Returns: TRUE if successfully unmounted, otherwise FALSE. Definition at line 2867 of file fat.c. References DISK_C, DISK_D, FAT__flush(), HDD_unmount(), and NAND_unmount(). Referenced by FAT_format(). { st_FATDISK * pDisk; if( DISK_C == disk) { pDisk = &DiskC; } else if( DISK_D == disk ) { pDisk = &DiskD; } else return FALSE; FAT__flush(pDisk); if(DISK_C == disk) return HDD_unmount(); else return NAND_unmount(); }

Here is the call graph for this function:

BOOL FAT__updateCopyOfFAT (  unsigned long  clus, unsigned long  ent, unsigned short  num, unsigned short  copy, st_FATDISK *  pDisk )

Function updates specified copy of FAT. Parameters: clus  cluster number. ent  cluster entry. num  Contiguous number of entry. copy  FAT copy number. pDisk  Disk structure pointer. Returns: TRUE if FAT successfully updated, otherwise FALSE. Definition at line 2560 of file fat.c. Referenced by FAT__fflush(), FAT__updateFAT(), FAT__updateSecondCopyOfFAT(), FAT_fclose(), FAT_frevive(), and FAT_fwrite(). { unsigned long sector; unsigned long fatSecOffset; unsigned long actvFatSec; unsigned short* pD; unsigned short* pEndBuf; unsigned short* pBuf; unsigned short offset; if( 0 == num ) return TRUE; FAT_lock(pDisk->lock2); fatSecOffset = (unsigned short)(copy*pDisk->FATsz16_32); // Following to optimize, but only support TWO copies of FAT. //fatSecOffset = (copy)? FAT_curDir.pDisk->FATsz16_32 : 0; pBuf = pDisk->fatSecBuf; pEndBuf = pBuf + 256; actvFatSec = pDisk->curActvFatPhySec; #ifndef _FAT_REMOVE_FAT12_SUPPORT if( FAT_12 == pDisk->fileSysType ) { } else #endif if( FAT_16 == pDisk->fileSysType ) { // For FAT16, there are (1*clus) words (or 2*clus bytes) in each FAT entry // sector += (FAT_curDir.pDisk->brPhySec + // FAT_curDir.pDisk->rsvdSecCnt + // (clus/FAT_curDir.pDisk->wordsPerLogSec) ); // Following to optimize, assuming sector size fixed to 512bytes. sector = fatSecOffset + (pDisk->brPhySec + pDisk->rsvdSecCnt + (clus>>8) ); //offset = (unsigned short)(clus%FAT_curDir.pDisk->wordsPerLogSec); offset = (unsigned short)(clus & 0x00FF); if(sector != actvFatSec) { if(pDisk->flag&DISK_FATWRITE_PENDING) pDisk->writeSec(actvFatSec, pBuf, FALSE); pDisk->readSec(sector, pBuf, FALSE); } if( copy == 0 ) pDisk->freeClusNum -= num; while(num) { pD = pBuf + offset; while(pD < pEndBuf) { *pD++ = ((ent & 0x000000FFL)<<8)|((ent & 0x0000FF00L)>>8); offset++; num--; if( 0 == num ) break; ent++; } if( pD == pEndBuf) { pDisk->writeSec(sector, pBuf, FALSE); if( num ) { sector++; pDisk->readSec(sector, pBuf, FALSE); } offset = 0; } } } else if( FAT_32 == pDisk->fileSysType ) { // For FAT32, there are (2*clus) words (or 4*clus bytes) in each FAT entry // sector += (FAT_curDir.pDisk->brPhySec + // FAT_curDir.pDisk->rsvdSecCnt + // (2*clus/FAT_curDir.pDisk->wordsPerLogSec) ); sector = fatSecOffset + (pDisk->brPhySec + pDisk->rsvdSecCnt + (clus>>7) ); //offset = (unsigned short)(2*clus% // FAT_curDir.pDisk->wordsPerLogSec); offset = (unsigned short)((clus<<1)&0x00FF); if(sector != actvFatSec) { if(pDisk->flag&DISK_FATWRITE_PENDING) pDisk->writeSec(actvFatSec, pBuf, FALSE); pDisk->readSec(sector, pBuf, FALSE); } if( copy == 0 ) pDisk->freeClusNum -= num; while(num) { pD = pBuf + offset; while(pD < pEndBuf) { *pD++ = ((ent & 0x000000FFL)<<8)|((ent & 0x0000FF00L)>>8); *pD++ = ((ent>>8) & 0x0000FF00L)|((ent>>24) & 0x000000FFL); offset+= 2; num--; if( 0 == num ) break; ent++; } if( pD == pEndBuf) { pDisk->writeSec(sector, pBuf, FALSE); if( num ) { sector++; pDisk->readSec(sector, pBuf, FALSE); } offset = 0; } } } pDisk->curActvFatPhySec = sector; if(offset) pDisk->flag |= DISK_FATWRITE_PENDING; else pDisk->flag &= ~DISK_FATWRITE_PENDING; FAT_unlock(pDisk->lock2); return TRUE; }

BOOL FAT__updateFAT (  unsigned long  clus, unsigned long  ent, unsigned short  num, st_FATDISK *  pDisk )

Function updates both copies of FAT. Parameters: clus  cluster number. ent  cluster entry. num  Contiguous number of entry. pDisk  Disk structure pointer. Returns: TRUE if FAT successfully updated, otherwise FALSE. Definition at line 2527 of file fat.c. References FAT__updateCopyOfFAT(). Referenced by FAT__createFile(), and FAT__format(). { unsigned short ii; for(ii=0; ii<pDisk->numFATs; ii++) { FAT__updateCopyOfFAT(clus, ent, num, ii, pDisk); } return TRUE; }

Here is the call graph for this function:

BOOL FAT__updateSecondCopyOfFAT (  unsigned long  startClus, st_FATDISK *  pDisk )

Function updates the second copy of FAT based on FAT entry in first copy. Parameters: startClus  Start cluster. pDisk  Disk data pointer. Returns: TRUE if second copy FAT is successfully updated, otherwise FALSE. Definition at line 2713 of file fat.c. References FAT__clusEntry(), and FAT__updateCopyOfFAT(). Referenced by FAT_fclose(), and FAT_frevive(). { unsigned long EOC = pDisk->EOC; unsigned long entry; unsigned long startUpdtClus; unsigned short contiguousClusNum; unsigned short kk; unsigned short numFATs = pDisk->numFATs; startUpdtClus = startClus; contiguousClusNum = 0; while(1) { entry = FAT__clusEntry(startClus, pDisk); if((entry == startClus)||(entry == 0)) { // Unexpected error, simply return; // entry == startClus, cluster cross-linked. // entry == 0, cluster chain has to be ended by EOC. return FALSE; } if( (entry != startClus+1)&&(contiguousClusNum != 0xffff) ) { for( kk = 1; kk < numFATs; kk++ ) { FAT__updateCopyOfFAT(startUpdtClus, startUpdtClus+1, contiguousClusNum, kk, pDisk); FAT__updateCopyOfFAT(startClus, entry, 1, kk, pDisk); } if( entry >= EOC ) break; startUpdtClus = entry; contiguousClusNum = 0; } else { contiguousClusNum++; } startClus = entry; } return TRUE; }

Here is the call graph for this function:

BOOL FAT__writeWord (  unsigned long  ulPhySec, unsigned short  usWordOffset, unsigned short *  pWord, unsigned short  wordNum, st_FATDISK *  pDisk )

Function writes a word to data area. It is the caller's responsibility to make sure words do not cross sector boundary. Parameters: ulPhySec  physical sector number. usWordOffset  word offset in sector. pWord  Word buffer. wordNum  Number of words to write. pDisk  drive global data structure pointer. Returns: TRUE if successfully written, otherwise FALSE. Definition at line 2995 of file fat.c. References st_FATDISK::curActvPhySec, st_FATDISK::flag, st_FATDISK::readSec, st_FATDISK::secBuf, and st_FATDISK::writeSec. Referenced by FAT__bfopen(), FAT__delete(), FAT__flush(), FAT_attr(), FAT_fclose(), FAT_frevive(), and FAT_fwrite(). { unsigned short * pBuf = (unsigned short *) &pDisk->secBuf[0]; FAT_assert(ulPhySec < pDisk->totalSec16_32, FAT__WRITEWORD); FAT_assert(usWordOffset <= 256, FAT__WRITEWORD2 ); FAT_lock(pDisk->lock); if(ulPhySec != pDisk->curActvPhySec) { if(pDisk->flag&DISK_WRITE_PENDING) pDisk->writeSec(pDisk->curActvPhySec, pDisk->secBuf, FALSE); pDisk->readSec(ulPhySec, pBuf, FALSE); pDisk->curActvPhySec = ulPhySec; } pBuf += usWordOffset; while(wordNum--) *pBuf++ = *pWord++; pDisk->flag |= DISK_WRITE_PENDING; FAT_unlock(pDisk->lock); return TRUE; }

BOOL FAT_attr (  const char *  pName, unsigned short  attr )

Function changes attribute of the specified file/directory. Parameters: pName  Dir/file name. attr  Target attributes. Returns: TRUE if attributes successfully changed, otherwise FALSE. Definition at line 2423 of file fat.c. References FAT__chg2PathDir(), FAT__findFirst(), FAT__flush(), FAT__getCurWorkDir(), FAT__readWord(), FAT__writeWord(), st_CURWORKDIR::pDisk, st_FATFILEINFO::phySec, and st_FATFILEINFO::wordOffset. { long handle; unsigned long sec; unsigned short offset, word; st_FATDISK * pDisk; char * pNext; st_CURWORKDIR * pDir = FAT__getCurWorkDir(); st_CURWORKDIR dir; st_FATFILEINFO info; dir = *pDir; if(FAT__chg2PathDir(pName, &pNext, &dir) == FALSE) return FALSE; handle = FAT__findFirst(pNext, &info, &dir); if(handle == -1) return FALSE; else { FAT_findClose(handle); pDisk = dir.pDisk; sec = info.phySec; offset = info.wordOffset+5; FAT__readWord(sec, offset, &word, 1, FALSE, pDisk); word &= 0xFF00; word |= attr; FAT__writeWord(sec, offset, &word, 1, pDisk); } return FAT__flush(dir.pDisk); }

Here is the call graph for this function:

File* FAT_bfopen (  const char *  pName, FOPEN_MODE  eMode, File *  file )

Function opens the file with supplied file object buffer. Parameters: pName  file name. eMode  file open mode. file  file object pointer, if NULL, operation is the same as that of FAT_fopen. Returns: file pointer if successfully opened, other wise NULL. Definition at line 1380 of file fat.c. References FAT__bfopen(), FAT__fopen(), and FAT__getCurWorkDir(). Referenced by UI_m3uOpen(), UI_playQprevious(), and UI_setupPlayQ(). { st_CURWORKDIR * pDir = FAT__getCurWorkDir(); st_CURWORKDIR dir; dir = *pDir; if(file) { file->flag = 0; return FAT__bfopen(pName, eMode, file, &dir); } return FAT__fopen(pName, eMode, &dir); }

Here is the call graph for this function:

BOOL FAT_cd (  const char *  pName  )

Function changes current workding directory to specified path. Directory name MUST take the following format: "DRIVE:/XDIR/YDIR/" "/XDIR/YDIR/" "XDIR/YDIR/" the tailing '/' character is OPTIONAL. pName is NOT case sensitive. Parameters: pName  Path name. Returns: TRUE if directory successfully changed, otherwise FALSE. Definition at line 2399 of file fat.c. References FAT__cd(), FAT__chg2PathDir(), and FAT__getCurWorkDir(). Referenced by DB__cdDBdir(), DB_checkSyncMark(), DB_creator(), DB_setSyncMark(), EAR_getFirst(), EAR_init(), SYS_regist(), SYS_serialNumber(), UI_m3uClear(), UI_m3uInit(), UI_m3uOpen(), UI_pendingEarDiskSpace(), UI_processEAR(), and UI_rdSynclog(). { char * pNext; st_CURWORKDIR * pDir = FAT__getCurWorkDir(); if(FAT__chg2PathDir(pName, &pNext, pDir) == FALSE) return FALSE; return FAT__cd(pNext, pDir); }

Here is the call graph for this function:

BOOL FAT_copyDir (  const char *  srcDir, const char *  dstDir, USHORT *  cpybuf, USHORT  buflen )

Copy all files in srcDir to dstDir. NOTE that this function recursively copy the subdirectory to dstDir. If directory name does not contain drive letter, directory shall be relative to current working directory. If dstDir is NULL, copy source dirctory to current working directory. The current directory will be dstdir after the copying is done. NOTE that the dstDir doesn't include the destination directory name, for example FAT_copyDir( "c:/woid", "d:/" ); This will create D:/woid, if d:/ alread has woid directory it will go to that dir, then copy all content to d:/woid. FAT_copyDir( "c:/woid", "d:/woid" ) meaning copy content of c:/woid to d:/woid/woid. NOTE that the source directory must be different from the target directory. This function doesn't handle this case. For example, FAT_copyDir( "c:/woid", "c:/"); // wrong, same directory!! NOTE that the srcDir can NOT be root directory. This will be fixed in near future. This function uses stack to copy directory recursivly, so be careful, don't copy a directory which has too many sub-dir Parameters: srcDir  Source directory name. dstDir  Destination directory name. cpybuf  Supplied copy buffer if not NULL. buflen  Supplied copy buffer length. Returns: TRUE if successfully copied, otherwise FALSE. Definition at line 2223 of file fat.c. References st_FATFILEINFO::attr, st_CURWORKDIR::bIsRoot, File::curClus, File::curPhySec, File::curSecOffsetInClus, File::curWordOffsetInSec, FAT__calcPhySecOfClus(), FAT__cd(), FAT__chg2PathDir(), FAT__findClose(), FAT__findFirst(), FAT__findNext(), FAT__findNxtOcupdClus(), FAT__fopen(), FAT__getCurWorkDir(), FAT__mkdir(), FAT_fclose(), FAT_fread(), FAT_fwrite(), File::flag, File::flushedSize, File::hdlID, st_FATFILEINFO::lname, File::mode, File::nxtBroknClus, File::pDisk, st_CURWORKDIR::pDisk, File::preBroknClus, File::ptr, st_FATFILEINFO::size, File::size, File::startClus, st_FATFILEINFO::startClus, st_CURWORKDIR::startClus, and wb. { char * pSrcNext; char * pDstNext; File * dstFP; File * srcFP; st_FATDISK * pDisk; USHORT len; USHORT usNum; USHORT oldRoundCounter; USHORT newRoundCounter; ULONG clus; long handle; unsigned long srcClus; BOOL bSrcIsRoot; BOOL bDirFound = TRUE; BOOL bSecondRound = FALSE; st_FATFILEINFO info; USHORT localbuf[COPY_BUF_LEN]; USHORT * buf; st_CURWORKDIR srcWorkDir; st_CURWORKDIR dstWorkDir; srcWorkDir = *FAT__getCurWorkDir(); dstWorkDir = srcWorkDir; if(buflen&&cpybuf) buf = cpybuf; else { buflen = COPY_BUF_LEN; buf = localbuf; } FAT_assert(srcDir&&dstDir, FAT_COPYDIR); if(FAT__chg2PathDir(srcDir, &pSrcNext, &srcWorkDir) == FALSE) return FALSE; if(FAT__chg2PathDir(dstDir, &pDstNext, &dstWorkDir) == FALSE) return FALSE; // Let's remember where current directory starts and if it is the ROOT. srcClus = srcWorkDir.startClus; bSrcIsRoot = srcWorkDir.bIsRoot; // Directory does not exist, report error. if(FAT__cd(pSrcNext, &srcWorkDir) == FALSE) return FALSE; if(FAT__cd(pDstNext, &dstWorkDir) == FALSE) return FALSE; FAT__mkdir(pSrcNext, &dstWorkDir); FAT__cd(pSrcNext, &dstWorkDir); oldRoundCounter = 0; newRoundCounter = 0; // Check to copy. while(1) { bDirFound = FALSE; // Skip '.' and '..' entries. handle = FAT__findFirst(NULL, &info, &srcWorkDir); FAT__findNext(handle, &info); // First round, copy all files. while( FAT__findNext(handle, &info) != FALSE ) { if( (info.attr & ( FAT_ATTR_DIR|FAT_ATTR_VOLUME)) == FAT_ATTR_DIR ) { if(bSecondRound == TRUE) { if(0 == oldRoundCounter) { bSecondRound = FALSE; newRoundCounter++; } else oldRoundCounter--; } else { FAT__findClose(handle); // New subdir found, cd to it. bSecondRound = FALSE; bDirFound = TRUE; // Go one subdir further. FAT__cd((const char *)info.lname, &srcWorkDir); FAT__mkdir((const char *)info.lname, &dstWorkDir); FAT__cd((const char *)info.lname, &dstWorkDir); break; } } else { // If it is a file, copy it directly. // rb mode open src. srcFP = (File *)malloc(sizeof(File)); if(srcFP == NULL) return FALSE; srcFP->hdlID = FAT__getHdlID(); if(srcFP->hdlID == 0) { free(srcFP); return FALSE; } pDisk = srcWorkDir.pDisk; srcFP->mode = rb; srcFP->pDisk = pDisk; srcFP->flushedSize = 0; srcFP->ptr = 0; srcFP->flag = FILE_OBJ_ALLOCATED; clus = info.startClus; usNum = FAT__findNxtOcupdClus(clus, pDisk); srcFP->size = (info.size + 1)/2; srcFP->startClus = clus; srcFP->curClus = clus; srcFP->preBroknClus = clus; srcFP->nxtBroknClus = clus+usNum; srcFP->curPhySec = FAT__calcPhySecOfClus(clus, pDisk); srcFP->curSecOffsetInClus = 0; srcFP->curWordOffsetInSec = 0; dstFP = FAT__fopen((const char *)info.lname, wb, &dstWorkDir ); if(dstFP == NULL) { FAT_fclose(srcFP); return FALSE; } while ( 1 ) { len = FAT_fread( srcFP, buf, buflen ); if(len) FAT_fwrite( dstFP, buf, len ); else break; } FAT_fclose( dstFP ); FAT_fclose( srcFP ); } } if(bDirFound == FALSE) { // This subdir is fully copied now, cd to parent. bSecondRound = TRUE; oldRoundCounter = newRoundCounter; FAT__findClose(handle); // Go up one level. FAT__cd(strDOTDOT, &srcWorkDir); FAT__cd(strDOTDOT, &dstWorkDir); if( (srcClus == srcWorkDir.startClus)&&(bSrcIsRoot == srcWorkDir.bIsRoot) ) break; } } return TRUE; }

Here is the call graph for this function:

BOOL FAT_copyFile (  const char *  srcFile, const char *  dstFile, USHORT *  cpybuf, USHORT  buflen )

Copy srcFile to dstFile. NOTE that if file name does not contain drive letter, file shall be relative to current working directory. NOTE that, the source file must be different from the destination file. This function does not deal with the situation that the both files are the same name and in the same direcotry. For example, FAT_copyFile( "c:/abc/a.mp3", "c:/abc/a.mp3"); // wrong, same file same directory!! Parameters: srcFile  Source file name. dstFile  Destination file name. cpybuf  Supplied copy buffer if not NULL. buflen  Supplied copy buffer length. Returns: TRUE if successfully copied, otherwise FALSE. Definition at line 2146 of file fat.c. References FAT_fclose(), FAT_fopen(), FAT_fread(), FAT_fwrite(), rb, and wb. { File *srcFP, *dstFP; USHORT localbuf[COPY_BUF_LEN]; USHORT len; USHORT * buf; if(buflen&&cpybuf) buf = cpybuf; else { buflen = COPY_BUF_LEN; buf = localbuf; } FAT_assert(srcFile&&dstFile, FAT_COPYFILE); /* open source file with read mode */ srcFP = FAT_fopen( srcFile, rb ); if ( srcFP == NULL ) return FALSE; /* open destination file with write mode */ dstFP = FAT_fopen( dstFile, wb ); if ( dstFP == NULL ) { FAT_fclose(srcFP); return FALSE; } while ( 1 ) { len = FAT_fread( srcFP, buf, buflen ); if(len) FAT_fwrite( dstFP, buf, len ); else break; } FAT_fclose( dstFP ); FAT_fclose( srcFP ); return TRUE; }

Here is the call graph for this function:

BOOL FAT_delete (  const char *  pName  )

Function deletes file ONLY under current working directory. Parameters: pName  File to be deleted. Returns: TRUE if file is successfully deleted or does not exist, otherwise FALSE. Definition at line 2101 of file fat.c. References FAT__chg2PathDir(), FAT__delete(), FAT__findClose(), FAT__findFirst(), FAT__flush(), FAT__getCurWorkDir(), and st_CURWORKDIR::pDisk. Referenced by SYS_regist(), UI_processEAR(), UI_PSF_hisidone(), UI_PSF_play(), UI_PSF_record(), and UI_PSF_recorddone(). { char * pNext; long handle; st_CURWORKDIR * pDir = FAT__getCurWorkDir(); st_CURWORKDIR dir; st_FATFILEINFO info; dir = *pDir; if(FAT__chg2PathDir(pName, &pNext, &dir) == FALSE) return FALSE; handle = FAT__findFirst(pNext, &info, &dir); if(-1 == handle) return FALSE; FAT__findClose(handle); FAT__delete(&info, &dir); return FAT__flush(dir.pDisk); }

Here is the call graph for this function:

BOOL FAT_fclose (  File *  file  )

Function closes file and flushes disk. Parameters: file  File pointer. Returns: TRUE if successfully closed file object, otherwise FALSE. Definition at line 2005 of file fat.c. References ab, st_FATDISK::EOC, FAT__fflush(), FAT__flush(), FAT__updateCopyOfFAT(), FAT__updateSecondCopyOfFAT(), FAT__writeWord(), st_FATDISK::flag, FOPEN_MODE, st_FATDISK::maxClus, st_FATDISK::minAvlblClus, File::mode, st_FATDISK::newStartSrchClus, File::pDisk, r_b, wb, and st_FATDISK::wrFileNum. Referenced by DB__addSAIentry(), DB__deleteChildRecord(), DB__info(), DB__insert2leaf(), DB__recordPosition(), DB__register(), DB__removePAIentry(), DB_add2child(), DB_checkSyncMark(), DB_deleteRecordByMdb(), DB_dspData(), DB_getField(), DB_getMdbByRecord(), DB_getSaiByMdb(), DB_insertRecord(), DB_queryClose(), DB_queryFirst(), DB_removeRecord(), DB_setSyncMark(), EAR_getClose(), EAR_getFirst(), EAR_init(), EAR_put(), FAT_copyDir(), FAT_copyFile(), SYS_regist(), SYS_serialNumber(), UI_m3uClear(), UI_m3uClose(), UI_m3uInit(), UI_pendingEarDiskSpace(), UI_playQprevious(), UI_rdSynclog(), and UI_setupPlayQ(). { FOPEN_MODE mode = file->mode; unsigned short tmpClusHi, tmpClusLo, tmpSizeHi, tmpSizeLo; st_FATDISK * pDisk = file->pDisk; unsigned long phySec; unsigned short wordOffset; if(FALSE == FAT__isHdlValid(file)) return FALSE; if( (wb==mode)||(ab==mode)||(r_b==mode) ) { unsigned long size = file->size<<1; // Byte-swap to match "PC endian" tmpClusHi = (unsigned short)((file->startClus >>16) & 0x0000FFFF); tmpClusHi = ((tmpClusHi<<8) & 0xFF00) | ((tmpClusHi>>8) & 0x00FF); tmpClusLo = (unsigned short)(file->startClus & 0x0000FFFF); tmpClusLo = ((tmpClusLo<<8) & 0xFF00) | ((tmpClusLo>>8) & 0x00FF); tmpSizeHi = (unsigned short)((size >>16) & 0x0000FFFF); tmpSizeHi = ((tmpSizeHi<<8) & 0xFF00) | ((tmpSizeHi>>8) & 0x00FF); tmpSizeLo = (unsigned short)((size) & 0x0000FFFF); tmpSizeLo = ((tmpSizeLo<<8) & 0xFF00) | ((tmpSizeLo>>8) & 0x00FF); // Update dir entry. phySec = file->dirEntphySec; wordOffset = file->dirEntwordOffset; // start cluster low. FAT__writeWord(phySec, (unsigned short)(wordOffset + 13), &tmpClusLo, 1, pDisk); // start cluster high. FAT__writeWord(phySec, (unsigned short)(wordOffset + 10), &tmpClusHi, 1, pDisk); // size LOW FAT__writeWord(phySec, (unsigned short)(wordOffset + 14), &tmpSizeLo, 1, pDisk); // size HIGH FAT__writeWord(phySec, (unsigned short)(wordOffset + 15), &tmpSizeHi, 1, pDisk); // check to minimize the fragmentation. if( (file->curClus < file->nxtBroknClus)&&(file->curClus < pDisk->minAvlblClus) ) { pDisk->minAvlblClus = file->curClus; } // Update FAT table. FAT__fflush(file); if(file->size == 0) { // To support zero-sized file. FAT__updateCopyOfFAT(file->startUpdtClus, pDisk->EOC, 1, 0, pDisk); } // We are now done with the preallocated clusters, really don't have to clear // this flag, just to make code clean. Upon closing, file flag shall be all // cleared. file->flag &= ~FILE_CLUS_PREALLOCATED; FAT__updateSecondCopyOfFAT(file->startUpdtClus, pDisk); } FAT__flush(pDisk); if((wb==mode)||(ab==mode)||(r_b==mode)) { pDisk->wrFileNum--; if( 0 == pDisk->wrFileNum ) { pDisk->newStartSrchClus = (file->curClus<pDisk->minAvlblClus)? file->curClus:pDisk->minAvlblClus; pDisk->minAvlblClus = pDisk->maxClus; } } FAT__releaseHdlID(file); if(file->flag & FILE_OBJ_ALLOCATED) free(file); return TRUE; }

Here is the call graph for this function:

long FAT_findFirst (  const char *  pName, st_FATFILEINFO *  pInfo )

Function finds the first valid directory or file under current directory. If any time function returns a valid handle, caller has to call FAT_findClose(...) to release control objects. If pName is NULL, function returns the first valid entry, this is so-called limited wildcard support. Parameters: pName  Dir/file name to be found if any. pInfo  Dir/file info buffer. Returns: find handle that can be used by findnext(...), -1 otherwise. Definition at line 1907 of file fat.c. References FAT__findFirst(), and FAT__getCurWorkDir(). { st_CURWORKDIR dir; st_CURWORKDIR * pDir = FAT__getCurWorkDir(); dir = *pDir; return( FAT__findFirst(pName, pInfo, &dir) ); }

Here is the call graph for this function:

BOOL FAT_finsert (  File *  file, unsigned long  offset, const unsigned short *  pData, unsigned short  len, unsigned long  endOffset )

This function is used to insert data inside of file. This is a standalong function, meaning no OPEN/CLOSE action needed before/after. Basically there are tow insert modes: 1. endOffset = 0 When insert data, the origin data from the insert point will be moved backward to make space for new data. So the file's boundary and size will change after new data is inserted. 2. endOffset > 0 In this situation, endOffset must larger than ( offset + len ), when insert data, the old data before endOffset will be moved backward, the old data after endOffset will stay there. So the size and boundary of the file will not be changed. For example, a file is 50 words long, offset = 10; len = 2; endOffset = 20, after function returns, the words after 20 remain the same, data at 10 and 11 are new, data from 12 to 19 are old data, but they have been moved from location 10, the old data data at 18 and 19 have been removed since they have crossed the boundary at 20. Parameters: file  file pointer, has to be opened in r_b mode. offset  the insert point counting from begining of file. pData  the data to be inserted. len  the length of the new data in words. endOffset  the boundary of the old data to be moved. Returns: TRUE if successful, otherwise FALSE. Definition at line 1766 of file fat.c. References FAT_fread(), FAT_fseek(), FAT_fwrite(), SEEK_HEAD, and SEEK_TAIL. Referenced by DB__addSAIentry(), DB__insert2leaf(), and UI_m3uChgOrder(). { unsigned short buf[BUF_LEN]; unsigned short rdLen; unsigned short wrLen; unsigned long startOffset; if( 0 == len ) return TRUE; if( (endOffset < offset+len)&&(0 != endOffset) ) return TRUE; if(0 == endOffset) { unsigned long oldSize; oldSize = file->size; if(file->size < offset+len) { unsigned short tmp; tmp = file->size-offset; FAT_fseek(file, 0, SEEK_TAIL); FAT_fwrite(file, (unsigned short *)pData-tmp, len-tmp); len = tmp; endOffset = file->size; startOffset = offset; } else { endOffset = file->size; startOffset = endOffset-len; } rdLen = len; while(rdLen) { if(rdLen > BUF_LEN) wrLen = BUF_LEN; else wrLen = rdLen; FAT_fseek(file, startOffset, SEEK_HEAD); FAT_fread(file, buf, wrLen); FAT_fseek(file, endOffset, SEEK_HEAD); FAT_fwrite(file, buf, wrLen); rdLen -= wrLen; startOffset += wrLen; endOffset += wrLen; } endOffset = oldSize; } startOffset = endOffset - len; rdLen = startOffset - offset; while(rdLen) { if(rdLen > BUF_LEN) wrLen = BUF_LEN; else wrLen = rdLen; FAT_fseek(file, startOffset-wrLen, SEEK_HEAD); FAT_fread(file, buf, wrLen); FAT_fseek(file, endOffset-wrLen, SEEK_HEAD); FAT_fwrite(file, buf, wrLen); rdLen -= wrLen; startOffset -= wrLen; endOffset -= wrLen; } FAT_fseek(file, offset, SEEK_HEAD); FAT_fwrite(file, (unsigned short *)pData, len); return TRUE; }

Here is the call graph for this function:

BOOL FAT_flushDisk (  DISK_ID  disk  )

Function flushes the FAT disk and makes all change final. Parameters: disk  Disk ID. Returns: TRUE if successfully flushed, otherwise FALSE. Definition at line 1713 of file fat.c. References DiskC, FAT__flush(), HDD_flush(), and NAND_flush(). { if(disk == DISK_D) { if(FAT__flush(&DiskD) == TRUE) { return NAND_flush(); } } else { if(FAT__flush(&DiskC) == TRUE) { return HDD_flush(); } } return FALSE; }

Here is the call graph for this function:

File* FAT_fopen (  const char *  pName, FOPEN_MODE  eMode )

Function opens the file specified by pName in a mode specified by eMode under current working directory. Functoin will NOT change the current working directory. Function will NOT open or create any directory. pName is NOT case sensitive. Parameters: pName  file name. eMode  file open mode. Returns: file pointer if successfully opened, other wise NULL. Definition at line 1356 of file fat.c. References FAT__fopen(), and FAT__getCurWorkDir(). Referenced by DB__addSAIentry(), DB__deleteChildRecord(), DB__info(), DB__insert2leaf(), DB__recordPosition(), DB__register(), DB__removePAIentry(), DB_add2child(), DB_checkSyncMark(), DB_deleteRecordByMdb(), DB_dspData(), DB_getField(), DB_getMdbByRecord(), DB_getSaiByMdb(), DB_insertRecord(), DB_queryFirst(), DB_removeRecord(), DB_setSyncMark(), EAR_getFirst(), EAR_init(), EAR_put(), FAT_copyFile(), SYS_regist(), SYS_serialNumber(), UI_m3uClear(), UI_m3uInit(), UI_pendingEarDiskSpace(), and UI_rdSynclog(). { st_CURWORKDIR * pDir = FAT__getCurWorkDir(); st_CURWORKDIR dir; dir = *pDir; return FAT__fopen(pName, eMode, &dir); }

Here is the call graph for this function:

BOOL FAT_format (  DISK_ID  disk, FAT_FORMAT_TYPE  type, unsigned long  rsvSecs )

Function will reformat the entire volume at given level. It will rewrite the MBR and BR, clear the entire FAT table if low level format is performed. Parameters: disk  Disk specifier. type  format type. rsvSecs  Reserved number of sectors that are not FAT accessible. Returns: TRUE if successfully formated, otherwise FALSE. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Definition at line 931 of file fat.c. References DISK_C, DISK_D, DiskC, FAT__format(), FAT__unmountDisk(), FAT_HIGH_LEVEL_FORMAT, FAT_LOW_LEVEL_FORMAT, FAT_MEDIA_FORMAT, st_FATDISK::lock, st_FATDISK::lock2, st_FATDISK::readSec, SYS_getParams(), SYS_setParams(), and st_FATDISK::writeSec. { st_FATDISK * pDisk; if( DISK_C == disk) { pDisk = &DiskC; DiskC.readSec = HDD_readSec; DiskC.writeSec = HDD_writeSec; DiskC.lock = &LCK_fathdd; DiskC.lock2 = &LCK_fathdd2; } else if( DISK_D == disk ) { pDisk = &DiskD; DiskD.readSec = NAND_readSec; DiskD.writeSec = NAND_writeSec; DiskD.lock = &LCK_fatnand; DiskD.lock2 = &LCK_fatnand2; } else return FALSE; switch( type ) { case FAT_HIGH_LEVEL_FORMAT: if ( FAT__format(pDisk, FAT_HIGH_LEVEL_FORMAT, rsvSecs ) == TRUE ) break; case FAT_LOW_LEVEL_FORMAT: if ( FAT__format(pDisk, FAT_LOW_LEVEL_FORMAT, rsvSecs ) == TRUE ) break; case FAT_MEDIA_FORMAT: if ( FAT__format(pDisk, FAT_MEDIA_FORMAT, rsvSecs ) == TRUE ) break; default: return FALSE; } if(DISK_D == disk) { USHORT ii; #include "../SYSTEM/sys_param.h" // THIS REALLY SHOULD BE A GUI CALL, PLACE HERE TO // SAVE CODE SPACE.-----------------------12/18/03. MG. // Clear HDD DB sync status. SYS_getParams(HDD_DB_STATUS, &ii); ii &= ~SP_HDS_NANDSYNCED; SYS_setParams(HDD_DB_STATUS, &ii); ii = SP_NDC_EMPTY; SYS_setParams(NAND_DB_CONTENTS, &ii); } // If successfully format, unmount the disk then. It is the caller's // responsibility to make sure that disk is mounted before any FAT // operation. return FAT__unmountDisk(disk); }

Here is the call graph for this function:

short FAT_fread (  File *  file, unsigned short *  pBuf, short  len )

Function read file and return number of read words. If returned length is not equal to specified length, it is either due to end of file or disk operation error. It is the caller's responsibility to handle any errors. Parameters: file  File pointer. pBuf  Data buffer. len  Data length in words. Returns: Number of words read. Definition at line 814 of file fat.c. References FAT__calcPhySecOfClus(), FAT__clusEntry(), FAT__fflush(), FAT__findNxtOcupdClus(), FAT__readWord(), st_FATDISK::readSec, and st_FATDISK::secPerClus. Referenced by DB__addSAIentry(), DB__deleteChildRecord(), DB__getRecord(), DB__info(), DB__insert2leaf(), DB__recordPosition(), DB__register(), DB__removePAIentry(), DB_add2child(), DB_checkSyncMark(), DB_deleteRecordByMdb(), DB_dspData(), DB_getMdbByRecord(), DB_getSaiByMdb(), DB_queryFirst(), DB_queryNext(), DB_removeRecord(), DB_setSyncMark(), DECODER_cache(), DECODER_getData(), EAR_getFirst(), EAR_getNext(), EAR_put(), FAT_copyDir(), FAT_copyFile(), FAT_finsert(), SYS_regist(), SYS_serialNumber(), UI_m3uChgOrder(), UI_pendingEarDiskSpace(), and UI_rdSynclog(). { unsigned short ii; short length; st_FATDISK * pDisk = file->pDisk; unsigned short wordOffset; unsigned long ulTmp; unsigned long size = file->size; unsigned long ptr = file->ptr; ii = file->mode; if( ((ii != rb)&&(ii != r_b))||(ptr >= size) ) return 0; if(ii == r_b) { if(file->flag & FILE_FAT_FLUSH_PENDING) { if(FAT__fflush(file) == FALSE) return -1; } } size = file->size; ptr = file->ptr; if(len >= (long)(size - ptr)) len = (short)(size - ptr); length = len; while(1) { if(file->curSecOffsetInClus >= pDisk->secPerClus) { // Cross cluster boundary. file->curSecOffsetInClus = 0; file->curWordOffsetInSec = 0; if(file->curClus < file->nxtBroknClus ) file->curClus++; else { ulTmp = FAT__clusEntry(file->nxtBroknClus, pDisk); if(0L == ulTmp) { file->ptr += (len-length); file->curSecOffsetInClus = pDisk->secPerClus; return(len - length); } file->curClus = ulTmp; file->preBroknClus = ulTmp; file->nxtBroknClus = ulTmp + FAT__findNxtOcupdClus(ulTmp, pDisk); file->curPhySec = FAT__calcPhySecOfClus(ulTmp, pDisk); } } wordOffset = file->curWordOffsetInSec; if( (wordOffset != 0)||(length < 256) ) { ii = 256-wordOffset; if( ii >= length ) ii = (unsigned short)length; FAT__readWord(file->curPhySec, wordOffset, pBuf, ii, FALSE, pDisk); file->curWordOffsetInSec += ii; pBuf += ii; if(file->curWordOffsetInSec == 256) { file->curWordOffsetInSec = 0; file->curPhySec++; file->curSecOffsetInClus++; } if(length == ii) { file->ptr += len; return len; } else length -= ii; } else { pDisk->readSec(file->curPhySec, pBuf, FALSE); pBuf += 256; length -= 256; file->curPhySec++; file->curSecOffsetInClus++; if(length == 0) { file->ptr += len; return len; } } } }

Here is the call graph for this function:

ULONG FAT_freeSpace (  DISK_ID  disk  )

Function returns disk free space. Parameters: disk  Disk specifier. Returns: Current disk free space in kilo(1024) bytes. Definition at line 771 of file fat.c. References DISK_D, DiskC, FAT__freeClusNum(), st_FATDISK::freeClusNum, and st_FATDISK::secPerClus. Referenced by MENU__createPropertiesMenu(), UI_earPut(), UI_PSF_hisi(), UI_PSF_record(), and UI_updateMembar(). { if(DISK_D == disk) { return((unsigned long)FAT__freeClusNum(DISK_D)*DiskD.secPerClus>>1); } return(DiskC.freeClusNum*DiskC.secPerClus>>1); }

Here is the call graph for this function:

BOOL FAT_frevive (  const char *  pName  )

Function checks to revive unclosed file. Parameters: pName  file name. Returns: TRUE if file successfully revived, otherwise FALSE. Definition at line 1406 of file fat.c. References st_FATDISK::EOC, FAT__chg2PathDir(), FAT__clusEntry(), FAT__findFirst(), FAT__flush(), FAT__getCurWorkDir(), FAT__updateCopyOfFAT(), FAT__updateSecondCopyOfFAT(), FAT__writeWord(), st_CURWORKDIR::pDisk, st_FATFILEINFO::phySec, st_FATFILEINFO::startClus, st_FATFILEINFO::wordOffset, and st_FATDISK::wordsPerClus. { st_CURWORKDIR * pDir = FAT__getCurWorkDir(); st_CURWORKDIR dir; char * pNext; long handle; st_FATFILEINFO info; st_FATDISK * pDisk; dir = *pDir; if(FAT__chg2PathDir(pName, &pNext, &dir) == FALSE) return FALSE; pDisk = dir.pDisk; handle = FAT__findFirst(pNext, &info, &dir ); if(handle != -1) { unsigned long nextClus, curClus = info.startClus, clusNum = 1; FAT_findClose(handle); while(curClus != pDisk->EOC) { nextClus = FAT__clusEntry(curClus, pDisk); if(nextClus == 0L) { FAT__updateCopyOfFAT(curClus, pDisk->EOC, 1, 0, pDisk); FAT__updateSecondCopyOfFAT(info.startClus, pDisk); // Update the size field of directory entry. { unsigned short tmpSizeHi, tmpSizeLo, wordOffset; unsigned long phySec, size; size = clusNum*pDisk->wordsPerClus*2; tmpSizeHi = (unsigned short)((size >>16) & 0x0000FFFF); tmpSizeHi = ((tmpSizeHi<<8) & 0xFF00) | ((tmpSizeHi>>8) & 0x00FF); tmpSizeLo = (unsigned short)((size) & 0x0000FFFF); tmpSizeLo = ((tmpSizeLo<<8) & 0xFF00) | ((tmpSizeLo>>8) & 0x00FF); // Update dir entry. phySec = info.phySec; wordOffset = info.wordOffset; // size LOW FAT__writeWord(phySec, (unsigned short)(wordOffset + 14), &tmpSizeLo, 1, pDisk); // size HIGH FAT__writeWord(phySec, (unsigned short)(wordOffset + 15), &tmpSizeHi, 1, pDisk); } FAT__flush(pDisk); break; } else { curClus = nextClus; clusNum++; } } return TRUE; } return FALSE; }

Here is the call graph for this function:

BOOL FAT_fseek (  File *  file, long  len, SEEK_MODE  eMod )

Function seeks in file. Parameters: file  File pointer. len  Seek offset. eMod  Seek mode. Returns: TRUE if successfully reset file pointer, otherwise FALSE. Definition at line 5370 of file fat.c. References FAT__fflush(), FAT__fseek(), and FOPEN_MODE. Referenced by DB__addSAIentry(), DB__deleteChildRecord(), DB__info(), DB__insert2leaf(), DB__recordPosition(), DB__register(), DB__removePAIentry(), DB_add2child(), DB_deleteRecordByMdb(), DB_dspData(), DB_getField(), DB_getMdbByRecord(), DB_getSaiByMdb(), DB_queryFirst(), DB_queryNext(), DB_removeRecord(), DB_setSyncMark(), DECODER_cache(), DECODER_getData(), EAR_getNext(), EAR_put(), FAT_finsert(), UI_m3uChgOrder(), UI_m3uPut(), UI_m3uRemove(), and UI_pendingEarDiskSpace(). { FOPEN_MODE mode = file->mode; // Seek operation is only valid under "rb" and "r_b" mode. if( (mode != rb ) && ( mode != r_b) ) return FALSE; if(file->flag & FILE_FAT_FLUSH_PENDING) { if(FAT__fflush(file) == FALSE) return FALSE; } return FAT__fseek(file, len, eMod); }

Here is the call graph for this function:

short FAT_fwrite (  File *  file, unsigned short *  pBuf, short  len )

Function writes to file and return number of written words. Parameters: file  File pointer. pBuf  Data buffer. len  Data length in words. Returns: Number of words written, -1 indicates error. Definition at line 554 of file fat.c. References FAT__calcPhySecOfClus(), FAT__clusEntry(), FAT__findNxtAvlblClus(), FAT__findNxtOcupdClus(), FAT__updateCopyOfFAT(), FAT__writeWord(), st_FATDISK::flag, FOPEN_MODE, st_FATDISK::maxFndClus, st_CURWORKDIR::pDisk, st_FATDISK::secPerClus, and st_FATDISK::writeSec. Referenced by DB__addSAIentry(), DB__deleteChildRecord(), DB__insert2leaf(), DB__register(), DB__removePAIentry(), DB_add2child(), DB_insertRecord(), DB_removeRecord(), DB_setSyncMark(), EAR_init(), EAR_put(), ENCODER_cache(), ENCODER_putData(), FAT_copyDir(), FAT_copyFile(), FAT_finsert(), SYS_serialNumber(), UI_m3uClear(), UI_m3uInit(), UI_m3uPut(), and UI_m3uRemove(). { unsigned short ii; unsigned short wordOffset; short length = len; st_FATDISK * pDisk = file->pDisk; FOPEN_MODE mode; unsigned long ulTmp; mode = file->mode; if( ((mode != wb)&&(mode != r_b)&&(mode!= ab))||(file->flag&FILE_DISK_FULL) ) return 0; // check if file length over 4G limit. if ( file->ptr > 0x80000000L ) return 0; file->flag |= FILE_FAT_FLUSH_PENDING; while(1) { if(file->curSecOffsetInClus >= pDisk->secPerClus) { // Cross cluster boundary. file->curSecOffsetInClus = 0; file->curWordOffsetInSec = 0; if( (mode == r_b) && (file->ptr < file->flushedSize) ) { // No preallocation needed at this time. } else { if( file->curClus == file->centClus ) { if(file->flag & FILE_FLUSH_BROKNCLUS_PENDING) { file->flag &= ~FILE_FLUSH_BROKNCLUS_PENDING; FAT__updateCopyOfFAT( file->nxtPreBroknClus, file->preBroknClus, 1, 0, pDisk); } if( !(file->flag&FILE_CLUS_PREALLOCATED) ) { // Preallocate next available clusters. file->preAllocatedClusNum = FAT__findNxtAvlblClus( &file->nxtPreBroknClus, pDisk->maxFndClus, pDisk); file->flag |= FILE_CLUS_PREALLOCATED; } } } if(file->curClus < file->nxtBroknClus ) file->curClus++; else { if( (mode == r_b) && (file->ptr < file->flushedSize) ) { file->preBroknClus = FAT__clusEntry(file->nxtBroknClus, pDisk); // Note that at least one cluster has been found here, even // this is the last available cluster in file. file->preAllocatedClusNum = FAT__findNxtOcupdClus( file->preBroknClus, pDisk) + 1; } else { // Update FAT table FAT__updateCopyOfFAT( file->preBroknClus, file->preBroknClus+1, (unsigned short)(file->curClus - file->preBroknClus), 0, pDisk ); // Normally, this flag should have been set before coming here. // But there are cases that it is not set yet, for example, in r_b mode, // seek to the end of file before any writing happens. if( !(file->flag&FILE_CLUS_PREALLOCATED) ) { // Preallocate next available clusters. file->preAllocatedClusNum = FAT__findNxtAvlblClus( &file->nxtPreBroknClus, pDisk->maxFndClus, pDisk); file->flag |= FILE_CLUS_PREALLOCATED; } if( file->preAllocatedClusNum == 0 ) { // Disk Full! // clusters from preBroknClus to curClus have been // updated to FAT already. file->preBroknClus = file->curClus; file->flag |= FILE_DISK_FULL; file->size = file->ptr; return (len-length); } file->preBroknClus = file->nxtPreBroknClus; // Remember that file->nxtBroknClus has not been flushed yet. file->flag |= FILE_FLUSH_BROKNCLUS_PENDING; // Remember which cluster needs to be flushed. file->nxtPreBroknClus = file->nxtBroknClus; file->flag &= ~FILE_CLUS_PREALLOCATED; } ulTmp = file->preBroknClus; file->curClus = ulTmp; file->nxtBroknClus = ulTmp + file->preAllocatedClusNum - 1; file->centClus = ulTmp + file->preAllocatedClusNum/2; file->curPhySec = FAT__calcPhySecOfClus(ulTmp, pDisk); } } wordOffset = file->curWordOffsetInSec; if( (wordOffset != 0)||(length < 256) ) { ii = 256-wordOffset; if( ii >= length ) ii = (unsigned short)length; FAT__writeWord(file->curPhySec, wordOffset, pBuf, ii, pDisk); file->curWordOffsetInSec += ii; pBuf += ii; if(file->curWordOffsetInSec == 256) { file->curWordOffsetInSec = 0; file->curPhySec++; file->curSecOffsetInClus++; } if(length == ii) { file->ptr += len; // Check to update file size. if(mode == r_b) { if(file->ptr > file->flushedSize) file->size = file->ptr; } else file->size = file->ptr; return len; } else length -= ii; } else { pDisk->writeSec(file->curPhySec, pBuf, FALSE); pBuf += 256; length -= 256; file->curPhySec++; file->curSecOffsetInClus++; if(length == 0) { file->ptr += len; // Check to update file size. if(mode == r_b) { if(file->ptr > file->flushedSize) file->size = file->ptr; } else file->size = file->ptr; return len; } } } }

Here is the call graph for this function:

BOOL FAT_mkdir (  const char *  pDirName  )

Function creates directory under current working directory if not exists already. Root directory can NOT be created by definition. Function does not translate path delimiters, which means only one directory can be created per call. No character validity function here, it is the caller's responsibility to make sure pDirName points to valid dir name. Parameters: pDirName  Directory name. Returns: TRUE if directory successfully created, otherwise FALSE. Definition at line 495 of file fat.c. References FAT__getCurWorkDir(), and FAT__mkdir(). Referenced by DB_creator(), and EAR_init(). { st_CURWORKDIR * pDir = FAT__getCurWorkDir(); st_CURWORKDIR dir; dir = *pDir; return(FAT__mkdir(pDirName, &dir)); }

Here is the call graph for this function:

FAT_MOUNT_MSG FAT_mountDisk (  DISK_ID  disk  )

Function checks to mount specified disk and reports mount message. FAT_mountDisk(...) and FAT_unmountDisk(...) can only be called by operating system. Parameters: disk  Disk specifier. Returns: Mount message based on media status. Definition at line 255 of file fat.c. References DISK_C, DiskC, HDD_mount(), st_FATDISK::lock, st_FATDISK::lock2, st_FATDISK::readSec, and st_FATDISK::writeSec. { unsigned short usTmp; st_FATDISK * pDisk; unsigned long navMaxAddr; if( DISK_C == disk) { if(SYS_isHDDpresent()) { pDisk = &DiskC; DiskC.readSec = HDD_readSec; DiskC.writeSec = HDD_writeSec; DiskC.lock = &LCK_fathdd; DiskC.lock2 = &LCK_fathdd2; navMaxAddr = HDD_mount(); } else return FAT_MOUNT_MEDIA_NOT_PRESENT; } else if( DISK_D == disk ) { pDisk = &DiskD; DiskD.readSec = NAND_readSec; DiskD.writeSec = NAND_writeSec; DiskD.lock = &LCK_fatnand; DiskD.lock2 = &LCK_fatnand2; navMaxAddr = NAND_mount(); } else return FAT_MOUNT_UNKNOWN_ERROR; if ( navMaxAddr == 0 ) return FAT_MOUNT_MEDIA_FAILURE; pDisk->flag = 0; // enable word/sector interface. pDisk->curActvPhySec = FAT_INVALIDSEC; pDisk->curActvFatPhySec = FAT_INVALIDSEC; if(FAT__globalsInit(pDisk) == TRUE) { // Double check if BR/MBR does not match current media. if(pDisk->totalSec16_32 <= navMaxAddr) { unsigned long num = (unsigned long)FAT__freeClusNum(disk); if( 0xffffffff != num ) { pDisk->freeClusNum = num; pDisk->oldFreeClusNum = num; if ( pDisk->fileSysType == FAT_32 ) { /* FSI_Nxt_Free */ FAT__readWord( pDisk->fsInfoSec, 492>>1, &usTmp, 1, TRUE, pDisk ); pDisk->newStartSrchClus = usTmp; FAT__readWord( pDisk->fsInfoSec, 494>>1, &usTmp, 1, TRUE, pDisk ); pDisk->newStartSrchClus |= (unsigned long)usTmp<<16; if ( pDisk->newStartSrchClus == 0x0FFFFFFF ) pDisk->newStartSrchClus = FAT_FIRSTCLUS; } else { pDisk->newStartSrchClus = FAT_FIRSTCLUS; } // init the pSearch and pStart, they should be equal when no file is open. pDisk->wrFileNum = 0; pDisk->minAvlblClus = pDisk->maxClus; pDisk->oldStartSrchClus = pDisk->newStartSrchClus; return FAT_MOUNT_SUCCESS; } } } // Unmount media before return. if( DISK_C == disk) HDD_unmount(); else NAND_unmount(); return FAT_MOUNT_FAT_FAILURE; }

Here is the call graph for this function:

void FAT_releaseCurWorkDir (  TSK_Handle  task  )

Function release the current working directory of given task. Parameters: task  Task handle. Definition at line 3810 of file fat.c. Referenced by SYS_hookDelete(), and SYS_hookExit(). { unsigned short ii = MAX_CONCURRENT_WORKDIR; st_WORKDIRREG * pReg = &workdirREG[0]; // Don't bother me at this time. TSK_disable(); while(ii--) { if(pReg->task == task) { pReg->task = NULL; break; } pReg++; } TSK_enable(); }

BOOL FAT_rmdir (  const char *  pDirName  )

Function removes the given directory under current working directory and any subdirs or files. Parameters: pDirName  Directory that is going to be removed. Returns: TRUE if directory is successfully removed or does not exist, otherwise FALSE. Definition at line 144 of file fat.c. References FAT__chg2PathDir(), FAT__flush(), FAT__getCurWorkDir(), and st_CURWORKDIR::pDisk. { char * pNext; st_CURWORKDIR * pDir = FAT__getCurWorkDir(); st_CURWORKDIR dir; dir = *pDir; if(FAT__chg2PathDir(pDirName, &pNext, &dir) == FALSE) return FALSE; _deleteDir(pNext, &dir); return FAT__flush(dir.pDisk); }

Here is the call graph for this function:

ULONG FAT_totalSpace (  DISK_ID  disk  )

Function returns total disk space. Parameters: disk  Disk specifier. Returns: Total disk space in kilo(1024) bytes. Definition at line 790 of file fat.c. References DISK_D, st_FATDISK::maxClus, and st_FATDISK::secPerClus. Referenced by ENCODER_putData(), and UI_updateMembar(). { st_FATDISK * pDisk; pDisk = (DISK_D == disk)? &DiskD: &DiskC; return(pDisk->maxClus*pDisk->secPerClus>>1); }

---