/*****************************************************************************\*              efs - General purpose Embedded Filesystem library              **          --------------------- -----------------------------------          **                                                                             ** Filename : fs.c                                                             ** Description : These are general filesystem functions, supported by the      **               functions of dir.c and fat.c  file.c uses these functions     **               heavily, but is not used by fs.c (not true anymore)           **                                                                             ** This program is free software; you can redistribute it and/or               ** modify it under the terms of the GNU General Public License                 ** as published by the Free Software Foundation; version 2                     ** of the License.                                                             *                                                                              ** This program is distributed in the hope that it will be useful,             ** but WITHOUT ANY WARRANTY; without even the implied warranty of              ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               ** GNU General Public License for more details.                                **                                                                             ** As a special exception, if other files instantiate templates or             ** use macros or inline functions from this file, or you compile this          ** file and link it with other works to produce a work based on this file,     ** this file does not by itself cause the resulting work to be covered         ** by the GNU General Public License. However the source code for this         ** file must still be made available in accordance with section (3) of         ** the GNU General Public License.                                             **                                                                             ** This exception does not invalidate any other reasons why a work based       ** on this file might be covered by the GNU General Public License.            **                                                                             **                                                    (c)2006 Lennart Yseboodt **                                                    (c)2006 Michael De Nil   *\*****************************************************************************//*****************************************************************************/#include "fs.h"#include "fat.h"#include "dir.h"/*****************************************************************************//* ****************************************************************************   * eint16 fs_initFs(FileSystem *fs,Partition *part) * Description: This functions glues the initialisation of the filesystem together. * It loads the volumeID, computes the FS type and searches for the rootsector. * Return value: Returns 0 on succes and -1 on error (if magic code is wrong)*/eint16 fs_initFs(FileSystem *fs,Partition *part){	if(!fs_isValidFat(part)){		return(-1);	}	fs->part=part;	fs_loadVolumeId(fs,part);	if(!fs_verifySanity(fs))return(-2);  	fs_countDataSectors(fs);	fs_determineFatType(fs);	fs_findFirstSectorRootDir(fs);	fs_initCurrentDir(fs); 	return(0);}/*****************************************************************************/ /* ****************************************************************************   * eint16 fs_isValidFat(Partition *part) * Description: This functions loads the volumeID and checks if the magic * value is present. * Return value: returns 0 when magic code is missing, 1 if it is there.*/eint16 fs_isValidFat(Partition *part){	euint8 *buf;		buf=part_getSect(part,0,IOM_MODE_READONLY|IOM_MODE_EXP_REQ); /* Load Volume label */	if( ex_getb16(buf,0x1FE) != 0xAA55 ){		return (0);	}	part_relSect(part,buf);	return(1);}/*****************************************************************************/ /* ****************************************************************************   * void fs_loadVolumeId(FileSystem *fs, Partition *part) * Description: This function loads all relevant fields from the volumeid.*/void fs_loadVolumeId(FileSystem *fs, Partition *part){	euint8 *buf;		buf=part_getSect(part,0,IOM_MODE_READONLY|IOM_MODE_EXP_REQ);		fs->volumeId.BytesPerSector=ex_getb16(buf,0x0B);	fs->volumeId.SectorsPerCluster=*((eint8*)(buf+0x0D));	fs->volumeId.ReservedSectorCount=ex_getb16(buf,0x0E);	fs->volumeId.NumberOfFats=*((eint8*)(buf+0x10));	fs->volumeId.RootEntryCount=ex_getb16(buf,0x11);	fs->volumeId.SectorCount16=ex_getb16(buf,0x13);	fs->volumeId.FatSectorCount16=ex_getb16(buf,0x16);	fs->volumeId.SectorCount32=ex_getb32(buf,0x20);	fs->volumeId.FatSectorCount32=ex_getb32(buf,0x24);	fs->volumeId.RootCluster=ex_getb32(buf,0x2C);		part_relSect(part,buf);	}/*****************************************************************************/ /* ****************************************************************************   * esint16 fs_verifySanity(FileSystem *fs) * Description: Does some sanity calculations. * Return value: 1 on success, 0 when discrepancies were found.*/esint16 fs_verifySanity(FileSystem *fs){	esint16 sane=1; /* Sane until proven otherwise */	/* First check, BPS, we only support 512 */	if(fs->volumeId.BytesPerSector!=512)sane=0;	/* Check is SPC is valid (multiple of 2, and clustersize >=32KB */	if(!((fs->volumeId.SectorsPerCluster == 1 ) |	     (fs->volumeId.SectorsPerCluster == 2 ) |	     (fs->volumeId.SectorsPerCluster == 4 ) |	     (fs->volumeId.SectorsPerCluster == 8 ) |	     (fs->volumeId.SectorsPerCluster == 16) |	     (fs->volumeId.SectorsPerCluster == 32) |	     (fs->volumeId.SectorsPerCluster == 64) ))sane=0;	/* Any number of FAT's should be supported... (untested) */	/* There should be at least 1 reserved sector */	if(fs->volumeId.ReservedSectorCount==0)sane=0;	if(fs->volumeId.FatSectorCount16 != 0){		if(fs->volumeId.FatSectorCount16 > fs->part->disc->partitions[fs->part->activePartition].numSectors)sane=0;	}else{		if(fs->volumeId.FatSectorCount32 > fs->part->disc->partitions[fs->part->activePartition].numSectors)sane=0;	} 	return(sane);}/*****************************************************************************//* ****************************************************************************   * void fs_countDataSectors(FileSystem *fs) * Description: This functions calculates the sectorcounts, fatsectorcounts and * dataclustercounts. It fills in the general fields.*/void fs_countDataSectors(FileSystem *fs){  euint32 rootDirSectors,dataSectorCount;  rootDirSectors=((fs->volumeId.RootEntryCount*32) +                 (fs->volumeId.BytesPerSector - 1)) /                 fs->volumeId.BytesPerSector;  if(fs->volumeId.FatSectorCount16 != 0)  {    fs->FatSectorCount=fs->volumeId.FatSectorCount16;    fs->volumeId.FatSectorCount32=0;  }  else  {    fs->FatSectorCount=fs->volumeId.FatSectorCount32;    fs->volumeId.FatSectorCount16=0;  }  if(fs->volumeId.SectorCount16!=0)  {    fs->SectorCount=fs->volumeId.SectorCount16;    fs->volumeId.SectorCount32=0;  }  else  {    fs->SectorCount=fs->volumeId.SectorCount32;    fs->volumeId.SectorCount16=0;  }  dataSectorCount=fs->SectorCount - (                  fs->volumeId.ReservedSectorCount +                  (fs->volumeId.NumberOfFats * fs->FatSectorCount) +                  rootDirSectors);  fs->DataClusterCount=dataSectorCount/fs->volumeId.SectorsPerCluster;}/*****************************************************************************/ /* ****************************************************************************   * void fs_determineFatType(FileSystem *fs) * Description: This function looks af the Dataclustercount and determines the * FAT type. It fills in fs->type.*/void fs_determineFatType(FileSystem *fs){	if(fs->DataClusterCount < 4085)	{		fs->type=FAT12;		fs->volumeId.RootCluster=0;	}	else if(fs->DataClusterCount < 65525)	{		fs->type=FAT16;		fs->volumeId.RootCluster=0;	}	else	{		fs->type=FAT32;	}}/*****************************************************************************/ /* ****************************************************************************   * void fs_findFirstSectorRootDir(FileSystem *fs) * Description: This functions fills in the fs->FirstSectorRootDir field, even * for FAT32, although that is not necessary (because you have FirstClusterRootDir).*/void fs_findFirstSectorRootDir(FileSystem *fs){	if(fs->type==FAT32)		fs->FirstSectorRootDir = fs->volumeId.ReservedSectorCount + 		                         (fs->volumeId.NumberOfFats*fs->volumeId.FatSectorCount32) +								 (fs->volumeId.RootCluster-2)*fs->volumeId.SectorsPerCluster;	else		fs->FirstSectorRootDir = fs->volumeId.ReservedSectorCount + 		                         (fs->volumeId.NumberOfFats*fs->volumeId.FatSectorCount16);}/*****************************************************************************/ void fs_initCurrentDir(FileSystem *fs){	fs->FirstClusterCurrentDir = fs_getFirstClusterRootDir(fs);}/*****************************************************************************//* ****************************************************************************   * long fs_clusterToSector(FileSystem *fs,euint32 cluster) * Description: This function converts a clusternumber in the effective sector * number where this cluster starts. Boundary check is not implemented * Return value: A long is returned representing the sectornumber.*/euint32 fs_clusterToSector(FileSystem *fs,euint32 cluster){	eint32 base;		if(fs->type==FAT32)	{		base=			fs->volumeId.ReservedSectorCount+			fs->FatSectorCount*fs->volumeId.NumberOfFats;	}	else	{		base=			fs->volumeId.ReservedSectorCount+			fs->FatSectorCount*fs->volumeId.NumberOfFats+			fs->volumeId.RootEntryCount/16;	}	return( base + (cluster-2)*fs->volumeId.SectorsPerCluster );}/*****************************************************************************/ /* Function is unused, but may be usefull */euint32 fs_sectorToCluster(FileSystem *fs,euint32 sector){	eint32 base;		if(fs->type==FAT32)	{		base=