VLSI Solution Oy Evaluation MP3 Player Source Code Documentation

filesys.c

Go to the documentation of this file.

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


/* This needs display to put file name directly to display buffer */
/* It's not pretty but it saves a lot of memory! */
#include "display.h"



data  unsigned long fatStart;

data unsigned long rootStart;

data unsigned long dataStart;

data unsigned char fatSectorsPerCluster;



#define MAX_NUMBER_FRAGMENTS 10


xdata struct fragmentEntry {
  unsigned long start; 
  unsigned long length; 
} fragment[MAX_NUMBER_FRAGMENTS];

xdata unsigned long fileSize;

#define MAX_NUMBER_SUBDIRECTORIES 5

xdata struct directoryStack {
  unsigned long sector; 
  unsigned char entry;  
} dirStack[MAX_NUMBER_SUBDIRECTORIES];

xdata unsigned char dirLevel = 0;

xdata unsigned long freeSector = 0;

xdata char currentFileName[12];

void PConvertSectorToCluster(unsigned long *sector){
  *sector-=dataStart;
  *sector/=fatSectorsPerCluster;
}

void PConvertClusterToSector(unsigned long *cluster){
  *cluster*=fatSectorsPerCluster;
  *cluster+=dataStart;
}


unsigned long GetFatEntry(unsigned long clusterNumber){
  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;
}




void WriteClusterChain(){

  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

}




unsigned char ScanForFreeSector(){

  //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;
}


unsigned long GetNextSector(unsigned long currentSector){
  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;
}


Public unsigned char BuildFragmentTable(){

  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;
}



unsigned char LoadNextSector(){
  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 */
}
  
Public unsigned char FGetChar(){

  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++);
}



Public unsigned char OpenFile(unsigned int fileNumber){
  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 */
}



unsigned char FatInitGlobals(){

  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 InitFileSystem(){
  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 */

}

---

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