remove big comments

2009-08-06 09:07:25 +02:00
parent 13aa3536b4
commit a823badfe0
3 changed files with 0 additions and 34 deletions
--- a/avr/usbload/fat.c
+++ b/avr/usbload/fat.c
@@ -1,5 +1,4 @@
 /*
- * ####################################################################################### FAT for AVR (MMC/SD)   Copyright (C) 2004
 * Ulrich Radig  Bei Fragen und Verbesserungen wendet euch per EMail an  mail@ulrichradig.de  oder im Forum meiner Web Page :
 * www.ulrichradig.de   Dieses Programm ist freie Software. Sie k<>nnen es unter den Bedingungen der  GNU General Public License, wie
 * von der Free Software Foundation ver<65>ffentlicht,  weitergeben und/oder modifizieren, entweder gem<65><6D> Version 2 der Lizenz oder  (nach
@@ -7,7 +6,6 @@
 * wird, aber OHNE IRGENDEINE GARANTIE,  sogar ohne die implizite Garantie der MARKTREIFE oder der VERWENDBARKEIT  F<>R EINEN BESTIMMTEN
 * ZWECK. Details finden Sie in der GNU General Public License.   Sie sollten eine Kopie der GNU General Public License zusammen mit
 * diesem  Programm erhalten haben.  Falls nicht, schreiben Sie an die Free Software Foundation,  Inc., 59 Temple Place, Suite 330,
- * Boston, MA 02111-1307, USA.  #######################################################################################
 */

 #include "fat.h"
@@ -16,11 +14,9 @@ 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<67><72>e ins EEprom
    // Auslesen Cluster Offset der MMC/SD Karte und Speichern der gr<67><72>e ins EEprom
 void fat_init(uint8_t * Buffer)
-// ############################################################################
 {
    struct BootSec *bootp;      // Zeiger auf Bootsektor Struktur

@@ -53,10 +49,8 @@ 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)
-// ############################################################################
 {
    struct BootSec *bootp;      // Zeiger auf Bootsektor Struktur
    uint16_t FirstRootDirSecNum;
@@ -72,7 +66,6 @@ uint16_t fat_root_dir_addr(uint8_t *Buffer)
    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
@@ -82,7 +75,6 @@ uint16_t fat_read_dir_ent(uint16_t dir_cluster, // Angabe Dir Cluster
                              uint32_t *Size,      // R<>ckgabe der File Gr<47><72>e
                              uint8_t *Dir_Attrib,        // R<>ckgabe des Dir Attributs
                              uint8_t *Buffer)    // Working Buffer
-// ############################################################################
 {
    uint8_t *pointer;
    uint16_t TMP_Entry_Count = 0;
@@ -151,7 +143,6 @@ uint16_t fat_read_dir_ent(uint16_t dir_cluster, // Angabe Dir Cluster
    return (0xFFFF);            // Kein Eintrag mehr gefunden R<>cksprung mit 0xFFFF
 }

-    // ############################################################################
    // Auslesen der Cluster f<>r ein File aus der FAT
    // in den Buffer(512Byte). Bei einer 128MB MMC/SD 
    // Karte ist die Cluster gr<67><72>e normalerweise 16KB gro<72>
@@ -161,7 +152,6 @@ uint16_t fat_read_dir_ent(uint16_t dir_cluster, // Angabe Dir Cluster
    // Cluster = Start Clusterangabe aus dem Directory 
 void fat_load(uint16_t Cluster,     // Angabe Startcluster
              uint32_t *Block, uint8_t *TMP_Buffer)  // Workingbuffer
-// ############################################################################
 {

    // Zum <20>berpr<70>fen ob der FAT Block schon geladen wurde
@@ -206,13 +196,11 @@ 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
-// ############################################################################
 {

    // Berechnung des Blocks aus BlockCount und Cluster aus FATTabelle
@@ -231,13 +219,11 @@ void fat_read_file(uint16_t Cluster,        // Angabe des Startclusters vom File
    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
-// ############################################################################
 {

    // Berechnung des Blocks aus BlockCount und Cluster aus FATTabelle
@@ -257,7 +243,6 @@ void fat_write_file(uint16_t cluster,       // Angabe des Startclusters vom File
    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
@@ -268,7 +253,6 @@ uint8_t fat_search_file(uint8_t *File_Name, // Name des zu suchenden Files
                              uint32_t *Size,      // R<>ckgabe der File Gr<47><72>e
                              uint8_t *Dir_Attrib,        // R<>ckgabe des Dir Attributs
                              uint8_t *Buffer)    // Working Buffer
-// ####################################################################################
 {
    uint16_t Dir_Cluster_Store = *Cluster;
    uint8_t a ;
--- a/avr/usbload/fat.h
+++ b/avr/usbload/fat.h
@@ -1,6 +1,4 @@
 /*
- * ####################################################################################### Connect ARM to MMC/SD   Copyright (C) 2004
- * Ulrich Radig #######################################################################################
 */

 #ifndef _FAT_H_
--- a/avr/usbload/mmc.c
+++ b/avr/usbload/mmc.c
@@ -44,10 +44,8 @@ uint8_t mmc_init()
    return (0);
 }

-    // ############################################################################
    // Sendet ein Commando an die MMC/SD-Karte
 uint8_t mmc_write_command(uint8_t *cmd)
-// ############################################################################
 {
    uint8_t tmp = 0xff;
    uint16_t Timeout = 0;
@@ -69,10 +67,8 @@ uint8_t mmc_write_command(uint8_t *cmd)
    return (tmp);
 }

-    // ############################################################################
    // Routine zum Empfangen eines Bytes von der MMC-Karte 
 uint8_t mmc_read_byte(void)
-// ############################################################################
 {
    uint8_t Byte = 0, j;
    for (j = 0; j < 8; j++) {
@@ -92,10 +88,8 @@ 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;
    for (i = 0; i < 8; i++) {
@@ -115,10 +109,8 @@ 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 tmp;

@@ -168,11 +160,9 @@ uint8_t mmc_write_sector(uint32_t addr, uint8_t *Buffer)
    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)
-// ############################################################################
 {
    uint16_t a;

@@ -195,10 +185,8 @@ void mmc_read_block(uint8_t *cmd, uint8_t *Buffer,
    return;
 }

-    // ############################################################################
    // Routine zum lesen eines Blocks(512Byte) von der MMC/SD-Karte
 uint8_t mmc_read_sector(uint32_t addr, uint8_t *Buffer)
-// ############################################################################
 {

    // Commando 16 zum lesen eines Blocks von der MMC/SD - Karte
@@ -216,10 +204,8 @@ 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)
-// ############################################################################
 {

    // Commando zum lesen des CID Registers
@@ -228,10 +214,8 @@ uint8_t mmc_read_cid(uint8_t *Buffer)
    return (0);
 }

-    // ############################################################################
    // Routine zum lesen des CSD Registers von der MMC/SD-Karte (16Bytes)
 uint8_t mmc_read_csd(uint8_t *Buffer)
-// ############################################################################
 {

    // Commando zum lesen des CSD Registers