317 lines
11 KiB
C
317 lines
11 KiB
C
/*#######################################################################################
|
||
FAT for AVR (MMC/SD)
|
||
|
||
Copyright (C) 2004 Ulrich Radig
|
||
|
||
Bei Fragen und Verbesserungen wendet euch per EMail an
|
||
|
||
mail@ulrichradig.de
|
||
|
||
oder im Forum meiner Web Page : www.ulrichradig.de
|
||
|
||
|
||
Dieses Programm ist freie Software. Sie können es unter den Bedingungen der
|
||
GNU General Public License, wie von der Free Software Foundation veröffentlicht,
|
||
weitergeben und/oder modifizieren, entweder gemäß Version 2 der Lizenz oder
|
||
(nach Ihrer Option) jeder späteren Version.
|
||
|
||
Die Veröffentlichung dieses Programms erfolgt in der Hoffnung,
|
||
daß es Ihnen von Nutzen sein wird, aber OHNE IRGENDEINE GARANTIE,
|
||
sogar ohne die implizite Garantie der MARKTREIFE oder der VERWENDBARKEIT
|
||
FÜR EINEN BESTIMMTEN ZWECK. Details finden Sie in der GNU General Public License.
|
||
|
||
Sie sollten eine Kopie der GNU General Public License zusammen mit diesem
|
||
Programm erhalten haben.
|
||
Falls nicht, schreiben Sie an die Free Software Foundation,
|
||
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
|
||
#######################################################################################*/
|
||
|
||
#include "fat.h"
|
||
|
||
unsigned char cluster_size;
|
||
unsigned int fat_offset;
|
||
unsigned int cluster_offset;
|
||
unsigned int volume_boot_record_addr;
|
||
|
||
//############################################################################
|
||
//Auslesen Cluster Size der MMC/SD Karte und Speichern der größe ins EEprom
|
||
//Auslesen Cluster Offset der MMC/SD Karte und Speichern der größe ins EEprom
|
||
void fat_init (uint8_t *Buffer)
|
||
//############################################################################
|
||
{
|
||
struct BootSec *bootp; //Zeiger auf Bootsektor Struktur
|
||
|
||
// unsigned char Buffer[BlockSize];
|
||
|
||
//volume_boot_record_addr = fat_addr (Buffer);
|
||
mmc_read_sector (MASTER_BOOT_RECORD,Buffer); //Read Master Boot Record
|
||
if (Buffer[510] == 0x55 && Buffer[511] == 0xAA)
|
||
{
|
||
FAT_DEBUG("MBR Signatur found!\r\n");
|
||
}
|
||
else
|
||
{
|
||
FAT_DEBUG("MBR Signatur not found!\r\n");
|
||
while(1);
|
||
}
|
||
|
||
|
||
volume_boot_record_addr = Buffer[VBR_ADDR] + (Buffer[VBR_ADDR+1] << 8);
|
||
|
||
mmc_read_sector (volume_boot_record_addr,Buffer);
|
||
if (Buffer[510] == 0x55 && Buffer[511] == 0xAA)
|
||
{
|
||
FAT_DEBUG("VBR Signatur found!\r\n");
|
||
}
|
||
else
|
||
{
|
||
FAT_DEBUG("VBR Signatur not found!\r\n");
|
||
volume_boot_record_addr = MASTER_BOOT_RECORD;//<- added by Hennie
|
||
mmc_read_sector (MASTER_BOOT_RECORD,Buffer); //Read Master Boot Record
|
||
}
|
||
|
||
bootp=(struct BootSec *)Buffer;
|
||
cluster_size = bootp->BPB_SecPerClus;
|
||
fat_offset = bootp->BPB_RsvdSecCnt;
|
||
|
||
cluster_offset = ((bootp->BPB_BytesPerSec * 32)/BlockSize);
|
||
cluster_offset += fat_root_dir_addr(Buffer);
|
||
}
|
||
|
||
//############################################################################
|
||
//Auslesen der Adresse des First Root Directory von Volume Boot Record
|
||
unsigned int fat_root_dir_addr (unsigned char *Buffer)
|
||
//############################################################################
|
||
{
|
||
struct BootSec *bootp; //Zeiger auf Bootsektor Struktur
|
||
unsigned int FirstRootDirSecNum;
|
||
//auslesen des Volume Boot Record von der MMC/SD Karte
|
||
mmc_read_sector (volume_boot_record_addr,Buffer);
|
||
bootp=(struct BootSec *)Buffer;
|
||
|
||
//berechnet den ersten Sector des Root Directory
|
||
FirstRootDirSecNum = ( bootp->BPB_RsvdSecCnt +
|
||
(bootp->BPB_NumFATs * bootp->BPB_FATSz16));
|
||
|
||
FirstRootDirSecNum+= volume_boot_record_addr;
|
||
|
||
return(FirstRootDirSecNum);
|
||
}
|
||
|
||
//############################################################################
|
||
// Ausgabe des angegebenen Directory Eintrag in Entry_Count
|
||
// ist kein Eintrag vorhanden, ist der Eintrag im
|
||
// Rückgabe Cluster 0xFFFF. Es wird immer nur ein Eintrag ausgegeben
|
||
// um Speicherplatz zu sparen um es auch für kleine Atmels zu benutzen
|
||
unsigned int fat_read_dir_ent (unsigned int dir_cluster, //Angabe Dir Cluster
|
||
unsigned char Entry_Count, //Angabe welcher Direintrag
|
||
unsigned long *Size, //Rückgabe der File Größe
|
||
unsigned char *Dir_Attrib, //Rückgabe des Dir Attributs
|
||
unsigned char *Buffer) //Working Buffer
|
||
//############################################################################
|
||
{
|
||
unsigned char *pointer;
|
||
unsigned int TMP_Entry_Count = 0;
|
||
unsigned long Block = 0;
|
||
struct DirEntry *dir; //Zeiger auf einen Verzeichniseintrag
|
||
|
||
pointer = Buffer;
|
||
|
||
if (dir_cluster == 0)
|
||
{
|
||
Block = fat_root_dir_addr(Buffer);
|
||
}
|
||
else
|
||
{
|
||
//Berechnung des Blocks aus BlockCount und Cluster aus FATTabelle
|
||
//Berechnung welcher Cluster zu laden ist
|
||
//Auslesen der FAT - Tabelle
|
||
fat_load (dir_cluster,&Block,Buffer);
|
||
Block = ((Block-2) * cluster_size) + cluster_offset;
|
||
}
|
||
|
||
//auslesen des gesamten Root Directory
|
||
for (unsigned int blk = Block;;blk++)
|
||
{
|
||
mmc_read_sector (blk,Buffer); //Lesen eines Blocks des Root Directory
|
||
for (unsigned int a=0;a<BlockSize; a = a + 32)
|
||
{
|
||
dir=(struct DirEntry *)&Buffer[a]; //Zeiger auf aktuellen Verzeichniseintrag holen
|
||
|
||
if (dir->DIR_Name[0] == 0) //Kein weiterer Eintrag wenn erstes Zeichen des Namens 0 ist
|
||
{
|
||
return (0xFFFF);
|
||
}
|
||
|
||
//Prüfen ob es ein 8.3 Eintrag ist
|
||
//Das ist der Fall wenn es sich nicht um einen Eintrag für lange Dateinamen
|
||
//oder um einen als gelöscht markierten Eintrag handelt.
|
||
if ((dir->DIR_Attr != ATTR_LONG_NAME) &&
|
||
(dir->DIR_Name[0] != DIR_ENTRY_IS_FREE))
|
||
{
|
||
//Ist es der gewünschte Verzeichniseintrag
|
||
if (TMP_Entry_Count == Entry_Count)
|
||
{
|
||
//Speichern des Verzeichnis Eintrages in den Rückgabe Buffer
|
||
for(unsigned char b=0;b<11;b++)
|
||
{
|
||
if (dir->DIR_Name[b] != SPACE)
|
||
{
|
||
if (b == 8)
|
||
{
|
||
*pointer++= '.';
|
||
}
|
||
*pointer++=dir->DIR_Name[b];
|
||
}
|
||
}
|
||
*pointer++='\0';
|
||
*Dir_Attrib = dir->DIR_Attr;
|
||
|
||
//Speichern der Filegröße
|
||
*Size=dir->DIR_FileSize;
|
||
|
||
//Speichern des Clusters des Verzeichniseintrages
|
||
dir_cluster = dir->DIR_FstClusLO;
|
||
|
||
//Eintrag gefunden Rücksprung mit Cluster File Start
|
||
return(dir_cluster);
|
||
}
|
||
TMP_Entry_Count++;
|
||
}
|
||
}
|
||
}
|
||
return (0xFFFF); //Kein Eintrag mehr gefunden Rücksprung mit 0xFFFF
|
||
}
|
||
|
||
//############################################################################
|
||
// Auslesen der Cluster für ein File aus der FAT
|
||
// in den Buffer(512Byte). Bei einer 128MB MMC/SD
|
||
// Karte ist die Cluster größe normalerweise 16KB groß
|
||
// das bedeutet das File kann max. 4MByte groß sein.
|
||
// Bei größeren Files muß der Buffer größer definiert
|
||
// werden! (Ready)
|
||
// Cluster = Start Clusterangabe aus dem Directory
|
||
void fat_load ( unsigned int Cluster, //Angabe Startcluster
|
||
unsigned long *Block,
|
||
unsigned char *TMP_Buffer) //Workingbuffer
|
||
//############################################################################
|
||
{
|
||
//Zum Überprüfen ob der FAT Block schon geladen wurde
|
||
unsigned int FAT_Block_Store = 0;
|
||
|
||
//Byte Adresse innerhalb des Fat Blocks
|
||
unsigned int FAT_Byte_Addresse;
|
||
|
||
//FAT Block Adresse
|
||
unsigned int FAT_Block_Addresse;
|
||
|
||
//Berechnung für den ersten FAT Block (FAT Start Addresse)
|
||
for (unsigned int a = 0;;a++)
|
||
{
|
||
if (a == *Block)
|
||
{
|
||
*Block = (0x0000FFFF & Cluster);
|
||
return;
|
||
}
|
||
|
||
if (Cluster == 0xFFFF)
|
||
{
|
||
break; //Ist das Ende des Files erreicht Schleife beenden
|
||
}
|
||
//Berechnung des Bytes innerhalb des FAT Block´s
|
||
FAT_Byte_Addresse = (Cluster*2) % BlockSize;
|
||
|
||
//Berechnung des Blocks der gelesen werden muß
|
||
FAT_Block_Addresse = ((Cluster*2) / BlockSize) +
|
||
volume_boot_record_addr + fat_offset;
|
||
//Lesen des FAT Blocks
|
||
//Überprüfung ob dieser Block schon gelesen wurde
|
||
if (FAT_Block_Addresse != FAT_Block_Store)
|
||
{
|
||
FAT_Block_Store = FAT_Block_Addresse;
|
||
//Lesen des FAT Blocks
|
||
mmc_read_sector (FAT_Block_Addresse,TMP_Buffer);
|
||
}
|
||
|
||
//Lesen der nächsten Clusternummer
|
||
Cluster = (TMP_Buffer[FAT_Byte_Addresse + 1] << 8) +
|
||
TMP_Buffer[FAT_Byte_Addresse];
|
||
}
|
||
return;
|
||
}
|
||
|
||
//############################################################################
|
||
//Lesen eines 512Bytes Blocks von einem File
|
||
void fat_read_file (unsigned int Cluster,//Angabe des Startclusters vom File
|
||
unsigned char *Buffer, //Workingbuffer
|
||
unsigned long BlockCount) //Angabe welcher Bock vom File geladen
|
||
//werden soll a 512 Bytes
|
||
//############################################################################
|
||
{
|
||
//Berechnung des Blocks aus BlockCount und Cluster aus FATTabelle
|
||
//Berechnung welcher Cluster zu laden ist
|
||
|
||
unsigned long Block = (BlockCount/cluster_size);
|
||
|
||
//Auslesen der FAT - Tabelle
|
||
fat_load (Cluster,&Block,Buffer);
|
||
Block = ((Block-2) * cluster_size) + cluster_offset;
|
||
//Berechnung des Blocks innerhalb des Cluster
|
||
Block += (BlockCount % cluster_size);
|
||
//Read Data Block from Device
|
||
mmc_read_sector (Block,Buffer);
|
||
return;
|
||
}
|
||
|
||
//############################################################################
|
||
//Lesen eines 512Bytes Blocks von einem File
|
||
void fat_write_file (unsigned int cluster,//Angabe des Startclusters vom File
|
||
unsigned char *buffer, //Workingbuffer
|
||
unsigned long blockCount) //Angabe welcher Bock vom File gespeichert
|
||
//werden soll a 512 Bytes
|
||
//############################################################################
|
||
{
|
||
//Berechnung des Blocks aus BlockCount und Cluster aus FATTabelle
|
||
//Berechnung welcher Cluster zu speichern ist
|
||
unsigned char tmp_buffer[513];
|
||
unsigned long block = (blockCount/cluster_size);
|
||
|
||
//Auslesen der FAT - Tabelle
|
||
fat_load (cluster,&block,tmp_buffer);
|
||
block = ((block-2) * cluster_size) + cluster_offset;
|
||
//Berechnung des Blocks innerhalb des Cluster
|
||
block += (blockCount % cluster_size);
|
||
//Write Data Block to Device
|
||
mmc_write_sector (block,buffer);
|
||
return;
|
||
}
|
||
|
||
//####################################################################################
|
||
//Sucht ein File im Directory
|
||
unsigned char fat_search_file (unsigned char *File_Name, //Name des zu suchenden Files
|
||
unsigned int *Cluster, //Angabe Dir Cluster welches
|
||
//durchsucht werden soll
|
||
//und Rückgabe des clusters
|
||
//vom File welches gefunden
|
||
//wurde
|
||
unsigned long *Size, //Rückgabe der File Größe
|
||
unsigned char *Dir_Attrib,//Rückgabe des Dir Attributs
|
||
unsigned char *Buffer) //Working Buffer
|
||
//####################################################################################
|
||
{
|
||
unsigned int Dir_Cluster_Store = *Cluster;
|
||
for (unsigned char a = 0;a < 100;a++)
|
||
{
|
||
*Cluster = fat_read_dir_ent(Dir_Cluster_Store,a,Size,Dir_Attrib,Buffer);
|
||
if (*Cluster == 0xffff)
|
||
{
|
||
return(0); //File not Found
|
||
}
|
||
if(strcasecmp((char *)File_Name,(char *)Buffer) == 0)
|
||
{
|
||
return(1); //File Found
|
||
}
|
||
}
|
||
return(2); //Error
|
||
}
|