From 9859b1fbc8afbc8c3f8fd9e330c57dbd92053318 Mon Sep 17 00:00:00 2001 From: David Voswinkel Date: Mon, 10 Aug 2009 19:34:03 +0200 Subject: [PATCH] cleanup types: --- avr/usbload/fat.c | 154 +++++++++++++++++++++++---------------------- avr/usbload/fat.h | 88 +++++++++++++------------- avr/usbload/file.c | 52 +++++++-------- avr/usbload/file.h | 18 +++--- avr/usbload/mmc.h | 14 ++--- 5 files changed, 164 insertions(+), 162 deletions(-) diff --git a/avr/usbload/fat.c b/avr/usbload/fat.c index f19207e..ac95da7 100644 --- a/avr/usbload/fat.c +++ b/avr/usbload/fat.c @@ -1,6 +1,8 @@ -#include #include +#include +#include +#include #include "fat.h" #include "file.h" @@ -16,7 +18,7 @@ struct File file; // wichtige dateibezogene daten/variablen // 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) +uint8_t fat_writeSector(uint32_t sec) { fat.bufferDirty = 0; // buffer kann nicht dirty sein weil wird geschrieben @@ -29,7 +31,7 @@ unsigned char fat_writeSector(unsigned long int sec) // *************************************************************************************************************** // umrechnung cluster auf 1.sektor des clusters (möglicherweise mehrere sektoren/cluster) ! // *************************************************************************************************************** -unsigned long int fat_clustToSec(unsigned long int clust) +uint32_t fat_clustToSec(uint32_t clust) { return (fat.dataDirSec + 2 + ((clust - 2) * fat.secPerClust)); // errechnet den 1. sektor der sektoren des clusters @@ -38,7 +40,7 @@ unsigned long int fat_clustToSec(unsigned long int clust) // *************************************************************************************************************** // umrechnung sektor auf cluster (nicht die position im cluster selber!!) // *************************************************************************************************************** -unsigned long int fat_secToClust(unsigned long int sec) +uint32_t fat_secToClust(uint32_t sec) { return ((sec - fat.dataDirSec - 2 + 2 * fat.secPerClust) / fat.secPerClust); // umkerhrfunktion von fat_clustToSec @@ -50,7 +52,7 @@ unsigned long int fat_secToClust(unsigned long int sec) // 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) +uint8_t fat_loadSector(uint32_t sec) { if (sec != fat.currentSectorNr) { // nachladen nötig @@ -84,10 +86,10 @@ unsigned char fat_loadSector(unsigned long int sec) // 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) +uint8_t fat_loadRowOfSector(uint16_t row) { - unsigned char i; + uint8_t 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 :) @@ -98,13 +100,13 @@ unsigned char fat_loadRowOfSector(unsigned int row) 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; + file.firstCluster = *(uint16_t *) vsector; vsector = &fat.sector[row + 20]; // high word von first.cluster - file.firstCluster |= (*(unsigned short *) vsector) << 16; + file.firstCluster |= (*(uint16_t *) vsector) << 16; vsector = &fat.sector[row + 28]; // 4 byte von file.length - file.length = *(unsigned long int *) vsector; + file.length = *(uint32_t *) vsector; return (0); } @@ -115,11 +117,11 @@ unsigned char fat_loadRowOfSector(unsigned int row) // 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[]) +uint8_t fat_loadFileDataFromCluster(uint32_t sec, char name[]) { - unsigned char r; - unsigned char s = 0; + uint8_t r; + uint8_t s = 0; do { // sektoren des clusters prüfen r = 0; // neuer sektor, dann reihen von 0 an. @@ -149,13 +151,13 @@ unsigned char fat_loadFileDataFromCluster(unsigned long int sec, char name[]) // 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[]) +uint8_t fat_loadFileDataFromDir(char name[]) { - unsigned int s; + uint16_t 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 + for (s = 0; s < (uint16_t) (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) @@ -163,7 +165,7 @@ unsigned char fat_loadFileDataFromDir(char name[]) } else { - unsigned long int i; + uint32_t i; if (fat.dir == 0 && fat.fatType == 32) i = fat.rootDir; // IM ROOTDIR. fat32 else @@ -186,7 +188,7 @@ unsigned char fat_loadFileDataFromDir(char name[]) // 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[]) +uint8_t fat_cd(char name[]) { if (name[0] == 0) { // ZUM ROOTDIR FAT16/32 @@ -218,11 +220,11 @@ unsigned char fat_cd(char name[]) // 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) +uint8_t fat_getFreeRowOfCluster(unsigned long secStart) { - unsigned int b; // zum durchgenen der sektor bytes - unsigned char s = 0; // sektoren des clusters. + uint16_t b; // zum durchgenen der sektor bytes + uint8_t s = 0; // sektoren des clusters. do { file.row = 0; // neuer sektor(oder 1.sektor), reihen von vorne. @@ -246,10 +248,10 @@ unsigned char fat_getFreeRowOfCluster(unsigned long secStart) // 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) +void fat_getFreeRowOfDir(uint32_t dir) { - unsigned long int start = dir; + uint32_t start = dir; // solange bis ende cluster chain. while (! @@ -272,12 +274,12 @@ void fat_getFreeRowOfDir(unsigned long int dir) fat.currentSectorNr = fat_clustToSec(dir); // setzen des richtigen sektors, also auf den 1. der neu verketteten - unsigned int j = 511; + uint16_t 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... + uint8_t 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++; @@ -292,8 +294,8 @@ void fat_getFreeRowOfDir(unsigned long int dir) // 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) +void fat_makeRowDataEntry(uint16_t row, char name[], uint8_t attrib, + uint32_t cluster, uint32_t length) { fat.bufferDirty = 1; // puffer beschrieben, also neue daten darin(vor lesen muss geschrieben werden) @@ -301,8 +303,8 @@ void fat_makeRowDataEntry(unsigned int row, char name[], unsigned char attrib, 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 + uint8_t i; // byte zähler in reihe von sektor (32byte eintrag) + uint8_t *bytesOfSec = &fat.sector[row]; // zeiger auf sector bytes void *vsector; for (i = 0; i < 11; i++) @@ -311,20 +313,20 @@ void fat_makeRowDataEntry(unsigned int row, char name[], unsigned char attrib, *bytesOfSec++ = attrib; // attrib schreiben vsector = &fat.sector[row + 12]; - *(unsigned long int *) vsector++ = 0x01010101; // unnoetige felder beschreiben - *(unsigned long int *) vsector = 0x01010101; + *(uint32_t *) vsector++ = 0x01010101; // unnoetige felder beschreiben + *(uint32_t *) vsector = 0x01010101; vsector = &fat.sector[row + 20]; - *(unsigned short *) vsector = (cluster & 0xffff0000) >> 16; // low word von cluster + *(uint16_t *) vsector = (cluster & 0xffff0000) >> 16; // low word von cluster vsector = &fat.sector[row + 22]; - *(unsigned long int *) vsector = 0x01010101; // unnoetige felder beschreiben + *(uint32_t *) vsector = 0x01010101; // unnoetige felder beschreiben vsector = &fat.sector[row + 26]; - *(unsigned short *) vsector = (cluster & 0x0000ffff); // high word von cluster + *(uint16_t *) vsector = (cluster & 0x0000ffff); // high word von cluster vsector = &fat.sector[row + 28]; - *(unsigned long int *) vsector = length; // laenge + *(uint32_t *) vsector = length; // laenge } @@ -334,17 +336,17 @@ void fat_makeRowDataEntry(unsigned int row, char name[], unsigned char attrib, // 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) +void fat_makeFileEntry(char name[], uint8_t attrib, + uint32_t length) { - unsigned int s; // zähler für root dir sektoren fat16 + uint16_t 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 + for (s = 0; s < (uint16_t) (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. @@ -371,29 +373,29 @@ void fat_makeFileEntry(char name[], unsigned char attrib, // 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) +uint32_t fat_getNextCluster(uint32_t 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 + uint32_t i = oneCluster >> 8;; // (i=oneCluster/256)errechnet den sektor der fat in dem oneCluster ist (rundet immer ab) + uint32_t 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 :) + return *(uint16_t *) 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 + uint32_t i = oneCluster >> 7; // (i=oneCluster/128)errechnet den sektor der fat in dem oneCluster ist (rundet immer ab) + uint32_t 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 *(uint32_t *) bytesOfSec; // da der ram auch little endian ist, kann einfach gecastet werden und gut :) } } @@ -407,10 +409,10 @@ unsigned long int fat_getNextCluster(unsigned long int oneCluster) // 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) +void fat_getFatChainClustersInRow(uint32_t offsetCluster) { - unsigned int i = 0; + uint16_t i = 0; fat.startSectors = fat_clustToSec(offsetCluster); // setzen des 1. sektors der datei fat.endSectors = fat.startSectors; do { @@ -432,10 +434,10 @@ void fat_getFatChainClustersInRow(unsigned long int offsetCluster) // 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) +void fat_getFreeClustersInRow(uint32_t offsetCluster) { - unsigned int i = 1; // variable für anzahl der zu suchenden sektoren + uint16_t i = 1; // variable für anzahl der zu suchenden sektoren while (fat_getNextCluster(offsetCluster)) offsetCluster++; // suche des 1. freien clusters @@ -458,8 +460,8 @@ void fat_getFreeClustersInRow(unsigned long int offsetCluster) // 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) +void fat_setClusterChain(uint32_t startCluster, + uint16_t endCluster) { fat_setCluster(file.lastCluster, startCluster); // ende der chain setzen, bzw verketten der ketten @@ -482,30 +484,30 @@ void fat_setClusterChain(unsigned long int startCluster, // 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) +void fat_setCluster(uint32_t cluster, uint32_t 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 + uint32_t i = cluster >> 8; // (i=cluster/256)errechnet den sektor der fat in dem cluster ist (rundet immer ab) + uint32_t 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 :) + *(uint16_t *) 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 + uint32_t i = cluster >> 7; // (i=cluster/128)errechnet den sektor der fat in dem cluster ist (rundet immer ab) + uint32_t 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 :) + *(uint32_t *) bytesOfSec = content; // weil ram auch little endian geht das so :) fat.bufferDirty = 1; // zeigt an, dass im aktuellen sector geschrieben wurde } } @@ -516,10 +518,10 @@ void fat_setCluster(unsigned long int cluster, unsigned long int content) // 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) +void fat_delClusterChain(uint32_t startCluster) { - unsigned long int nextCluster = startCluster; // tmp variable, wegen verketteter cluster.. + uint32_t nextCluster = startCluster; // tmp variable, wegen verketteter cluster.. do { startCluster = nextCluster; @@ -539,13 +541,13 @@ void fat_delClusterChain(unsigned long int startCluster) // 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) +uint8_t fat_loadFatData(uint32_t 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 + uint16_t rootEntCnt; // 17,2 größe die eine fat belegt + uint16_t fatSz16; // 22,2 sectors occupied by one fat16 + uint32_t fatSz32; // 36,4 sectors occupied by one fat32 void *vsector; @@ -556,23 +558,23 @@ unsigned char fat_loadFatData(unsigned long int sec) fat.secPerClust = fat.sector[13]; // fat.secPerClust, 13 only (power of 2) vsector = &fat.sector[14]; - fat.fatSec = *(unsigned short *) vsector; + fat.fatSec = *(uint16_t *) vsector; vsector = &fat.sector[17]; - rootEntCnt = *(unsigned short *) vsector; + rootEntCnt = *(uint16_t *) vsector; vsector = &fat.sector[22]; - fatSz16 = *(unsigned short *) vsector; + fatSz16 = *(uint16_t *) 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; + fatSz32 = *(uint32_t *) vsector; vsector = &fat.sector[44]; - fat.rootDir = *(unsigned long int *) vsector; + fat.rootDir = *(uint32_t *) vsector; fat.dataDirSec = fat.fatSec + (fatSz32 * fat.sector[16]); // data sector (beginnt mit cluster 2) fat.fatType = 32; // fat typ @@ -600,15 +602,15 @@ unsigned char fat_loadFatData(unsigned long int sec) // ************************************************************************************************<<*************** // int fat sucht den 1. cluster des dateisystems (fat16/32) auch VBR genannt, // ************************************************************************************************<<*************** -unsigned char fat_initfat(void) +uint8_t fat_initfat(void) { - unsigned long int secOfFirstPartition = 0; // ist 1. sektor der 1. partition aus dem MBR + uint32_t 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; + secOfFirstPartition = *(uint32_t *) vsector; // prüfung ob man schon im VBR gelesen hat (0x6964654d = "Medi") if (secOfFirstPartition == 0x6964654d) @@ -633,9 +635,9 @@ unsigned char fat_initfat(void) char *fat_str(char *str) { - unsigned char i; - unsigned char j = 0; - unsigned char c; + uint8_t i; + uint8_t j = 0; + uint8_t c; char tmp[12]; // tmp string zum einfacheren umwandeln strcpy(tmp, str); diff --git a/avr/usbload/fat.h b/avr/usbload/fat.h index 9767227..85a7684 100644 --- a/avr/usbload/fat.h +++ b/avr/usbload/fat.h @@ -17,31 +17,31 @@ // ************************************************************************************************************************** // funktionen -extern unsigned long int fat_clustToSec(unsigned long int); // rechnet cluster zu 1. sektor des clusters um -extern unsigned long int fat_secToClust(unsigned long int sec); // rechnet sektor zu cluster um! -extern unsigned long int fat_getNextCluster(unsigned long int oneCluster); // fat auf nächsten, verketteten cluster durchsuchen -extern unsigned char fat_initfat(void); // initalisierung (durchsucht MBR oder nicht) -extern unsigned char fat_writeSector(unsigned long int sec); // schreibt sektor auf karte -extern void fat_setCluster(unsigned long int cluster, unsigned long int content); // setzt cluster inhalt in der fat -extern void fat_delClusterChain(unsigned long int startCluster); // löscht cluster-chain in der fat -extern void fat_getFreeRowOfDir(unsigned long int dir); // durchsucht directory nach feiem eintrag -extern void fat_makeFileEntry(char name[], unsigned char attrib, - unsigned long int length); -extern unsigned char fat_loadSector(unsigned long int sec); // läd übergebenen absoluten sektor -extern unsigned char fat_loadFileDataFromDir(char name[]); // durchsucht das aktuelle directory -extern unsigned char fat_cd(char *); // wechselt directory (start im rootDir) -extern unsigned char fat_loadFatData(unsigned long int); // läd fat daten -extern unsigned char fat_getFreeRowOfCluster(unsigned long secStart); // durchsucht cluster nach freiem eintrag -extern void fat_getFreeClustersInRow(unsigned long int offsetCluster); // sucht zusammenhängende freie cluster aus der fat -extern void fat_getFatChainClustersInRow(unsigned long int offsetCluster); // sucht fat-chain cluster die zusammenhängen -extern void fat_makeRowDataEntry(unsigned int row, char name[], - unsigned char attrib, - unsigned long int cluster, - unsigned long int length); -extern unsigned char fat_loadRowOfSector(unsigned int); // läd reihe des geladen sektors auf struct:file -extern unsigned char fat_loadFileDataFromCluster(unsigned long int sec, char name[]); // durchsucht die reihen des geladenen sektors -extern void fat_setClusterChain(unsigned long int newOffsetCluster, - unsigned int length); +extern uint32_t fat_clustToSec(uint32_t); // rechnet cluster zu 1. sektor des clusters um +extern uint32_t fat_secToClust(uint32_t sec); // rechnet sektor zu cluster um! +extern uint32_t fat_getNextCluster(uint32_t oneCluster); // fat auf nächsten, verketteten cluster durchsuchen +extern uint8_t fat_initfat(void); // initalisierung (durchsucht MBR oder nicht) +extern uint8_t fat_writeSector(uint32_t sec); // schreibt sektor auf karte +extern void fat_setCluster(uint32_t cluster, uint32_t content); // setzt cluster inhalt in der fat +extern void fat_delClusterChain(uint32_t startCluster); // löscht cluster-chain in der fat +extern void fat_getFreeRowOfDir(uint32_t dir); // durchsucht directory nach feiem eintrag +extern void fat_makeFileEntry(char name[], uint8_t attrib, + uint32_t length); +extern uint8_t fat_loadSector(uint32_t sec); // läd übergebenen absoluten sektor +extern uint8_t fat_loadFileDataFromDir(char name[]); // durchsucht das aktuelle directory +extern uint8_t fat_cd(char *); // wechselt directory (start im rootDir) +extern uint8_t fat_loadFatData(uint32_t); // läd fat daten +extern uint8_t fat_getFreeRowOfCluster(unsigned long secStart); // durchsucht cluster nach freiem eintrag +extern void fat_getFreeClustersInRow(uint32_t offsetCluster); // sucht zusammenhängende freie cluster aus der fat +extern void fat_getFatChainClustersInRow(uint32_t offsetCluster); // sucht fat-chain cluster die zusammenhängen +extern void fat_makeRowDataEntry(uint16_t row, char name[], + uint8_t attrib, + uint32_t cluster, + uint32_t length); +extern uint8_t fat_loadRowOfSector(uint16_t); // läd reihe des geladen sektors auf struct:file +extern uint8_t fat_loadFileDataFromCluster(uint32_t sec, char name[]); // durchsucht die reihen des geladenen sektors +extern void fat_setClusterChain(uint32_t newOffsetCluster, + uint16_t length); extern char *fat_str(char *str); // wandelt einen string so, dass er der fat konvention entspricht ! @@ -49,29 +49,29 @@ extern char *fat_str(char *str); // wandelt einen string so, dass er der // variablen extern struct Fat { // fat daten (1.cluster, root-dir, dir usw.) - unsigned char sector[512]; // der puffer für sektoren ! - unsigned char bufferDirty; // puffer wurde beschrieben, sector muss geschrieben werden bevor er neu geladen wird - unsigned long int currentSectorNr; // aktuell geladener Sektor (in sector) //beschleunigt wenn z.b 2* 512 byte puffer vorhanden, oder + uint8_t sector[512]; // der puffer für sektoren ! + uint8_t bufferDirty; // puffer wurde beschrieben, sector muss geschrieben werden bevor er neu geladen wird + uint32_t currentSectorNr; // aktuell geladener Sektor (in sector) //beschleunigt wenn z.b 2* 512 byte puffer vorhanden, oder // bei fat operationen im gleichen sektor - unsigned long int dir; // Direktory zeiger rootDir=='0' sonst(1.Cluster des dir; start auf root) - unsigned long int rootDir; // Sektor(f16)/Cluster(f32) nr root directory - unsigned long int dataDirSec; // Sektor nr data area - unsigned long int fatSec; // Sektor nr fat area - unsigned long int startSectors; // der erste sektor in einer reihe (freie oder verkettete) - unsigned long int endSectors; - unsigned char secPerClust; // anzahl der sektoren pro cluster - unsigned char fatType; // fat16 oder fat32 (16 oder 32) + uint32_t dir; // Direktory zeiger rootDir=='0' sonst(1.Cluster des dir; start auf root) + uint32_t rootDir; // Sektor(f16)/Cluster(f32) nr root directory + uint32_t dataDirSec; // Sektor nr data area + uint32_t fatSec; // Sektor nr fat area + uint32_t startSectors; // der erste sektor in einer reihe (freie oder verkettete) + uint32_t endSectors; + uint8_t secPerClust; // anzahl der sektoren pro cluster + uint8_t fatType; // fat16 oder fat32 (16 oder 32) } fat; extern struct File { // datei infos - unsigned int cntOfBytes; // -nicht direkt aus dem dateisystem- zäht geschriebene bytes eines sektors - unsigned char name[13]; // 0,10 datei Name.ext (8.3 = max 11)(MUSS unsigned char weil E5) - unsigned char attrib; // 11,1 datei Attribut: 8=value name, 32=datei, 16=Verzeichniss, 15=linux kleingeschrieben eintrag - unsigned char row; // reihe im sektor in der die datei infos stehen (reihe 0-15) - unsigned long int firstCluster; // 20,2 /26,2 datei 1.cluster hi,low(möglicherweise der einzige) (4-byte) - unsigned long int length; // 28,4 datei Länge (4-byte) - unsigned long int lastCluster; // -nicht direkt aus dem dateisystem- letzter cluster der ersten kette - unsigned long int seek; // schreib position in der datei + uint16_t cntOfBytes; // -nicht direkt aus dem dateisystem- zäht geschriebene bytes eines sektors + uint8_t name[13]; // 0,10 datei Name.ext (8.3 = max 11)(MUSS uint8_t weil E5) + uint8_t attrib; // 11,1 datei Attribut: 8=value name, 32=datei, 16=Verzeichniss, 15=linux kleingeschrieben eintrag + uint8_t row; // reihe im sektor in der die datei infos stehen (reihe 0-15) + uint32_t firstCluster; // 20,2 /26,2 datei 1.cluster hi,low(möglicherweise der einzige) (4-byte) + uint32_t length; // 28,4 datei Länge (4-byte) + uint32_t lastCluster; // -nicht direkt aus dem dateisystem- letzter cluster der ersten kette + uint32_t seek; // schreib position in der datei } file; #endif diff --git a/avr/usbload/file.c b/avr/usbload/file.c index 376cbd7..6f2d96d 100644 --- a/avr/usbload/file.c +++ b/avr/usbload/file.c @@ -17,10 +17,10 @@ // danach wird der dateieintrag gemacht(auf karte). dort wird auch geprüft ob genügend platz im aktuellen verzeichniss existiert. // möglicherweise wird der 1. cluster der datei nochmal geändert. jetzt ist der erste frei sektor bekannt und es kann geschrieben werden. // ******************************************************************************************************************************* -unsigned char ffopen(char name[]) +uint8_t ffopen(char name[]) { - unsigned char file_flag = fat_loadFileDataFromDir(name); // prüfung ob datei vorhanden und evetuelles laden des file struct + uint8_t file_flag = fat_loadFileDataFromDir(name); // prüfung ob datei vorhanden und evetuelles laden des file struct if (file_flag == 0) { /** Datei existiert, anlegen nicht nötig! **/ fat_getFatChainClustersInRow(file.firstCluster); // verkettete cluster aus der fat-chain suchen. @@ -52,7 +52,7 @@ unsigned char ffopen(char name[]) // und die neue datei länge muss ermitt weden. abschließend wird entweder (fall 2) nur der aktuelle sektor geschrieben, oder // der aktuallisierte datei eintrag und die cluster (diese werden verkettet, siehe fileUpdate() ). // ******************************************************************************************************************************* -unsigned char ffclose(void) +uint8_t ffclose(void) { #if (WRITE==1) /** 2 möglichkeiten beim schließen !! (lesend spielt keine rolle, nichts muss geupdatet werden) **/ @@ -78,13 +78,13 @@ unsigned char ffclose(void) void fileUpdate(void) { - unsigned int comp_cntOfBytes = file.cntOfBytes; // sicher nötig wegen schleife... + uint16_t comp_cntOfBytes = file.cntOfBytes; // sicher nötig wegen schleife... while (comp_cntOfBytes < 512) { // sektor ist beschrieben worden, daher nötigenfalls mit 00 füllen fat.sector[comp_cntOfBytes] = 0x00; // beschreibt ungenutzte bytes mit 0x00 comp_cntOfBytes++; } char name[13]; // zum sichern des dateinamens - unsigned long int save_length = file.cntOfBytes + file.seek; // muss gesichert werden, wird sonst von der karte geladen und + uint32_t save_length = file.cntOfBytes + file.seek; // muss gesichert werden, wird sonst von der karte geladen und // verändert ! strcpy(name, (char *) file.name); // muss gesichert werden, wird sonst von der karte geladen und verändert ! @@ -101,7 +101,7 @@ void fileUpdate(void) // ist, dann wird der sektor geladen und der zähler für die bytes eines sektors gesetzt. wenn das byte nicht in den sektoren ist, // die "vorgesucht" wurden, müssen noch weitere sektoren der datei gesucht werden (sec > fat.endSectors). // ******************************************************************************************************************************* -void ffseek(unsigned long int offset) +void ffseek(uint32_t offset) { #if (OVER_WRITE==1) // man muss den dateieintrag updaten, um die daten zu retten !! @@ -110,7 +110,7 @@ void ffseek(unsigned long int offset) #endif fat_getFatChainClustersInRow(file.firstCluster); // suchen von anfang der cluster chain aus ! - unsigned long int sec = fat.startSectors; // sektor variable zum durchgehen durch die sektoren + uint32_t sec = fat.startSectors; // sektor variable zum durchgehen durch die sektoren file.seek = 0; // weil auch von anfang an der chain gesucht wird mit 0 initialisiert while (offset >= 512) { /** suchen des sektors in dem offset ist **/ @@ -136,7 +136,7 @@ void ffseek(unsigned long int offset) // wechselt verzeichniss. start immer im root Dir. // MUSS in das direktory gewechselt werden, in dem die datei zum lesen/schreiben ist ! // ******************************************************************************************************************************* -unsigned char ffcd(char name[]) +uint8_t ffcd(char name[]) { return (fat_cd(name)); } @@ -148,11 +148,11 @@ unsigned char ffcd(char name[]) // eintrag in der reihe ist (nicht gelöscht, nicht frei usw). die sektoren des clusters werden nachgeladen. // die dateien werden mit namen und datei größe angezeigt. // ******************************************************************************************************************************* -void lsRowsOfClust(unsigned long int start_sec) +void lsRowsOfClust(uint32_t start_sec) { - unsigned char row; // reihen - unsigned char sec = 0; // sektoren + uint8_t row; // reihen + uint8_t sec = 0; // sektoren do { fat_loadSector(start_sec + sec); // sektoren des clusters laden for (row = 0; row < 16; row++) { // geht durch reihen des sektors @@ -174,11 +174,11 @@ void lsRowsOfClust(unsigned long int start_sec) void ffls(void) { - unsigned long int clust; // cluster - unsigned int s; // fat16 root dir sektoren + uint32_t clust; // cluster + uint16_t s; // fat16 root dir sektoren 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 + for (s = 0; s < (uint16_t) (fat.dataDirSec + 2 - fat.rootDir); s++) { // zählt durch RootDir sektoren (errechnet anzahl // rootDir sektoren). lsRowsOfClust(fat.rootDir + s); // zeigt reihen eines root dir clust an } @@ -205,7 +205,7 @@ void ffls(void) // die variable fat.dir enthält den start cluster des direktory in dem man sich grade befindet, anhand diesem, // kann der "." bzw ".." eintrag im ersten sektor des direktory ausgelesen und das parent direktory bestimmt werden. // ******************************************************************************************************************************* -unsigned char ffcdLower(void) +uint8_t ffcdLower(void) { if (fat.dir == 0) @@ -232,8 +232,8 @@ unsigned char ffcdLower(void) void ffmkdir(char name[]) { - unsigned char i; - unsigned int j; + uint8_t i; + uint16_t j; if (0 == fat_loadFileDataFromDir(name)) return; // prüft ob dirname im dir schon vorhanden, wenn ja, abbruch ! @@ -272,7 +272,7 @@ void ffmkdir(char name[]) // löscht datei/ordner aus aktuellem verzeichniss, wenn es die datei gibt. // löscht dateien und ordner rekursiv ! // ******************************************************************************************************************************* -unsigned char ffrm(char name[]) +uint8_t ffrm(char name[]) { if (0 == fat_loadFileDataFromDir(name)) { // datei oder ordner ist vorhanden, nur dann lösch operation @@ -292,11 +292,11 @@ unsigned char ffrm(char name[]) // TODO noch nicht optimal. zu viele schreib vorgänge beim löschen von datei einträgen. max bis zu 16/sektor ! else { // ist ordner, dann rekursiv löschen !! #ifndef __AVR_ATmega8__ // mega8 zu klein für die funktionalität.... - unsigned long int parent; - unsigned long int own; - unsigned long int clustsOfDir; // um durch die cluster chain eines dirs zu gehen. - unsigned char cntSecOfClust = 0; - unsigned char i = 0; + uint32_t parent; + uint32_t own; + uint32_t clustsOfDir; // um durch die cluster chain eines dirs zu gehen. + uint8_t cntSecOfClust = 0; + uint8_t i = 0; fat.sector[file.row << 5] = 0xE5; // löscht dir eintrag if ((file.row - 1) >= 0) { // gibt es einen eintrag davor (langer datei eintrag)? @@ -392,7 +392,7 @@ unsigned char ffrm(char name[]) // liest 512 bytes aus dem puffer fat.sector. dann werden neue 512 bytes der datei geladen, sind nicht genügend verkettete // sektoren in einer reihe bekannt, wird in der fat nachgeschaut. dann werden weiter bekannte nachgeladen... // ******************************************************************************************************************************* -inline unsigned char ffread(void) +inline uint8_t ffread(void) { if (file.cntOfBytes == 512) { /** EINEN SEKTOR GLESEN (ab hier 2 möglichkeiten !) **/ @@ -417,7 +417,7 @@ inline unsigned char ffread(void) // zusammenhängende sektoren bekannt sein, werden die alten verkettet und neue gesucht. es ist nötig sich den letzten bekannten // einer kette zu merken -> file.lastCluster, um auch nicht zusammenhängende cluster verketten zu können (fat_setClusterChain macht das)! // ******************************************************************************************************************************* -inline void ffwrite(unsigned char c) +inline void ffwrite(uint8_t c) { fat.sector[file.cntOfBytes++] = c; // schreiben des chars auf den puffer sector und zähler erhöhen (pre-increment) @@ -450,7 +450,7 @@ inline void ffwrite(unsigned char c) // hat. das ist blöd, weil so ein daten overhead von 50% entsteht. da lesen aber schneller als schreiben geht, verliert man nicht 50% an // geschwindigkeit. // ******************************************************************************************************************************* -inline void ffwrite(unsigned char c) +inline void ffwrite(uint8_t c) { fat.sector[file.cntOfBytes++] = c; // schreiben des chars auf den puffer sector und zähler erhöhen (pre-increment) diff --git a/avr/usbload/file.h b/avr/usbload/file.h index 3cd682e..d1fb140 100644 --- a/avr/usbload/file.h +++ b/avr/usbload/file.h @@ -8,20 +8,20 @@ // ************************************************************************************************************************** // funktionen -extern inline unsigned char ffread(void); // liest byte-weise aus der datei (puffert immer 512 bytes zwischen) -extern inline void ffwrite(unsigned char c); // schreibt ein byte in die geöffnete datei +extern inline uint8_t ffread(void); // liest byte-weise aus der datei (puffert immer 512 bytes zwischen) +extern inline void ffwrite(uint8_t c); // schreibt ein byte in die geöffnete datei extern inline void ffwrites(const char *s); // schreibt string auf karte -extern unsigned char ffopen(char name[]); // kann immer nur 1 datei bearbeiten. -extern unsigned char ffclose(void); // muss aufgerufen werden bevor neue datei bearbeitet wird. +extern uint8_t ffopen(char name[]); // kann immer nur 1 datei bearbeiten. +extern uint8_t ffclose(void); // muss aufgerufen werden bevor neue datei bearbeitet wird. -extern void ffseek(unsigned long int offset); // setzt zeiger:bytesOfSec auf position in der geöffneten datei. -extern unsigned char ffcd(char name[]); // wechselt direktory +extern void ffseek(uint32_t offset); // setzt zeiger:bytesOfSec auf position in der geöffneten datei. +extern uint8_t ffcd(char name[]); // wechselt direktory extern void ffls(void); // zeigt direktory inhalt an -extern unsigned char ffcdLower(void); // geht ein direktory zurück, also cd.. (parent direktory) -extern unsigned char ffrm(char name[]); // löscht datei aus aktuellem verzeichniss. +extern uint8_t ffcdLower(void); // geht ein direktory zurück, also cd.. (parent direktory) +extern uint8_t ffrm(char name[]); // löscht datei aus aktuellem verzeichniss. extern void ffmkdir(char name[]); // legt ordner in aktuellem verzeichniss an. -void lsRowsOfClust(unsigned long int start_sec); // zeigt reihen eines clusters an, ab start_sec +void lsRowsOfClust(uint32_t start_sec); // zeigt reihen eines clusters an, ab start_sec void fileUpdate(void); // updatet datei eintrag auf karte // **************************************************************************************************************************// diff --git a/avr/usbload/mmc.h b/avr/usbload/mmc.h index 8417033..3be8a24 100644 --- a/avr/usbload/mmc.h +++ b/avr/usbload/mmc.h @@ -27,13 +27,13 @@ -extern unsigned char mmc_read_byte(void); -extern void mmc_write_byte(unsigned char); -extern void mmc_read_block(unsigned char *, unsigned char *, unsigned in); -extern unsigned char mmc_init(void); -extern unsigned char mmc_read_sector(unsigned long, unsigned char *); -extern unsigned char mmc_write_sector(unsigned long, unsigned char *); -extern unsigned char mmc_write_command(unsigned char *); +extern uint8_t mmc_read_byte(void); +extern void mmc_write_byte(uint8_t); +extern void mmc_read_block(uint8_t *, uint8_t *, unsigned in); +extern uint8_t mmc_init(void); +extern uint8_t mmc_read_sector(unsigned long, uint8_t *); +extern uint8_t mmc_write_sector(unsigned long, uint8_t *); +extern uint8_t mmc_write_command(uint8_t *); #define mmc_disable() MMC_WRITE|= (1<