📄 mmc.lst
字号:
06EE: MOVFF 118,170
06F2: MOVLB 0
06F4: RCALL 03E8
06F6: MOVFF 03,0B
06FA: MOVFF 02,0A
06FE: MOVFF 01,09
0702: MOVFF 00,08
.................... fat2_address=fat1_address+bytes_per_sector*sec_for_FAT;
0706: MOVFF 119,14B
070A: MOVFF 118,14A
070E: MOVFF 117,14D
0712: MOVFF 116,14C
0716: RCALL 03C6
0718: MOVF 01,W
071A: ADDWF 08,W
071C: MOVWF 0C
071E: MOVF 02,W
0720: ADDWFC 09,W
0722: MOVWF 0D
0724: MOVLW 00
0726: ADDWFC 0A,W
0728: MOVWF 0E
072A: MOVLW 00
072C: ADDWFC 0B,W
072E: MOVWF 0F
.................... root_dir_address=(sec_for_FAT*2+start_lsec+sec_resv)*bytes_per_sector;
0730: BCF FD8.0
0732: MOVLB 1
0734: RLCF x16,W
0736: MOVWF x48
0738: RLCF x17,W
073A: MOVWF x49
073C: MOVF x48,W
073E: ADDWF x10,W
0740: MOVWF x4A
0742: MOVF x49,W
0744: ADDWFC x11,W
0746: MOVWF x4B
0748: MOVLW 00
074A: ADDWFC x12,W
074C: MOVWF x4C
074E: MOVLW 00
0750: ADDWFC x13,W
0752: MOVWF x4D
0754: MOVF x14,W
0756: ADDWF x4A,W
0758: MOVWF x4E
075A: MOVF x15,W
075C: ADDWFC x4B,W
075E: MOVWF x4F
0760: MOVLW 00
0762: ADDWFC x4C,W
0764: MOVWF x50
0766: MOVLW 00
0768: ADDWFC x4D,W
076A: MOVWF x51
076C: MOVWF x6F
076E: MOVFF 150,16E
0772: MOVFF 14F,16D
0776: MOVFF 14E,16C
077A: CLRF x73
077C: CLRF x72
077E: MOVFF 119,171
0782: MOVFF 118,170
0786: MOVLB 0
0788: RCALL 03E8
078A: MOVFF 03,13
078E: MOVFF 02,12
0792: MOVFF 01,11
0796: MOVFF 00,10
.................... data_area_address=root_dir_address+root_dir_entries*32;
079A: MOVLB 1
079C: RLCF x1A,W
079E: MOVWF 02
07A0: RLCF x1B,W
07A2: MOVWF 03
07A4: RLCF 02,F
07A6: RLCF 03,F
07A8: RLCF 02,F
07AA: RLCF 03,F
07AC: RLCF 02,F
07AE: RLCF 03,F
07B0: RLCF 02,F
07B2: RLCF 03,F
07B4: MOVLW E0
07B6: ANDWF 02,F
07B8: MOVF 02,W
07BA: ADDWF 10,W
07BC: MOVWF 14
07BE: MOVF 03,W
07C0: ADDWFC 11,W
07C2: MOVWF 15
07C4: MOVLW 00
07C6: ADDWFC 12,W
07C8: MOVWF 16
07CA: MOVLW 00
07CC: ADDWFC 13,W
07CE: MOVWF 17
.................... ///// check for FAT16
.................... root_dir_sectors=root_dir_entries>>4;
07D0: RRCF x1B,W
07D2: MOVWF x21
07D4: RRCF x1A,W
07D6: MOVWF x20
07D8: RRCF x21,F
07DA: RRCF x20,F
07DC: RRCF x21,F
07DE: RRCF x20,F
07E0: RRCF x21,F
07E2: RRCF x20,F
07E4: MOVLW 0F
07E6: ANDWF x21,F
....................
.................... sec_for_data=total_sectors - sec_resv -sec_for_fat*2 -root_dir_sectors;
07E8: MOVF x14,W
07EA: SUBWF x22,W
07EC: MOVWF x48
07EE: MOVF x15,W
07F0: SUBWFB x23,W
07F2: MOVWF x49
07F4: BCF FD8.0
07F6: RLCF x16,W
07F8: MOVWF 02
07FA: RLCF x17,W
07FC: MOVWF 03
07FE: MOVF 02,W
0800: SUBWF x48,W
0802: MOVWF x4A
0804: MOVF 03,W
0806: SUBWFB x49,W
0808: MOVWF x4B
080A: MOVF x20,W
080C: SUBWF x4A,W
080E: MOVWF x1C
0810: MOVF x21,W
0812: SUBWFB x4B,W
0814: MOVWF x1D
....................
.................... count_of_clusters=sec_for_data/sec_per_cluster;
0816: MOVFF 11D,149
081A: MOVFF 11C,148
081E: CLRF x4B
0820: MOVFF 126,14A
0824: MOVLB 0
0826: BRA 0442
0828: MOVFF 02,11F
082C: MOVFF 01,11E
....................
.................... if (count_of_clusters <4085 || count_of_clusters>65525) return(17);
0830: MOVLB 1
0832: MOVF x1F,W
0834: SUBLW 0F
0836: BNC 0840
0838: BNZ 0850
083A: MOVF x1E,W
083C: SUBLW F4
083E: BC 0850
0840: MOVF x1F,W
0842: SUBLW FE
0844: BC 0856
0846: XORLW FF
0848: BNZ 0850
084A: MOVF x1E,W
084C: SUBLW F5
084E: BC 0856
0850: MOVLW 11
0852: MOVWF 01
0854: BRA 0872
....................
.................... winhex_adj=fat1_address-bytes_per_sector;
0856: MOVF x18,W
0858: SUBWF 08,W
085A: MOVWF 18
085C: MOVF x19,W
085E: SUBWFB 09,W
0860: MOVWF 19
0862: MOVLW 00
0864: SUBWFB 0A,W
0866: MOVWF 1A
0868: MOVLW 00
086A: SUBWFB 0B,W
086C: MOVWF 1B
....................
.................... #if MMC_INIT_TRACE
....................
.................... printf("Files:/n/r");
.................... for(i=0;i<MAX_FILES;i++){
.................... printf("/n/r",file[i].name[i]);
.................... }
....................
.................... #ENDIF
....................
.................... return(0);
086E: MOVLW 00
0870: MOVWF 01
.................... }
0872: MOVLB 0
0874: GOTO 1D40 (RETURN)
....................
....................
.................... #separate
.................... int get_CID(char s){
.................... int i,r1;
.................... r1=mmc_cmd(0x4A,0x00000000,16,0x00,0x99);
....................
....................
.................... if (r1==0x00) goto get_token ; // we can read data payload
....................
.................... return(false);
.................... get_token:
.................... for(i=0;i<16;i++)if (SPI_READ(0xFF)==0xFE) goto read_CID; // read token $FE
.................... return(false);
.................... read_CID:
.................... //for (i=0;i<18;i++) s[i]=SPI_READ(0xFF);
....................
.................... return(true);
.................... }
....................
....................
.................... #separate
.................... int get_CSD(char s){
.................... int i,r1;
.................... r1=mmc_cmd(0x4A,0x00000000,16,0x00,0x99);
....................
....................
.................... if (r1==0x00) goto get_token ; // we can read data payload
....................
.................... return(false);
.................... get_token:
.................... for(i=0;i<16;i++)if (SPI_READ(0xFF)==0xFE) goto read_CSD; // read token $FE
.................... return(false);
.................... read_CSD:
.................... //for(i=0;i<18;i++) s[i]=SPI_READ(0xFF);
....................
.................... return(true);
.................... }
....................
....................
.................... #separate
.................... int write_BLOCK( int32 address,char *buff,int16 size)
.................... {
.................... /// low level write ....MMC restriction is that exactly 512 bytes must be written
.................... /// so a 512 byte section is read in starting at address the first (size) bytes
.................... /// are over written with the new data and the updated 512 bytes written back
.................... /// the starting address of the block that contains the requeseted address
.................... ///
.................... /// the data may span a block if so it is split and two writes are done
.................... /// so as to maitain MMC 512 write boundary restrictions
....................
.................... int r1,a,b,c,d;
.................... int16 i,blk_offset,bytes_posted;
.................... char tmp_buff[512];
.................... int32 block_address;
....................
.................... #if MMC_WRITE_BLOCK_TRACE
.................... printf("addr=%lu",address);
.................... #endif
....................
.................... a=make8(address,3);
.................... b=make8(address,2);
.................... c=make8(address,1);
.................... c=c & 0b11111110;
.................... d=0;
.................... block_address=make32(a,b,c,d); //// address int divided by 512
.................... #if MMC_WRITE_BLOCK_TRACE
.................... printf("wb>> size=%lu payload=",size);
.................... for(i=0;i<size;i++)printf("%c",buff[i]);
.................... #endif
....................
.................... /// first set up the block size to 512
.................... if(set_BLOCKLEN((int32)512)==false) return(false); // sets global block_size
....................
.................... if(block_size!=512) return(false);
.................... bytes_posted=0; /// no data updated yet
....................
.................... ////////////////////////////////////////////////
.................... next_block: /// loop back here for second block
.................... ////////////////////////////////////////////////
.................... #if MMC_WRITE_BLOCK_TRACE
.................... printf("\n\r blk addr=%lu \n\r",block_address);
.................... #endif
....................
.................... if((block_address < data_area_address) && MMC_dir_protected) return(false);
....................
.................... MMC_dir_protected=true;
.................... #if MMC_WRITE_BLOCK_TRACE
.................... printf("read blk");
.................... #endif
.................... /// first read in the existing block
.................... if(read_block(block_address,tmp_buff)==false) return(false) ;
....................
....................
....................
.................... /// now update the block with new data
.................... blk_offset=(address - block_address); /// offset within the block
.................... #if MMC_WRITE_BLOCK_TRACE
.................... printf("blk_offset=%lu size=%lu",blk_offset,size);
.................... #endif
....................
.................... if( blk_offset + size > 512 ){
.................... // data spans the block so write to end of block first
....................
.................... #if MMC_WRITE_BLOCK_TRACE
.................... //// original data
.................... printf("\n\r spans wb=");
.................... for(i=blk_offset;i<512;i++)printf("%c",tmp_buff[i]);
.................... #endif
....................
.................... for (i=blk_offset;i < 512;i++)tmp_buff[i]=buff[i-blk_offset];
....................
.................... #if MMC_WRITE_BLOCK_TRACE
.................... /// updated data
.................... printf("\n\r spans wb*=");
.................... for(i=blk_offset;i<512;i++)printf("%c",tmp_buff[i]);
.................... #endif
....................
.................... bytes_posted=512-blk_offset; /// wrote from offset to end of block
....................
.................... #if MMC_WRITE_BLOCK_TRACE
.................... printf("\n\r posted=%lu",bytes_posted);
.................... #endif
....................
.................... }
.................... else{
.................... //original or remaining spanned block data fits in next block or original block
....................
.................... #if MMC_WRITE_BLOCK_TRACE
.................... printf(" blk offset=%lu",blk_offset);
.................... /// original data
.................... printf("\n\r wb=");
.................... for(i=blk_offset;i<blk_offset+size;i++)printf("%c",tmp_buff[i]);
.................... #endif
....................
.................... for (i=blk_offset;i<blk_offset+ size;i++)tmp_buff[i]=buff[bytes_posted+i-blk_offset];
....................
.................... #if MMC_WRITE_BLOCK_TRACE
.................... /// updated data
.................... printf("\n\r wb*=");
.................... for(i=blk_offset;i<blk_offset+size;i++)printf("%c",tmp_buff[i]);
.................... #endif
....................
.................... bytes_posted=size;
....................
.................... #if MMC_WRITE_BLOCK_TRACE
.................... printf("\n\r posted=%lu",bytes_posted);
.................... #endif
....................
.................... }
....................
.................... ///////////////////////////////////
.................... /////////// write out the block
.................... //////////////////////////////////
.................... #if MMC_WRITE_BLOCK_TRACE
.................... printf("wb>> writing block %lu",block_address);
.................... #endif
.................... r1=mmc_cmd(0x58,block_address,16,0x00,0x40);
....................
....................
.................... if (r1==0x00) goto send_token ; // we can send data payload
.................... if (r1==0x40) goto invalid;
....................
....................
.................... return(false);
.................... invalid:
.................... printf("\n\r write block err %2X\n\r",r1);
.................... return(false);
.................... send_token:
.................... SPI_READ(0xFE);
....................
.................... for (i=0;i < 512;i++) {
....................
.................... SPI_READ(tmp_buff[i]); /// send payload
.................... }
....................
....................
.................... SPI_READ(0xFF); // send dummy chcksum
.................... SPI_READ(0xFF);
.................... r1=SPI_READ(0xFF);
.................... for( i=0;i<0x0fff;i++) {
.................... r1=SPI_READ(0xFF);// digest prior operation
.................... if (r1!=0x00) break;
.................... }
....................
.................... if(size > bytes_posted){
.................... /// data spanned block so we need to upadte next block as well
.................... size=size-bytes_posted;
.................... block_address=block_address+512;/// advance a block
....................
.................... address=address+bytes_posted; /// move address ptr forward
....................
.................... goto next_block;
.................... }
....................
....................
.................... return(true);
.................... }
....................
....................
.................... #separate
.................... void dump_block(){
.................... int in_buff[12],c,i,j;
.................... int32 read_address;
.................... char buff[MMC_BUFF_SIZE+1];
.................... for(i=0;i<12;i++)in_buff[i]=0;
.................... printf("\n\r Input Start address:");
.................... j=0;
.................... do {
.................... c=getc();
.................... in_buff[j++]=c;
.................... putc(c);
.................... }
.................... while(c!=13);
.................... in_buff[j-1]=0;
....................
.................... read_address=atoint32(in_buff);
.................... if (read_BLOCK(read_address,buff)==true){
.................... printf(" BLOCK\n\r");
.................... for(j=0;j<MMC_BUFF_SIZE;j=j+8){
.................... printf("%4LX ",read_address+j);
.................... for(i=0;i<8;i++)printf(" %2X",buff[i+j]);
.................... printf("\n\r");
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -