VLSI Solution Oy Evaluation MP3 Player Source Code Documentation

filesys.c File Reference

File system functions, Implemented: FAT16, FAT32. More...

#include "board.h"
#include "filesys.h"
#include "storage.h"
#include "console.h"
#include "mmc.h"
#include "display.h"

Include dependency graph for filesys.c:

Go to the source code of this file.

Classes
struct	fragmentEntry
	Fragment Table. More...
struct	directoryStack
	Directory traversing structure. More...
Defines
#define	MAX_NUMBER_FRAGMENTS   10
	Maximum allowable number of fragments in file.
#define	MAX_NUMBER_SUBDIRECTORIES   5
	Maximum number of nested subdirectories.
Functions
void	PConvertSectorToCluster (unsigned long *sector)
	Convert sector number to cluster number.
void	PConvertClusterToSector (unsigned long *cluster)
	Convert cluster number to sector number.
unsigned long	GetFatEntry (unsigned long clusterNumber)
	Return the FAT entry for cluster clusterNumber.
void	WriteClusterChain ()
	Write a cluster chain to FAT for a fragment.
unsigned char	ScanForFreeSector ()
	Search for next free sector.
unsigned long	GetNextSector (unsigned long currentSector)
	Calculate next sector from currentSector.
Public unsigned char	BuildFragmentTable ()
	Build a fragment table starting from current sector.
unsigned char	LoadNextSector ()
	Traverse to next sector in file or directory.
Public unsigned char	FGetChar ()
	Read a character from current file.
Public unsigned char	OpenFile (unsigned int fileNumber)
	Open a file for reading.
unsigned char	FatInitGlobals ()
	Decipher structure of FAT volume and set globals accordingly.
Public unsigned char	InitFileSystem ()
	Start the filing system and initialize all necessary subsystems.
Variables
data unsigned long	fatStart
	Starting sector of FAT table.
data unsigned long	rootStart
	Starting sector of root directory.
data unsigned long	dataStart
	(In FAT the start is cluster 2, so dataStart actually points to 2 clusters before the start of data area)
data unsigned char	fatSectorsPerCluster
	FAT Global sectors per cluster.
xdata struct fragmentEntry	fragment [MAX_NUMBER_FRAGMENTS]
	Fragment Table.
xdata unsigned long	fileSize
	Size of current file to play.
xdata struct directoryStack	dirStack [MAX_NUMBER_SUBDIRECTORIES]
	Directory traversing structure.
xdata unsigned char	dirLevel = 0
	Current directory level, 0=Root directory.
xdata unsigned long	freeSector = 0
	Next free cluster number.
xdata char	currentFileName [12]
	8 first characters of current file name

---

Detailed Description

File system functions, Implemented: FAT16, FAT32.

Definition in file filesys.c.

---

Define Documentation

#define MAX_NUMBER_FRAGMENTS   10

Maximum allowable number of fragments in file. Definition at line 37 of file filesys.c. Referenced by BuildFragmentTable().

#define MAX_NUMBER_SUBDIRECTORIES   5

Maximum number of nested subdirectories. Definition at line 50 of file filesys.c. Referenced by OpenFile().

---

Function Documentation

Public unsigned char BuildFragmentTable (  void   )

Build a fragment table starting from current sector. Returns number of fragments in song. This function is used to get fast access to the filesystem when playing so cluster chain needs not be followed when the song is playing, that would be too slow with MMC cards without extra buffer memory for the file allocation tables. Note: filesys.c module does not use the fragment table internally. it is written to be a service to the player routine, which uses storage.c module directly for disk access after using the filesys.c module for finding a file to play. I am listening to Darude's Sandstorm while coding this. In terms of memory allocation, this function is devilish. At one stage temp.l is used just to make compiler use memory at temp.l instead of spilling to another unnecessary temp variable... Definition at line 397 of file filesys.c. References Address::b, Address::B::b0, Address::B::b1, Address::B::b3, dataStart, diskSect, DiskBlock::Fat16Table, DiskBlock::Fat32Table, fatSectorsPerCluster, fatStart, fragment, IS_FAT_32, Address::l, Temp::l, fragmentEntry::length, MAX_NUMBER_FRAGMENTS, Public, ReadDiskSector(), sectorAddress, fragmentEntry::start, and temp. Referenced by PlayCurrentFile(). { unsigned char c=0; addressType this,next; addressType fatSector; unsigned char entryNumber; //as long as the sectorAddress is "sane"... while (!(sectorAddress.b.b3 & 0x80)){ fragment[c].start = sectorAddress.l; fragment[c].length = fatSectorsPerCluster; /* Find cluster entry for the current sector */ /* in how manyth sector from start of data area are we? ->this */ this.l = sectorAddress.l - dataStart; /* convert from CurrentSectorN to currentClusterN */ this.l /= fatSectorsPerCluster; /* this.l is now the current cluster number */ /* now let's find the FAT entry for this.l cluster */ if (!IS_FAT_32){ //FAT16 entryNumber = this.b.b0; /* 256 entries / page in FAT16 table */ fatSector.l = this.l >> 8; /* Div by n of entries/page in FAT16 tbl*/ }else{ //FAT32 entryNumber = (this.b.b0 & 0x7f); /* 128 entries/page in FAT32 table */ fatSector.l = this.l >> 7; /* Div by n of entries/page in FAT32 tbl*/ } fatSector.l += fatStart; /* fatSector.l is now the DISK SECTOR NUMBER CONTAINING THE FAT table */ /* read this page into memory */ ReadDiskSector(fatSector.l); if (!IS_FAT_32){ //FAT16 next.l = diskSect.Fat16Table[entryNumber]; /* get next cluster n */ /* Check for FAT16 end-of-file condition */ if ((next.b.b1 == 0xff) && (next.b.b0 == 0xff)){ /* FAT16 End of file */ next.b.b3 = 0xff; /* return a large value (fat32 compatible) */ } }else{ //FAT32 next.l = diskSect.Fat32Table[entryNumber]&0x0fffffff; } /* next.l is the FAT entry (next cluster number) */ ConsoleWrite("\rFragment start: cluster "); ConsolePutUInt(this.l); ConsoleWrite("sector "); ConsolePutUInt(fragment[c].start); while (next.l==(this.l+1)){ //Not a fragment break -- continue to next entry //in this temp.l is used only to allow compiler memory spilling to temp temp.l = fragment[c].length; temp.l += fatSectorsPerCluster; fragment[c].length = temp.l; entryNumber++; // --- Check for a page break if (entryNumber==0){ //entryNumber has rolled over!!!! (8bit char) //FAT16 table page border is reached fatSector.l++; //Advance to next page; entryNumber=0; ReadDiskSector(fatSector.l); } if (IS_FAT_32 && (entryNumber==128)){ //FAT32 table page border is reached fatSector.l++; entryNumber=0; ReadDiskSector(fatSector.l); } // --- Advance to next cluster this.l = next.l; if (!IS_FAT_32){ //FAT16 get next cluster n next.l = diskSect.Fat16Table[entryNumber]; if ((next.b.b1==0xff)&&(next.b.b0==0xff)){ //FAT16 end-of-file next.b.b3 = 0xff; //mark end-of-file (FAT32 compatible) } }else{ //FAT32 get next cluster n next.l = diskSect.Fat32Table[entryNumber]; } }//This repeats until there is a discontinuity /* next.l now has the cluster entry for last cluster in fragment it has a high value if eof (see FAT spec) */ ConsoleWrite("Size: "); ConsolePutUInt(fragment[c].length); ConsoleWrite("sectors."); //EOF test if ((next.b.b3&0x08) //Quick test && ((next.l>0x0ffffff0) | !IS_FAT_32)){ //Complete test //EOF ConsoleWrite(" <EOF>\r"); sectorAddress.b.b3 = 0xff; }else{ //Determine next physical sector for next fragment sectorAddress.l = next.l; sectorAddress.l *= fatSectorsPerCluster; sectorAddress.l += dataStart; } c++; //Advance to next fragment number if (c==MAX_NUMBER_FRAGMENTS){ //End of RAM space allocated for fragment table //Force end-of-file sectorAddress.b.b3=0xff; } }//break or continue to next cluster return c; //Return number of fragments; } Here is the call graph for this function:

unsigned char FatInitGlobals (   )

Decipher structure of FAT volume and set globals accordingly. Definition at line 794 of file filesys.c. References DiskBlock::Fat::Extensions::_16, DiskBlock::Fat::Extensions::_32, DiskBlock::Fat::BPB_BytsPerSec, DiskBlock::Fat::BPB_FATSz16, DiskBlock::Fat::Extensions::Fat32Specific::BPB_FATSz32, DiskBlock::Fat::BPB_HiddSec, DiskBlock::Fat::BPB_NumFATs, DiskBlock::Fat::BPB_RootEntCnt, DiskBlock::Fat::BPB_RsvdSecCnt, DiskBlock::Fat::BPB_SecPerClus, DiskBlock::Fat::BPB_TotSec16, DiskBlock::Fat::BPB_TotSec32, DiskBlock::Fat::Extensions::Fat16Specific::BS_FilSysType, DiskBlock::Fat::Extensions::Fat32Specific::BS_FilSysType, DiskBlock::Fat::BS_OEMName, DiskBlock::Fat::Extensions::Fat16Specific::BS_VolLab, DiskBlock::Fat::Extensions::Fat32Specific::BS_VolLab, Temp::c, dataStart, diskSect, DiskBlock::Fat::ext, DiskBlock::fat, fatSectorsPerCluster, fatStart, IS_FAT_32, Address::l, rootStart, sectorAddress, and temp. Referenced by InitFileSystem(). { ConsoleWrite("Formatter signature:"); for (temp.c=0; temp.c<8; temp.c++){ ConsolePutChar(diskSect.fat.BS_OEMName[temp.c]); } ConsoleWrite("\rBytes per sector: "); ConsolePutUInt(diskSect.fat.BPB_BytsPerSec); ConsoleWrite("\rSectors per Cluster: "); ConsolePutUInt(diskSect.fat.BPB_SecPerClus); ConsoleWrite("\rReserved sectors: "); ConsolePutUInt(diskSect.fat.BPB_RsvdSecCnt); ConsoleWrite("\rNumber of FATs: "); ConsolePutUInt(diskSect.fat.BPB_NumFATs); ConsoleWrite("\rRoot entries: "); ConsolePutUInt(diskSect.fat.BPB_RootEntCnt); ConsoleWrite("\rTotal Sectors 16: "); ConsolePutUInt(diskSect.fat.BPB_TotSec16); ConsoleWrite("\rFat Size 16: "); ConsolePutUInt(diskSect.fat.BPB_FATSz16); ConsoleWrite("\rHidden Sectors: "); ConsolePutUInt(diskSect.fat.BPB_HiddSec); ConsoleWrite("\rTotal Sectors 32: "); ConsolePutUInt(diskSect.fat.BPB_TotSec32); /* Determine FAT Type (16/32) */ /* This should be done better, but it'll do for now. */ IS_FAT_32 = 1; if (diskSect.fat.BPB_RootEntCnt) IS_FAT_32 = 0; /* FAT32 does not have separate root entries. */ ConsoleWrite("\rFile system is "); if (IS_FAT_32){ ConsoleWrite("FAT32"); } else { ConsoleWrite("FAT16"); } ConsoleWrite("\rFile system signature is "); for (temp.c=0;temp. c<8; temp.c++) if (IS_FAT_32){ ConsolePutChar(diskSect.fat.ext._32.BS_FilSysType[temp.c]); } else { ConsolePutChar(diskSect.fat.ext._16.BS_FilSysType[temp.c]); } ConsoleWrite("\rVolume Label is "); for (temp.c=0; temp.c<11; temp.c++) if (IS_FAT_32){ ConsolePutChar(diskSect.fat.ext._32.BS_VolLab[temp.c]); } else { ConsolePutChar(diskSect.fat.ext._16.BS_VolLab[temp.c]); } /* OK, let's calculate */ /* First, let's get rid of the idea that we have byte addresses in the file system. Nope, let's only deal in physical disk sectors of 512 bytes. First we convert the FAT byter per sector value to "512B disk sectors per fat sector" value. */ diskSect.fat.BPB_BytsPerSec /= 512; /* Then we adjust the Sector per Cluster to mean physical disk sectors. in 99% of the cases it is already so because bytes per sector almost always is 512 in FAT. Maximum cluster size is 65536 bytes (128 disk sectors). */ fatSectorsPerCluster = diskSect.fat.BPB_SecPerClus *= diskSect.fat.BPB_BytsPerSec; /* Note: BPB_BytsPerSec has already been divided by 512 */ ConsoleWrite("\rSectors per Cluster: "); ConsolePutUInt(fatSectorsPerCluster); fatStart = (unsigned long)sectorAddress.l + (unsigned long)diskSect.fat.BPB_RsvdSecCnt * (unsigned long)diskSect.fat.BPB_BytsPerSec; ConsoleWrite("\rFAT Start sector: "); ConsolePutUInt(fatStart); rootStart = diskSect.fat.BPB_FATSz16; if (rootStart==0){ if (!IS_FAT_32) return 0x0b; /* should be FAT32; can not find root directory */ rootStart = diskSect.fat.ext._32.BPB_FATSz32; } rootStart *= diskSect.fat.BPB_NumFATs; rootStart *= diskSect.fat.BPB_BytsPerSec; /* ADJUSTED BytsPerSec! */ rootStart += fatStart; ConsoleWrite("\rRoot start sector: "); ConsolePutUInt(rootStart); dataStart = diskSect.fat.BPB_RootEntCnt >> 4; dataStart += rootStart; dataStart -= (fatSectorsPerCluster*2); /*first cluster is cluster 2*/ ConsoleWrite("\rData start sector: "); ConsolePutUInt(dataStart); ConsolePutChar(13); return 0; }

Public unsigned char FGetChar (   )

Read a character from current file. This can be called after calling OpenFile. It is a slow method for reading character based file data. fileSize holds the number of characters still left in file to be read, check for fileSize=0 to detect end-of-file. If FGetChar is called after the end of file is reached, it does nothing and returns 0. Definition at line 549 of file filesys.c. References DiskBlock::Raw::buf, dataBufPtr, diskSect, fileSize, Address::l, LoadNextSector(), Public, DiskBlock::raw, ReadDiskSector(), and sectorAddress. Referenced by GetAVIBlock(). { if (!fileSize) return 0; //return 0 for end-of-file if (dataBufPtr==0){ /* A file has been opened but not read from yet, so read the first sector. */ ReadDiskSector(sectorAddress.l); dataBufPtr = diskSect.raw.buf; } if (dataBufPtr>diskSect.raw.buf+511){ /* An end of sector has been reached, read the next sector */ if (LoadNextSector()){ /* Error, end-of-file according to FAT records */ return 0; /* must return something */ } dataBufPtr=diskSect.raw.buf; } /* Everything should now be ok for reading a byte. */ fileSize--; return (*dataBufPtr++); } Here is the call graph for this function:

unsigned long GetFatEntry (  unsigned long  clusterNumber  )

Return the FAT entry for cluster clusterNumber. Definition at line 81 of file filesys.c. References diskSect, DiskBlock::Fat16Table, DiskBlock::Fat32Table, fatStart, IS_FAT_32, Address::l, ReadDiskSector(), and sectorAddress. Referenced by ScanForFreeSector(). { unsigned char entryNumber; /* entry number inside page */ if (!IS_FAT_32){ //FAT16 entryNumber = clusterNumber & 0xff; clusterNumber >>= 8; }else{ //FAT32 entryNumber = clusterNumber & 0x7f; clusterNumber >>= 7; } clusterNumber += fatStart; if (sectorAddress.l != clusterNumber){ sectorAddress.l = clusterNumber; ReadDiskSector(sectorAddress.l); } if (IS_FAT_32){ clusterNumber=diskSect.Fat32Table[entryNumber]; return clusterNumber; } if ((clusterNumber=diskSect.Fat16Table[entryNumber])==0xffff) return 0xffffffff; return clusterNumber; } Here is the call graph for this function:

unsigned long GetNextSector (  unsigned long  currentSector  )

Calculate next sector from currentSector. Return sector address with MSB set if end of file. This is the essence of FAT filesystem: traversing through the file allocation table to scan for cluster chains. Definition at line 299 of file filesys.c. References Address::b, Address::B::b0, Address::B::b1, Address::B::b3, dataStart, diskSect, DiskBlock::Fat16Table, DiskBlock::Fat32Table, fatSectorsPerCluster, fatStart, IS_FAT_32, Address::l, ReadDiskSector(), and sectorAddress. Referenced by LoadNextSector(), and OpenFile(). { addressType fatSector; unsigned char entryNumber; /* how manyth sector from start of data area -> fatsector */ fatSector.l = currentSector - dataStart; /* Check for cluster boundary */ /* if we're not in cluster boundary then return currentsector + 1 */ if ((fatSector.b.b0 + 1) % fatSectorsPerCluster){ return currentSector + 1; } /* is the value negative? then return currentSector + 1 */ if (fatSector.b.b3 & 0x80) { return currentSector + 1; } /* The trivial conditions are not met, we actually do need to look up the next sector info from FAT tables in the disk.*/ /* convert fatSector from CurrentSectorN to currentClusterN */ fatSector.l /= fatSectorsPerCluster; /* calculate which page (fatSector) and entry of FAT table correspond to current sector */ if (!IS_FAT_32){ //FAT16 entryNumber = fatSector.b.b0; /* 256 entries / page in FAT16 table */ fatSector.l >>= 8; /* Divide by 256 (n of entries/page in FAT32 table */ }else{ //FAT32 entryNumber =(fatSector.b.b0 & 0x7f); /* 128 entries/page in FAT32 tbl */ fatSector.l >>= 7; /* Divide by 128 (n of entries/sector in FAT32 table */ } /* Get sector address for the needed page */ fatSector.l += fatStart; /* Load (if needed) table page from disk */ if (sectorAddress.l != fatSector.l){ sectorAddress.l = fatSector.l; /* (not needed because mmc.c does this) */ ReadDiskSector(fatSector.l); ConsolePutChar('n'); } /* Now there should be correct FAT entry page in memory... */ if (!IS_FAT_32){ //FAT16 fatSector.l = diskSect.Fat16Table[entryNumber]; /* Check for FAT16 end-of-file condition */ if ((fatSector.b.b1 == 0xff) && (fatSector.b.b0 == 0xff)){ /* End of file */ fatSector.b.b3 = 0xff; /* return a large value (fat32 compatible) */ return fatSector.l; } }else{ //FAT32 fatSector.l = diskSect.Fat32Table[entryNumber] & 0x0fffffff; /* Check for FAT32 end-of-file condition */ if ((fatSector.b.b3&0x08) //Quick test && (fatSector.l>0x0ffffff0)){ //Complete test /* End of file */ return 0xffffffff; /* return EOF*/ } } /* now fatSector.l contains the proper next cluster value */ fatSector.l *= fatSectorsPerCluster; /* now fatSector.l contains the next sector value */ fatSector.l += dataStart; /* now fatSector.l contains the proper absolute sector address */ return fatSector.l; } Here is the call graph for this function:

Public unsigned char InitFileSystem (   )

Start the filing system and initialize all necessary subsystems. Init storage and file system. FAT16 and FAT32 are supported Definition at line 902 of file filesys.c. References Address::b, Address::B::b0, Address::B::b1, Address::B::b2, Address::B::b3, DiskBlock::Raw::buf, dataStart, diskSect, FatInitGlobals(), fatStart, freeSector, InitStorage(), Address::l, Public, DiskBlock::raw, ReadDiskSector(), rootStart, and sectorAddress. Referenced by main(). { unsigned char c; /* Initialize variables to sane values in case of error exit. */ fatStart = 0; rootStart = 0; dataStart = 0; freeSector = 0; ConsoleWrite("Init: Filesystem; supports: MBR, FAT16, FAT32\r"); ConsoleWrite("Trying to bring up storage...\r"); /* Initialize the storage system */ if ((c=InitStorage())){ ConsoleWrite("Storage init returns error "); ConsolePutUInt(c); ConsolePutChar(13); return c; /* Error in InitStorage */ } ConsoleWrite("Storage ok.\rSector 0 read..."); /* Load MBR */ sectorAddress.l = 0; /* the first sector on disk */ ReadDiskSector(0); ConsoleWrite("ok.\rSector signature..."); /* Ok, it should be a MBR sector. Let's verify */ if (diskSect.raw.buf[510] != 0x55) return 8; /* sector 0 is not MBR. */ if (diskSect.raw.buf[511] != 0xaa) return 8; /* sector 0 is not MBR. */ ConsoleWrite("ok.\rPartition 1..."); /* This checks that partition 1 is active. Alter code to allow * other partition configurations. */ if (diskSect.raw.buf[0x1be] == 0x80){ sectorAddress.b.b0 = diskSect.raw.buf[0x1c6]; sectorAddress.b.b1 = diskSect.raw.buf[0x1c7]; sectorAddress.b.b2 = diskSect.raw.buf[0x1c8]; sectorAddress.b.b3 = diskSect.raw.buf[0x1c9]; ConsoleWrite (" active"); }else{ //-------- DEBUG: Uncomment if you want to explore the sector //DumpDiskSector(); //while (!KEY_BUTTON); sectorAddress.b.b0 = diskSect.raw.buf[0x1c6]; sectorAddress.b.b1 = diskSect.raw.buf[0x1c7]; sectorAddress.b.b2 = diskSect.raw.buf[0x1c8]; sectorAddress.b.b3 = diskSect.raw.buf[0x1c9]; } // return 9; /* No active partition*/ ConsoleWrite(" at sector "); ConsolePutHex8(sectorAddress.b.b3); ConsolePutHex8(sectorAddress.b.b2); ConsolePutHex8(sectorAddress.b.b1); ConsolePutHex8(sectorAddress.b.b0); ConsolePutChar('\r'); /* Now leave MBR and load sector 0 of partition */ //SeekDiskSectorToRead(); //ReadDiskSector(); /* to global buffer */ ReadDiskSector(sectorAddress.l); if (FatInitGlobals()){ return 0x0a; /* FAT init failed */ } return 0; /* All ok return */ } Here is the call graph for this function:

unsigned char LoadNextSector (   )

Traverse to next sector in file or directory. End of File Definition at line 529 of file filesys.c. References Address::b, Address::B::b1, GetNextSector(), Address::l, ReadDiskSector(), and sectorAddress. Referenced by FGetChar(). { sectorAddress.l = GetNextSector(sectorAddress.l); if (sectorAddress.b.b1 & 0x80){ return 0x0d; /*EOF*/ } if (ReadDiskSector(sectorAddress.l)){ return 0x0d; /*EOF*/ } return 0; /* All OK return */ } Here is the call graph for this function:

Public unsigned char OpenFile (  unsigned int  fileNumber  )

Open a file for reading. Prepares the Filing System to read a data file from the storage. Files are referred to by their numbers, not file names. This makes the system generic, not necessarily needing a complex file system such as FAT. The way to assign numbers to files is implementation dependent. Returns 0 when ok, error code otherwise. Parameters: fileNumber  number of file, starting from beginning of storage, to open. What this function actually does, is: it starts reading the FAT records from start of the root directory, traversing through subdirectories as it encounters them. When the fileNumber'th valid record is encountered, it sets sectorAddress to point to its first data sector but doesn't load any sector. fileSize is loaded with the size in bytes indicated in the FAT record. Additionally, if it's called with 0 as the fileNumber and it happens to see an empty directory record, it registers a new file with name RECnnnnn.WAV starting from cluster fragment[0].start with file size from fragment[0].length Definition at line 598 of file filesys.c. References DirRecordUnion::Entry::Attr, Temp::c, currentFileName, dataBufPtr, dataStart, DiskBlock::dir, dirLevel, dirStack, diskSect, displayText, directoryStack::entry, DirRecordUnion::entry, fatSectorsPerCluster, DirRecordUnion::Entry::FileSize, fileSize, fragment, DirRecordUnion::Entry::FstClusHi, DirRecordUnion::Entry::FstClusLo, GetNextSector(), InitMMC(), Address::l, fragmentEntry::length, MAX_NUMBER_SUBDIRECTORIES, DirRecordUnion::Entry::Name, Public, ReadDiskSector(), rootStart, directoryStack::sector, sectorAddress, fragmentEntry::start, temp, and WriteDiskSector(). Referenced by main(), and WriteClusterChain(). { char tempc; ConsoleWrite("\rFilesystem: Looking for file "); ConsolePutUInt(fileNumber); ConsoleWrite("... "); /* Start at the start of root directory. */ dirLevel = 0; /* At root directory */ dirStack[dirLevel].sector=rootStart; dirStack[dirLevel].entry=0; if (fileNumber==0){ fileNumber = 32766; //use max-1 value for scanning for free entry } while (fileNumber){ if (dirStack[dirLevel].entry==0){ /* At the start of new dir, load first disk sector */ while (ReadDiskSector(dirStack[dirLevel].sector)){ InitMMC; } } temp.c = dirStack[dirLevel].entry; /* We are now looking at FAT directory structure. */ /* Is current entry empty? */ if ((diskSect.dir[temp.c].entry.Name[0]==0) ||(diskSect.dir[temp.c].entry.Name[0]==0xe5)){ /* Yes. Are we supposed to make an entry now? */ if (fileNumber>30000){ //yes, this is actually a request to write file directory entry!; fileNumber = 32767-fileNumber; diskSect.dir[temp.c].entry.Name[0] ='R'; diskSect.dir[temp.c].entry.Name[1] ='E'; diskSect.dir[temp.c].entry.Name[2] ='C'; diskSect.dir[temp.c].entry.Name[7] =(fileNumber%10)+'0'; fileNumber /= 10; diskSect.dir[temp.c].entry.Name[6] =(fileNumber%10)+'0'; fileNumber /= 10; diskSect.dir[temp.c].entry.Name[5] =(fileNumber%10)+'0'; fileNumber /= 10; diskSect.dir[temp.c].entry.Name[4] =(fileNumber%10)+'0'; fileNumber /= 10; diskSect.dir[temp.c].entry.Name[3] =(fileNumber%10)+'0'; diskSect.dir[temp.c].entry.Name[8] ='W'; diskSect.dir[temp.c].entry.Name[9] ='A'; diskSect.dir[temp.c].entry.Name[10]='V'; diskSect.dir[temp.c].entry.Attr = 0; diskSect.dir[temp.c].entry.FstClusHi = (fragment[0].start >> 16); diskSect.dir[temp.c].entry.FstClusLo = (fragment[0].start & 0xffff); diskSect.dir[temp.c].entry.FileSize = (fragment[0].length); ConsoleWrite(" Making Directory Entry "); WriteDiskSector(sectorAddress.l); return 99; //created a FAT entry } //register file } /* Does current entry point to a regular file? */ /* Attributes: NO directory, NO volume id, NO system, NO hidden */ if (((diskSect.dir[temp.c].entry.Attr & 222) == 0) && (diskSect.dir[temp.c].entry.Name[0] != 0xe5) && (diskSect.dir[temp.c].entry.Name[0] != 0) ){ /* It is a regular file. */ if (!(--fileNumber)){ /* ------------ FILE FOUND ------------- */ sectorAddress.l = ((unsigned long)diskSect.dir[temp.c].entry.FstClusHi<<16) + diskSect.dir[temp.c].entry.FstClusLo; sectorAddress.l *= fatSectorsPerCluster; sectorAddress.l += dataStart; fileSize = diskSect.dir[temp.c].entry.FileSize; dataBufPtr = 0; /* Reset data buffer ptr for FGetChar */ ConsoleWrite("found, FAT name is \""); for (tempc=0; tempc<11; tempc++){ ConsolePutChar(diskSect.dir[temp.c].entry.Name[tempc]); } //Store file name nicely for displaying on screen :) for (tempc=0; tempc<8; tempc++){ currentFileName[tempc]=diskSect.dir[temp.c].entry.Name[tempc]; } currentFileName[8]='.'; currentFileName[9]=diskSect.dir[temp.c].entry.Name[8]; currentFileName[10]=diskSect.dir[temp.c].entry.Name[9]; currentFileName[11]=diskSect.dir[temp.c].entry.Name[10]; displayText[0]=' '; for (tempc=0; tempc<12; tempc++){ displayText[tempc+1]=currentFileName[tempc]; } ConsoleWrite("\"\rFile size: "); ConsolePutUInt(fileSize); ConsoleWrite("bytes. "); ConsoleWrite("Start cluster: "); ConsolePutHex8(diskSect.dir[temp.c].entry.FstClusHi); ConsolePutHex8(diskSect.dir[temp.c].entry.FstClusLo); ConsoleWrite("h, sector "); ConsolePutUInt(sectorAddress.l); ConsoleWrite("decimal.\r"); return 0; /* File found, All OK return */ } } /* it was a regular file */ /* Is it a subdirectory? */ if (((diskSect.dir[temp.c].entry.Attr & 16) != 0) && (diskSect.dir[temp.c].entry.Name[0] != '.') /* skip . and .. */ && (diskSect.dir[temp.c].entry.Name[0] != 0xe5) && (diskSect.dir[temp.c].entry.Name[0] != 0) ){ /* It is a subdirectory. */ if (dirLevel<MAX_NUMBER_SUBDIRECTORIES-1){ /* Yes, we have room in dirStack to traverse deeper. */ dirLevel++; /* Advance to next directory level */ sectorAddress.l = ((unsigned long)diskSect.dir[temp.c].entry.FstClusHi<<16) + diskSect.dir[temp.c].entry.FstClusLo; sectorAddress.l *= fatSectorsPerCluster; sectorAddress.l += dataStart; /* Prepare for loading. */ dirStack[dirLevel].sector = sectorAddress.l; dirStack[dirLevel].entry = 255; /* Magic number */ } /* we had room in dirStack */ } /* it was a subdirectory */ /* Have we reached the end of the directory? */ if (diskSect.dir[temp.c].entry.Name[0] == 0){ /* It's the end of directory. */ /* Is it the end of root directory? */ if (dirLevel == 0){ /* End of root directory, end of all files in volume */ ConsoleWrite("File not found.\r"); sectorAddress.l = dataStart; /* when in error point to start of data */ return 0x0c; /* File Not Found return */ } /* End of subdirectory, return from subdirectory */ dirLevel--; ReadDiskSector(dirStack[dirLevel].sector); /* restore temp entry pointer */ temp.c = dirStack[dirLevel].entry; } /* it was end of directory */ /* Advance to next entry */ temp.c++; /* If we just went to a subdir, set temp entry pointer to 0 */ if (dirStack[dirLevel].entry == 255){ /* Magic Number 255: we have gone to a subdirectory */ temp.c=0; } if (temp.c==16){ /* End of sector */ /* Prepare to load next sector */ dirStack[dirLevel].sector = GetNextSector (dirStack[dirLevel].sector); temp.c=0; } dirStack[dirLevel].entry = temp.c; } /* Control should never reach this far, end of root directory should occur first. */ sectorAddress.l = dataStart; /* when in error point to start of data */ return 0x0c; /* File Not Found return */ } Here is the call graph for this function:

void PConvertClusterToSector (  unsigned long *  cluster  )

Convert cluster number to sector number. Definition at line 74 of file filesys.c. References dataStart, and fatSectorsPerCluster. Referenced by ScanForFreeSector(). { *cluster*=fatSectorsPerCluster; *cluster+=dataStart; }

void PConvertSectorToCluster (  unsigned long *  sector  )

Convert sector number to cluster number. Definition at line 68 of file filesys.c. References dataStart, and fatSectorsPerCluster. Referenced by ScanForFreeSector(), and WriteClusterChain(). { *sector-=dataStart; *sector/=fatSectorsPerCluster; }

unsigned char ScanForFreeSector (   )

Search for next free sector. If freeSector is zero, a new file should be allocated. Definition at line 244 of file filesys.c. References dataStart, fatSectorsPerCluster, freeSector, GetFatEntry(), PConvertClusterToSector(), and PConvertSectorToCluster(). Referenced by Record(). { //ConsoleWrite("\rLooking for free space starting from "); if ((freeSector) && (freeSector-dataStart+1)%fatSectorsPerCluster){ //Still room in current cluster... freeSector++; //ConsoleWrite("free at sector "); //ConsolePutUInt(freeSector); return 1; } if (freeSector){ //Advance to next sector freeSector++; //switch from using sectors to using clusters PConvertSectorToCluster(&freeSector); }else{ freeSector=3; //starting cluster entry (should be 2?) } //scan until free entry is found //freeSector actually counts clusters here. while(GetFatEntry(freeSector)){ freeSector++; } ConsoleWrite("F"); ConsolePutUInt(freeSector); //while (!KEY_BUTTON); //ConsoleWrite("free at cluster "); //ConsolePutUInt(freeSector); //switch back from using clusters to using sectors. PConvertClusterToSector(&freeSector); //ConsoleWrite("sector "); //ConsolePutUInt(freeSector); return 1; } Here is the call graph for this function:

void WriteClusterChain (   )

Write a cluster chain to FAT for a fragment. This takes its input from the fragment[] table. It currently has the ability to register only single fragment from fragment[0]. fragment[1].start should contain the next cluster number after this fragment or 0x0fffffff if this is the last fragment. This function currently also registers a FAT directory entry for the file to first free entry slot in the directory structure. If no free directory entries are available, it will behave unpredictably. This could happen in FAT32. OpenFile(0) is a special call to register a directory entry for fragment[0]. Todo: update second FAT too update second FAT too Definition at line 125 of file filesys.c. References Temp::c, diskSect, DiskBlock::Fat16Table, DiskBlock::Fat32Table, fatSectorsPerCluster, fatStart, fragment, IS_FAT_32, Address::l, fragmentEntry::length, OpenFile(), PConvertSectorToCluster(), ReadDiskSector(), sectorAddress, fragmentEntry::start, temp, and WriteDiskSector(). Referenced by Record(). { xdata unsigned long currentCluster; //is now fragment[0].start xdata unsigned long fragSize; //is now fragment[0].length xdata unsigned long fatPageSector; xdata unsigned char entryNumber; // PREPARE // Calculate starting cluster number... currentCluster = fragment[0].start; PConvertSectorToCluster(&currentCluster); fragSize = fragment[0].length; //size in sectors // Write cluster number and size in bytes to fragment[0] // for the function that registers directory entries fragment[0].start = currentCluster; fragment[0].length *= 512; // Locate the relevant page in FAT clusterchain records fatPageSector = currentCluster; if (!IS_FAT_32){ //FAT16 entryNumber = fatPageSector & 0xff; fatPageSector >>= 8; }else{ //FAT32 entryNumber = fatPageSector & 0x7f; fatPageSector >>= 7; } fatPageSector += fatStart; ConsoleWrite("Writing clusterchain from: "); ConsolePutUInt(currentCluster); ConsoleWrite("Fragment size (sectors): "); ConsolePutUInt(fragSize); ConsoleWrite("FatPageSector: "); ConsolePutUInt(fatPageSector); ConsoleWrite("EntryNumber: "); ConsolePutUInt(entryNumber); // WRITE CLUSTER CHAIN TO FIRST FAT while (fragSize>fatSectorsPerCluster){ // while more than 1 cluster left... // is the FAT clusterchain page changed? if (sectorAddress.l != fatPageSector){ // Yes, have we advanced by 1 sector? if (sectorAddress.l == (fatPageSector - 1)){ //Yes, we must save the edited sector WriteDiskSector (sectorAddress.l); } // at least we need to load the new clusterchain page sectorAddress.l = fatPageSector; ReadDiskSector(sectorAddress.l); }//Load/Save FAT sector // Register Middle Entry currentCluster++; //advancce to next cluster //fragSize-=fatSectorsPerCluster; //we will register one cluster //to avoid memory spill in C compiler, the preceding line is written as: for (temp.c = fatSectorsPerCluster;temp.c;temp.c--){ fragSize--; } if (IS_FAT_32){ diskSect.Fat32Table[entryNumber]=currentCluster; }else{ diskSect.Fat16Table[entryNumber]=(currentCluster&0xffff); } // Calculate next entry position in FAT records fatPageSector = currentCluster; if (!IS_FAT_32){ //FAT16 entryNumber = fatPageSector & 0xff; fatPageSector >>= 8; }else{ //FAT32 entryNumber = fatPageSector & 0x7f; fatPageSector >>= 7; } fatPageSector += fatStart; }//while // WRITE THE FINAL ENTRY TO FAT CLUSTERCHAIN // is the FAT clusterchain page changed? if (sectorAddress.l != fatPageSector){ // Yes, have we advanced by 1 sector? if (sectorAddress.l == (fatPageSector - 1)){ //Yes, we must save the edited sector WriteDiskSector (sectorAddress.l); } // at least we need to load the new clusterchain page sectorAddress.l = fatPageSector; ReadDiskSector(sectorAddress.l); }//Load/Save FAT sector //Write the Last entry if (IS_FAT_32){ diskSect.Fat32Table[entryNumber]=fragment[1].start; }else{ diskSect.Fat16Table[entryNumber]=(fragment[1].start & 0xffff); } WriteDiskSector(sectorAddress.l); //Write last sector OpenFile(0); //Register FAT entry } Here is the call graph for this function:

---

Variable Documentation

xdata char currentFileName[12]

8 first characters of current file name Definition at line 65 of file filesys.c. Referenced by main(), and OpenFile().

data unsigned long dataStart

(In FAT the start is cluster 2, so dataStart actually points to 2 clusters before the start of data area) Definition at line 29 of file filesys.c. Referenced by BuildFragmentTable(), FatInitGlobals(), GetNextSector(), InitFileSystem(), OpenFile(), PConvertClusterToSector(), PConvertSectorToCluster(), and ScanForFreeSector().

xdata unsigned char dirLevel = 0

Current directory level, 0=Root directory. Definition at line 59 of file filesys.c. Referenced by OpenFile().

xdata struct directoryStack dirStack[MAX_NUMBER_SUBDIRECTORIES]

Directory traversing structure. Referenced by OpenFile().

data unsigned char fatSectorsPerCluster

FAT Global sectors per cluster. Definition at line 32 of file filesys.c. Referenced by BuildFragmentTable(), FatInitGlobals(), GetNextSector(), OpenFile(), PConvertClusterToSector(), PConvertSectorToCluster(), Record(), ScanForFreeSector(), and WriteClusterChain().

data unsigned long fatStart

Starting sector of FAT table. Definition at line 21 of file filesys.c. Referenced by BuildFragmentTable(), FatInitGlobals(), GetFatEntry(), GetNextSector(), InitFileSystem(), and WriteClusterChain().

xdata unsigned long fileSize

Size of current file to play. Definition at line 47 of file filesys.c. Referenced by FGetChar(), GetAVIBlock(), OpenFile(), and PlayAvi().

xdata struct fragmentEntry fragment[MAX_NUMBER_FRAGMENTS]

Fragment Table. Maximum fragment size is (4G-1 sectors) Referenced by BuildFragmentTable(), OpenFile(), PlayCurrentFile(), Record(), and WriteClusterChain().

xdata unsigned long freeSector = 0

Next free cluster number. Definition at line 62 of file filesys.c. Referenced by InitFileSystem(), Record(), and ScanForFreeSector().

data unsigned long rootStart

Starting sector of root directory. Definition at line 24 of file filesys.c. Referenced by FatInitGlobals(), InitFileSystem(), and OpenFile().

---

All software copyright 2000-2004 VLSI Solution OY. Redistribution of these software modules are limited to promotional use only and only with the VS1011 / VS1002 / VS1003 MP3-Evakit evaluation boards. Free or commercial use of these software modules in MP3 players is ok if the product includes MP3 decoder chip(s) from VLSI. You can request the complete (compilable) package from mp3@vlsi.fi