Ver código fonte

cleanup code

David Voswinkel 15 anos atrás
pai
commit
b018ae6f78
4 arquivos alterados com 104 adições e 217 exclusões
  1. 41 119
      avr/usbload/fat.c
  2. 33 35
      avr/usbload/fat.h
  3. 29 60
      avr/usbload/mmc.c
  4. 1 3
      avr/usbload/mmc.h

+ 41 - 119
avr/usbload/fat.c

@@ -1,29 +1,14 @@
-/*
- * 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,
- */
-
 #include "fat.h"
+
 uint8_t cluster_size;
 uint16_t fat_offset;
 uint16_t cluster_offset;
 uint16_t 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
-
-    // uint8_t Buffer[BlockSize];
-
-    // volume_boot_record_addr = fat_addr (Buffer); 
-    mmc_read_sector(MASTER_BOOT_RECORD, Buffer);        // Read Master Boot Record 
+    struct BootSec *bootp;
+    mmc_read_sector(MASTER_BOOT_RECORD, Buffer);
     if (Buffer[510] == 0x55 && Buffer[511] == 0xAA) {
         FAT_DEBUG("MBR Signatur found!\r\n");
     }
@@ -40,8 +25,8 @@ void fat_init(uint8_t * Buffer)
 
     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 
+        volume_boot_record_addr = MASTER_BOOT_RECORD;
+        mmc_read_sector(MASTER_BOOT_RECORD, Buffer);
     }
     bootp = (struct BootSec *) Buffer;
     cluster_size = bootp->BPB_SecPerClus;
@@ -49,37 +34,33 @@ void fat_init(uint8_t * Buffer)
     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
-uint16_t fat_root_dir_addr(uint8_t *Buffer)
+
+uint16_t fat_root_dir_addr(uint8_t * Buffer)
 {
-    struct BootSec *bootp;      // Zeiger auf Bootsektor Struktur
+    struct BootSec *bootp;
     uint16_t 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
-uint16_t fat_read_dir_ent(uint16_t dir_cluster, // Angabe Dir Cluster
-                              uint8_t Entry_Count,        // Angabe welcher Direintrag
-                              uint32_t *Size,      // Rückgabe der File Größe
-                              uint8_t *Dir_Attrib,        // Rückgabe des Dir Attributs
-                              uint8_t *Buffer)    // Working Buffer
+
+uint16_t fat_read_dir_ent(uint16_t dir_cluster,
+                          uint8_t Entry_Count,
+                          uint32_t * Size,
+                          uint8_t * Dir_Attrib, uint8_t * Buffer)
 {
     uint8_t *pointer;
     uint16_t TMP_Entry_Count = 0;
     uint32_t Block = 0;
-    struct DirEntry *dir;       // Zeiger auf einen Verzeichniseintrag
+    struct DirEntry *dir;
     uint16_t blk;
     uint16_t a;
     uint8_t b;
@@ -89,34 +70,27 @@ uint16_t fat_read_dir_ent(uint16_t dir_cluster, // Angabe Dir Cluster
     }
 
     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 (blk = Block;; blk++) {
-        mmc_read_sector(blk, Buffer);   // Lesen eines Blocks des Root Directory
+        mmc_read_sector(blk, Buffer);
         for (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
-            {
+            dir = (struct DirEntry *) &Buffer[a];
+            if (dir->DIR_Name[0] == 0) {
                 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 ( b = 0; b < 11; b++) {
+
+                    for (b = 0; b < 11; b++) {
                         if (dir->DIR_Name[b] != SPACE) {
                             if (b == 8) {
                                 *pointer++ = '.';
@@ -127,68 +101,48 @@ uint16_t fat_read_dir_ent(uint16_t dir_cluster, // Angabe Dir Cluster
                     *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
+    return (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(uint16_t Cluster,     // Angabe Startcluster
-              uint32_t *Block, uint8_t *TMP_Buffer)  // Workingbuffer
+void fat_load(uint16_t Cluster, uint32_t * Block, uint8_t * TMP_Buffer)
 {
-
-    // Zum Überprüfen ob der FAT Block schon geladen wurde
     uint16_t FAT_Block_Store = 0;
-
-    // Byte Adresse innerhalb des Fat Blocks
     uint16_t FAT_Byte_Addresse;
-
-    // FAT Block Adresse
     uint16_t FAT_Block_Addresse;
     uint16_t a;
 
-    // Berechnung für den ersten FAT Block (FAT Start Addresse)
     for (a = 0;; a++) {
         if (a == *Block) {
             *Block = (0x0000FFFF & Cluster);
             return;
         }
         if (Cluster == 0xFFFF) {
-            break;              // Ist das Ende des Files erreicht Schleife beenden
+            break;
         }
-        // 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];
@@ -196,75 +150,43 @@ void fat_load(uint16_t Cluster,     // Angabe Startcluster
     return;
 }
 
-    // Lesen eines 512Bytes Blocks von einem File
-void fat_read_file(uint16_t Cluster,        // Angabe des Startclusters vom File
-                   uint8_t *Buffer,       // Workingbuffer
-                   uint32_t BlockCount)    // Angabe welcher Bock vom File geladen 
-                                                                                      // werden soll a 512 Bytes
+void fat_read_file(uint16_t Cluster, uint8_t * Buffer, uint32_t BlockCount)
 {
 
-    // Berechnung des Blocks aus BlockCount und Cluster aus FATTabelle
-    // Berechnung welcher Cluster zu laden ist
     uint32_t 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(uint16_t cluster,       // Angabe des Startclusters vom File
-                    uint8_t *buffer,      // Workingbuffer
-                    uint32_t blockCount)   // Angabe welcher Bock vom File gespeichert 
-                                                                          // werden soll a 512 Bytes
+void fat_write_file(uint16_t cluster, uint8_t * buffer, uint32_t blockCount)
 {
-
-    // Berechnung des Blocks aus BlockCount und Cluster aus FATTabelle
-    // Berechnung welcher Cluster zu speichern ist
     uint8_t tmp_buffer[513];
     uint32_t 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
-uint8_t fat_search_file(uint8_t *File_Name, // Name des zu suchenden Files
-                              uint16_t *Cluster,    // Angabe Dir Cluster welches
-                              // durchsucht werden soll
-                              // und Rückgabe des clusters
-                              // vom File welches gefunden
-                              // wurde
-                              uint32_t *Size,      // Rückgabe der File Größe
-                              uint8_t *Dir_Attrib,        // Rückgabe des Dir Attributs
-                              uint8_t *Buffer)    // Working Buffer
+uint8_t fat_search_file(uint8_t * File_Name,
+                        uint16_t * Cluster,
+                        uint32_t * Size, uint8_t * Dir_Attrib, uint8_t * Buffer)
 {
     uint16_t Dir_Cluster_Store = *Cluster;
-    uint8_t a ;
+    uint8_t a;
     for (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
+            return (0);
         }
         if (strcasecmp((char *) File_Name, (char *) Buffer) == 0) {
-            return (1);         // File Found
+            return (1);
         }
     }
-    return (2);                 // Error
+    return (2);
 }

+ 33 - 35
avr/usbload/fat.h

@@ -8,37 +8,35 @@
 #include "uart.h"
 
 #define FAT_DEBUG	uart_puts
-    // #define FAT_DEBUG(...) 
 
-    // Prototypes
+
+
 extern uint16_t fat_root_dir_addr(uint8_t *);
 extern uint16_t fat_read_dir_ent(uint16_t, uint8_t,
-                                     uint32_t *, uint8_t *,
-                                     uint8_t *);
+                                 uint32_t *, uint8_t *, uint8_t *);
 extern void fat_load(uint16_t, uint32_t *, uint8_t *);
 extern void fat_read_file(uint16_t, uint8_t *, uint32_t);
 extern void fat_write_file(uint16_t, uint8_t *, uint32_t);
 extern void fat_init(uint8_t * Buffer);
 extern uint8_t fat_search_file(uint8_t *, uint16_t *,
-                                     uint32_t *, uint8_t *,
-                                     uint8_t *);
+                               uint32_t *, uint8_t *, uint8_t *);
+
 
-    // Block Size in Bytes
 #define BlockSize			512
 
-    // Master Boot Record
+
 #define MASTER_BOOT_RECORD	0
 
-    // Volume Boot Record location in Master Boot Record
+
 #define VBR_ADDR 			0x1C6
 
-    // define ASCII
+
 #define SPACE 				0x20
 #define DIR_ENTRY_IS_FREE   0xE5
 #define FIRST_LONG_ENTRY	0x01
 #define SECOND_LONG_ENTRY	0x42
 
-    // define DIR_Attr
+
 #define ATTR_LONG_NAME		0x0F
 #define ATTR_READ_ONLY		0x01
 #define ATTR_HIDDEN			0x02
@@ -49,21 +47,21 @@ extern uint8_t fat_search_file(uint8_t *, uint16_t *,
 struct BootSec {
     uint8_t BS_jmpBoot[3];
     uint8_t BS_OEMName[8];
-    uint16_t BPB_BytesPerSec;       // 2 bytes
+    uint16_t BPB_BytesPerSec;
     uint8_t BPB_SecPerClus;
-    uint16_t BPB_RsvdSecCnt;        // 2 bytes
+    uint16_t BPB_RsvdSecCnt;
     uint8_t BPB_NumFATs;
-    uint16_t BPB_RootEntCnt;        // 2 bytes
-    uint16_t BPB_TotSec16;  // 2 bytes
+    uint16_t BPB_RootEntCnt;
+    uint16_t BPB_TotSec16;
     uint8_t BPB_Media;
-    uint16_t BPB_FATSz16;   // 2 bytes
-    uint16_t BPB_SecPerTrk; // 2 bytes
-    uint16_t BPB_NumHeads;  // 2 bytes
-    uint32_t BPB_HiddSec;  // 4 bytes
-    uint32_t BPB_TotSec32; // 4 bytes
+    uint16_t BPB_FATSz16;
+    uint16_t BPB_SecPerTrk;
+    uint16_t BPB_NumHeads;
+    uint32_t BPB_HiddSec;
+    uint32_t BPB_TotSec32;
 };
 
-    // FAT12 and FAT16 Structure Starting at Offset 36
+
 #define BS_DRVNUM			36
 #define BS_RESERVED1		37
 #define BS_BOOTSIG			38
@@ -71,7 +69,7 @@ struct BootSec {
 #define BS_VOLLAB			43
 #define BS_FILSYSTYPE		54
 
-    // FAT32 Structure Starting at Offset 36
+
 #define BPB_FATSZ32			36
 #define BPB_EXTFLAGS		40
 #define BPB_FSVER			42
@@ -86,20 +84,20 @@ struct BootSec {
 #define FAT32_BS_VOLID		67
 #define FAT32_BS_VOLLAB		71
 #define FAT32_BS_FILSYSTYPE	82
-    // End of Boot Sctor and BPB Structure
+
 struct DirEntry {
-    uint8_t DIR_Name[11]; // 8 chars filename
-    uint8_t DIR_Attr;     // file attributes RSHA, Longname, Drive Label, Directory
-    uint8_t DIR_NTRes;    // set to zero
-    uint8_t DIR_CrtTimeTenth;     // creation time part in milliseconds
-    uint16_t DIR_CrtTime;   // creation time
-    uint16_t DIR_CrtDate;   // creation date
-    uint16_t DIR_LastAccDate;       // last access date
-    uint16_t DIR_FstClusHI; // first cluster high word 
-    uint16_t DIR_WrtTime;   // last write time
-    uint16_t DIR_WrtDate;   // last write date
-    uint16_t DIR_FstClusLO; // first cluster low word 
+    uint8_t DIR_Name[11];
+    uint8_t DIR_Attr;
+    uint8_t DIR_NTRes;
+    uint8_t DIR_CrtTimeTenth;
+    uint16_t DIR_CrtTime;
+    uint16_t DIR_CrtDate;
+    uint16_t DIR_LastAccDate;
+    uint16_t DIR_FstClusHI;
+    uint16_t DIR_WrtTime;
+    uint16_t DIR_WrtDate;
+    uint16_t DIR_FstClusLO;
     uint32_t DIR_FileSize;
 };
 
-#endif                          // _FAT_H_
+#endif

+ 29 - 60
avr/usbload/mmc.c

@@ -1,18 +1,13 @@
 #include "mmc.h"
 #include <util/delay.h>
+
 uint8_t mmc_init()
 {
     uint16_t Timeout = 0, i;
-
-    // Konfiguration des Ports an der die MMC/SD-Karte angeschlossen wurde
     MMC_REG |= ((1 << MMC_DO) | (1 << MMC_CS) | (1 << MMC_CLK));
     MMC_REG &= ~(1 << MMC_DI);
     MMC_WRITE |= ((1 << MMC_DO) | (1 << MMC_DI) | (1 << MMC_CS));
-
-    // Wartet eine kurze Zeit
     _delay_ms(20);
-
-    // Initialisiere MMC/SD-Karte in den SPI-Mode
     for (i = 0; i < 250; i++) {
         MMC_WRITE ^= (1 << MMC_CLK);
         _delay_us(4);
@@ -22,52 +17,46 @@ uint8_t mmc_init()
     MMC_WRITE &= ~(1 << MMC_CS);
     _delay_us(3);
 
-    // Sendet Commando CMD0 an MMC/SD-Karte
     uint8_t CMD[] = { 0x40, 0x00, 0x00, 0x00, 0x00, 0x95 };
     while (mmc_write_command(CMD) != 1) {
         if (Timeout++ > 20) {
             mmc_disable();
-            return (1);         // Abbruch bei Commando1 (Return Code1)
+            return (1);
         }
     }
 
-    // Sendet Commando CMD1 an MMC/SD-Karte
     Timeout = 0;
-    CMD[0] = 0x41;              // Commando 1
+    CMD[0] = 0x41;
     CMD[5] = 0xFF;
     while (mmc_write_command(CMD) != 0) {
         if (Timeout++ > 800) {
             mmc_disable();
-            return (9);         // Abbruch bei Commando2 (Return Code2)
+            return (9);
         }
     }
     return (0);
 }
 
-    // Sendet ein Commando an die MMC/SD-Karte
-uint8_t mmc_write_command(uint8_t *cmd)
+uint8_t mmc_write_command(uint8_t * cmd)
 {
     uint8_t tmp = 0xff;
     uint16_t Timeout = 0;
     uint8_t a;
 
-    // sendet 6 Byte Commando
-    for (a = 0; a < 0x06; a++)  // sendet 6 Byte Commando zur MMC/SD-Karte
-    {
+    for (a = 0; a < 0x06; a++) {
         mmc_write_byte(*cmd++);
     }
 
-    // Wartet auf ein gültige Antwort von der MMC/SD-Karte
     while (tmp == 0xff) {
         tmp = mmc_read_byte();
         if (Timeout++ > 50) {
-            break;              // Abbruch da die MMC/SD-Karte nicht Antwortet
+            break;
         }
     }
     return (tmp);
 }
 
-    // Routine zum Empfangen eines Bytes von der MMC-Karte 
+
 uint8_t mmc_read_byte(void)
 {
     uint8_t Byte = 0, j;
@@ -88,7 +77,7 @@ uint8_t mmc_read_byte(void)
     return (Byte);
 }
 
-    // Routine zum Senden eines Bytes zur MMC-Karte
+
 void mmc_write_byte(uint8_t Byte)
 {
     uint8_t i;
@@ -109,94 +98,76 @@ void mmc_write_byte(uint8_t Byte)
     MMC_WRITE |= (1 << MMC_DO);
 }
 
-    // Routine zum schreiben eines Blocks(512Byte) auf die MMC/SD-Karte
-uint8_t mmc_write_sector(uint32_t addr, uint8_t *Buffer)
+uint8_t mmc_write_sector(uint32_t addr, uint8_t * Buffer)
 {
     uint8_t tmp;
 
-    // Commando 24 zum schreiben eines Blocks auf die MMC/SD - Karte
+
     uint8_t cmd[] = { 0x58, 0x00, 0x00, 0x00, 0x00, 0xFF };
     uint8_t a;
     uint16_t i;
 
-    /*
-     * Die Adressierung der MMC/SD-Karte wird in Bytes angegeben, addr wird von Blocks zu Bytes umgerechnet danach werden  diese in
-     * das Commando eingefügt
-     */
-    addr = addr << 9;           // addr = addr * 512
+    addr = addr << 9;
     cmd[1] = ((addr & 0xFF000000) >> 24);
     cmd[2] = ((addr & 0x00FF0000) >> 16);
     cmd[3] = ((addr & 0x0000FF00) >> 8);
 
-    // Sendet Commando cmd24 an MMC/SD-Karte (Write 1 Block/512 Bytes)
+
     tmp = mmc_write_command(cmd);
     if (tmp != 0) {
         return (tmp);
     }
-    // Wartet einen Moment und sendet einen Clock an die MMC/SD-Karte
+
     for (a = 0; a < 100; a++) {
         mmc_read_byte();
     }
 
-    // Sendet Start Byte an MMC/SD-Karte
     mmc_write_byte(0xFE);
 
-    // Schreiben des Bolcks (512Bytes) auf MMC/SD-Karte
     for (a = 0; i < 512; i++) {
         mmc_write_byte(*Buffer++);
     }
 
-    // CRC-Byte schreiben
-    mmc_write_byte(0xFF);       // Schreibt Dummy CRC
-    mmc_write_byte(0xFF);       // CRC Code wird nicht benutzt
+    mmc_write_byte(0xFF);
+    mmc_write_byte(0xFF);
 
-    // Fehler beim schreiben? (Data Response XXX00101 = OK)
     if ((mmc_read_byte() & 0x1F) != 0x05)
         return (1);
 
-    // Wartet auf MMC/SD-Karte Bussy
     while (mmc_read_byte() != 0xff) {
     };
     return (0);
 }
 
-    // Routine zum lesen des CID Registers von der MMC/SD-Karte (16Bytes)
-void mmc_read_block(uint8_t *cmd, uint8_t *Buffer,
-                    uint16_t Bytes)
+
+void mmc_read_block(uint8_t * cmd, uint8_t * Buffer, uint16_t Bytes)
 {
     uint16_t a;
 
-    // Sendet Commando cmd an MMC/SD-Karte
     if (mmc_write_command(cmd) != 0) {
         return;
     }
-    // Wartet auf Start Byte von der MMC/SD-Karte (FEh/Start Byte)
+
     while (mmc_read_byte() != 0xfe) {
     };
 
-    // Lesen des Bolcks (normal 512Bytes) von MMC/SD-Karte
+
     for (a = 0; a < Bytes; a++) {
         *Buffer++ = mmc_read_byte();
     }
 
-    // CRC-Byte auslesen
-    mmc_read_byte();            // CRC - Byte wird nicht ausgewertet
-    mmc_read_byte();            // CRC - Byte wird nicht ausgewertet
+    mmc_read_byte();
+    mmc_read_byte();
     return;
 }
 
-    // Routine zum lesen eines Blocks(512Byte) von der MMC/SD-Karte
-uint8_t mmc_read_sector(uint32_t addr, uint8_t *Buffer)
+uint8_t mmc_read_sector(uint32_t addr, uint8_t * Buffer)
 {
 
-    // Commando 16 zum lesen eines Blocks von der MMC/SD - Karte
+
     uint8_t cmd[] = { 0x51, 0x00, 0x00, 0x00, 0x00, 0xFF };
 
-    /*
-     * Die Adressierung der MMC/SD-Karte wird in Bytes angegeben, addr wird von Blocks zu Bytes umgerechnet danach werden  diese in
-     * das Commando eingefügt
-     */
-    addr = addr << 9;           // addr = addr * 512
+    addr = addr << 9;
     cmd[1] = ((addr & 0xFF000000) >> 24);
     cmd[2] = ((addr & 0x00FF0000) >> 16);
     cmd[3] = ((addr & 0x0000FF00) >> 8);
@@ -204,21 +175,19 @@ uint8_t mmc_read_sector(uint32_t addr, uint8_t *Buffer)
     return (0);
 }
 
-    // Routine zum lesen des CID Registers von der MMC/SD-Karte (16Bytes)
-uint8_t mmc_read_cid(uint8_t *Buffer)
+
+uint8_t mmc_read_cid(uint8_t * Buffer)
 {
 
-    // Commando zum lesen des CID Registers
     uint8_t cmd[] = { 0x4A, 0x00, 0x00, 0x00, 0x00, 0xFF };
     mmc_read_block(cmd, Buffer, 16);
     return (0);
 }
 
-    // Routine zum lesen des CSD Registers von der MMC/SD-Karte (16Bytes)
-uint8_t mmc_read_csd(uint8_t *Buffer)
+
+uint8_t mmc_read_csd(uint8_t * Buffer)
 {
 
-    // Commando zum lesen des CSD Registers
     uint8_t cmd[] = { 0x49, 0x00, 0x00, 0x00, 0x00, 0xFF };
     mmc_read_block(cmd, Buffer, 16);
     return (0);

+ 1 - 3
avr/usbload/mmc.h

@@ -4,7 +4,7 @@
 #include <avr/io.h>
 
 
-#define MMC_WRITE			PORTB   // Port an der die MMC/SD-Karte angeschlossen ist also des SPI
+#define MMC_WRITE			PORTB
 #define MMC_READ			PINB
 #define MMC_REG	DDRB
 
@@ -26,6 +26,4 @@ extern uint8_t mmc_read_cid(uint8_t *);
 
 #define mmc_enable() MMC_WRITE&=~(1<<MMC_CS);
 
-#define nop()  __asm__ __volatile__ ("nop" ::)
-
 #endif