diff --git a/avr/usbload/fat.c b/avr/usbload/fat.c index 606c359..6ffea09 100644 --- a/avr/usbload/fat.c +++ b/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); } diff --git a/avr/usbload/fat.h b/avr/usbload/fat.h index a096f8e..cea4292 100644 --- a/avr/usbload/fat.h +++ b/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 diff --git a/avr/usbload/mmc.c b/avr/usbload/mmc.c index f11050a..f276f67 100644 --- a/avr/usbload/mmc.c +++ b/avr/usbload/mmc.c @@ -1,18 +1,13 @@ #include "mmc.h" #include + 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); diff --git a/avr/usbload/mmc.h b/avr/usbload/mmc.h index d46599d..190f8ad 100644 --- a/avr/usbload/mmc.h +++ b/avr/usbload/mmc.h @@ -4,7 +4,7 @@ #include -#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<