📄 main.lss
字号:
000004ec <mmc_read_sector>:
return;
}
//############################################################################
//Routine zum lesen eines Blocks(512Byte) von der MMC/SD-Karte
U08 mmc_read_sector (U32 addr,U08 *Buffer)
//############################################################################
{
4ec: cf 92 push r12
4ee: df 92 push r13
4f0: ef 92 push r14
4f2: ff 92 push r15
4f4: 0f 93 push r16
4f6: 1f 93 push r17
4f8: cf 93 push r28
4fa: df 93 push r29
4fc: cd b7 in r28, 0x3d ; 61
4fe: de b7 in r29, 0x3e ; 62
500: 26 97 sbiw r28, 0x06 ; 6
502: 0f b6 in r0, 0x3f ; 63
504: f8 94 cli
506: de bf out 0x3e, r29 ; 62
508: 0f be out 0x3f, r0 ; 63
50a: cd bf out 0x3d, r28 ; 61
50c: 6b 01 movw r12, r22
50e: 7c 01 movw r14, r24
510: ba 01 movw r22, r20
//Commando 16 zum lesen eines Blocks von der MMC/SD - Karte
U08 cmd[] = {0x51,0x00,0x00,0x00,0x00,0xFF};
512: 8e 01 movw r16, r28
514: 0f 5f subi r16, 0xFF ; 255
516: 1f 4f sbci r17, 0xFF ; 255
518: 26 e0 ldi r18, 0x06 ; 6
51a: 4c e1 ldi r20, 0x1C ; 28
51c: 51 e0 ldi r21, 0x01 ; 1
51e: d8 01 movw r26, r16
520: fa 01 movw r30, r20
522: 01 90 ld r0, Z+
524: 0d 92 st X+, r0
526: 2a 95 dec r18
528: e1 f7 brne .-8 ; 0x522
/*Die Adressierung der MMC/SD-Karte wird in Bytes angegeben,
addr wird von Blocks zu Bytes umgerechnet danach werden
diese in das Commando eingef黦t*/
addr = addr << 9; //addr = addr * 512
52a: 59 e0 ldi r21, 0x09 ; 9
52c: cc 0c add r12, r12
52e: dd 1c adc r13, r13
530: ee 1c adc r14, r14
532: ff 1c adc r15, r15
534: 5a 95 dec r21
536: d1 f7 brne .-12 ; 0x52c
cmd[1] = ((addr & 0xFF000000) >>24 );
538: 2f 2d mov r18, r15
53a: 33 27 eor r19, r19
53c: 44 27 eor r20, r20
53e: 55 27 eor r21, r21
540: 2a 83 std Y+2, r18 ; 0x02
cmd[2] = ((addr & 0x00FF0000) >>16 );
542: eb 82 std Y+3, r14 ; 0x03
cmd[3] = ((addr & 0x0000FF00) >>8 );
544: 80 e0 ldi r24, 0x00 ; 0
546: 9f ef ldi r25, 0xFF ; 255
548: a0 e0 ldi r26, 0x00 ; 0
54a: b0 e0 ldi r27, 0x00 ; 0
54c: c8 22 and r12, r24
54e: d9 22 and r13, r25
550: ea 22 and r14, r26
552: fb 22 and r15, r27
554: bb 27 eor r27, r27
556: af 2d mov r26, r15
558: 9e 2d mov r25, r14
55a: 8d 2d mov r24, r13
55c: 8c 83 std Y+4, r24 ; 0x04
mmc_read_block(cmd,Buffer,512);
55e: 40 e0 ldi r20, 0x00 ; 0
560: 52 e0 ldi r21, 0x02 ; 2
562: c8 01 movw r24, r16
564: 0e 94 42 02 call 0x484
return(0);
}
568: 80 e0 ldi r24, 0x00 ; 0
56a: 90 e0 ldi r25, 0x00 ; 0
56c: 26 96 adiw r28, 0x06 ; 6
56e: 0f b6 in r0, 0x3f ; 63
570: f8 94 cli
572: de bf out 0x3e, r29 ; 62
574: 0f be out 0x3f, r0 ; 63
576: cd bf out 0x3d, r28 ; 61
578: df 91 pop r29
57a: cf 91 pop r28
57c: 1f 91 pop r17
57e: 0f 91 pop r16
580: ff 90 pop r15
582: ef 90 pop r14
584: df 90 pop r13
586: cf 90 pop r12
588: 08 95 ret
0000058a <mmc_read_cid>:
//############################################################################
//Routine zum lesen des CID Registers von der MMC/SD-Karte (16Bytes)
U08 mmc_read_cid (U08 *Buffer)
//############################################################################
{
58a: 0f 93 push r16
58c: 1f 93 push r17
58e: cf 93 push r28
590: df 93 push r29
592: cd b7 in r28, 0x3d ; 61
594: de b7 in r29, 0x3e ; 62
596: 26 97 sbiw r28, 0x06 ; 6
598: 0f b6 in r0, 0x3f ; 63
59a: f8 94 cli
59c: de bf out 0x3e, r29 ; 62
59e: 0f be out 0x3f, r0 ; 63
5a0: cd bf out 0x3d, r28 ; 61
5a2: 9c 01 movw r18, r24
//Commando zum lesen des CID Registers
U08 cmd[] = {0x4A,0x00,0x00,0x00,0x00,0xFF};
5a4: 8e 01 movw r16, r28
5a6: 0f 5f subi r16, 0xFF ; 255
5a8: 1f 4f sbci r17, 0xFF ; 255
5aa: 86 e0 ldi r24, 0x06 ; 6
5ac: 42 e2 ldi r20, 0x22 ; 34
5ae: 51 e0 ldi r21, 0x01 ; 1
5b0: d8 01 movw r26, r16
5b2: fa 01 movw r30, r20
5b4: 01 90 ld r0, Z+
5b6: 0d 92 st X+, r0
5b8: 8a 95 dec r24
5ba: e1 f7 brne .-8 ; 0x5b4
mmc_read_block(cmd,Buffer,16);
5bc: 40 e1 ldi r20, 0x10 ; 16
5be: 50 e0 ldi r21, 0x00 ; 0
5c0: b9 01 movw r22, r18
5c2: c8 01 movw r24, r16
5c4: 0e 94 42 02 call 0x484
return(0);
}
5c8: 80 e0 ldi r24, 0x00 ; 0
5ca: 90 e0 ldi r25, 0x00 ; 0
5cc: 26 96 adiw r28, 0x06 ; 6
5ce: 0f b6 in r0, 0x3f ; 63
5d0: f8 94 cli
5d2: de bf out 0x3e, r29 ; 62
5d4: 0f be out 0x3f, r0 ; 63
5d6: cd bf out 0x3d, r28 ; 61
5d8: df 91 pop r29
5da: cf 91 pop r28
5dc: 1f 91 pop r17
5de: 0f 91 pop r16
5e0: 08 95 ret
000005e2 <mmc_read_csd>:
//############################################################################
//Routine zum lesen des CSD Registers von der MMC/SD-Karte (16Bytes)
U08 mmc_read_csd (U08 *Buffer)
//############################################################################
{
5e2: 0f 93 push r16
5e4: 1f 93 push r17
5e6: cf 93 push r28
5e8: df 93 push r29
5ea: cd b7 in r28, 0x3d ; 61
5ec: de b7 in r29, 0x3e ; 62
5ee: 26 97 sbiw r28, 0x06 ; 6
5f0: 0f b6 in r0, 0x3f ; 63
5f2: f8 94 cli
5f4: de bf out 0x3e, r29 ; 62
5f6: 0f be out 0x3f, r0 ; 63
5f8: cd bf out 0x3d, r28 ; 61
5fa: 9c 01 movw r18, r24
//Commando zum lesen des CSD Registers
U08 cmd[] = {0x49,0x00,0x00,0x00,0x00,0xFF};
5fc: 8e 01 movw r16, r28
5fe: 0f 5f subi r16, 0xFF ; 255
600: 1f 4f sbci r17, 0xFF ; 255
602: 86 e0 ldi r24, 0x06 ; 6
604: 48 e2 ldi r20, 0x28 ; 40
606: 51 e0 ldi r21, 0x01 ; 1
608: d8 01 movw r26, r16
60a: fa 01 movw r30, r20
60c: 01 90 ld r0, Z+
60e: 0d 92 st X+, r0
610: 8a 95 dec r24
612: e1 f7 brne .-8 ; 0x60c
mmc_read_block(cmd,Buffer,16);
614: 40 e1 ldi r20, 0x10 ; 16
616: 50 e0 ldi r21, 0x00 ; 0
618: b9 01 movw r22, r18
61a: c8 01 movw r24, r16
61c: 0e 94 42 02 call 0x484
return(0);
}
620: 80 e0 ldi r24, 0x00 ; 0
622: 90 e0 ldi r25, 0x00 ; 0
624: 26 96 adiw r28, 0x06 ; 6
626: 0f b6 in r0, 0x3f ; 63
628: f8 94 cli
62a: de bf out 0x3e, r29 ; 62
62c: 0f be out 0x3f, r0 ; 63
62e: cd bf out 0x3d, r28 ; 61
630: df 91 pop r29
632: cf 91 pop r28
634: 1f 91 pop r17
636: 0f 91 pop r16
638: 08 95 ret
0000063a <fat_addr>:
//############################################################################
//Auslesen der Adresse des Volume Boot Record von MBR
U16 fat_addr (U08 *Buffer)
//############################################################################
{
63a: ef 92 push r14
63c: ff 92 push r15
63e: 0f 93 push r16
640: 1f 93 push r17
642: 8c 01 movw r16, r24
U16 volume_boot_record_addr;
//auslesen des Master Boot Record von der MMC/SD Karte (addr = 0)
mmc_read_sector (MASTER_BOOT_RECORD,Buffer); //Read Master Boot Record
644: ac 01 movw r20, r24
646: 60 e0 ldi r22, 0x00 ; 0
648: 70 e0 ldi r23, 0x00 ; 0
64a: 80 e0 ldi r24, 0x00 ; 0
64c: 90 e0 ldi r25, 0x00 ; 0
64e: 0e 94 76 02 call 0x4ec
volume_boot_record_addr = Buffer[VBR_ADDR] + (Buffer[VBR_ADDR+1] << 8);
652: 0a 53 subi r16, 0x3A ; 58
654: 1e 4f sbci r17, 0xFE ; 254
656: f8 01 movw r30, r16
658: 21 91 ld r18, Z+
65a: 8f 01 movw r16, r30
65c: 80 81 ld r24, Z
65e: 07 5c subi r16, 0xC7 ; 199
660: 11 40 sbci r17, 0x01 ; 1
662: 99 27 eor r25, r25
664: f8 2e mov r15, r24
666: ee 24 eor r14, r14
668: e2 0e add r14, r18
66a: f1 1c adc r15, r1
//Berechnet Volume Boot Record
mmc_read_sector (volume_boot_record_addr,Buffer); //Read Master Boot Record
66c: c7 01 movw r24, r14
66e: aa 27 eor r26, r26
670: bb 27 eor r27, r27
672: a8 01 movw r20, r16
674: bc 01 movw r22, r24
676: cd 01 movw r24, r26
678: 0e 94 76 02 call 0x4ec
return (volume_boot_record_addr);
}
67c: c7 01 movw r24, r14
67e: 1f 91 pop r17
680: 0f 91 pop r16
682: ff 90 pop r15
684: ef 90 pop r14
686: 08 95 ret
00000688 <fat_root_dir_addr>:
//############################################################################
//Auslesen der Adresse des First Root Directory von Volume Boot Record
U16 fat_root_dir_addr (U08 *Buffer)
//############################################################################
{
688: 0f 93 push r16
68a: 1f 93 push r17
68c: 8c 01 movw r16, r24
struct BootSec *bootp; //Zeiger auf Bootsektor Struktur
U16 FirstRootDirSecNum;
//auslesen des Volume Boot Record von der MMC/SD Karte
mmc_read_sector (volume_boot_record_addr,Buffer);
68e: 80 91 34 01 lds r24, 0x0134
692: 90 91 35 01 lds r25, 0x0135
696: aa 27 eor r26, r26
698: bb 27 eor r27, r27
69a: a8 01 movw r20, r16
69c: bc 01 movw r22, r24
69e: cd 01 movw r24, r26
6a0: 0e 94 76 02 call 0x4ec
bootp=(struct BootSec *)Buffer;
//berechnet den ersten Sector des Root Directory
FirstRootDirSecNum = ( bootp->BPB_RsvdSecCnt +
6a4: f8 01 movw r30, r16
6a6: 80 89 ldd r24, Z+16 ; 0x10
6a8: 28 2f mov r18, r24
6aa: 33 27 eor r19, r19
6ac: 86 89 ldd r24, Z+22 ; 0x16
6ae: 97 89 ldd r25, Z+23 ; 0x17
6b0: 28 9f mul r18, r24
6b2: a0 01 movw r20, r0
6b4: 29 9f mul r18, r25
6b6: 50 0d add r21, r0
6b8: 38 9f mul r19, r24
6ba: 50 0d add r21, r0
6bc: 11 24 eor r1, r1
6be: 86 85 ldd r24, Z+14 ; 0x0e
6c0: 97 85 ldd r25, Z+15 ; 0x0f
6c2: 84 0f add r24, r20
6c4: 95 1f adc r25, r21
(bootp->BPB_NumFATs * bootp->BPB_FATSz16));
FirstRootDirSecNum+= volume_boot_record_addr;
6c6: 20 91 34 01 lds r18, 0x0134
6ca: 30 91 35 01 lds r19, 0x0135
return(FirstRootDirSecNum);
}
6ce: 82 0f add r24, r18
6d0: 93 1f adc r25, r19
6d2: 1f 91 pop r17
6d4: 0f 91 pop r16
6d6: 08 95 ret
000006d8 <fat_load>:
//############################################################################
// Ausgabe des angegebenen Directory Eintrag in Entry_Count
// ist kein Eintrag vorhanden, ist der Eintrag im
// R點kgabe Cluster 0xFFFF. Es wird immer nur ein Eintrag ausgegeben
// um Speicherplatz zu sparen um es auch f黵 kleine Atmels zu benutzen
U16 fat_read_dir_ent (U16 dir_cluster, //Angabe Dir Cluster
U08 Entry_Count, //Angabe welcher Direintrag
U32 *Size, //R點kgabe der File Gr鲞e
U08 *Dir_Attrib, //R點kgabe des Dir Attributs
U08 *Buffer) //Working Buffer
//############################################################################
{
U08 *pointer;
U16 TMP_Entry_Count = 0;
U32 Block = 0;
struct DirEntry *dir; //Zeiger auf einen Verzeichniseintrag
pointer = Buffer;
if (dir_cluster == 0)
{
Block = fat_root_dir_addr(Buffer);
}
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 (U16 blk = Block;;blk++)
{
mmc_read_sector (blk,Buffer); //Lesen eines Blocks des Root Directory
for (U16 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
{
return (0xFFFF);
}
//Pr黤en ob es ein 8.3 Eintrag ist
//Das ist der Fall wenn es sich nicht um einen Eintrag f黵 lange Dateinamen
//oder um einen als gel鰏cht markierten Eintrag handelt.
if ((dir->DIR_Attr != ATTR_LONG_NAME) &&
(dir->DIR_Name[0] != DIR_ENTRY_IS_FREE))
{
//Ist es der gew黱schte Verzeichniseintrag
if (TMP_Entry_Count == Entry_Count)
{
//Speichern des Verzeichnis Eintrages in den R點kgabe Buffer
for(U08 b=0;b<11;b++)
{
if (dir->DIR_Name[b] != SPACE)
{
if (b == 8)
{
*pointer++= '.';
}
*pointer++=dir->DIR_Name[b];
}
}
*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點ksprung mit Cluster File Start
return(dir_cluster);
}
TMP_Entry_Count++;
}
}
}
return (0xFFFF); //Kein Eintrag mehr gefunden R點ksprung mit 0xFFFF
}
//############################################################################
// Auslesen der Cluster f黵 ein File aus der FAT
// in den Buffer(512Byte). Bei einer 128MB MMC/SD
// Karte ist die Cluster gr鲞e normalerweise 16KB gro⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -