609 lines
27 KiB
C
609 lines
27 KiB
C
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
|
|
#include "fat.h"
|
|
#include "file.h"
|
|
#include "hardware.h"
|
|
|
|
struct Fat fat; // wichtige daten/variablen der fat
|
|
struct File file; // wichtige dateibezogene daten/variablen
|
|
|
|
|
|
#if (WRITE==1)
|
|
|
|
//***************************************************************************************************************
|
|
// schreibt sektor nummer:sec auf die karte (puffer:sector) !!
|
|
// setzt bufferFlag=0 da puffer nicht dirty sein kann nach schreiben !
|
|
//***************************************************************************************************************
|
|
unsigned char fat_writeSector(unsigned long int sec){
|
|
|
|
fat.bufferDirty=0; // buffer kann nicht dirty sein weil wird geschrieben
|
|
return(mmc_write_sector(sec,fat.sector)); // schreiben von sektor puffer
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
// ***************************************************************************************************************
|
|
// umrechnung cluster auf 1.sektor des clusters (möglicherweise mehrere sektoren/cluster) !
|
|
// ***************************************************************************************************************
|
|
unsigned long int fat_clustToSec(unsigned long int clust){
|
|
|
|
return (fat.dataDirSec+2+((clust-2) * fat.secPerClust)); // errechnet den 1. sektor der sektoren des clusters
|
|
}
|
|
|
|
// ***************************************************************************************************************
|
|
// umrechnung sektor auf cluster (nicht die position im cluster selber!!)
|
|
// ***************************************************************************************************************
|
|
unsigned long int fat_secToClust(unsigned long int sec){
|
|
|
|
return ((sec-fat.dataDirSec-2+2*fat.secPerClust)/fat.secPerClust); // umkerhrfunktion von fat_clustToSec
|
|
}
|
|
|
|
|
|
//***************************************************************************************************************
|
|
// läd sektor:sec auf puffer:sector zum bearbeiten im ram !
|
|
// setzt currentSectorNr auf richtigen wert (also den sektor der gepuffert ist). es wird geprüft
|
|
// ob der gepufferte sektor geändert wurde, wenn ja muss erst geschrieben werden, um diese daten nicht zu verlieren !
|
|
//***************************************************************************************************************
|
|
unsigned char fat_loadSector(unsigned long int sec){
|
|
|
|
if(sec!=fat.currentSectorNr){ // nachladen nötig
|
|
#if (WRITE==1)
|
|
if(fat.bufferDirty==1) fat_writeSector(fat.currentSectorNr); // puffer diry, also vorher schreiben
|
|
#endif
|
|
mmc_read_sector(sec,fat.sector); // neuen sektor laden
|
|
fat.currentSectorNr=sec; // aktualisiert sektor nummer (nummer des gepufferten sektors)
|
|
return(0);
|
|
}
|
|
|
|
else return(0); // alles ok, daten sind schon da (sec==fat.currentSectorNr)
|
|
|
|
return(1); // fehler
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// datei lesen funktionen:
|
|
|
|
// fat_loadSector -> fat_loadRowOfSector -> fat_loadFileDataFromCluster -> fat_loadFileDataFromDir -> fat_loadFileDataFromDir -> fat_cd "daten chain"
|
|
|
|
//***************************************************************************************************************
|
|
// läd die reihe:row des gepufferten sektors auf das struct:file. dort stehen dann
|
|
// alle wichgigen daten wie: 1.cluster,länge bei dateien, name des eintrags, reihen nummer (im sektor), attribut use...
|
|
//***************************************************************************************************************
|
|
unsigned char fat_loadRowOfSector(unsigned int row){
|
|
|
|
unsigned char i;
|
|
row=row<<5; // multipliziert mit 32 um immer auf zeilen anfang zu kommen (zeile 0=0,zeile 1=32,zeile 2=62 usw).
|
|
|
|
void *vsector; // void, damit man schoen umbiegen kann :)
|
|
|
|
for(i=0;i<11;i++)
|
|
file.name[i]=fat.sector[row+i]; // datei name, ersten 10 bytes vom 32 byte eintrag.
|
|
|
|
file.attrib=fat.sector[row+11]; // datei attribut, byte 11.
|
|
|
|
vsector=&fat.sector[row+26]; // low word von fist.cluster
|
|
file.firstCluster=*(unsigned short*)vsector;
|
|
|
|
vsector=&fat.sector[row+20]; // high word von first.cluster
|
|
file.firstCluster|=(*(unsigned short*)vsector)<<16;
|
|
|
|
vsector=&fat.sector[row+28]; // 4 byte von file.length
|
|
file.length=*(unsigned long int*)vsector;
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
//***************************************************************************************************************
|
|
// geht reihen weise durch sektoren des clusters mit dem startsektor:sec, und sucht nach der datei mit dem
|
|
// namen:name. es werden die einzelnen sektoren nachgeladen auf puffer:sector vor dem bearbeiten.
|
|
// wird die datei in dem cluster gefunden ist return 0 , sonst return1.
|
|
//***************************************************************************************************************
|
|
unsigned char fat_loadFileDataFromCluster(unsigned long int sec , char name[]){
|
|
|
|
unsigned char r;
|
|
unsigned char s=0;
|
|
|
|
do{ // sektoren des clusters prüfen
|
|
r=0; // neuer sektor, dann reihen von 0 an.
|
|
mmc_read_sector(sec+s,fat.sector); // läd den sektor sec auf den puffer fat.sector
|
|
fat.currentSectorNr=sec+s; // setzen des aktuellen sektors
|
|
do{ // reihen des sektors prüfen
|
|
fat_loadRowOfSector(r); // zeile 0-15 auf struct file laden
|
|
if(file.name[0]==0){ // wenn man auf erste 0 stößt müsste der rest auch leer sein!
|
|
file.row=r; // zeile sichern.
|
|
return(1);
|
|
}
|
|
if(0==strncmp((char*)file.name,name,10)){ // zeile r ist gesuchte
|
|
file.row=r; // zeile sichern.
|
|
return(0);
|
|
}
|
|
r++;
|
|
}while(r<16); // zählt zeilennummer (16(zeilen) * 32(spalten) == 512 bytes des sektors)
|
|
s++;
|
|
}while(s<fat.secPerClust); // geht durch sektoren des clusters
|
|
|
|
return (1); // fehler (datei nicht gefunden, oder fehler beim lesen)
|
|
}
|
|
|
|
|
|
//***************************************************************************************************************
|
|
// wenn dir == 0 dann wird das root direktory durchsucht, wenn nicht wird der ordner cluster-chain gefolgt, um
|
|
// die datei zu finden. es wird das komplette directory in dem man sich befindet durchsucht.
|
|
// bei fat16 wird der rootDir berreich durchsucht, bei fat32 die cluster chain des rootDir.
|
|
//***************************************************************************************************************
|
|
unsigned char fat_loadFileDataFromDir(char name[]){
|
|
|
|
unsigned int s;
|
|
|
|
if(fat.dir==0 && fat.fatType==16){ // IM ROOTDIR. fat16
|
|
for(s=0;s<(unsigned int)(fat.dataDirSec+2-fat.rootDir);s++){ // zählt durch RootDir sektoren (errechnet anzahl rootDir sektoren).
|
|
if(0==fat_loadFileDataFromCluster(fat.rootDir+s,name))return(0);// sucht die datei, wenn da, läd daten (1.cluster usw)
|
|
}
|
|
}
|
|
|
|
else {
|
|
unsigned long int i;
|
|
if(fat.dir==0 && fat.fatType==32)i=fat.rootDir; // IM ROOTDIR. fat32
|
|
else i=fat.dir; // NICHT ROOTDIR
|
|
while(!((i==0xfffffff&&fat.fatType==32)||(i==0xffff&&fat.fatType==16))){ // prüft ob weitere sektoren zum lesen da sind (fat32||fat16)
|
|
if(0==fat_loadFileDataFromCluster(fat_clustToSec(i),name))return(0); // lät die daten der datei auf struct:file. datei gefunden (umrechnung auf absoluten sektor)
|
|
i=fat_getNextCluster(i); // liest nächsten cluster des dir-eintrags (unterverzeichniss größer 16 einträge)
|
|
}
|
|
}
|
|
|
|
return(1); // datei/verzeichniss nicht gefunden
|
|
}
|
|
|
|
|
|
#if (SMALL_FILE_SYSTEM==0)
|
|
|
|
//***************************************************************************************************************
|
|
// start immer im root Dir. start in root dir (dir==0).
|
|
// es MUSS in das direktory gewechselt werden, in dem die datei zum lesen/anhängen ist (außer root, da startet mann)!
|
|
//***************************************************************************************************************
|
|
unsigned char fat_cd(char name[]){
|
|
|
|
if(name[0]==0){ // ZUM ROOTDIR FAT16/32
|
|
fat.dir=0; // root dir
|
|
return(0);
|
|
}
|
|
|
|
if(0==fat_loadFileDataFromDir(name)){ // NICHT ROOTDIR (fat16/32)
|
|
fat.dir=file.firstCluster; // zeigt auf 1.cluster des dir (fat16/32)
|
|
return(0);
|
|
}
|
|
|
|
return(1); // dir nicht gewechselt (nicht da?) !!
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if (WRITE==1)
|
|
|
|
// datei anlegen funktionen :
|
|
|
|
// ***************************************************************************************************************
|
|
// sucht leeren eintrag (zeile) im cluster mit dem startsektor:secStart.
|
|
// wird dort kein freier eintrag gefunden ist return (1).
|
|
// wird ein freier eintrag gefunden, ist die position der freien reihe auf file.row abzulesen und return (0).
|
|
// der sektor mit der freien reihe ist auf dem puffer:sector gepuffert.
|
|
// ****************************************************************************************************************
|
|
unsigned char fat_getFreeRowOfCluster(unsigned long secStart){
|
|
|
|
unsigned int b; // zum durchgenen der sektor bytes
|
|
unsigned char s=0; // sektoren des clusters.
|
|
|
|
do{
|
|
file.row=0; // neuer sektor(oder 1.sektor), reihen von vorne.
|
|
if(0==fat_loadSector(secStart+s)){ // laed sektor auf puffer fat.sector
|
|
for(b=0;b<512;b=b+32){ // zaehlt durch zeilen (0-15).
|
|
if(fat.sector[b]==0x00||fat.sector[b]==0xE5)return(0); // prueft auf freihen eintrag (leer oder geloescht == OK!).
|
|
file.row++; // zählt reihe hoch (nächste reihe im sektor).
|
|
}
|
|
}
|
|
s++; // sektoren des clusters ++ weil einen geprüft.
|
|
}while(s<fat.secPerClust); // geht die sektoren des clusters durch (moeglicherweise auch nur 1. sektor).
|
|
return (1); // nicht gefunden in diesem cluster (== nicht OK!).
|
|
}
|
|
|
|
|
|
// ***************************************************************************************************************
|
|
// sucht leeren eintrag (zeile) im directory mit dem startcluster:dir.
|
|
// geht die cluster chain des direktories durch. dabei werden auch alle sektoren der cluster geprüft.
|
|
// wird dort kein freier eintrag gefunden, wird ein neuer leerer cluster gesucht, verkettet und der
|
|
// 1. sektor des freien clusters geladen. die reihe wird auf den ersten eintrag gesetzt, da frei.
|
|
// anhand der reihe kann man nun den direktory eintrag vornehmen, und auf die karte schreiben.
|
|
// ****************************************************************************************************************
|
|
void fat_getFreeRowOfDir(unsigned long int dir){
|
|
|
|
unsigned long int start=dir;
|
|
|
|
// solange bis ende cluster chain.
|
|
while( !((dir==0xfffffff&&fat.fatType==32)||(dir==0xffff&&fat.fatType==16)) ){
|
|
if(0==fat_getFreeRowOfCluster(fat_clustToSec(dir)))return; // freien eintrag in clustern, des dir gefunden !!
|
|
start=dir;
|
|
dir=fat_getNextCluster(dir);
|
|
} // wenn aus schleife raus, kein freier eintrag da -> neuer cluster nötig.
|
|
|
|
dir=fat_secToClust(fat.startSectors); // dir ist jetzt neuer cluster zum verketten !
|
|
fat_setCluster(start,dir); // cluster-chain mit neuem cluster verketten
|
|
fat_setCluster(dir,0x0fffffff); // cluster-chain ende markieren
|
|
|
|
//es muessen neue gesucht werden, weil der bekannte aus file.c ja grade verkettet wurden. datei eintrag passte nicht mehr ins dir...
|
|
fat_getFreeClustersInRow(2); // neue freie cluster suchen, für datei.
|
|
file.firstCluster=fat_secToClust(fat.startSectors); // 1. cluster der datei
|
|
file.lastCluster=fat_secToClust(fat.endSectors); // letzter bekannter cluster der datei
|
|
|
|
fat.currentSectorNr=fat_clustToSec(dir); // setzen des richtigen sektors, also auf den 1. der neu verketteten
|
|
|
|
unsigned int j=511;
|
|
do{
|
|
fat.sector[j]=0x00; //schreibt puffer fat.sector voll mit 0x00==leer
|
|
}while(j--);
|
|
|
|
unsigned char i=1; // ab 1 weil der 1.sektor des clusters eh noch beschrieben wird...
|
|
do{
|
|
fat_writeSector(fat.currentSectorNr+i); // löschen des cluster (überschreibt mit 0x00), wichtig bei ffls,
|
|
i++;
|
|
}while(i<fat.secPerClust);
|
|
|
|
file.row=0; // erste reihe frei, weil grad neuen cluster verkettet !
|
|
}
|
|
|
|
|
|
//***************************************************************************************************************
|
|
// erstellt 32 byte eintrag einer datei, oder verzeichnisses im puffer:sector.
|
|
// erstellt eintrag in reihe:row, mit namen:name usw... !!
|
|
// muss noch auf die karte geschrieben werden ! nicht optimiert auf geschwindigkeit.
|
|
//***************************************************************************************************************
|
|
void fat_makeRowDataEntry(unsigned int row,char name[],unsigned char attrib,unsigned long int cluster,unsigned long int length){
|
|
|
|
fat.bufferDirty=1; // puffer beschrieben, also neue daten darin(vor lesen muss geschrieben werden)
|
|
|
|
row=row<<5; // multipliziert mit 32 um immer auf zeilen anfang zu kommen (zeile 0=0,zeile 1=32,zeile 2=62 ... zeile 15=480)
|
|
|
|
unsigned char i; // byte zähler in reihe von sektor (32byte eintrag)
|
|
unsigned char *bytesOfSec=&fat.sector[row]; // zeiger auf sector bytes
|
|
void *vsector;
|
|
|
|
for(i=0;i<11;i++) *bytesOfSec++=name[i]; // namen schreiben
|
|
|
|
*bytesOfSec++=attrib; // attrib schreiben
|
|
|
|
vsector=&fat.sector[row+12];
|
|
*(unsigned long int*)vsector++=0x01010101; // unnoetige felder beschreiben
|
|
*(unsigned long int*)vsector=0x01010101;
|
|
|
|
vsector=&fat.sector[row+20];
|
|
*(unsigned short*)vsector=(cluster&0xffff0000)>>16;// low word von cluster
|
|
|
|
vsector=&fat.sector[row+22];
|
|
*(unsigned long int*)vsector=0x01010101; // unnoetige felder beschreiben
|
|
|
|
vsector=&fat.sector[row+26];
|
|
*(unsigned short*)vsector=(cluster&0x0000ffff); // high word von cluster
|
|
|
|
vsector=&fat.sector[row+28];
|
|
*(unsigned long int*)vsector=length; // laenge
|
|
}
|
|
|
|
|
|
//***************************************************************************************************************
|
|
// macht den datei eintrag im jetzigen verzeichniss (fat.dir).
|
|
// file.row enthält die reihen nummer des leeren eintrags, der vorher gesucht wurde, auf puffer:sector ist der gewünschte
|
|
// sektor gepuffert. für fat16 im root dir muss andere funktion genutzt werden, als fat_getFreeRowOfDir (durchsucht nur dirs).
|
|
// fat.rootDir enthält bei fat32 den start cluster des directory, bei fat16 den 1. sektor des rootDir bereichs!
|
|
//***************************************************************************************************************
|
|
void fat_makeFileEntry(char name[],unsigned char attrib,unsigned long int length){
|
|
|
|
unsigned int s; // zähler für root dir sektoren fat16
|
|
|
|
if(fat.dir==0&&fat.fatType==32)fat_getFreeRowOfDir(fat.rootDir); // IM ROOT DIR (fat32)
|
|
|
|
else if(fat.dir==0 && fat.fatType==16){ // IM ROOT DIR (fat16)
|
|
for(s=0;s<(unsigned int)(fat.dataDirSec+2-fat.rootDir);s++){ // zählt durch RootDir sektoren (errechnet anzahl rootDir sektoren).
|
|
if(0==fat_getFreeRowOfCluster(fat.rootDir+s))break; // geht durch sektoren des root dir.
|
|
}
|
|
}
|
|
|
|
else fat_getFreeRowOfDir(fat.dir); // NICHT ROOT DIR fat32/fat16
|
|
|
|
fat_makeRowDataEntry(file.row,name,attrib,file.firstCluster,length); // schreibt file eintrag auf puffer
|
|
fat_writeSector(fat.currentSectorNr); // schreibt puffer auf karte
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
// fat funktionen:
|
|
|
|
//***************************************************************************************************************
|
|
// sucht nötige folge Cluster aus der fat !
|
|
// erster daten cluster = 2, ende einer cluster chain 0xFFFF (fat16) oder 0xFFFFFFF, 0xFFFFFF8 (fat32),
|
|
// stelle des clusters in der fat, hat als wert, den nächsten cluster. (1:1 gemapt)!
|
|
//***************************************************************************************************************
|
|
unsigned long int fat_getNextCluster(unsigned long int oneCluster){
|
|
|
|
// FAT 16**************FAT 16
|
|
if(fat.fatType==16){
|
|
unsigned long int i=oneCluster>>8;; // (i=oneCluster/256)errechnet den sektor der fat in dem oneCluster ist (rundet immer ab)
|
|
unsigned long int j=(oneCluster<<1)-(i<<9); // (j=(oneCluster-256*i)*2 == 2*oneCluster-512*i)errechnet das low byte von oneCluster
|
|
|
|
if(0==fat_loadSector(i+fat.fatSec)){ // ob neu laden nötig, wird von fat_loadSector geprüft
|
|
void *bytesOfSec=&fat.sector[j]; // zeiger auf puffer
|
|
return *(unsigned short*)bytesOfSec; // da der ram auch little endian ist, kann einfach gecastet werden und gut :)
|
|
}
|
|
}
|
|
|
|
// FAT 32**************FAT 32
|
|
else{
|
|
unsigned long int i=oneCluster>>7; // (i=oneCluster/128)errechnet den sektor der fat in dem oneCluster ist (rundet immer ab)
|
|
unsigned long int j=(oneCluster<<2)-(i<<9); // (j=(oneCluster-128*i)*4 == oneCluster*4-512*i)errechnet das low byte von oneCluster
|
|
|
|
if(0==fat_loadSector(i+fat.fatSec)){ // ob neu laden nötig wird von fat_loadSector geprüft
|
|
void *bytesOfSec=&fat.sector[j]; // zeiger auf puffer
|
|
return *(unsigned long int*)bytesOfSec; // da der ram auch little endian ist, kann einfach gecastet werden und gut :)
|
|
}
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
//***************************************************************************************************************
|
|
// sucht verkettete cluster einer datei, die in einer reihe liegen. worst case: nur ein cluster.
|
|
// sieht in der fat ab dem cluster offsetCluster nach. sucht die anzahl von MAX_CLUSTERS_IN_ROW,
|
|
// am stück,falls möglich. prüft ob der cluster neben offsetCluster dazu gehört...
|
|
// setzt dann fat.endSectors und fat.startSectors. das -1 weil z.b. [95,98] = {95,96,97,98} = 4 sektoren
|
|
//***************************************************************************************************************
|
|
void fat_getFatChainClustersInRow(unsigned long int offsetCluster){
|
|
|
|
unsigned int i=0;
|
|
fat.startSectors=fat_clustToSec(offsetCluster); // setzen des 1. sektors der datei
|
|
fat.endSectors=fat.startSectors;
|
|
do{
|
|
if( (offsetCluster+1+i)==fat_getNextCluster(offsetCluster+i) ) fat.endSectors+=fat.secPerClust; // zählen der zusammenhängenden sektoren
|
|
else {
|
|
file.lastCluster=offsetCluster+i; // cluster daneben gehört nicht dazu, somit ist offset+i der letzte bekannte
|
|
break;
|
|
}
|
|
}while(i++<MAX_CLUSTERS_IN_ROW);
|
|
fat.endSectors+=fat.secPerClust-1;
|
|
}
|
|
|
|
|
|
#if (WRITE==1)
|
|
|
|
//***************************************************************************************************************
|
|
// sucht freie zusammenhängende cluster aus der fat. maximal MAX_CLUSTERS_IN_ROW am stück.
|
|
// erst wir der erste frei cluster gesucht, ab offsetCluster(iklusive) und dann wird geschaut, ob der
|
|
// daneben auch frei ist. setzt dann fat.endSectors und fat.startSectors. das -1 weil z.b. [95,98] = {95,96,97,98} = 4 sektoren
|
|
//***************************************************************************************************************
|
|
void fat_getFreeClustersInRow(unsigned long int offsetCluster){
|
|
|
|
unsigned int i=1; // variable für anzahl der zu suchenden sektoren
|
|
while(fat_getNextCluster(offsetCluster)) offsetCluster++; // suche des 1. freien clusters
|
|
|
|
fat.startSectors=fat_clustToSec(offsetCluster); // setzen des startsektors der freien sektoren (umrechnen von cluster zu sektoren)
|
|
fat.endSectors=fat.startSectors;
|
|
|
|
do{ // suche der nächsten freien
|
|
if(0==fat_getNextCluster(offsetCluster+i) ) fat.endSectors+=fat.secPerClust; // zählen der zusammenhängenden sektoren
|
|
else break; // cluster daneben ist nicht frei
|
|
}while(i++<MAX_CLUSTERS_IN_ROW);
|
|
|
|
fat.endSectors+=fat.secPerClust-1; // -1 weil der erste sektor schon mit zählt z.b. [95,98] = 4 sektoren
|
|
}
|
|
|
|
|
|
//***************************************************************************************************************
|
|
// verkettet ab startCluster bis einschließlich endCluster. verkettet auch den letzten bekannten mit den neu übergebenen !
|
|
// es ist wegen der fragmentierung der fat nötig, sich den letzten bekannten cluster zu merken,
|
|
// damit man bei weiteren cluster in einer reihe die alten cluster noch dazu verketten kann (so sind lücken im verketten möglich).
|
|
//***************************************************************************************************************
|
|
void fat_setClusterChain(unsigned long int startCluster,unsigned int endCluster){
|
|
|
|
fat_setCluster(file.lastCluster,startCluster); // ende der chain setzen, bzw verketten der ketten
|
|
|
|
while(startCluster!=endCluster){
|
|
startCluster++;
|
|
fat_setCluster( startCluster-1 ,startCluster ); // verketten der cluster der neuen kette
|
|
}
|
|
|
|
fat_setCluster(startCluster,0xfffffff); // ende der chain setzen
|
|
file.lastCluster=endCluster; // ende cluster der kette updaten
|
|
fat_writeSector(fat.currentSectorNr); // schreiben des fat sektors auf die karte
|
|
|
|
}
|
|
|
|
|
|
//***************************************************************************************************************
|
|
// setzt den cluster inhalt. errechnet den sektor der fat in dem cluster ist, errechnet das low byte von
|
|
// cluster und setzt dann byteweise den inhalt:content.
|
|
// prüft ob buffer dirty (zu setztender cluster nicht in jetzt gepuffertem).
|
|
// prüfung erfolgt in fat_loadSector, dann wird alter vorher geschrieben, sonst gehen dort daten verloren !!
|
|
//***************************************************************************************************************
|
|
void fat_setCluster(unsigned long int cluster, unsigned long int content){
|
|
|
|
// FAT 16**************FAT 16
|
|
if(fat.fatType==16){
|
|
unsigned long int i=cluster>>8; // (i=cluster/256)errechnet den sektor der fat in dem cluster ist (rundet immer ab)
|
|
unsigned long int j=(cluster<<1)-(i<<9); // (j=(cluster-256*i)*2 == 2*cluster-512*i)errechnet das low byte von cluster
|
|
|
|
if(0==fat_loadSector(i+fat.fatSec)){ // neu laden (fat_loadSector prüft ob schon gepuffert)
|
|
void *bytesOfSec=&fat.sector[j]; // init des zeigers auf unterste adresse
|
|
*(unsigned short*)bytesOfSec=content;// weil ram auch little endian geht das so :)
|
|
fat.bufferDirty=1; // zeigt an, dass im aktuellen sector geschrieben wurde
|
|
}
|
|
}
|
|
|
|
// FAT 32**************FAT 32
|
|
else{
|
|
unsigned long int i=cluster>>7; // (i=cluster/128)errechnet den sektor der fat in dem cluster ist (rundet immer ab)
|
|
unsigned long int j=(cluster<<2)-(i<<9); //(j=(cluster-128*i)*4 == cluster*4-512*i)errechnet das low byte von cluster
|
|
|
|
if(0==fat_loadSector(i+fat.fatSec)){ // neu laden (fat_loadSector prüft ob schon gepuffert)
|
|
void *bytesOfSec=&fat.sector[j]; // init des zeigers auf unterste adresse
|
|
*(unsigned long int*)bytesOfSec=content; // weil ram auch little endian geht das so :)
|
|
fat.bufferDirty=1; // zeigt an, dass im aktuellen sector geschrieben wurde
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//***************************************************************************************************************
|
|
// löscht cluster chain, beginnend ab dem startCluster.
|
|
// sucht cluster, setzt inhalt usw.. abschließend noch den cluster-chain ende markierten cluster löschen.
|
|
//***************************************************************************************************************
|
|
void fat_delClusterChain(unsigned long int startCluster){
|
|
|
|
unsigned long int nextCluster=startCluster; // tmp variable, wegen verketteter cluster..
|
|
|
|
do{
|
|
startCluster=nextCluster;
|
|
nextCluster=fat_getNextCluster(startCluster);
|
|
fat_setCluster(startCluster,0x00000000);
|
|
}while(!((nextCluster==0xfffffff&&fat.fatType==32)||(nextCluster==0xffff&&fat.fatType==16)));
|
|
fat_writeSector(fat.currentSectorNr);
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
//***************************************************************************************************************
|
|
// Initialisiert die Fat(16/32) daten, wie: root directory sektor, daten sektor, fat sektor...
|
|
// siehe auch Fatgen103.pdf. ist NICHT auf performance optimiert!
|
|
// byte/sector, byte/cluster, anzahl der fats, sector/fat ... (halt alle wichtigen daten zum lesen ders datei systems!)
|
|
//*****************************************************************<**********************************************
|
|
unsigned char fat_loadFatData(unsigned long int sec){
|
|
|
|
// offset,size
|
|
unsigned int rootEntCnt; // 17,2 größe die eine fat belegt
|
|
unsigned int fatSz16; // 22,2 sectors occupied by one fat16
|
|
unsigned long int fatSz32; // 36,4 sectors occupied by one fat32
|
|
|
|
void *vsector;
|
|
|
|
if(0==mmc_read_sector(sec,fat.sector)){ // lesen von fat sector und bestimmen der wichtigen berreiche
|
|
|
|
fat.bufferDirty = 0; // init wert des flags
|
|
|
|
fat.secPerClust=fat.sector[13]; // fat.secPerClust, 13 only (power of 2)
|
|
|
|
vsector=&fat.sector[14];
|
|
fat.fatSec=*(unsigned short*)vsector;
|
|
|
|
vsector=&fat.sector[17];
|
|
rootEntCnt=*(unsigned short*)vsector;
|
|
|
|
vsector=&fat.sector[22];
|
|
fatSz16=*(unsigned short*)vsector;
|
|
|
|
fat.rootDir = (((rootEntCnt <<5) + 512) /512)-1; // ist 0 bei fat 32, sonst der root dir sektor
|
|
|
|
if(fat.rootDir==0){ // FAT32 spezifisch (die prüfung so, ist nicht spezifikation konform !).
|
|
|
|
vsector=&fat.sector[36];
|
|
fatSz32=*(unsigned long int *)vsector;
|
|
|
|
vsector=&fat.sector[44];
|
|
fat.rootDir=*(unsigned long int *)vsector;
|
|
|
|
fat.dataDirSec = fat.fatSec + (fatSz32 * fat.sector[16]); // data sector (beginnt mit cluster 2)
|
|
fat.fatType=32; // fat typ
|
|
}
|
|
|
|
else{ // FAT16 spezifisch
|
|
fat.dataDirSec = fat.fatSec + (fatSz16 * fat.sector[16]) + fat.rootDir; // data sektor (beginnt mit cluster 2)
|
|
fat.rootDir=fat.dataDirSec-fat.rootDir; // root dir sektor, da nicht im datenbereich (cluster)
|
|
fat.rootDir+=sec; // addiert den startsektor auf "
|
|
fat.fatType=16; // fat typ
|
|
}
|
|
|
|
fat.fatSec+=sec; // addiert den startsektor auf
|
|
fat.dataDirSec+=sec; // addiert den startsektor auf (umrechnung von absolut auf real)
|
|
fat.dataDirSec-=2; // zeigt auf 1. cluster
|
|
fat.dir=0; // dir auf '0'==root dir, sonst 1.Cluster des dir
|
|
return (0);
|
|
}
|
|
|
|
|
|
return (1); // sector nicht gelesen, fat nicht initialisiert!!
|
|
}
|
|
|
|
|
|
//************************************************************************************************<<***************
|
|
// int fat sucht den 1. cluster des dateisystems (fat16/32) auch VBR genannt,
|
|
//************************************************************************************************<<***************
|
|
unsigned char fat_initfat(void){
|
|
|
|
unsigned long int secOfFirstPartition=0; // ist 1. sektor der 1. partition aus dem MBR
|
|
|
|
if(0==mmc_read_sector(0,fat.sector)){
|
|
|
|
void *vsector=&fat.sector[454]; //startsektor bestimmen
|
|
secOfFirstPartition=*(unsigned long int*)vsector;
|
|
|
|
//prüfung ob man schon im VBR gelesen hat (0x6964654d = "Medi")
|
|
if(secOfFirstPartition==0x6964654d) return fat_loadFatData(0); //ist superfloppy
|
|
|
|
else {return fat_loadFatData(secOfFirstPartition);} // ist partitioniert...
|
|
}
|
|
|
|
return (1);
|
|
}
|
|
|
|
|
|
#if (SMALL_FILE_SYSTEM==0)
|
|
|
|
// *****************************************************************************************************************
|
|
// bereitet str so auf, dass man es auf die mmc/sd karte schreiben kann.
|
|
// wandelt z.b. "t.txt" -> "T TXT" oder "main.c" in "MAIN C " => also immer 8.3 und upper case letter
|
|
// VORSICHT es werden keine Prüfungen gemacht !
|
|
// *****************************************************************************************************************
|
|
char * fat_str(char *str){
|
|
|
|
unsigned char i;
|
|
unsigned char j=0;
|
|
unsigned char c;
|
|
char tmp[12]; // tmp string zum einfacheren umwandeln
|
|
|
|
strcpy(tmp,str);
|
|
|
|
for(i=0;i<11;i++)str[i]=' '; // als vorbereitung alles mit leerzeichen füllen
|
|
str[11]='\0';
|
|
|
|
i=0;
|
|
|
|
do{
|
|
c=toupper(tmp[j]);
|
|
if(c=='\0')return str;
|
|
if(c!='.')str[i]=c;
|
|
else i=7;
|
|
i++;
|
|
j++;
|
|
}while(i<12);
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
#endif
|
|
|