| 0,0 → 1,7338 |
|---|
| |
| glg.elf: file format elf32-avr |
| |
| Sections: |
| Idx Name Size VMA LMA File off Algn |
| 0 .data 0000000c 00800100 00002a28 00002a9c 2**0 |
| CONTENTS, ALLOC, LOAD, DATA |
| 1 .text 00002a28 00000000 00000000 00000074 2**1 |
| CONTENTS, ALLOC, LOAD, READONLY, CODE |
| 2 .bss 00000341 0080010c 00002a34 00002aa8 2**0 |
| ALLOC |
| 3 .stab 00002040 00000000 00000000 00002aa8 2**2 |
| CONTENTS, READONLY, DEBUGGING |
| 4 .stabstr 00000db4 00000000 00000000 00004ae8 2**0 |
| CONTENTS, READONLY, DEBUGGING |
| 5 .debug_aranges 00000060 00000000 00000000 0000589c 2**0 |
| CONTENTS, READONLY, DEBUGGING |
| 6 .debug_pubnames 0000019e 00000000 00000000 000058fc 2**0 |
| CONTENTS, READONLY, DEBUGGING |
| 7 .debug_info 00001f60 00000000 00000000 00005a9a 2**0 |
| CONTENTS, READONLY, DEBUGGING |
| 8 .debug_abbrev 000007b9 00000000 00000000 000079fa 2**0 |
| CONTENTS, READONLY, DEBUGGING |
| 9 .debug_line 00001b85 00000000 00000000 000081b3 2**0 |
| CONTENTS, READONLY, DEBUGGING |
| 10 .debug_frame 00000200 00000000 00000000 00009d38 2**2 |
| CONTENTS, READONLY, DEBUGGING |
| 11 .debug_str 000005cc 00000000 00000000 00009f38 2**0 |
| CONTENTS, READONLY, DEBUGGING |
| 12 .debug_loc 00002af1 00000000 00000000 0000a504 2**0 |
| CONTENTS, READONLY, DEBUGGING |
| 13 .debug_ranges 000001d0 00000000 00000000 0000cff5 2**0 |
| CONTENTS, READONLY, DEBUGGING |
| Disassembly of section .text: |
| |
| 00000000 <__vectors>: |
| 0: 0c 94 41 00 jmp 0x82 ; 0x82 <__ctors_end> |
| 4: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 8: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| c: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 10: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 14: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 18: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 1c: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 20: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 24: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 28: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 2c: 0c 94 18 03 jmp 0x630 ; 0x630 <__vector_11> |
| 30: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 34: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 38: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 3c: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 40: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 44: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 48: 0c 94 b5 00 jmp 0x16a ; 0x16a <__vector_18> |
| 4c: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 50: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 54: 0c 94 60 00 jmp 0xc0 ; 0xc0 <__vector_21> |
| 58: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 5c: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 60: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| 64: 0c 94 5e 00 jmp 0xbc ; 0xbc <__bad_interrupt> |
| |
| 00000068 <__c.1757>: |
| 68: 24 47 50 52 4d 43 00 $GPRMC. |
| |
| 0000006f <__c.1755>: |
| 6f: 24 47 50 47 47 41 00 $GPGGA. |
| |
| 00000076 <__c.1753>: |
| 76: 2e 6c 6f 67 00 .log. |
| |
| 0000007b <__c.1747>: |
| 7b: 24 47 50 52 4d 43 00 $GPRMC. |
| |
| 00000082 <__ctors_end>: |
| 82: 11 24 eor r1, r1 |
| 84: 1f be out 0x3f, r1 ; 63 |
| 86: cf ef ldi r28, 0xFF ; 255 |
| 88: d4 e0 ldi r29, 0x04 ; 4 |
| 8a: de bf out 0x3e, r29 ; 62 |
| 8c: cd bf out 0x3d, r28 ; 61 |
| |
| 0000008e <__do_copy_data>: |
| 8e: 11 e0 ldi r17, 0x01 ; 1 |
| 90: a0 e0 ldi r26, 0x00 ; 0 |
| 92: b1 e0 ldi r27, 0x01 ; 1 |
| 94: e8 e2 ldi r30, 0x28 ; 40 |
| 96: fa e2 ldi r31, 0x2A ; 42 |
| 98: 02 c0 rjmp .+4 ; 0x9e <.do_copy_data_start> |
| |
| 0000009a <.do_copy_data_loop>: |
| 9a: 05 90 lpm r0, Z+ |
| 9c: 0d 92 st X+, r0 |
| |
| 0000009e <.do_copy_data_start>: |
| 9e: ac 30 cpi r26, 0x0C ; 12 |
| a0: b1 07 cpc r27, r17 |
| a2: d9 f7 brne .-10 ; 0x9a <.do_copy_data_loop> |
| |
| 000000a4 <__do_clear_bss>: |
| a4: 14 e0 ldi r17, 0x04 ; 4 |
| a6: ac e0 ldi r26, 0x0C ; 12 |
| a8: b1 e0 ldi r27, 0x01 ; 1 |
| aa: 01 c0 rjmp .+2 ; 0xae <.do_clear_bss_start> |
| |
| 000000ac <.do_clear_bss_loop>: |
| ac: 1d 92 st X+, r1 |
| |
| 000000ae <.do_clear_bss_start>: |
| ae: ad 34 cpi r26, 0x4D ; 77 |
| b0: b1 07 cpc r27, r17 |
| b2: e1 f7 brne .-8 ; 0xac <.do_clear_bss_loop> |
| b4: 0e 94 35 01 call 0x26a ; 0x26a <main> |
| b8: 0c 94 12 15 jmp 0x2a24 ; 0x2a24 <_exit> |
| |
| 000000bc <__bad_interrupt>: |
| bc: 0c 94 00 00 jmp 0 ; 0x0 <__heap_end> |
| |
| 000000c0 <__vector_21>: |
| /*---------------------------------------------------------*/ |
| /* ADC interrupt */ |
| /*---------------------------------------------------------*/ |
| |
| ISR(ADC_vect) |
| { |
| c0: 1f 92 push r1 |
| c2: 0f 92 push r0 |
| c4: 0f b6 in r0, 0x3f ; 63 |
| c6: 0f 92 push r0 |
| c8: 11 24 eor r1, r1 |
| ca: 2f 93 push r18 |
| cc: 3f 93 push r19 |
| ce: 8f 93 push r24 |
| WORD n; |
| static BYTE l, h; |
| |
| n = ADC; |
| d0: 20 91 78 00 lds r18, 0x0078 |
| d4: 30 91 79 00 lds r19, 0x0079 |
| |
| if(ADMUX == POWER_check) |
| d8: 80 91 7c 00 lds r24, 0x007C |
| { |
| if (n < VTH_LOW) { |
| dc: 20 3d cpi r18, 0xD0 ; 208 |
| de: 31 05 cpc r19, r1 |
| e0: 70 f4 brcc .+28 ; 0xfe <__vector_21+0x3e> |
| if (l >= 15) { |
| e2: 80 91 0f 01 lds r24, 0x010F |
| e6: 8f 30 cpi r24, 0x0F ; 15 |
| e8: 30 f0 brcs .+12 ; 0xf6 <__vector_21+0x36> |
| Stat |= 0x01; |
| ea: 80 91 6f 01 lds r24, 0x016F |
| ee: 81 60 ori r24, 0x01 ; 1 |
| f0: 80 93 6f 01 sts 0x016F, r24 |
| f4: 06 c0 rjmp .+12 ; 0x102 <__vector_21+0x42> |
| } |
| else {l++;} |
| f6: 8f 5f subi r24, 0xFF ; 255 |
| f8: 80 93 0f 01 sts 0x010F, r24 |
| fc: 02 c0 rjmp .+4 ; 0x102 <__vector_21+0x42> |
| } |
| else {l = 0;} |
| fe: 10 92 0f 01 sts 0x010F, r1 |
| |
| if (n > VTH_HIGH) { |
| 102: 81 e0 ldi r24, 0x01 ; 1 |
| 104: 2c 32 cpi r18, 0x2C ; 44 |
| 106: 38 07 cpc r19, r24 |
| 108: 70 f0 brcs .+28 ; 0x126 <__vector_21+0x66> |
| if (h >= 15) { |
| 10a: 80 91 0e 01 lds r24, 0x010E |
| 10e: 8f 30 cpi r24, 0x0F ; 15 |
| 110: 30 f0 brcs .+12 ; 0x11e <__vector_21+0x5e> |
| Stat &= 0xFE; |
| 112: 80 91 6f 01 lds r24, 0x016F |
| 116: 8e 7f andi r24, 0xFE ; 254 |
| 118: 80 93 6f 01 sts 0x016F, r24 |
| 11c: 06 c0 rjmp .+12 ; 0x12a <__vector_21+0x6a> |
| } |
| else {h++;} |
| 11e: 8f 5f subi r24, 0xFF ; 255 |
| 120: 80 93 0e 01 sts 0x010E, r24 |
| 124: 02 c0 rjmp .+4 ; 0x12a <__vector_21+0x6a> |
| } |
| else {h = 0;} |
| 126: 10 92 0e 01 sts 0x010E, r1 |
| |
| battery = n; |
| 12a: 30 93 75 01 sts 0x0175, r19 |
| 12e: 20 93 74 01 sts 0x0174, r18 |
| ADMUX = ANALOG_IN1; |
| 132: 82 e4 ldi r24, 0x42 ; 66 |
| 134: 80 93 7c 00 sts 0x007C, r24 |
| } |
| |
| if(ADMUX == ANALOG_IN1) |
| 138: 80 91 7c 00 lds r24, 0x007C |
| { |
| intensity = n; |
| 13c: 30 93 10 02 sts 0x0210, r19 |
| 140: 20 93 0f 02 sts 0x020F, r18 |
| ADMUX = POWER_check; |
| 144: 81 e4 ldi r24, 0x41 ; 65 |
| 146: 80 93 7c 00 sts 0x007C, r24 |
| } |
| |
| //!!!! |
| //Stat &= 0xFE; |
| |
| ADCSRA = _BV(ADEN)|_BV(ADSC)|_BV(ADIF)|_BV(ADIE)|0b111; |
| 14a: 8f ed ldi r24, 0xDF ; 223 |
| 14c: 80 93 7a 00 sts 0x007A, r24 |
| } |
| 150: 8f 91 pop r24 |
| 152: 3f 91 pop r19 |
| 154: 2f 91 pop r18 |
| 156: 0f 90 pop r0 |
| 158: 0f be out 0x3f, r0 ; 63 |
| 15a: 0f 90 pop r0 |
| 15c: 1f 90 pop r1 |
| 15e: 18 95 reti |
| |
| 00000160 <get_fattime>: |
| /* FatFs module. Any valid time must be returned even if */ |
| /* the system does not support a real time clock. */ |
| |
| |
| DWORD get_fattime () |
| { |
| 160: 60 e0 ldi r22, 0x00 ; 0 |
| 162: 70 e0 ldi r23, 0x00 ; 0 |
| 164: 81 ea ldi r24, 0xA1 ; 161 |
| 166: 96 e3 ldi r25, 0x36 ; 54 |
| 168: 08 95 ret |
| |
| 0000016a <__vector_18>: |
| return d; |
| } |
| |
| /* USART0 RXC interrupt */ |
| ISR(USART_RX_vect) |
| { |
| 16a: 1f 92 push r1 |
| 16c: 0f 92 push r0 |
| 16e: 0f b6 in r0, 0x3f ; 63 |
| 170: 0f 92 push r0 |
| 172: 11 24 eor r1, r1 |
| 174: 8f 93 push r24 |
| 176: 9f 93 push r25 |
| 178: ef 93 push r30 |
| 17a: ff 93 push r31 |
| uint8_t d, n, i; |
| |
| |
| d = UDR0; |
| 17c: 90 91 c6 00 lds r25, 0x00C6 |
| n = rxfifo.count; |
| 180: 80 91 78 01 lds r24, 0x0178 |
| if(n < sizeof(rxfifo.buff)) { |
| 184: 86 39 cpi r24, 0x96 ; 150 |
| 186: 88 f4 brcc .+34 ; 0x1aa <__vector_18+0x40> |
| rxfifo.count = ++n; |
| 188: 8f 5f subi r24, 0xFF ; 255 |
| 18a: 80 93 78 01 sts 0x0178, r24 |
| i = rxfifo.idx_w; |
| 18e: 80 91 76 01 lds r24, 0x0176 |
| rxfifo.buff[i++] = d; |
| 192: e8 2f mov r30, r24 |
| 194: f0 e0 ldi r31, 0x00 ; 0 |
| 196: ea 58 subi r30, 0x8A ; 138 |
| 198: fe 4f sbci r31, 0xFE ; 254 |
| 19a: 93 83 std Z+3, r25 ; 0x03 |
| 19c: 8f 5f subi r24, 0xFF ; 255 |
| if(i >= sizeof(rxfifo.buff)) |
| 19e: 86 39 cpi r24, 0x96 ; 150 |
| 1a0: 08 f0 brcs .+2 ; 0x1a4 <__vector_18+0x3a> |
| 1a2: 80 e0 ldi r24, 0x00 ; 0 |
| i = 0; |
| rxfifo.idx_w = i; |
| 1a4: 80 93 76 01 sts 0x0176, r24 |
| 1a8: 05 c0 rjmp .+10 ; 0x1b4 <__vector_18+0x4a> |
| } else { |
| Stat |= 2; |
| 1aa: 80 91 6f 01 lds r24, 0x016F |
| 1ae: 82 60 ori r24, 0x02 ; 2 |
| 1b0: 80 93 6f 01 sts 0x016F, r24 |
| } |
| } |
| 1b4: ff 91 pop r31 |
| 1b6: ef 91 pop r30 |
| 1b8: 9f 91 pop r25 |
| 1ba: 8f 91 pop r24 |
| 1bc: 0f 90 pop r0 |
| 1be: 0f be out 0x3f, r0 ; 63 |
| 1c0: 0f 90 pop r0 |
| 1c2: 1f 90 pop r1 |
| 1c4: 18 95 reti |
| |
| 000001c6 <get_line>: |
| /* Get a line received from GPS module */ |
| /*----------------------------------------------------*/ |
| |
| static |
| BYTE get_line (void) // 0: Power fail occured, >0: Number of bytes received. |
| { |
| 1c6: 90 e0 ldi r25, 0x00 ; 0 |
| cli(); |
| UCSR0B = 0; |
| rxfifo.idx_r = 0; |
| rxfifo.idx_w = 0; |
| rxfifo.count = 0; |
| UBRR0L = SYSCLK/16/GPS_BAUDRATE; |
| 1c8: 52 e8 ldi r21, 0x82 ; 130 |
| UCSR0B = _BV(RXCIE0)|_BV(RXEN0)|_BV(TXEN0); |
| 1ca: 48 e9 ldi r20, 0x98 ; 152 |
| 1cc: 01 c0 rjmp .+2 ; 0x1d0 <get_line+0xa> |
| /* Get a line received from GPS module */ |
| /*----------------------------------------------------*/ |
| |
| static |
| BYTE get_line (void) // 0: Power fail occured, >0: Number of bytes received. |
| { |
| 1ce: 90 e0 ldi r25, 0x00 ; 0 |
| BYTE c, i = 0; |
| |
| |
| for (;;) { |
| if (Stat & 1) return 0; // When power fail is detected, return with zero. |
| 1d0: 80 91 6f 01 lds r24, 0x016F |
| 1d4: 80 fd sbrc r24, 0 |
| 1d6: 46 c0 rjmp .+140 ; 0x264 <get_line+0x9e> |
| uint8_t uart_get () |
| { |
| uint8_t d, i; |
| |
| |
| i = rxfifo.idx_r; |
| 1d8: 30 91 77 01 lds r19, 0x0177 |
| if (rxfifo.count == 0) return 0; |
| 1dc: 80 91 78 01 lds r24, 0x0178 |
| 1e0: 88 23 and r24, r24 |
| 1e2: 11 f4 brne .+4 ; 0x1e8 <get_line+0x22> |
| 1e4: 20 e0 ldi r18, 0x00 ; 0 |
| 1e6: 13 c0 rjmp .+38 ; 0x20e <get_line+0x48> |
| d = rxfifo.buff[i++]; |
| 1e8: e3 2f mov r30, r19 |
| 1ea: f0 e0 ldi r31, 0x00 ; 0 |
| 1ec: ea 58 subi r30, 0x8A ; 138 |
| 1ee: fe 4f sbci r31, 0xFE ; 254 |
| 1f0: 23 81 ldd r18, Z+3 ; 0x03 |
| 1f2: e3 2f mov r30, r19 |
| 1f4: ef 5f subi r30, 0xFF ; 255 |
| cli(); |
| 1f6: f8 94 cli |
| rxfifo.count--; |
| 1f8: 80 91 78 01 lds r24, 0x0178 |
| 1fc: 81 50 subi r24, 0x01 ; 1 |
| 1fe: 80 93 78 01 sts 0x0178, r24 |
| sei(); |
| 202: 78 94 sei |
| if(i >= sizeof(rxfifo.buff)) |
| 204: e6 39 cpi r30, 0x96 ; 150 |
| 206: 08 f0 brcs .+2 ; 0x20a <get_line+0x44> |
| 208: e0 e0 ldi r30, 0x00 ; 0 |
| i = 0; |
| rxfifo.idx_r = i; |
| 20a: e0 93 77 01 sts 0x0177, r30 |
| |
| |
| for (;;) { |
| if (Stat & 1) return 0; // When power fail is detected, return with zero. |
| c = uart_get(); |
| if (Stat & 2) { // When buffer overflow has occured, restart to receive line. |
| 20e: 80 91 6f 01 lds r24, 0x016F |
| 212: 81 ff sbrs r24, 1 |
| 214: 14 c0 rjmp .+40 ; 0x23e <get_line+0x78> |
| |
| |
| static |
| void uart_init (void) |
| { |
| cli(); |
| 216: f8 94 cli |
| UCSR0B = 0; |
| 218: 10 92 c1 00 sts 0x00C1, r1 |
| rxfifo.idx_r = 0; |
| 21c: 10 92 77 01 sts 0x0177, r1 |
| rxfifo.idx_w = 0; |
| 220: 10 92 76 01 sts 0x0176, r1 |
| rxfifo.count = 0; |
| 224: 10 92 78 01 sts 0x0178, r1 |
| UBRR0L = SYSCLK/16/GPS_BAUDRATE; |
| 228: 50 93 c4 00 sts 0x00C4, r21 |
| UCSR0B = _BV(RXCIE0)|_BV(RXEN0)|_BV(TXEN0); |
| 22c: 40 93 c1 00 sts 0x00C1, r20 |
| Stat &= 0xFD; // Clear overflow flag |
| 230: 80 91 6f 01 lds r24, 0x016F |
| 234: 8d 7f andi r24, 0xFD ; 253 |
| 236: 80 93 6f 01 sts 0x016F, r24 |
| sei(); |
| 23a: 78 94 sei |
| 23c: c8 cf rjmp .-112 ; 0x1ce <get_line+0x8> |
| c = uart_get(); |
| if (Stat & 2) { // When buffer overflow has occured, restart to receive line. |
| uart_init(); |
| i = 0; c = 0; |
| } |
| if (!c || (i == 0 && c != '$')) continue; |
| 23e: 22 23 and r18, r18 |
| 240: 39 f2 breq .-114 ; 0x1d0 <get_line+0xa> |
| 242: 99 23 and r25, r25 |
| 244: 19 f4 brne .+6 ; 0x24c <get_line+0x86> |
| 246: 24 32 cpi r18, 0x24 ; 36 |
| 248: 09 f0 breq .+2 ; 0x24c <get_line+0x86> |
| 24a: c2 cf rjmp .-124 ; 0x1d0 <get_line+0xa> |
| Buff[i++] = c; |
| 24c: e9 2f mov r30, r25 |
| 24e: f0 e0 ldi r31, 0x00 ; 0 |
| 250: e3 5e subi r30, 0xE3 ; 227 |
| 252: fe 4f sbci r31, 0xFE ; 254 |
| 254: 20 83 st Z, r18 |
| 256: 9f 5f subi r25, 0xFF ; 255 |
| if (c == '\n') break; |
| 258: 2a 30 cpi r18, 0x0A ; 10 |
| 25a: 29 f0 breq .+10 ; 0x266 <get_line+0xa0> |
| if (i >= sizeof(Buff)) i = 0; |
| 25c: 92 35 cpi r25, 0x52 ; 82 |
| 25e: 08 f0 brcs .+2 ; 0x262 <get_line+0x9c> |
| 260: b6 cf rjmp .-148 ; 0x1ce <get_line+0x8> |
| 262: b6 cf rjmp .-148 ; 0x1d0 <get_line+0xa> |
| 264: 90 e0 ldi r25, 0x00 ; 0 |
| } |
| return i; |
| } |
| 266: 89 2f mov r24, r25 |
| 268: 08 95 ret |
| |
| 0000026a <main>: |
| /*-----------------------------------------------------------------------*/ |
| /* Main */ |
| |
| |
| int main () |
| { |
| 26a: a2 e0 ldi r26, 0x02 ; 2 |
| 26c: b0 e0 ldi r27, 0x00 ; 0 |
| 26e: eb e3 ldi r30, 0x3B ; 59 |
| 270: f1 e0 ldi r31, 0x01 ; 1 |
| 272: 0c 94 c7 14 jmp 0x298e ; 0x298e <__prologue_saves__> |
| |
| |
| static |
| void ioinit (void) |
| { |
| PORTB = 0b00001101; // Port B |
| 276: 8d e0 ldi r24, 0x0D ; 13 |
| 278: 85 b9 out 0x05, r24 ; 5 |
| DDRB = 0b00101110; |
| 27a: 8e e2 ldi r24, 0x2E ; 46 |
| 27c: 84 b9 out 0x04, r24 ; 4 |
| PORTC = 0b00111111; // Port C |
| 27e: 8f e3 ldi r24, 0x3F ; 63 |
| 280: 88 b9 out 0x08, r24 ; 8 |
| DDRC = 0b00000000; |
| 282: 17 b8 out 0x07, r1 ; 7 |
| PORTD = 0b10101110; // Port D |
| 284: 8e ea ldi r24, 0xAE ; 174 |
| 286: 8b b9 out 0x0b, r24 ; 11 |
| DDRD = 0b01010010; |
| 288: 82 e5 ldi r24, 0x52 ; 82 |
| 28a: 8a b9 out 0x0a, r24 ; 10 |
| |
| SPCR = 0b01010000; /* Initialize SPI port (Mode 0) */ |
| 28c: 80 e5 ldi r24, 0x50 ; 80 |
| 28e: 8c bd out 0x2c, r24 ; 44 |
| SPSR = 0b00000001; |
| 290: 81 e0 ldi r24, 0x01 ; 1 |
| 292: 8d bd out 0x2d, r24 ; 45 |
| |
| OCR1A = SYSCLK/8/100-1; // Timer1: 100Hz interval (OC1A) |
| 294: 83 ed ldi r24, 0xD3 ; 211 |
| 296: 90 e3 ldi r25, 0x30 ; 48 |
| 298: 90 93 89 00 sts 0x0089, r25 |
| 29c: 80 93 88 00 sts 0x0088, r24 |
| TCCR1B = 0b00001010; |
| 2a0: 8a e0 ldi r24, 0x0A ; 10 |
| 2a2: 80 93 81 00 sts 0x0081, r24 |
| TIMSK1 = _BV(OCIE1A); // Enable TC1.oca interrupt |
| 2a6: 82 e0 ldi r24, 0x02 ; 2 |
| 2a8: 80 93 6f 00 sts 0x006F, r24 |
| |
| OCR0A = SYSCLK/64/4000/2-1; // Timer0: 4kHz sound (OC0A) |
| 2ac: 82 e1 ldi r24, 0x12 ; 18 |
| 2ae: 87 bd out 0x27, r24 ; 39 |
| TCCR0A = 0b01000010; |
| 2b0: 82 e4 ldi r24, 0x42 ; 66 |
| 2b2: 84 bd out 0x24, r24 ; 36 |
| |
| ADMUX = POWER_check; // Select ADC input |
| 2b4: 81 e4 ldi r24, 0x41 ; 65 |
| 2b6: 80 93 7c 00 sts 0x007C, r24 |
| ADCSRA = _BV(ADEN)|_BV(ADSC)|_BV(ADIF)|_BV(ADIE)|0b111; |
| 2ba: 8f ed ldi r24, 0xDF ; 223 |
| 2bc: 80 93 7a 00 sts 0x007A, r24 |
| |
| sei(); |
| 2c0: 78 94 sei |
| BYTE b, err, *p = NULL; |
| WORD s; |
| |
| |
| ioinit(); |
| f_mount(0, &fatfs); /* Enable file I/O layer */ |
| 2c2: 6d e2 ldi r22, 0x2D ; 45 |
| 2c4: 72 e0 ldi r23, 0x02 ; 2 |
| 2c6: 80 e0 ldi r24, 0x00 ; 0 |
| 2c8: 0e 94 7f 09 call 0x12fe ; 0x12fe <f_mount> |
| 2cc: ee 24 eor r14, r14 |
| 2ce: ff 24 eor r15, r15 |
| |
| static |
| void beep (BYTE len, BYTE cnt) |
| { |
| while (cnt--) { |
| BEEP_ON(); |
| 2d0: 53 e0 ldi r21, 0x03 ; 3 |
| 2d2: a5 2e mov r10, r21 |
| DELAY(len); |
| 2d4: 45 e0 ldi r20, 0x05 ; 5 |
| 2d6: b4 2e mov r11, r20 |
| beep(5, 1); // Single beep. Start to get current time. |
| uart_init(); |
| do { // Wait for valid RMC sentence. |
| b = get_line(); |
| if (!b) break; |
| if (gp_comp(Buff, PSTR("$GPRMC"))) continue; |
| 2d8: 3d e1 ldi r19, 0x1D ; 29 |
| 2da: c3 2e mov r12, r19 |
| 2dc: 31 e0 ldi r19, 0x01 ; 1 |
| 2de: d3 2e mov r13, r19 |
| // || !gp_comp(Buff, PSTR("$GPGSV")) |
| // || !gp_comp(Buff, PSTR("$GPZDA")) |
| // || !gp_comp(Buff, PSTR("$GPVTG")) |
| ) |
| { |
| if (f_write(&file1, Buff, b, &s) || b != s) { err = 5; break; }; |
| 2e0: 4e 01 movw r8, r28 |
| 2e2: 08 94 sec |
| 2e4: 81 1c adc r8, r1 |
| 2e6: 91 1c adc r9, r1 |
| itoa(battery,&Value1,10); // convert number to character |
| 2e8: 28 e1 ldi r18, 0x18 ; 24 |
| 2ea: 22 2e mov r2, r18 |
| 2ec: 21 e0 ldi r18, 0x01 ; 1 |
| 2ee: 32 2e mov r3, r18 |
| itoa(intensity,&Value2,10); |
| 2f0: 90 e7 ldi r25, 0x70 ; 112 |
| 2f2: 69 2e mov r6, r25 |
| 2f4: 91 e0 ldi r25, 0x01 ; 1 |
| 2f6: 79 2e mov r7, r25 |
| sprintf(Buff,"%d,%d\n",Value1,Value2); |
| 2f8: 80 e0 ldi r24, 0x00 ; 0 |
| 2fa: 48 2e mov r4, r24 |
| 2fc: 81 e0 ldi r24, 0x01 ; 1 |
| 2fe: 58 2e mov r5, r24 |
| |
| |
| static |
| void uart_stop (void) |
| { |
| UCSR0B = 0; |
| 300: 10 92 c1 00 sts 0x00C1, r1 |
| ioinit(); |
| f_mount(0, &fatfs); /* Enable file I/O layer */ |
| |
| for (;;) { |
| uart_stop(); |
| GPS_OFF(); |
| 304: 29 98 cbi 0x05, 1 ; 5 |
| Timer = 100; |
| 306: 84 e6 ldi r24, 0x64 ; 100 |
| 308: 80 93 1c 01 sts 0x011C, r24 |
| do { |
| if (Stat & 1) Timer = 100; |
| 30c: 94 e6 ldi r25, 0x64 ; 100 |
| 30e: 80 91 6f 01 lds r24, 0x016F |
| 312: 80 ff sbrs r24, 0 |
| 314: 02 c0 rjmp .+4 ; 0x31a <main+0xb0> |
| 316: 90 93 1c 01 sts 0x011C, r25 |
| } while (Timer); |
| 31a: 80 91 1c 01 lds r24, 0x011C |
| 31e: 88 23 and r24, r24 |
| 320: b1 f7 brne .-20 ; 0x30e <main+0xa4> |
| |
| GPS_ON(); |
| 322: 29 9a sbi 0x05, 1 ; 5 |
| Timer = 255; |
| 324: 8f ef ldi r24, 0xFF ; 255 |
| 326: 80 93 1c 01 sts 0x011C, r24 |
| do { |
| if ((Stat & 1) || (disk_status(0) & STA_NODISK)) Timer = 255; |
| 32a: 1f ef ldi r17, 0xFF ; 255 |
| 32c: 80 91 6f 01 lds r24, 0x016F |
| 330: 80 fd sbrc r24, 0 |
| 332: 05 c0 rjmp .+10 ; 0x33e <main+0xd4> |
| 334: 80 e0 ldi r24, 0x00 ; 0 |
| 336: 0e 94 95 0f call 0x1f2a ; 0x1f2a <disk_status> |
| 33a: 81 ff sbrs r24, 1 |
| 33c: 02 c0 rjmp .+4 ; 0x342 <main+0xd8> |
| 33e: 10 93 1c 01 sts 0x011C, r17 |
| } while (Timer); |
| 342: 80 91 1c 01 lds r24, 0x011C |
| 346: 88 23 and r24, r24 |
| 348: 89 f7 brne .-30 ; 0x32c <main+0xc2> |
| 34a: 91 e0 ldi r25, 0x01 ; 1 |
| 34c: 0e c0 rjmp .+28 ; 0x36a <main+0x100> |
| |
| static |
| void beep (BYTE len, BYTE cnt) |
| { |
| while (cnt--) { |
| BEEP_ON(); |
| 34e: a5 bc out 0x25, r10 ; 37 |
| DELAY(len); |
| 350: b0 92 1c 01 sts 0x011C, r11 |
| 354: 80 91 1c 01 lds r24, 0x011C |
| 358: 88 23 and r24, r24 |
| 35a: e1 f7 brne .-8 ; 0x354 <main+0xea> |
| BEEP_OFF(); |
| 35c: 15 bc out 0x25, r1 ; 37 |
| DELAY(len); |
| 35e: b0 92 1c 01 sts 0x011C, r11 |
| 362: 80 91 1c 01 lds r24, 0x011C |
| 366: 88 23 and r24, r24 |
| 368: e1 f7 brne .-8 ; 0x362 <main+0xf8> |
| /* Controls */ |
| |
| static |
| void beep (BYTE len, BYTE cnt) |
| { |
| while (cnt--) { |
| 36a: 91 50 subi r25, 0x01 ; 1 |
| 36c: 80 f7 brcc .-32 ; 0x34e <main+0xe4> |
| |
| |
| static |
| void uart_init (void) |
| { |
| cli(); |
| 36e: f8 94 cli |
| UCSR0B = 0; |
| 370: 10 92 c1 00 sts 0x00C1, r1 |
| rxfifo.idx_r = 0; |
| 374: 10 92 77 01 sts 0x0177, r1 |
| rxfifo.idx_w = 0; |
| 378: 10 92 76 01 sts 0x0176, r1 |
| rxfifo.count = 0; |
| 37c: 10 92 78 01 sts 0x0178, r1 |
| UBRR0L = SYSCLK/16/GPS_BAUDRATE; |
| 380: 82 e8 ldi r24, 0x82 ; 130 |
| 382: 80 93 c4 00 sts 0x00C4, r24 |
| UCSR0B = _BV(RXCIE0)|_BV(RXEN0)|_BV(TXEN0); |
| 386: 88 e9 ldi r24, 0x98 ; 152 |
| 388: 80 93 c1 00 sts 0x00C1, r24 |
| Stat &= 0xFD; // Clear overflow flag |
| 38c: 80 91 6f 01 lds r24, 0x016F |
| 390: 8d 7f andi r24, 0xFD ; 253 |
| 392: 80 93 6f 01 sts 0x016F, r24 |
| sei(); |
| 396: 78 94 sei |
| 398: 02 c0 rjmp .+4 ; 0x39e <main+0x134> |
| 39a: ee 24 eor r14, r14 |
| 39c: ff 24 eor r15, r15 |
| } while (Timer); |
| |
| beep(5, 1); // Single beep. Start to get current time. |
| uart_init(); |
| do { // Wait for valid RMC sentence. |
| b = get_line(); |
| 39e: 0e 94 e3 00 call 0x1c6 ; 0x1c6 <get_line> |
| if (!b) break; |
| 3a2: 88 23 and r24, r24 |
| 3a4: 09 f4 brne .+2 ; 0x3a8 <main+0x13e> |
| 3a6: ac cf rjmp .-168 ; 0x300 <main+0x96> |
| if (gp_comp(Buff, PSTR("$GPRMC"))) continue; |
| 3a8: 2b e7 ldi r18, 0x7B ; 123 |
| 3aa: 30 e0 ldi r19, 0x00 ; 0 |
| 3ac: ad e1 ldi r26, 0x1D ; 29 |
| 3ae: b1 e0 ldi r27, 0x01 ; 1 |
| 3b0: f9 01 movw r30, r18 |
| BYTE gp_comp (BYTE *str1, const prog_uint8_t *str2) |
| { |
| BYTE c; |
| |
| do { |
| c = pgm_read_byte(str2++); |
| 3b2: 2f 5f subi r18, 0xFF ; 255 |
| 3b4: 3f 4f sbci r19, 0xFF ; 255 |
| 3b6: 94 91 lpm r25, Z |
| } while (c && c == *str1++); |
| 3b8: 99 23 and r25, r25 |
| 3ba: 29 f0 breq .+10 ; 0x3c6 <main+0x15c> |
| 3bc: 8c 91 ld r24, X |
| 3be: 98 17 cp r25, r24 |
| 3c0: 71 f4 brne .+28 ; 0x3de <main+0x174> |
| 3c2: 11 96 adiw r26, 0x01 ; 1 |
| 3c4: f5 cf rjmp .-22 ; 0x3b0 <main+0x146> |
| 3c6: ed e1 ldi r30, 0x1D ; 29 |
| 3c8: f1 e0 ldi r31, 0x01 ; 1 |
| 3ca: 82 e0 ldi r24, 0x02 ; 2 |
| BYTE c; |
| |
| |
| while (col) { |
| do { |
| c = *buf++; |
| 3cc: 90 81 ld r25, Z |
| if (c <= ' ') return NULL; |
| 3ce: 91 32 cpi r25, 0x21 ; 33 |
| 3d0: 20 f3 brcs .-56 ; 0x39a <main+0x130> |
| BYTE c; |
| |
| |
| while (col) { |
| do { |
| c = *buf++; |
| 3d2: 31 96 adiw r30, 0x01 ; 1 |
| if (c <= ' ') return NULL; |
| } while (c != ','); |
| 3d4: 9c 32 cpi r25, 0x2C ; 44 |
| 3d6: d1 f7 brne .-12 ; 0x3cc <main+0x162> |
| col--; |
| 3d8: 81 50 subi r24, 0x01 ; 1 |
| BYTE col /* Column number (0 is the 1st item) */ |
| ) { |
| BYTE c; |
| |
| |
| while (col) { |
| 3da: c1 f7 brne .-16 ; 0x3cc <main+0x162> |
| c = *buf++; |
| if (c <= ' ') return NULL; |
| } while (c != ','); |
| col--; |
| } |
| return (BYTE*)buf; |
| 3dc: 7f 01 movw r14, r30 |
| do { // Wait for valid RMC sentence. |
| b = get_line(); |
| if (!b) break; |
| if (gp_comp(Buff, PSTR("$GPRMC"))) continue; |
| p = gp_col(Buff,2); |
| } while (!p || *p != 'A'); |
| 3de: e1 14 cp r14, r1 |
| 3e0: f1 04 cpc r15, r1 |
| 3e2: e9 f2 breq .-70 ; 0x39e <main+0x134> |
| 3e4: f7 01 movw r30, r14 |
| 3e6: 80 81 ld r24, Z |
| 3e8: 81 34 cpi r24, 0x41 ; 65 |
| 3ea: c9 f6 brne .-78 ; 0x39e <main+0x134> |
| 3ec: ed e1 ldi r30, 0x1D ; 29 |
| 3ee: f1 e0 ldi r31, 0x01 ; 1 |
| 3f0: 89 e0 ldi r24, 0x09 ; 9 |
| BYTE c; |
| |
| |
| while (col) { |
| do { |
| c = *buf++; |
| 3f2: 90 81 ld r25, Z |
| if (c <= ' ') return NULL; |
| 3f4: 91 32 cpi r25, 0x21 ; 33 |
| 3f6: 08 f4 brcc .+2 ; 0x3fa <main+0x190> |
| 3f8: f0 c0 rjmp .+480 ; 0x5da <__stack+0xdb> |
| BYTE c; |
| |
| |
| while (col) { |
| do { |
| c = *buf++; |
| 3fa: 31 96 adiw r30, 0x01 ; 1 |
| if (c <= ' ') return NULL; |
| } while (c != ','); |
| 3fc: 9c 32 cpi r25, 0x2C ; 44 |
| 3fe: c9 f7 brne .-14 ; 0x3f2 <main+0x188> |
| col--; |
| 400: 81 50 subi r24, 0x01 ; 1 |
| BYTE col /* Column number (0 is the 1st item) */ |
| ) { |
| BYTE c; |
| |
| |
| while (col) { |
| 402: b9 f7 brne .-18 ; 0x3f2 <main+0x188> |
| c = *buf++; |
| if (c <= ' ') return NULL; |
| } while (c != ','); |
| col--; |
| } |
| return (BYTE*)buf; |
| 404: 7f 01 movw r14, r30 |
| p = gp_col(Buff,2); |
| } while (!p || *p != 'A'); |
| if (!b) continue; |
| p = gp_col(Buff,9); // Open log file with the name of current date (YYMMDD.log in UTC). |
| |
| if (!p) {err = 3; break;} |
| 406: 30 97 sbiw r30, 0x00 ; 0 |
| 408: 09 f4 brne .+2 ; 0x40c <main+0x1a2> |
| 40a: e7 c0 rjmp .+462 ; 0x5da <__stack+0xdb> |
| |
| memcpy(&Buff[0], p+4, 2); |
| 40c: 84 81 ldd r24, Z+4 ; 0x04 |
| 40e: 95 81 ldd r25, Z+5 ; 0x05 |
| 410: 90 93 1e 01 sts 0x011E, r25 |
| 414: 80 93 1d 01 sts 0x011D, r24 |
| memcpy(&Buff[2], p+2, 2); |
| 418: 82 81 ldd r24, Z+2 ; 0x02 |
| 41a: 93 81 ldd r25, Z+3 ; 0x03 |
| 41c: 90 93 20 01 sts 0x0120, r25 |
| 420: 80 93 1f 01 sts 0x011F, r24 |
| memcpy(&Buff[4], p+0, 2); |
| 424: 80 81 ld r24, Z |
| 426: 91 81 ldd r25, Z+1 ; 0x01 |
| 428: 90 93 22 01 sts 0x0122, r25 |
| 42c: 80 93 21 01 sts 0x0121, r24 |
| strcpy_P(&Buff[6], PSTR(".log")); |
| 430: 66 e7 ldi r22, 0x76 ; 118 |
| 432: 70 e0 ldi r23, 0x00 ; 0 |
| 434: 83 e2 ldi r24, 0x23 ; 35 |
| 436: 91 e0 ldi r25, 0x01 ; 1 |
| 438: 0e 94 8f 11 call 0x231e ; 0x231e <strcpy_P> |
| if (f_open(&file1, Buff, FA_OPEN_ALWAYS | FA_WRITE) || f_lseek(&file1, file1.fsize)) { err = 4; break; } |
| 43c: 42 e1 ldi r20, 0x12 ; 18 |
| 43e: 6d e1 ldi r22, 0x1D ; 29 |
| 440: 71 e0 ldi r23, 0x01 ; 1 |
| 442: 81 e1 ldi r24, 0x11 ; 17 |
| 444: 92 e0 ldi r25, 0x02 ; 2 |
| 446: 0e 94 d7 09 call 0x13ae ; 0x13ae <f_open> |
| 44a: 89 2b or r24, r25 |
| 44c: 09 f0 breq .+2 ; 0x450 <main+0x1e6> |
| 44e: c7 c0 rjmp .+398 ; 0x5de <__stack+0xdf> |
| 450: 40 91 1b 02 lds r20, 0x021B |
| 454: 50 91 1c 02 lds r21, 0x021C |
| 458: 60 91 1d 02 lds r22, 0x021D |
| 45c: 70 91 1e 02 lds r23, 0x021E |
| 460: 81 e1 ldi r24, 0x11 ; 17 |
| 462: 92 e0 ldi r25, 0x02 ; 2 |
| 464: 0e 94 3c 05 call 0xa78 ; 0xa78 <f_lseek> |
| 468: 89 2b or r24, r25 |
| 46a: 09 f0 breq .+2 ; 0x46e <main+0x204> |
| 46c: b8 c0 rjmp .+368 ; 0x5de <__stack+0xdf> |
| 46e: 92 e0 ldi r25, 0x02 ; 2 |
| 470: 0e c0 rjmp .+28 ; 0x48e <main+0x224> |
| |
| static |
| void beep (BYTE len, BYTE cnt) |
| { |
| while (cnt--) { |
| BEEP_ON(); |
| 472: a5 bc out 0x25, r10 ; 37 |
| DELAY(len); |
| 474: b0 92 1c 01 sts 0x011C, r11 |
| 478: 80 91 1c 01 lds r24, 0x011C |
| 47c: 88 23 and r24, r24 |
| 47e: e1 f7 brne .-8 ; 0x478 <main+0x20e> |
| BEEP_OFF(); |
| 480: 15 bc out 0x25, r1 ; 37 |
| DELAY(len); |
| 482: b0 92 1c 01 sts 0x011C, r11 |
| 486: 80 91 1c 01 lds r24, 0x011C |
| 48a: 88 23 and r24, r24 |
| 48c: e1 f7 brne .-8 ; 0x486 <main+0x21c> |
| /* Controls */ |
| |
| static |
| void beep (BYTE len, BYTE cnt) |
| { |
| while (cnt--) { |
| 48e: 91 50 subi r25, 0x01 ; 1 |
| 490: 80 f7 brcc .-32 ; 0x472 <main+0x208> |
| 492: 85 c0 rjmp .+266 ; 0x59e <__stack+0x9f> |
| if (f_open(&file1, Buff, FA_OPEN_ALWAYS | FA_WRITE) || f_lseek(&file1, file1.fsize)) { err = 4; break; } |
| |
| beep(5, 2); // Two beeps. Start logging. |
| err = 0; |
| while ((b = get_line()) > 0) { |
| if ( !gp_comp(Buff, PSTR("$GPGGA")) // Which sentence is logged? |
| 494: 2f e6 ldi r18, 0x6F ; 111 |
| 496: 30 e0 ldi r19, 0x00 ; 0 |
| 498: ad e1 ldi r26, 0x1D ; 29 |
| 49a: b1 e0 ldi r27, 0x01 ; 1 |
| 49c: f9 01 movw r30, r18 |
| BYTE gp_comp (BYTE *str1, const prog_uint8_t *str2) |
| { |
| BYTE c; |
| |
| do { |
| c = pgm_read_byte(str2++); |
| 49e: 2f 5f subi r18, 0xFF ; 255 |
| 4a0: 3f 4f sbci r19, 0xFF ; 255 |
| 4a2: 94 91 lpm r25, Z |
| } while (c && c == *str1++); |
| 4a4: 99 23 and r25, r25 |
| 4a6: 89 f0 breq .+34 ; 0x4ca <main+0x260> |
| 4a8: 8c 91 ld r24, X |
| 4aa: 98 17 cp r25, r24 |
| 4ac: 09 f0 breq .+2 ; 0x4b0 <main+0x246> |
| 4ae: ae c0 rjmp .+348 ; 0x60c <__stack+0x10d> |
| 4b0: 11 96 adiw r26, 0x01 ; 1 |
| 4b2: f4 cf rjmp .-24 ; 0x49c <main+0x232> |
| BYTE gp_comp (BYTE *str1, const prog_uint8_t *str2) |
| { |
| BYTE c; |
| |
| do { |
| c = pgm_read_byte(str2++); |
| 4b4: 11 96 adiw r26, 0x01 ; 1 |
| 4b6: f9 01 movw r30, r18 |
| 4b8: 2f 5f subi r18, 0xFF ; 255 |
| 4ba: 3f 4f sbci r19, 0xFF ; 255 |
| 4bc: 94 91 lpm r25, Z |
| } while (c && c == *str1++); |
| 4be: 99 23 and r25, r25 |
| 4c0: 21 f0 breq .+8 ; 0x4ca <main+0x260> |
| 4c2: 8c 91 ld r24, X |
| 4c4: 98 17 cp r25, r24 |
| 4c6: b1 f3 breq .-20 ; 0x4b4 <main+0x24a> |
| 4c8: 57 c0 rjmp .+174 ; 0x578 <__stack+0x79> |
| // || !gp_comp(Buff, PSTR("$GPGSV")) |
| // || !gp_comp(Buff, PSTR("$GPZDA")) |
| // || !gp_comp(Buff, PSTR("$GPVTG")) |
| ) |
| { |
| if (f_write(&file1, Buff, b, &s) || b != s) { err = 5; break; }; |
| 4ca: 04 2f mov r16, r20 |
| 4cc: 10 e0 ldi r17, 0x00 ; 0 |
| 4ce: 94 01 movw r18, r8 |
| 4d0: a8 01 movw r20, r16 |
| 4d2: 6d e1 ldi r22, 0x1D ; 29 |
| 4d4: 71 e0 ldi r23, 0x01 ; 1 |
| 4d6: 81 e1 ldi r24, 0x11 ; 17 |
| 4d8: 92 e0 ldi r25, 0x02 ; 2 |
| 4da: 0e 94 0e 07 call 0xe1c ; 0xe1c <f_write> |
| 4de: 89 2b or r24, r25 |
| 4e0: 09 f0 breq .+2 ; 0x4e4 <main+0x27a> |
| 4e2: 64 c0 rjmp .+200 ; 0x5ac <__stack+0xad> |
| 4e4: 89 81 ldd r24, Y+1 ; 0x01 |
| 4e6: 9a 81 ldd r25, Y+2 ; 0x02 |
| 4e8: 08 17 cp r16, r24 |
| 4ea: 19 07 cpc r17, r25 |
| 4ec: 09 f0 breq .+2 ; 0x4f0 <main+0x286> |
| 4ee: 5e c0 rjmp .+188 ; 0x5ac <__stack+0xad> |
| itoa(battery,&Value1,10); // convert number to character |
| 4f0: 4a e0 ldi r20, 0x0A ; 10 |
| 4f2: 50 e0 ldi r21, 0x00 ; 0 |
| 4f4: 68 e1 ldi r22, 0x18 ; 24 |
| 4f6: 71 e0 ldi r23, 0x01 ; 1 |
| 4f8: 80 91 74 01 lds r24, 0x0174 |
| 4fc: 90 91 75 01 lds r25, 0x0175 |
| 500: 0e 94 b3 11 call 0x2366 ; 0x2366 <itoa> |
| itoa(intensity,&Value2,10); |
| 504: 4a e0 ldi r20, 0x0A ; 10 |
| 506: 50 e0 ldi r21, 0x00 ; 0 |
| 508: 60 e7 ldi r22, 0x70 ; 112 |
| 50a: 71 e0 ldi r23, 0x01 ; 1 |
| 50c: 80 91 0f 02 lds r24, 0x020F |
| 510: 90 91 10 02 lds r25, 0x0210 |
| 514: 0e 94 b3 11 call 0x2366 ; 0x2366 <itoa> |
| sprintf(Buff,"%d,%d\n",Value1,Value2); |
| 518: 7f 92 push r7 |
| 51a: 6f 92 push r6 |
| 51c: 3f 92 push r3 |
| 51e: 2f 92 push r2 |
| 520: 5f 92 push r5 |
| 522: 4f 92 push r4 |
| 524: df 92 push r13 |
| 526: cf 92 push r12 |
| 528: 0e 94 d4 11 call 0x23a8 ; 0x23a8 <sprintf> |
| if (f_write(&file1, Buff,strlen(Buff), &s) || (strlen(Buff) != s)) { err = 8; break; }; |
| 52c: f6 01 movw r30, r12 |
| 52e: 01 90 ld r0, Z+ |
| 530: 00 20 and r0, r0 |
| 532: e9 f7 brne .-6 ; 0x52e <__stack+0x2f> |
| 534: 31 97 sbiw r30, 0x01 ; 1 |
| 536: ec 19 sub r30, r12 |
| 538: fd 09 sbc r31, r13 |
| 53a: 94 01 movw r18, r8 |
| 53c: af 01 movw r20, r30 |
| 53e: 6d e1 ldi r22, 0x1D ; 29 |
| 540: 71 e0 ldi r23, 0x01 ; 1 |
| 542: 81 e1 ldi r24, 0x11 ; 17 |
| 544: 92 e0 ldi r25, 0x02 ; 2 |
| 546: 0e 94 0e 07 call 0xe1c ; 0xe1c <f_write> |
| 54a: 2d b7 in r18, 0x3d ; 61 |
| 54c: 3e b7 in r19, 0x3e ; 62 |
| 54e: 28 5f subi r18, 0xF8 ; 248 |
| 550: 3f 4f sbci r19, 0xFF ; 255 |
| 552: 0f b6 in r0, 0x3f ; 63 |
| 554: f8 94 cli |
| 556: 3e bf out 0x3e, r19 ; 62 |
| 558: 0f be out 0x3f, r0 ; 63 |
| 55a: 2d bf out 0x3d, r18 ; 61 |
| 55c: 89 2b or r24, r25 |
| 55e: 41 f5 brne .+80 ; 0x5b0 <__stack+0xb1> |
| 560: d6 01 movw r26, r12 |
| 562: 0d 90 ld r0, X+ |
| 564: 00 20 and r0, r0 |
| 566: e9 f7 brne .-6 ; 0x562 <__stack+0x63> |
| 568: 11 97 sbiw r26, 0x01 ; 1 |
| 56a: ac 19 sub r26, r12 |
| 56c: bd 09 sbc r27, r13 |
| 56e: 89 81 ldd r24, Y+1 ; 0x01 |
| 570: 9a 81 ldd r25, Y+2 ; 0x02 |
| 572: a8 17 cp r26, r24 |
| 574: b9 07 cpc r27, r25 |
| 576: e1 f4 brne .+56 ; 0x5b0 <__stack+0xb1> |
| } |
| if ((Stat & 4) == 0) continue; |
| 578: 80 91 6f 01 lds r24, 0x016F |
| 57c: 82 ff sbrs r24, 2 |
| 57e: 0f c0 rjmp .+30 ; 0x59e <__stack+0x9f> |
| if (f_sync(&file1)) { err = 6; break; };// Synchronize the file in interval of 300 sec. |
| 580: 81 e1 ldi r24, 0x11 ; 17 |
| 582: 92 e0 ldi r25, 0x02 ; 2 |
| 584: 0e 94 a9 06 call 0xd52 ; 0xd52 <f_sync> |
| 588: 89 2b or r24, r25 |
| 58a: 11 f0 breq .+4 ; 0x590 <__stack+0x91> |
| 58c: 96 e0 ldi r25, 0x06 ; 6 |
| 58e: 28 c0 rjmp .+80 ; 0x5e0 <__stack+0xe1> |
| cli(); Stat &= 0xFB; sei(); // Clear sync request |
| 590: f8 94 cli |
| 592: 80 91 6f 01 lds r24, 0x016F |
| 596: 8b 7f andi r24, 0xFB ; 251 |
| 598: 80 93 6f 01 sts 0x016F, r24 |
| 59c: 78 94 sei |
| strcpy_P(&Buff[6], PSTR(".log")); |
| if (f_open(&file1, Buff, FA_OPEN_ALWAYS | FA_WRITE) || f_lseek(&file1, file1.fsize)) { err = 4; break; } |
| |
| beep(5, 2); // Two beeps. Start logging. |
| err = 0; |
| while ((b = get_line()) > 0) { |
| 59e: 0e 94 e3 00 call 0x1c6 ; 0x1c6 <get_line> |
| 5a2: 48 2f mov r20, r24 |
| 5a4: 88 23 and r24, r24 |
| 5a6: 09 f0 breq .+2 ; 0x5aa <__stack+0xab> |
| 5a8: 75 cf rjmp .-278 ; 0x494 <main+0x22a> |
| 5aa: 35 c0 rjmp .+106 ; 0x616 <__stack+0x117> |
| 5ac: 95 e0 ldi r25, 0x05 ; 5 |
| 5ae: 18 c0 rjmp .+48 ; 0x5e0 <__stack+0xe1> |
| 5b0: 98 e0 ldi r25, 0x08 ; 8 |
| 5b2: 16 c0 rjmp .+44 ; 0x5e0 <__stack+0xe1> |
| |
| static |
| void beep (BYTE len, BYTE cnt) |
| { |
| while (cnt--) { |
| BEEP_ON(); |
| 5b4: a5 bc out 0x25, r10 ; 37 |
| DELAY(len); |
| 5b6: 32 e3 ldi r19, 0x32 ; 50 |
| 5b8: 30 93 1c 01 sts 0x011C, r19 |
| 5bc: 80 91 1c 01 lds r24, 0x011C |
| 5c0: 88 23 and r24, r24 |
| 5c2: e1 f7 brne .-8 ; 0x5bc <__stack+0xbd> |
| BEEP_OFF(); |
| 5c4: 15 bc out 0x25, r1 ; 37 |
| DELAY(len); |
| 5c6: 82 e3 ldi r24, 0x32 ; 50 |
| 5c8: 80 93 1c 01 sts 0x011C, r24 |
| 5cc: 80 91 1c 01 lds r24, 0x011C |
| 5d0: 88 23 and r24, r24 |
| 5d2: e1 f7 brne .-8 ; 0x5cc <__stack+0xcd> |
| /* Controls */ |
| |
| static |
| void beep (BYTE len, BYTE cnt) |
| { |
| while (cnt--) { |
| 5d4: 91 50 subi r25, 0x01 ; 1 |
| 5d6: 70 f7 brcc .-36 ; 0x5b4 <__stack+0xb5> |
| 5d8: 93 ce rjmp .-730 ; 0x300 <main+0x96> |
| 5da: 93 e0 ldi r25, 0x03 ; 3 |
| 5dc: 01 c0 rjmp .+2 ; 0x5e0 <__stack+0xe1> |
| 5de: 94 e0 ldi r25, 0x04 ; 4 |
| |
| |
| static |
| void uart_stop (void) |
| { |
| UCSR0B = 0; |
| 5e0: 10 92 c1 00 sts 0x00C1, r1 |
| beep(50, 1); |
| } |
| |
| // Unrecoverble error. Enter shutdown state. |
| uart_stop(); |
| GPS_OFF(); |
| 5e4: 29 98 cbi 0x05, 1 ; 5 |
| |
| static |
| void beep (BYTE len, BYTE cnt) |
| { |
| while (cnt--) { |
| BEEP_ON(); |
| 5e6: 33 e0 ldi r19, 0x03 ; 3 |
| DELAY(len); |
| 5e8: 29 e1 ldi r18, 0x19 ; 25 |
| |
| static |
| void beep (BYTE len, BYTE cnt) |
| { |
| while (cnt--) { |
| BEEP_ON(); |
| 5ea: 35 bd out 0x25, r19 ; 37 |
| DELAY(len); |
| 5ec: 20 93 1c 01 sts 0x011C, r18 |
| 5f0: 80 91 1c 01 lds r24, 0x011C |
| 5f4: 88 23 and r24, r24 |
| 5f6: e1 f7 brne .-8 ; 0x5f0 <__stack+0xf1> |
| BEEP_OFF(); |
| 5f8: 15 bc out 0x25, r1 ; 37 |
| DELAY(len); |
| 5fa: 20 93 1c 01 sts 0x011C, r18 |
| 5fe: 80 91 1c 01 lds r24, 0x011C |
| 602: 88 23 and r24, r24 |
| 604: e1 f7 brne .-8 ; 0x5fe <__stack+0xff> |
| 606: 91 50 subi r25, 0x01 ; 1 |
| /* Controls */ |
| |
| static |
| void beep (BYTE len, BYTE cnt) |
| { |
| while (cnt--) { |
| 608: 81 f7 brne .-32 ; 0x5ea <__stack+0xeb> |
| 60a: ff cf rjmp .-2 ; 0x60a <__stack+0x10b> |
| |
| beep(5, 2); // Two beeps. Start logging. |
| err = 0; |
| while ((b = get_line()) > 0) { |
| if ( !gp_comp(Buff, PSTR("$GPGGA")) // Which sentence is logged? |
| || !gp_comp(Buff, PSTR("$GPRMC")) |
| 60c: 28 e6 ldi r18, 0x68 ; 104 |
| 60e: 30 e0 ldi r19, 0x00 ; 0 |
| 610: ad e1 ldi r26, 0x1D ; 29 |
| 612: b1 e0 ldi r27, 0x01 ; 1 |
| 614: 50 cf rjmp .-352 ; 0x4b6 <main+0x24c> |
| |
| |
| static |
| void uart_stop (void) |
| { |
| UCSR0B = 0; |
| 616: 10 92 c1 00 sts 0x00C1, r1 |
| } |
| if (err) break; |
| |
| // Turn-off GPS power and close the log file by power supply is discharged. |
| uart_stop(); |
| GPS_OFF(); |
| 61a: 29 98 cbi 0x05, 1 ; 5 |
| if (f_close(&file1)) { err = 7; break; }; |
| 61c: 81 e1 ldi r24, 0x11 ; 17 |
| 61e: 92 e0 ldi r25, 0x02 ; 2 |
| 620: 0e 94 00 07 call 0xe00 ; 0xe00 <f_close> |
| 624: 89 2b or r24, r25 |
| 626: 11 f0 breq .+4 ; 0x62c <__stack+0x12d> |
| 628: 97 e0 ldi r25, 0x07 ; 7 |
| 62a: da cf rjmp .-76 ; 0x5e0 <__stack+0xe1> |
| 62c: 91 e0 ldi r25, 0x01 ; 1 |
| 62e: d2 cf rjmp .-92 ; 0x5d4 <__stack+0xd5> |
| |
| 00000630 <__vector_11>: |
| /* 100Hz timer interrupt generated by OC1A */ |
| /*---------------------------------------------------------*/ |
| |
| |
| ISR(TIMER1_COMPA_vect) |
| { |
| 630: 1f 92 push r1 |
| 632: 0f 92 push r0 |
| 634: 0f b6 in r0, 0x3f ; 63 |
| 636: 0f 92 push r0 |
| 638: 11 24 eor r1, r1 |
| 63a: 2f 93 push r18 |
| 63c: 8f 93 push r24 |
| 63e: 9f 93 push r25 |
| BYTE n; |
| static WORD ivt_sync; |
| |
| |
| n = Timer; |
| 640: 80 91 1c 01 lds r24, 0x011C |
| if (n) Timer = n - 1; |
| 644: 88 23 and r24, r24 |
| 646: 19 f0 breq .+6 ; 0x64e <__vector_11+0x1e> |
| 648: 81 50 subi r24, 0x01 ; 1 |
| 64a: 80 93 1c 01 sts 0x011C, r24 |
| |
| if (++ivt_sync >= 180 * 100) { |
| 64e: 80 91 0c 01 lds r24, 0x010C |
| 652: 90 91 0d 01 lds r25, 0x010D |
| 656: 01 96 adiw r24, 0x01 ; 1 |
| 658: 90 93 0d 01 sts 0x010D, r25 |
| 65c: 80 93 0c 01 sts 0x010C, r24 |
| 660: 80 55 subi r24, 0x50 ; 80 |
| 662: 96 44 sbci r25, 0x46 ; 70 |
| 664: 48 f0 brcs .+18 ; 0x678 <__vector_11+0x48> |
| ivt_sync = 0; |
| 666: 10 92 0d 01 sts 0x010D, r1 |
| 66a: 10 92 0c 01 sts 0x010C, r1 |
| Stat |= 4; |
| 66e: 80 91 6f 01 lds r24, 0x016F |
| 672: 84 60 ori r24, 0x04 ; 4 |
| 674: 80 93 6f 01 sts 0x016F, r24 |
| } |
| |
| disk_timerproc(); /* Drive timer procedure of low level disk I/O module */ |
| 678: 0e 94 6f 11 call 0x22de ; 0x22de <disk_timerproc> |
| |
| } |
| 67c: 9f 91 pop r25 |
| 67e: 8f 91 pop r24 |
| 680: 2f 91 pop r18 |
| 682: 0f 90 pop r0 |
| 684: 0f be out 0x3f, r0 ; 63 |
| 686: 0f 90 pop r0 |
| 688: 1f 90 pop r1 |
| 68a: 18 95 reti |
| |
| 0000068c <validate>: |
| static |
| FRESULT validate ( /* FR_OK(0): The id is valid, !=0: Not valid */ |
| const FATFS *fs, /* Pointer to the file system object */ |
| WORD id /* id member of the target object to be checked */ |
| ) |
| { |
| 68c: fc 01 movw r30, r24 |
| if (!fs || fs->id != id) |
| 68e: 00 97 sbiw r24, 0x00 ; 0 |
| 690: 69 f0 breq .+26 ; 0x6ac <validate+0x20> |
| 692: 80 81 ld r24, Z |
| 694: 91 81 ldd r25, Z+1 ; 0x01 |
| 696: 86 17 cp r24, r22 |
| 698: 97 07 cpc r25, r23 |
| 69a: 41 f4 brne .+16 ; 0x6ac <validate+0x20> |
| return FR_INVALID_OBJECT; |
| if (disk_status(0) & STA_NOINIT) |
| 69c: 80 e0 ldi r24, 0x00 ; 0 |
| 69e: 0e 94 95 0f call 0x1f2a ; 0x1f2a <disk_status> |
| 6a2: 28 2f mov r18, r24 |
| 6a4: 30 e0 ldi r19, 0x00 ; 0 |
| 6a6: 21 70 andi r18, 0x01 ; 1 |
| 6a8: 30 70 andi r19, 0x00 ; 0 |
| 6aa: 02 c0 rjmp .+4 ; 0x6b0 <validate+0x24> |
| 6ac: 2c e0 ldi r18, 0x0C ; 12 |
| 6ae: 30 e0 ldi r19, 0x00 ; 0 |
| return FR_NOT_READY; |
| |
| return FR_OK; |
| } |
| 6b0: c9 01 movw r24, r18 |
| 6b2: 08 95 ret |
| |
| 000006b4 <move_window>: |
| |
| static |
| BOOL move_window ( /* TRUE: successful, FALSE: failed */ |
| DWORD sector /* Sector number to make apperance in the FatFs->win */ |
| ) /* Move to zero only writes back dirty window */ |
| { |
| 6b4: a0 e0 ldi r26, 0x00 ; 0 |
| 6b6: b0 e0 ldi r27, 0x00 ; 0 |
| 6b8: e0 e6 ldi r30, 0x60 ; 96 |
| 6ba: f3 e0 ldi r31, 0x03 ; 3 |
| 6bc: 0c 94 cb 14 jmp 0x2996 ; 0x2996 <__prologue_saves__+0x8> |
| 6c0: 4b 01 movw r8, r22 |
| 6c2: 5c 01 movw r10, r24 |
| DWORD wsect; |
| FATFS *fs = FatFs; |
| 6c4: c0 91 10 01 lds r28, 0x0110 |
| 6c8: d0 91 11 01 lds r29, 0x0111 |
| |
| |
| wsect = fs->winsect; |
| 6cc: cc 80 ldd r12, Y+4 ; 0x04 |
| 6ce: dd 80 ldd r13, Y+5 ; 0x05 |
| 6d0: ee 80 ldd r14, Y+6 ; 0x06 |
| 6d2: ff 80 ldd r15, Y+7 ; 0x07 |
| if (wsect != sector) { /* Changed current window */ |
| 6d4: c6 16 cp r12, r22 |
| 6d6: d7 06 cpc r13, r23 |
| 6d8: e8 06 cpc r14, r24 |
| 6da: f9 06 cpc r15, r25 |
| 6dc: 09 f4 brne .+2 ; 0x6e0 <move_window+0x2c> |
| 6de: 4e c0 rjmp .+156 ; 0x77c <move_window+0xc8> |
| #if !_FS_READONLY |
| BYTE n; |
| if (fs->winflag) { /* Write back dirty window if needed */ |
| 6e0: 8f 8d ldd r24, Y+31 ; 0x1f |
| 6e2: 88 23 and r24, r24 |
| 6e4: a1 f1 breq .+104 ; 0x74e <move_window+0x9a> |
| if (disk_write(0, fs->win, wsect, 1) != RES_OK) |
| 6e6: 80 e2 ldi r24, 0x20 ; 32 |
| 6e8: 68 2e mov r6, r24 |
| 6ea: 71 2c mov r7, r1 |
| 6ec: 6c 0e add r6, r28 |
| 6ee: 7d 1e adc r7, r29 |
| 6f0: 01 e0 ldi r16, 0x01 ; 1 |
| 6f2: a7 01 movw r20, r14 |
| 6f4: 96 01 movw r18, r12 |
| 6f6: b3 01 movw r22, r6 |
| 6f8: 80 e0 ldi r24, 0x00 ; 0 |
| 6fa: 0e 94 fb 0f call 0x1ff6 ; 0x1ff6 <disk_write> |
| 6fe: 89 2b or r24, r25 |
| 700: d9 f5 brne .+118 ; 0x778 <move_window+0xc4> |
| return FALSE; |
| fs->winflag = 0; |
| 702: 1f 8e std Y+31, r1 ; 0x1f |
| if (wsect < (fs->fatbase + fs->sects_fat)) { /* In FAT area */ |
| 704: 8c 89 ldd r24, Y+20 ; 0x14 |
| 706: 9d 89 ldd r25, Y+21 ; 0x15 |
| 708: a0 e0 ldi r26, 0x00 ; 0 |
| 70a: b0 e0 ldi r27, 0x00 ; 0 |
| 70c: 28 85 ldd r18, Y+8 ; 0x08 |
| 70e: 39 85 ldd r19, Y+9 ; 0x09 |
| 710: 4a 85 ldd r20, Y+10 ; 0x0a |
| 712: 5b 85 ldd r21, Y+11 ; 0x0b |
| 714: 82 0f add r24, r18 |
| 716: 93 1f adc r25, r19 |
| 718: a4 1f adc r26, r20 |
| 71a: b5 1f adc r27, r21 |
| 71c: c8 16 cp r12, r24 |
| 71e: d9 06 cpc r13, r25 |
| 720: ea 06 cpc r14, r26 |
| 722: fb 06 cpc r15, r27 |
| 724: a0 f4 brcc .+40 ; 0x74e <move_window+0x9a> |
| for (n = fs->n_fats; n >= 2; n--) { /* Refrect the change to all FAT copies */ |
| 726: 1e 8d ldd r17, Y+30 ; 0x1e |
| 728: 10 c0 rjmp .+32 ; 0x74a <move_window+0x96> |
| wsect += fs->sects_fat; |
| 72a: 8c 89 ldd r24, Y+20 ; 0x14 |
| 72c: 9d 89 ldd r25, Y+21 ; 0x15 |
| 72e: a0 e0 ldi r26, 0x00 ; 0 |
| 730: b0 e0 ldi r27, 0x00 ; 0 |
| 732: c8 0e add r12, r24 |
| 734: d9 1e adc r13, r25 |
| 736: ea 1e adc r14, r26 |
| 738: fb 1e adc r15, r27 |
| disk_write(0, fs->win, wsect, 1); |
| 73a: 01 e0 ldi r16, 0x01 ; 1 |
| 73c: a7 01 movw r20, r14 |
| 73e: 96 01 movw r18, r12 |
| 740: b3 01 movw r22, r6 |
| 742: 80 e0 ldi r24, 0x00 ; 0 |
| 744: 0e 94 fb 0f call 0x1ff6 ; 0x1ff6 <disk_write> |
| if (fs->winflag) { /* Write back dirty window if needed */ |
| if (disk_write(0, fs->win, wsect, 1) != RES_OK) |
| return FALSE; |
| fs->winflag = 0; |
| if (wsect < (fs->fatbase + fs->sects_fat)) { /* In FAT area */ |
| for (n = fs->n_fats; n >= 2; n--) { /* Refrect the change to all FAT copies */ |
| 748: 11 50 subi r17, 0x01 ; 1 |
| 74a: 12 30 cpi r17, 0x02 ; 2 |
| 74c: 70 f7 brcc .-36 ; 0x72a <move_window+0x76> |
| disk_write(0, fs->win, wsect, 1); |
| } |
| } |
| } |
| #endif |
| if (sector) { |
| 74e: 81 14 cp r8, r1 |
| 750: 91 04 cpc r9, r1 |
| 752: a1 04 cpc r10, r1 |
| 754: b1 04 cpc r11, r1 |
| 756: 91 f0 breq .+36 ; 0x77c <move_window+0xc8> |
| if (disk_read(0, fs->win, sector, 1) != RES_OK) |
| 758: be 01 movw r22, r28 |
| 75a: 60 5e subi r22, 0xE0 ; 224 |
| 75c: 7f 4f sbci r23, 0xFF ; 255 |
| 75e: 01 e0 ldi r16, 0x01 ; 1 |
| 760: a5 01 movw r20, r10 |
| 762: 94 01 movw r18, r8 |
| 764: 80 e0 ldi r24, 0x00 ; 0 |
| 766: 0e 94 9c 0f call 0x1f38 ; 0x1f38 <disk_read> |
| 76a: 89 2b or r24, r25 |
| 76c: 29 f4 brne .+10 ; 0x778 <move_window+0xc4> |
| return FALSE; |
| fs->winsect = sector; |
| 76e: 8c 82 std Y+4, r8 ; 0x04 |
| 770: 9d 82 std Y+5, r9 ; 0x05 |
| 772: ae 82 std Y+6, r10 ; 0x06 |
| 774: bf 82 std Y+7, r11 ; 0x07 |
| 776: 02 c0 rjmp .+4 ; 0x77c <move_window+0xc8> |
| 778: 80 e0 ldi r24, 0x00 ; 0 |
| 77a: 01 c0 rjmp .+2 ; 0x77e <move_window+0xca> |
| 77c: 81 e0 ldi r24, 0x01 ; 1 |
| } |
| } |
| return TRUE; |
| } |
| 77e: cd b7 in r28, 0x3d ; 61 |
| 780: de b7 in r29, 0x3e ; 62 |
| 782: ee e0 ldi r30, 0x0E ; 14 |
| 784: 0c 94 e7 14 jmp 0x29ce ; 0x29ce <__epilogue_restores__+0x8> |
| |
| 00000788 <put_cluster>: |
| static |
| BOOL put_cluster ( /* TRUE: successful, FALSE: failed */ |
| CLUST clust, /* Cluster# to change */ |
| CLUST val /* New value to mark the cluster */ |
| ) |
| { |
| 788: a0 e0 ldi r26, 0x00 ; 0 |
| 78a: b0 e0 ldi r27, 0x00 ; 0 |
| 78c: ea ec ldi r30, 0xCA ; 202 |
| 78e: f3 e0 ldi r31, 0x03 ; 3 |
| 790: 0c 94 cb 14 jmp 0x2996 ; 0x2996 <__prologue_saves__+0x8> |
| 794: ec 01 movw r28, r24 |
| 796: 4b 01 movw r8, r22 |
| WORD bc; |
| BYTE *p; |
| DWORD fatsect; |
| FATFS *fs = FatFs; |
| 798: e0 90 10 01 lds r14, 0x0110 |
| 79c: f0 90 11 01 lds r15, 0x0111 |
| |
| |
| fatsect = fs->fatbase; |
| 7a0: f7 01 movw r30, r14 |
| 7a2: a0 84 ldd r10, Z+8 ; 0x08 |
| 7a4: b1 84 ldd r11, Z+9 ; 0x09 |
| 7a6: c2 84 ldd r12, Z+10 ; 0x0a |
| 7a8: d3 84 ldd r13, Z+11 ; 0x0b |
| switch (fs->fs_type) { |
| 7aa: 84 8d ldd r24, Z+28 ; 0x1c |
| 7ac: 81 30 cpi r24, 0x01 ; 1 |
| 7ae: 21 f0 breq .+8 ; 0x7b8 <put_cluster+0x30> |
| 7b0: 82 30 cpi r24, 0x02 ; 2 |
| 7b2: 09 f0 breq .+2 ; 0x7b6 <put_cluster+0x2e> |
| 7b4: 72 c0 rjmp .+228 ; 0x89a <put_cluster+0x112> |
| 7b6: 5a c0 rjmp .+180 ; 0x86c <put_cluster+0xe4> |
| case FS_FAT12 : |
| bc = (WORD)clust * 3 / 2; |
| 7b8: 8e 01 movw r16, r28 |
| 7ba: 00 0f add r16, r16 |
| 7bc: 11 1f adc r17, r17 |
| 7be: 0c 0f add r16, r28 |
| 7c0: 1d 1f adc r17, r29 |
| 7c2: 16 95 lsr r17 |
| 7c4: 07 95 ror r16 |
| if (!move_window(fatsect + bc / 512)) return FALSE; |
| 7c6: b8 01 movw r22, r16 |
| 7c8: 67 2f mov r22, r23 |
| 7ca: 77 27 eor r23, r23 |
| 7cc: 66 95 lsr r22 |
| 7ce: 80 e0 ldi r24, 0x00 ; 0 |
| 7d0: 90 e0 ldi r25, 0x00 ; 0 |
| 7d2: 6a 0d add r22, r10 |
| 7d4: 7b 1d adc r23, r11 |
| 7d6: 8c 1d adc r24, r12 |
| 7d8: 9d 1d adc r25, r13 |
| 7da: 0e 94 5a 03 call 0x6b4 ; 0x6b4 <move_window> |
| 7de: 88 23 and r24, r24 |
| 7e0: 09 f4 brne .+2 ; 0x7e4 <put_cluster+0x5c> |
| 7e2: 5b c0 rjmp .+182 ; 0x89a <put_cluster+0x112> |
| p = &fs->win[bc % 512]; |
| 7e4: d8 01 movw r26, r16 |
| 7e6: b1 70 andi r27, 0x01 ; 1 |
| *p = (clust & 1) ? ((*p & 0x0F) | ((BYTE)val << 4)) : (BYTE)val; |
| 7e8: 51 e0 ldi r21, 0x01 ; 1 |
| 7ea: 65 2e mov r6, r21 |
| 7ec: 71 2c mov r7, r1 |
| 7ee: 6c 22 and r6, r28 |
| 7f0: 7d 22 and r7, r29 |
| 7f2: c0 ff sbrs r28, 0 |
| 7f4: 0a c0 rjmp .+20 ; 0x80a <put_cluster+0x82> |
| 7f6: f7 01 movw r30, r14 |
| 7f8: ea 0f add r30, r26 |
| 7fa: fb 1f adc r31, r27 |
| 7fc: 80 a1 ldd r24, Z+32 ; 0x20 |
| 7fe: 8f 70 andi r24, 0x0F ; 15 |
| 800: 98 2d mov r25, r8 |
| 802: 92 95 swap r25 |
| 804: 90 7f andi r25, 0xF0 ; 240 |
| 806: 98 2b or r25, r24 |
| 808: 01 c0 rjmp .+2 ; 0x80c <put_cluster+0x84> |
| 80a: 98 2d mov r25, r8 |
| 80c: ae 0d add r26, r14 |
| 80e: bf 1d adc r27, r15 |
| 810: fd 01 movw r30, r26 |
| 812: 90 a3 std Z+32, r25 ; 0x20 |
| bc++; |
| 814: e8 01 movw r28, r16 |
| 816: 21 96 adiw r28, 0x01 ; 1 |
| fs->winflag = 1; |
| 818: 81 e0 ldi r24, 0x01 ; 1 |
| 81a: f7 01 movw r30, r14 |
| 81c: 87 8f std Z+31, r24 ; 0x1f |
| if (!move_window(fatsect + bc / 512)) return FALSE; |
| 81e: be 01 movw r22, r28 |
| 820: 67 2f mov r22, r23 |
| 822: 77 27 eor r23, r23 |
| 824: 66 95 lsr r22 |
| 826: 80 e0 ldi r24, 0x00 ; 0 |
| 828: 90 e0 ldi r25, 0x00 ; 0 |
| 82a: 6a 0d add r22, r10 |
| 82c: 7b 1d adc r23, r11 |
| 82e: 8c 1d adc r24, r12 |
| 830: 9d 1d adc r25, r13 |
| 832: 0e 94 5a 03 call 0x6b4 ; 0x6b4 <move_window> |
| 836: 88 23 and r24, r24 |
| 838: 81 f1 breq .+96 ; 0x89a <put_cluster+0x112> |
| p = &fs->win[bc % 512]; |
| 83a: de 01 movw r26, r28 |
| 83c: b1 70 andi r27, 0x01 ; 1 |
| *p = (clust & 1) ? (BYTE)(val >> 4) : ((*p & 0xF0) | ((BYTE)(val >> 8) & 0x0F)); |
| 83e: 61 14 cp r6, r1 |
| 840: 71 04 cpc r7, r1 |
| 842: 39 f0 breq .+14 ; 0x852 <put_cluster+0xca> |
| 844: 34 e0 ldi r19, 0x04 ; 4 |
| 846: 96 94 lsr r9 |
| 848: 87 94 ror r8 |
| 84a: 3a 95 dec r19 |
| 84c: e1 f7 brne .-8 ; 0x846 <put_cluster+0xbe> |
| 84e: 98 2d mov r25, r8 |
| 850: 08 c0 rjmp .+16 ; 0x862 <put_cluster+0xda> |
| 852: f7 01 movw r30, r14 |
| 854: ea 0f add r30, r26 |
| 856: fb 1f adc r31, r27 |
| 858: 90 a1 ldd r25, Z+32 ; 0x20 |
| 85a: 90 7f andi r25, 0xF0 ; 240 |
| 85c: 89 2d mov r24, r9 |
| 85e: 8f 70 andi r24, 0x0F ; 15 |
| 860: 98 2b or r25, r24 |
| 862: ae 0d add r26, r14 |
| 864: bf 1d adc r27, r15 |
| 866: fd 01 movw r30, r26 |
| 868: 90 a3 std Z+32, r25 ; 0x20 |
| 86a: 13 c0 rjmp .+38 ; 0x892 <put_cluster+0x10a> |
| break; |
| |
| case FS_FAT16 : |
| if (!move_window(fatsect + clust / 256)) return FALSE; |
| 86c: 6d 2f mov r22, r29 |
| 86e: 77 27 eor r23, r23 |
| 870: 80 e0 ldi r24, 0x00 ; 0 |
| 872: 90 e0 ldi r25, 0x00 ; 0 |
| 874: 6a 0d add r22, r10 |
| 876: 7b 1d adc r23, r11 |
| 878: 8c 1d adc r24, r12 |
| 87a: 9d 1d adc r25, r13 |
| 87c: 0e 94 5a 03 call 0x6b4 ; 0x6b4 <move_window> |
| 880: 88 23 and r24, r24 |
| 882: 59 f0 breq .+22 ; 0x89a <put_cluster+0x112> |
| ST_WORD(&fs->win[((WORD)clust * 2) % 512], (WORD)val); |
| 884: cc 0f add r28, r28 |
| 886: dd 1f adc r29, r29 |
| 888: d1 70 andi r29, 0x01 ; 1 |
| 88a: ce 0d add r28, r14 |
| 88c: df 1d adc r29, r15 |
| 88e: 99 a2 std Y+33, r9 ; 0x21 |
| 890: 88 a2 std Y+32, r8 ; 0x20 |
| break; |
| #endif |
| default : |
| return FALSE; |
| } |
| fs->winflag = 1; |
| 892: 81 e0 ldi r24, 0x01 ; 1 |
| 894: f7 01 movw r30, r14 |
| 896: 87 8f std Z+31, r24 ; 0x1f |
| 898: 01 c0 rjmp .+2 ; 0x89c <put_cluster+0x114> |
| return TRUE; |
| 89a: 80 e0 ldi r24, 0x00 ; 0 |
| } |
| 89c: cd b7 in r28, 0x3d ; 61 |
| 89e: de b7 in r29, 0x3e ; 62 |
| 8a0: ee e0 ldi r30, 0x0E ; 14 |
| 8a2: 0c 94 e7 14 jmp 0x29ce ; 0x29ce <__epilogue_restores__+0x8> |
| |
| 000008a6 <get_cluster>: |
| |
| static |
| CLUST get_cluster ( /* 0,>=2: successful, 1: failed */ |
| CLUST clust /* Cluster# to get the link information */ |
| ) |
| { |
| 8a6: a0 e0 ldi r26, 0x00 ; 0 |
| 8a8: b0 e0 ldi r27, 0x00 ; 0 |
| 8aa: e9 e5 ldi r30, 0x59 ; 89 |
| 8ac: f4 e0 ldi r31, 0x04 ; 4 |
| 8ae: 0c 94 ce 14 jmp 0x299c ; 0x299c <__prologue_saves__+0xe> |
| 8b2: 8c 01 movw r16, r24 |
| WORD wc, bc; |
| DWORD fatsect; |
| FATFS *fs = FatFs; |
| 8b4: e0 90 10 01 lds r14, 0x0110 |
| 8b8: f0 90 11 01 lds r15, 0x0111 |
| |
| |
| if (clust >= 2 && clust < fs->max_clust) { /* Valid cluster# */ |
| 8bc: 82 30 cpi r24, 0x02 ; 2 |
| 8be: 91 05 cpc r25, r1 |
| 8c0: 08 f4 brcc .+2 ; 0x8c4 <get_cluster+0x1e> |
| 8c2: 67 c0 rjmp .+206 ; 0x992 <get_cluster+0xec> |
| 8c4: e7 01 movw r28, r14 |
| 8c6: 8e 89 ldd r24, Y+22 ; 0x16 |
| 8c8: 9f 89 ldd r25, Y+23 ; 0x17 |
| 8ca: 08 17 cp r16, r24 |
| 8cc: 19 07 cpc r17, r25 |
| 8ce: 08 f0 brcs .+2 ; 0x8d2 <get_cluster+0x2c> |
| 8d0: 60 c0 rjmp .+192 ; 0x992 <get_cluster+0xec> |
| fatsect = fs->fatbase; |
| 8d2: a8 84 ldd r10, Y+8 ; 0x08 |
| 8d4: b9 84 ldd r11, Y+9 ; 0x09 |
| 8d6: ca 84 ldd r12, Y+10 ; 0x0a |
| 8d8: db 84 ldd r13, Y+11 ; 0x0b |
| switch (fs->fs_type) { |
| 8da: 8c 8d ldd r24, Y+28 ; 0x1c |
| 8dc: 81 30 cpi r24, 0x01 ; 1 |
| 8de: 21 f0 breq .+8 ; 0x8e8 <get_cluster+0x42> |
| 8e0: 82 30 cpi r24, 0x02 ; 2 |
| 8e2: 09 f0 breq .+2 ; 0x8e6 <get_cluster+0x40> |
| 8e4: 56 c0 rjmp .+172 ; 0x992 <get_cluster+0xec> |
| 8e6: 40 c0 rjmp .+128 ; 0x968 <get_cluster+0xc2> |
| case FS_FAT12 : |
| bc = (WORD)clust * 3 / 2; |
| 8e8: e8 01 movw r28, r16 |
| 8ea: cc 0f add r28, r28 |
| 8ec: dd 1f adc r29, r29 |
| 8ee: c0 0f add r28, r16 |
| 8f0: d1 1f adc r29, r17 |
| 8f2: d6 95 lsr r29 |
| 8f4: c7 95 ror r28 |
| if (!move_window(fatsect + bc / 512)) break; |
| 8f6: be 01 movw r22, r28 |
| 8f8: 67 2f mov r22, r23 |
| 8fa: 77 27 eor r23, r23 |
| 8fc: 66 95 lsr r22 |
| 8fe: 80 e0 ldi r24, 0x00 ; 0 |
| 900: 90 e0 ldi r25, 0x00 ; 0 |
| 902: 6a 0d add r22, r10 |
| 904: 7b 1d adc r23, r11 |
| 906: 8c 1d adc r24, r12 |
| 908: 9d 1d adc r25, r13 |
| 90a: 0e 94 5a 03 call 0x6b4 ; 0x6b4 <move_window> |
| 90e: 88 23 and r24, r24 |
| 910: 09 f4 brne .+2 ; 0x914 <get_cluster+0x6e> |
| 912: 3f c0 rjmp .+126 ; 0x992 <get_cluster+0xec> |
| wc = fs->win[bc % 512]; bc++; |
| 914: fe 01 movw r30, r28 |
| 916: f1 70 andi r31, 0x01 ; 1 |
| 918: ee 0d add r30, r14 |
| 91a: ff 1d adc r31, r15 |
| 91c: 90 a0 ldd r9, Z+32 ; 0x20 |
| 91e: 21 96 adiw r28, 0x01 ; 1 |
| if (!move_window(fatsect + bc / 512)) break; |
| 920: be 01 movw r22, r28 |
| 922: 67 2f mov r22, r23 |
| 924: 77 27 eor r23, r23 |
| 926: 66 95 lsr r22 |
| 928: 80 e0 ldi r24, 0x00 ; 0 |
| 92a: 90 e0 ldi r25, 0x00 ; 0 |
| 92c: 6a 0d add r22, r10 |
| 92e: 7b 1d adc r23, r11 |
| 930: 8c 1d adc r24, r12 |
| 932: 9d 1d adc r25, r13 |
| 934: 0e 94 5a 03 call 0x6b4 ; 0x6b4 <move_window> |
| 938: 88 23 and r24, r24 |
| 93a: 59 f1 breq .+86 ; 0x992 <get_cluster+0xec> |
| fatsect = fs->fatbase; |
| switch (fs->fs_type) { |
| case FS_FAT12 : |
| bc = (WORD)clust * 3 / 2; |
| if (!move_window(fatsect + bc / 512)) break; |
| wc = fs->win[bc % 512]; bc++; |
| 93c: 29 2d mov r18, r9 |
| 93e: 30 e0 ldi r19, 0x00 ; 0 |
| if (!move_window(fatsect + bc / 512)) break; |
| wc |= (WORD)fs->win[bc % 512] << 8; |
| 940: d1 70 andi r29, 0x01 ; 1 |
| 942: ec 0e add r14, r28 |
| 944: fd 1e adc r15, r29 |
| 946: f7 01 movw r30, r14 |
| 948: 90 a1 ldd r25, Z+32 ; 0x20 |
| 94a: 80 e0 ldi r24, 0x00 ; 0 |
| 94c: 28 2b or r18, r24 |
| 94e: 39 2b or r19, r25 |
| return (clust & 1) ? (wc >> 4) : (wc & 0xFFF); |
| 950: 00 ff sbrs r16, 0 |
| 952: 07 c0 rjmp .+14 ; 0x962 <get_cluster+0xbc> |
| 954: f9 01 movw r30, r18 |
| 956: 94 e0 ldi r25, 0x04 ; 4 |
| 958: f6 95 lsr r31 |
| 95a: e7 95 ror r30 |
| 95c: 9a 95 dec r25 |
| 95e: e1 f7 brne .-8 ; 0x958 <get_cluster+0xb2> |
| 960: 1a c0 rjmp .+52 ; 0x996 <get_cluster+0xf0> |
| 962: f9 01 movw r30, r18 |
| 964: ff 70 andi r31, 0x0F ; 15 |
| 966: 17 c0 rjmp .+46 ; 0x996 <get_cluster+0xf0> |
| |
| case FS_FAT16 : |
| if (!move_window(fatsect + clust / 256)) break; |
| 968: 61 2f mov r22, r17 |
| 96a: 77 27 eor r23, r23 |
| 96c: 80 e0 ldi r24, 0x00 ; 0 |
| 96e: 90 e0 ldi r25, 0x00 ; 0 |
| 970: 6a 0d add r22, r10 |
| 972: 7b 1d adc r23, r11 |
| 974: 8c 1d adc r24, r12 |
| 976: 9d 1d adc r25, r13 |
| 978: 0e 94 5a 03 call 0x6b4 ; 0x6b4 <move_window> |
| 97c: 88 23 and r24, r24 |
| 97e: 49 f0 breq .+18 ; 0x992 <get_cluster+0xec> |
| return LD_WORD(&fs->win[((WORD)clust * 2) % 512]); |
| 980: 00 0f add r16, r16 |
| 982: 11 1f adc r17, r17 |
| 984: 11 70 andi r17, 0x01 ; 1 |
| 986: e0 0e add r14, r16 |
| 988: f1 1e adc r15, r17 |
| 98a: e7 01 movw r28, r14 |
| 98c: e8 a1 ldd r30, Y+32 ; 0x20 |
| 98e: f9 a1 ldd r31, Y+33 ; 0x21 |
| 990: 02 c0 rjmp .+4 ; 0x996 <get_cluster+0xf0> |
| 992: e1 e0 ldi r30, 0x01 ; 1 |
| 994: f0 e0 ldi r31, 0x00 ; 0 |
| #endif |
| } |
| } |
| |
| return 1; /* There is no cluster information, or an error occured */ |
| } |
| 996: cf 01 movw r24, r30 |
| 998: cd b7 in r28, 0x3d ; 61 |
| 99a: de b7 in r29, 0x3e ; 62 |
| 99c: eb e0 ldi r30, 0x0B ; 11 |
| 99e: 0c 94 ea 14 jmp 0x29d4 ; 0x29d4 <__epilogue_restores__+0xe> |
| |
| 000009a2 <create_chain>: |
| #if !_FS_READONLY |
| static |
| CLUST create_chain ( /* 0: no free cluster, 1: error, >=2: new cluster number */ |
| CLUST clust /* Cluster# to stretch, 0 means create new */ |
| ) |
| { |
| 9a2: a0 e0 ldi r26, 0x00 ; 0 |
| 9a4: b0 e0 ldi r27, 0x00 ; 0 |
| 9a6: e7 ed ldi r30, 0xD7 ; 215 |
| 9a8: f4 e0 ldi r31, 0x04 ; 4 |
| 9aa: 0c 94 cf 14 jmp 0x299e ; 0x299e <__prologue_saves__+0x10> |
| 9ae: 7c 01 movw r14, r24 |
| CLUST cstat, ncl, scl, mcl; |
| FATFS *fs = FatFs; |
| 9b0: c0 90 10 01 lds r12, 0x0110 |
| 9b4: d0 90 11 01 lds r13, 0x0111 |
| |
| |
| mcl = fs->max_clust; |
| 9b8: f6 01 movw r30, r12 |
| 9ba: a6 88 ldd r10, Z+22 ; 0x16 |
| 9bc: b7 88 ldd r11, Z+23 ; 0x17 |
| if (clust == 0) { /* Create new chain */ |
| 9be: 00 97 sbiw r24, 0x00 ; 0 |
| 9c0: 49 f4 brne .+18 ; 0x9d4 <create_chain+0x32> |
| scl = fs->last_clust; /* Get last allocated cluster */ |
| 9c2: 00 8d ldd r16, Z+24 ; 0x18 |
| 9c4: 11 8d ldd r17, Z+25 ; 0x19 |
| if (scl < 2 || scl >= mcl) scl = 1; |
| 9c6: 02 30 cpi r16, 0x02 ; 2 |
| 9c8: 11 05 cpc r17, r1 |
| 9ca: 88 f0 brcs .+34 ; 0x9ee <create_chain+0x4c> |
| 9cc: 0a 15 cp r16, r10 |
| 9ce: 1b 05 cpc r17, r11 |
| 9d0: 70 f4 brcc .+28 ; 0x9ee <create_chain+0x4c> |
| 9d2: 0f c0 rjmp .+30 ; 0x9f2 <create_chain+0x50> |
| } |
| else { /* Stretch existing chain */ |
| cstat = get_cluster(clust); /* Check the cluster status */ |
| 9d4: 0e 94 53 04 call 0x8a6 ; 0x8a6 <get_cluster> |
| 9d8: 9c 01 movw r18, r24 |
| if (cstat < 2) return 1; /* It is an invalid cluster */ |
| 9da: 82 30 cpi r24, 0x02 ; 2 |
| 9dc: 91 05 cpc r25, r1 |
| 9de: 08 f4 brcc .+2 ; 0x9e2 <create_chain+0x40> |
| 9e0: 40 c0 rjmp .+128 ; 0xa62 <create_chain+0xc0> |
| if (cstat < mcl) return cstat; /* It is already followed by next cluster */ |
| 9e2: 8a 15 cp r24, r10 |
| 9e4: 9b 05 cpc r25, r11 |
| 9e6: 08 f4 brcc .+2 ; 0x9ea <create_chain+0x48> |
| 9e8: 41 c0 rjmp .+130 ; 0xa6c <create_chain+0xca> |
| 9ea: 87 01 movw r16, r14 |
| 9ec: 02 c0 rjmp .+4 ; 0x9f2 <create_chain+0x50> |
| 9ee: 01 e0 ldi r16, 0x01 ; 1 |
| 9f0: 10 e0 ldi r17, 0x00 ; 0 |
| 9f2: e8 01 movw r28, r16 |
| scl = clust; |
| } |
| |
| ncl = scl; /* Start cluster */ |
| for (;;) { |
| ncl++; /* Next cluster */ |
| 9f4: 21 96 adiw r28, 0x01 ; 1 |
| if (ncl >= mcl) { /* Wrap around */ |
| 9f6: ca 15 cp r28, r10 |
| 9f8: db 05 cpc r29, r11 |
| 9fa: 28 f0 brcs .+10 ; 0xa06 <create_chain+0x64> |
| ncl = 2; |
| if (ncl > scl) return 0; /* No free custer */ |
| 9fc: 02 30 cpi r16, 0x02 ; 2 |
| 9fe: 11 05 cpc r17, r1 |
| a00: 98 f1 brcs .+102 ; 0xa68 <create_chain+0xc6> |
| a02: c2 e0 ldi r28, 0x02 ; 2 |
| a04: d0 e0 ldi r29, 0x00 ; 0 |
| } |
| cstat = get_cluster(ncl); /* Get the cluster status */ |
| a06: ce 01 movw r24, r28 |
| a08: 0e 94 53 04 call 0x8a6 ; 0x8a6 <get_cluster> |
| a0c: 9c 01 movw r18, r24 |
| if (cstat == 0) break; /* Found a free cluster */ |
| a0e: 00 97 sbiw r24, 0x00 ; 0 |
| a10: 39 f0 breq .+14 ; 0xa20 <create_chain+0x7e> |
| if (cstat == 1) return 1; /* Any error occured */ |
| a12: 81 30 cpi r24, 0x01 ; 1 |
| a14: 91 05 cpc r25, r1 |
| a16: 51 f1 breq .+84 ; 0xa6c <create_chain+0xca> |
| if (ncl == scl) return 0; /* No free custer */ |
| a18: c0 17 cp r28, r16 |
| a1a: d1 07 cpc r29, r17 |
| a1c: 59 f7 brne .-42 ; 0x9f4 <create_chain+0x52> |
| a1e: 24 c0 rjmp .+72 ; 0xa68 <create_chain+0xc6> |
| a20: 1c 2f mov r17, r28 |
| a22: 0d 2f mov r16, r29 |
| } |
| |
| if (!put_cluster(ncl, (CLUST)0x0FFFFFFF)) return 1; /* Mark the new cluster "in use" */ |
| a24: 6f ef ldi r22, 0xFF ; 255 |
| a26: 7f ef ldi r23, 0xFF ; 255 |
| a28: ce 01 movw r24, r28 |
| a2a: 0e 94 c4 03 call 0x788 ; 0x788 <put_cluster> |
| a2e: 88 23 and r24, r24 |
| a30: c1 f0 breq .+48 ; 0xa62 <create_chain+0xc0> |
| if (clust && !put_cluster(clust, ncl)) return 1; /* Link it to previous one if needed */ |
| a32: e1 14 cp r14, r1 |
| a34: f1 04 cpc r15, r1 |
| a36: 31 f0 breq .+12 ; 0xa44 <create_chain+0xa2> |
| a38: be 01 movw r22, r28 |
| a3a: c7 01 movw r24, r14 |
| a3c: 0e 94 c4 03 call 0x788 ; 0x788 <put_cluster> |
| a40: 88 23 and r24, r24 |
| a42: 79 f0 breq .+30 ; 0xa62 <create_chain+0xc0> |
| |
| fs->last_clust = ncl; /* Update fsinfo */ |
| a44: f6 01 movw r30, r12 |
| a46: 10 8f std Z+24, r17 ; 0x18 |
| a48: 01 8f std Z+25, r16 ; 0x19 |
| if (fs->free_clust != (CLUST)0xFFFFFFFF) { |
| a4a: 82 8d ldd r24, Z+26 ; 0x1a |
| a4c: 93 8d ldd r25, Z+27 ; 0x1b |
| a4e: ff ef ldi r31, 0xFF ; 255 |
| a50: 8f 3f cpi r24, 0xFF ; 255 |
| a52: 9f 07 cpc r25, r31 |
| a54: 21 f0 breq .+8 ; 0xa5e <create_chain+0xbc> |
| fs->free_clust--; |
| a56: 01 97 sbiw r24, 0x01 ; 1 |
| a58: f6 01 movw r30, r12 |
| a5a: 93 8f std Z+27, r25 ; 0x1b |
| a5c: 82 8f std Z+26, r24 ; 0x1a |
| a5e: 9e 01 movw r18, r28 |
| a60: 05 c0 rjmp .+10 ; 0xa6c <create_chain+0xca> |
| a62: 21 e0 ldi r18, 0x01 ; 1 |
| a64: 30 e0 ldi r19, 0x00 ; 0 |
| a66: 02 c0 rjmp .+4 ; 0xa6c <create_chain+0xca> |
| a68: 20 e0 ldi r18, 0x00 ; 0 |
| a6a: 30 e0 ldi r19, 0x00 ; 0 |
| fs->fsi_flag = 1; |
| #endif |
| } |
| |
| return ncl; /* Return new cluster number */ |
| } |
| a6c: c9 01 movw r24, r18 |
| a6e: cd b7 in r28, 0x3d ; 61 |
| a70: de b7 in r29, 0x3e ; 62 |
| a72: ea e0 ldi r30, 0x0A ; 10 |
| a74: 0c 94 eb 14 jmp 0x29d6 ; 0x29d6 <__epilogue_restores__+0x10> |
| |
| 00000a78 <f_lseek>: |
| |
| FRESULT f_lseek ( |
| FIL *fp, /* Pointer to the file object */ |
| DWORD ofs /* File pointer from top of file */ |
| ) |
| { |
| a78: a0 e0 ldi r26, 0x00 ; 0 |
| a7a: b0 e0 ldi r27, 0x00 ; 0 |
| a7c: e2 e4 ldi r30, 0x42 ; 66 |
| a7e: f5 e0 ldi r31, 0x05 ; 5 |
| a80: 0c 94 cb 14 jmp 0x2996 ; 0x2996 <__prologue_saves__+0x8> |
| a84: ec 01 movw r28, r24 |
| a86: 7a 01 movw r14, r20 |
| a88: 8b 01 movw r16, r22 |
| CLUST clust; |
| DWORD csize; |
| BYTE csect; |
| FRESULT res; |
| FATFS *fs = fp->fs; |
| a8a: 6c 80 ldd r6, Y+4 ; 0x04 |
| a8c: 7d 80 ldd r7, Y+5 ; 0x05 |
| |
| |
| res = validate(fs, fp->id); /* Check validity of the object */ |
| a8e: 68 81 ld r22, Y |
| a90: 79 81 ldd r23, Y+1 ; 0x01 |
| a92: c3 01 movw r24, r6 |
| a94: 0e 94 46 03 call 0x68c ; 0x68c <validate> |
| a98: 4c 01 movw r8, r24 |
| if (res) return res; |
| a9a: 00 97 sbiw r24, 0x00 ; 0 |
| a9c: 09 f0 breq .+2 ; 0xaa0 <f_lseek+0x28> |
| a9e: d6 c0 rjmp .+428 ; 0xc4c <f_lseek+0x1d4> |
| |
| if (fp->flag & FA__ERROR) return FR_RW_ERROR; |
| aa0: 8a 81 ldd r24, Y+2 ; 0x02 |
| aa2: 87 fd sbrc r24, 7 |
| aa4: d0 c0 rjmp .+416 ; 0xc46 <f_lseek+0x1ce> |
| #if !_FS_READONLY |
| if (ofs > fp->fsize && !(fp->flag & FA_WRITE)) |
| aa6: aa 84 ldd r10, Y+10 ; 0x0a |
| aa8: bb 84 ldd r11, Y+11 ; 0x0b |
| aaa: cc 84 ldd r12, Y+12 ; 0x0c |
| aac: dd 84 ldd r13, Y+13 ; 0x0d |
| aae: ae 14 cp r10, r14 |
| ab0: bf 04 cpc r11, r15 |
| ab2: c0 06 cpc r12, r16 |
| ab4: d1 06 cpc r13, r17 |
| ab6: 10 f4 brcc .+4 ; 0xabc <f_lseek+0x44> |
| ab8: 81 ff sbrs r24, 1 |
| aba: 02 c0 rjmp .+4 ; 0xac0 <f_lseek+0x48> |
| abc: 57 01 movw r10, r14 |
| abe: 68 01 movw r12, r16 |
| #else |
| if (ofs > fp->fsize) |
| #endif |
| ofs = fp->fsize; |
| fp->fptr = 0; fp->sect_clust = 1; /* Set file R/W pointer to top of the file */ |
| ac0: 1e 82 std Y+6, r1 ; 0x06 |
| ac2: 1f 82 std Y+7, r1 ; 0x07 |
| ac4: 18 86 std Y+8, r1 ; 0x08 |
| ac6: 19 86 std Y+9, r1 ; 0x09 |
| ac8: 81 e0 ldi r24, 0x01 ; 1 |
| aca: 8b 83 std Y+3, r24 ; 0x03 |
| |
| /* Move file R/W pointer if needed */ |
| if (ofs) { |
| acc: a1 14 cp r10, r1 |
| ace: b1 04 cpc r11, r1 |
| ad0: c1 04 cpc r12, r1 |
| ad2: d1 04 cpc r13, r1 |
| ad4: 09 f4 brne .+2 ; 0xad8 <f_lseek+0x60> |
| ad6: 9d c0 rjmp .+314 ; 0xc12 <f_lseek+0x19a> |
| clust = fp->org_clust; /* Get start cluster */ |
| ad8: 6e 85 ldd r22, Y+14 ; 0x0e |
| ada: 7f 85 ldd r23, Y+15 ; 0x0f |
| #if !_FS_READONLY |
| if (!clust) { /* If the file does not have a cluster chain, create new cluster chain */ |
| adc: 61 15 cp r22, r1 |
| ade: 71 05 cpc r23, r1 |
| ae0: 71 f4 brne .+28 ; 0xafe <f_lseek+0x86> |
| clust = create_chain(0); |
| ae2: 80 e0 ldi r24, 0x00 ; 0 |
| ae4: 90 e0 ldi r25, 0x00 ; 0 |
| ae6: 0e 94 d1 04 call 0x9a2 ; 0x9a2 <create_chain> |
| aea: bc 01 movw r22, r24 |
| if (clust == 1) goto fk_error; |
| aec: 81 30 cpi r24, 0x01 ; 1 |
| aee: 91 05 cpc r25, r1 |
| af0: 09 f4 brne .+2 ; 0xaf4 <f_lseek+0x7c> |
| af2: a6 c0 rjmp .+332 ; 0xc40 <f_lseek+0x1c8> |
| fp->org_clust = clust; |
| af4: 9f 87 std Y+15, r25 ; 0x0f |
| af6: 8e 87 std Y+14, r24 ; 0x0e |
| } |
| #endif |
| if (clust) { /* If the file has a cluster chain, it can be followed */ |
| af8: 00 97 sbiw r24, 0x00 ; 0 |
| afa: 09 f4 brne .+2 ; 0xafe <f_lseek+0x86> |
| afc: 8a c0 rjmp .+276 ; 0xc12 <f_lseek+0x19a> |
| csize = (DWORD)fs->sects_clust * 512; /* Cluster size in unit of byte */ |
| afe: f3 01 movw r30, r6 |
| b00: 85 8d ldd r24, Z+29 ; 0x1d |
| b02: e8 2e mov r14, r24 |
| b04: ff 24 eor r15, r15 |
| b06: 00 e0 ldi r16, 0x00 ; 0 |
| b08: 10 e0 ldi r17, 0x00 ; 0 |
| b0a: f9 e0 ldi r31, 0x09 ; 9 |
| b0c: ee 0c add r14, r14 |
| b0e: ff 1c adc r15, r15 |
| b10: 00 1f adc r16, r16 |
| b12: 11 1f adc r17, r17 |
| b14: fa 95 dec r31 |
| b16: d1 f7 brne .-12 ; 0xb0c <f_lseek+0x94> |
| for (;;) { /* Loop to skip leading clusters */ |
| fp->curr_clust = clust; /* Update current cluster */ |
| b18: 79 8b std Y+17, r23 ; 0x11 |
| b1a: 68 8b std Y+16, r22 ; 0x10 |
| if (ofs <= csize) break; |
| b1c: ea 14 cp r14, r10 |
| b1e: fb 04 cpc r15, r11 |
| b20: 0c 05 cpc r16, r12 |
| b22: 1d 05 cpc r17, r13 |
| b24: 58 f5 brcc .+86 ; 0xb7c <f_lseek+0x104> |
| #if !_FS_READONLY |
| if (fp->flag & FA_WRITE) /* Check if in write mode or not */ |
| b26: 8a 81 ldd r24, Y+2 ; 0x02 |
| b28: 81 ff sbrs r24, 1 |
| b2a: 04 c0 rjmp .+8 ; 0xb34 <f_lseek+0xbc> |
| clust = create_chain(clust); /* Force streached if in write mode */ |
| b2c: cb 01 movw r24, r22 |
| b2e: 0e 94 d1 04 call 0x9a2 ; 0x9a2 <create_chain> |
| b32: 03 c0 rjmp .+6 ; 0xb3a <f_lseek+0xc2> |
| else |
| #endif |
| clust = get_cluster(clust); /* Only follow cluster chain if not in write mode */ |
| b34: cb 01 movw r24, r22 |
| b36: 0e 94 53 04 call 0x8a6 ; 0x8a6 <get_cluster> |
| b3a: bc 01 movw r22, r24 |
| if (clust == 0) { /* Stop if could not follow the cluster chain */ |
| b3c: 00 97 sbiw r24, 0x00 ; 0 |
| b3e: e1 f0 breq .+56 ; 0xb78 <f_lseek+0x100> |
| ofs = csize; break; |
| } |
| if (clust == 1 || clust >= fs->max_clust) goto fk_error; |
| b40: 81 30 cpi r24, 0x01 ; 1 |
| b42: 91 05 cpc r25, r1 |
| b44: 09 f4 brne .+2 ; 0xb48 <f_lseek+0xd0> |
| b46: 7c c0 rjmp .+248 ; 0xc40 <f_lseek+0x1c8> |
| b48: f3 01 movw r30, r6 |
| b4a: 86 89 ldd r24, Z+22 ; 0x16 |
| b4c: 97 89 ldd r25, Z+23 ; 0x17 |
| b4e: 68 17 cp r22, r24 |
| b50: 79 07 cpc r23, r25 |
| b52: 08 f0 brcs .+2 ; 0xb56 <f_lseek+0xde> |
| b54: 75 c0 rjmp .+234 ; 0xc40 <f_lseek+0x1c8> |
| fp->fptr += csize; /* Update R/W pointer */ |
| b56: 8e 81 ldd r24, Y+6 ; 0x06 |
| b58: 9f 81 ldd r25, Y+7 ; 0x07 |
| b5a: a8 85 ldd r26, Y+8 ; 0x08 |
| b5c: b9 85 ldd r27, Y+9 ; 0x09 |
| b5e: 8e 0d add r24, r14 |
| b60: 9f 1d adc r25, r15 |
| b62: a0 1f adc r26, r16 |
| b64: b1 1f adc r27, r17 |
| b66: 8e 83 std Y+6, r24 ; 0x06 |
| b68: 9f 83 std Y+7, r25 ; 0x07 |
| b6a: a8 87 std Y+8, r26 ; 0x08 |
| b6c: b9 87 std Y+9, r27 ; 0x09 |
| ofs -= csize; |
| b6e: ae 18 sub r10, r14 |
| b70: bf 08 sbc r11, r15 |
| b72: c0 0a sbc r12, r16 |
| b74: d1 0a sbc r13, r17 |
| b76: d0 cf rjmp .-96 ; 0xb18 <f_lseek+0xa0> |
| } |
| b78: 57 01 movw r10, r14 |
| b7a: 68 01 movw r12, r16 |
| csect = (BYTE)((ofs - 1) / 512); /* Sector offset in the cluster */ |
| b7c: d6 01 movw r26, r12 |
| b7e: c5 01 movw r24, r10 |
| b80: 01 97 sbiw r24, 0x01 ; 1 |
| b82: a1 09 sbc r26, r1 |
| b84: b1 09 sbc r27, r1 |
| b86: e9 e0 ldi r30, 0x09 ; 9 |
| b88: b6 95 lsr r27 |
| b8a: a7 95 ror r26 |
| b8c: 97 95 ror r25 |
| b8e: 87 95 ror r24 |
| b90: ea 95 dec r30 |
| b92: d1 f7 brne .-12 ; 0xb88 <f_lseek+0x110> |
| b94: f8 2e mov r15, r24 |
| static |
| DWORD clust2sect ( /* !=0: sector number, 0: failed - invalid cluster# */ |
| CLUST clust /* Cluster# to be converted */ |
| ) |
| { |
| FATFS *fs = FatFs; |
| b96: 00 91 10 01 lds r16, 0x0110 |
| b9a: 10 91 11 01 lds r17, 0x0111 |
| |
| |
| clust -= 2; |
| b9e: 62 50 subi r22, 0x02 ; 2 |
| ba0: 70 40 sbci r23, 0x00 ; 0 |
| if (clust >= (fs->max_clust - 2)) return 0; /* Invalid cluster# */ |
| ba2: f8 01 movw r30, r16 |
| ba4: 86 89 ldd r24, Z+22 ; 0x16 |
| ba6: 97 89 ldd r25, Z+23 ; 0x17 |
| ba8: 02 97 sbiw r24, 0x02 ; 2 |
| baa: 68 17 cp r22, r24 |
| bac: 79 07 cpc r23, r25 |
| bae: 28 f0 brcs .+10 ; 0xbba <f_lseek+0x142> |
| bb0: 20 e0 ldi r18, 0x00 ; 0 |
| bb2: 30 e0 ldi r19, 0x00 ; 0 |
| bb4: 40 e0 ldi r20, 0x00 ; 0 |
| bb6: 50 e0 ldi r21, 0x00 ; 0 |
| bb8: 14 c0 rjmp .+40 ; 0xbe2 <f_lseek+0x16a> |
| return (DWORD)clust * fs->sects_clust + fs->database; |
| bba: 80 e0 ldi r24, 0x00 ; 0 |
| bbc: 90 e0 ldi r25, 0x00 ; 0 |
| bbe: f8 01 movw r30, r16 |
| bc0: 25 8d ldd r18, Z+29 ; 0x1d |
| bc2: 30 e0 ldi r19, 0x00 ; 0 |
| bc4: 40 e0 ldi r20, 0x00 ; 0 |
| bc6: 50 e0 ldi r21, 0x00 ; 0 |
| bc8: 0e 94 86 14 call 0x290c ; 0x290c <__mulsi3> |
| bcc: 9b 01 movw r18, r22 |
| bce: ac 01 movw r20, r24 |
| bd0: f8 01 movw r30, r16 |
| bd2: 80 89 ldd r24, Z+16 ; 0x10 |
| bd4: 91 89 ldd r25, Z+17 ; 0x11 |
| bd6: a2 89 ldd r26, Z+18 ; 0x12 |
| bd8: b3 89 ldd r27, Z+19 ; 0x13 |
| bda: 28 0f add r18, r24 |
| bdc: 39 1f adc r19, r25 |
| bde: 4a 1f adc r20, r26 |
| be0: 5b 1f adc r21, r27 |
| if (clust == 1 || clust >= fs->max_clust) goto fk_error; |
| fp->fptr += csize; /* Update R/W pointer */ |
| ofs -= csize; |
| } |
| csect = (BYTE)((ofs - 1) / 512); /* Sector offset in the cluster */ |
| fp->curr_sect = clust2sect(clust) + csect; /* Current sector */ |
| be2: 2f 0d add r18, r15 |
| be4: 31 1d adc r19, r1 |
| be6: 41 1d adc r20, r1 |
| be8: 51 1d adc r21, r1 |
| bea: 2a 8b std Y+18, r18 ; 0x12 |
| bec: 3b 8b std Y+19, r19 ; 0x13 |
| bee: 4c 8b std Y+20, r20 ; 0x14 |
| bf0: 5d 8b std Y+21, r21 ; 0x15 |
| fp->sect_clust = fs->sects_clust - csect; /* Left sector counter in the cluster */ |
| bf2: f3 01 movw r30, r6 |
| bf4: 85 8d ldd r24, Z+29 ; 0x1d |
| bf6: 8f 19 sub r24, r15 |
| bf8: 8b 83 std Y+3, r24 ; 0x03 |
| fp->fptr += ofs; /* Update file R/W pointer */ |
| bfa: 8e 81 ldd r24, Y+6 ; 0x06 |
| bfc: 9f 81 ldd r25, Y+7 ; 0x07 |
| bfe: a8 85 ldd r26, Y+8 ; 0x08 |
| c00: b9 85 ldd r27, Y+9 ; 0x09 |
| c02: 8a 0d add r24, r10 |
| c04: 9b 1d adc r25, r11 |
| c06: ac 1d adc r26, r12 |
| c08: bd 1d adc r27, r13 |
| c0a: 8e 83 std Y+6, r24 ; 0x06 |
| c0c: 9f 83 std Y+7, r25 ; 0x07 |
| c0e: a8 87 std Y+8, r26 ; 0x08 |
| c10: b9 87 std Y+9, r27 ; 0x09 |
| } |
| } |
| #if !_FS_READONLY |
| if ((fp->flag & FA_WRITE) && fp->fptr > fp->fsize) { /* Set updated flag if in write mode */ |
| c12: 6a 81 ldd r22, Y+2 ; 0x02 |
| c14: 61 ff sbrs r22, 1 |
| c16: 1a c0 rjmp .+52 ; 0xc4c <f_lseek+0x1d4> |
| c18: 2e 81 ldd r18, Y+6 ; 0x06 |
| c1a: 3f 81 ldd r19, Y+7 ; 0x07 |
| c1c: 48 85 ldd r20, Y+8 ; 0x08 |
| c1e: 59 85 ldd r21, Y+9 ; 0x09 |
| c20: 8a 85 ldd r24, Y+10 ; 0x0a |
| c22: 9b 85 ldd r25, Y+11 ; 0x0b |
| c24: ac 85 ldd r26, Y+12 ; 0x0c |
| c26: bd 85 ldd r27, Y+13 ; 0x0d |
| c28: 82 17 cp r24, r18 |
| c2a: 93 07 cpc r25, r19 |
| c2c: a4 07 cpc r26, r20 |
| c2e: b5 07 cpc r27, r21 |
| c30: 68 f4 brcc .+26 ; 0xc4c <f_lseek+0x1d4> |
| fp->fsize = fp->fptr; |
| c32: 2a 87 std Y+10, r18 ; 0x0a |
| c34: 3b 87 std Y+11, r19 ; 0x0b |
| c36: 4c 87 std Y+12, r20 ; 0x0c |
| c38: 5d 87 std Y+13, r21 ; 0x0d |
| fp->flag |= FA__WRITTEN; |
| c3a: 60 62 ori r22, 0x20 ; 32 |
| c3c: 6a 83 std Y+2, r22 ; 0x02 |
| c3e: 06 c0 rjmp .+12 ; 0xc4c <f_lseek+0x1d4> |
| #endif |
| |
| return FR_OK; |
| |
| fk_error: /* Abort this function due to an unrecoverable error */ |
| fp->flag |= FA__ERROR; |
| c40: 8a 81 ldd r24, Y+2 ; 0x02 |
| c42: 80 68 ori r24, 0x80 ; 128 |
| c44: 8a 83 std Y+2, r24 ; 0x02 |
| c46: 68 e0 ldi r22, 0x08 ; 8 |
| c48: 86 2e mov r8, r22 |
| c4a: 91 2c mov r9, r1 |
| return FR_RW_ERROR; |
| } |
| c4c: c4 01 movw r24, r8 |
| c4e: cd b7 in r28, 0x3d ; 61 |
| c50: de b7 in r29, 0x3e ; 62 |
| c52: ee e0 ldi r30, 0x0E ; 14 |
| c54: 0c 94 e7 14 jmp 0x29ce ; 0x29ce <__epilogue_restores__+0x8> |
| |
| 00000c58 <next_dir_entry>: |
| |
| static |
| BOOL next_dir_entry ( /* TRUE: successful, FALSE: could not move next */ |
| DIR *dirobj /* Pointer to directory object */ |
| ) |
| { |
| c58: ef 92 push r14 |
| c5a: ff 92 push r15 |
| c5c: 0f 93 push r16 |
| c5e: 1f 93 push r17 |
| c60: cf 93 push r28 |
| c62: df 93 push r29 |
| c64: 8c 01 movw r16, r24 |
| CLUST clust; |
| WORD idx; |
| FATFS *fs = FatFs; |
| c66: c0 91 10 01 lds r28, 0x0110 |
| c6a: d0 91 11 01 lds r29, 0x0111 |
| |
| |
| idx = dirobj->index + 1; |
| c6e: fc 01 movw r30, r24 |
| c70: e2 80 ldd r14, Z+2 ; 0x02 |
| c72: f3 80 ldd r15, Z+3 ; 0x03 |
| c74: 08 94 sec |
| c76: e1 1c adc r14, r1 |
| c78: f1 1c adc r15, r1 |
| if ((idx & 15) == 0) { /* Table sector changed? */ |
| c7a: c7 01 movw r24, r14 |
| c7c: 8f 70 andi r24, 0x0F ; 15 |
| c7e: 90 70 andi r25, 0x00 ; 0 |
| c80: 89 2b or r24, r25 |
| c82: 09 f0 breq .+2 ; 0xc86 <next_dir_entry+0x2e> |
| c84: 5b c0 rjmp .+182 ; 0xd3c <next_dir_entry+0xe4> |
| dirobj->sect++; /* Next sector */ |
| c86: 82 85 ldd r24, Z+10 ; 0x0a |
| c88: 93 85 ldd r25, Z+11 ; 0x0b |
| c8a: a4 85 ldd r26, Z+12 ; 0x0c |
| c8c: b5 85 ldd r27, Z+13 ; 0x0d |
| c8e: 01 96 adiw r24, 0x01 ; 1 |
| c90: a1 1d adc r26, r1 |
| c92: b1 1d adc r27, r1 |
| c94: 82 87 std Z+10, r24 ; 0x0a |
| c96: 93 87 std Z+11, r25 ; 0x0b |
| c98: a4 87 std Z+12, r26 ; 0x0c |
| c9a: b5 87 std Z+13, r27 ; 0x0d |
| if (!dirobj->clust) { /* In static table */ |
| c9c: 40 85 ldd r20, Z+8 ; 0x08 |
| c9e: 51 85 ldd r21, Z+9 ; 0x09 |
| ca0: 41 15 cp r20, r1 |
| ca2: 51 05 cpc r21, r1 |
| ca4: 39 f4 brne .+14 ; 0xcb4 <next_dir_entry+0x5c> |
| if (idx >= fs->n_rootdir) return FALSE; /* Reached to end of table */ |
| ca6: 8a 81 ldd r24, Y+2 ; 0x02 |
| ca8: 9b 81 ldd r25, Y+3 ; 0x03 |
| caa: e8 16 cp r14, r24 |
| cac: f9 06 cpc r15, r25 |
| cae: 08 f4 brcc .+2 ; 0xcb2 <next_dir_entry+0x5a> |
| cb0: 45 c0 rjmp .+138 ; 0xd3c <next_dir_entry+0xe4> |
| cb2: 49 c0 rjmp .+146 ; 0xd46 <next_dir_entry+0xee> |
| } else { /* In dynamic table */ |
| if (((idx / 16) & (fs->sects_clust - 1)) == 0) { /* Cluster changed? */ |
| cb4: 8d 8d ldd r24, Y+29 ; 0x1d |
| cb6: 90 e0 ldi r25, 0x00 ; 0 |
| cb8: 01 97 sbiw r24, 0x01 ; 1 |
| cba: 97 01 movw r18, r14 |
| cbc: a4 e0 ldi r26, 0x04 ; 4 |
| cbe: 36 95 lsr r19 |
| cc0: 27 95 ror r18 |
| cc2: aa 95 dec r26 |
| cc4: e1 f7 brne .-8 ; 0xcbe <next_dir_entry+0x66> |
| cc6: 82 23 and r24, r18 |
| cc8: 93 23 and r25, r19 |
| cca: 89 2b or r24, r25 |
| ccc: b9 f5 brne .+110 ; 0xd3c <next_dir_entry+0xe4> |
| clust = get_cluster(dirobj->clust); /* Get next cluster */ |
| cce: ca 01 movw r24, r20 |
| cd0: 0e 94 53 04 call 0x8a6 ; 0x8a6 <get_cluster> |
| cd4: bc 01 movw r22, r24 |
| if (clust < 2 || clust >= fs->max_clust) /* Reached to end of table */ |
| cd6: 82 30 cpi r24, 0x02 ; 2 |
| cd8: 91 05 cpc r25, r1 |
| cda: a8 f1 brcs .+106 ; 0xd46 <next_dir_entry+0xee> |
| cdc: 8e 89 ldd r24, Y+22 ; 0x16 |
| cde: 9f 89 ldd r25, Y+23 ; 0x17 |
| ce0: 68 17 cp r22, r24 |
| ce2: 79 07 cpc r23, r25 |
| ce4: 80 f5 brcc .+96 ; 0xd46 <next_dir_entry+0xee> |
| return FALSE; |
| dirobj->clust = clust; /* Initialize for new cluster */ |
| ce6: f8 01 movw r30, r16 |
| ce8: 71 87 std Z+9, r23 ; 0x09 |
| cea: 60 87 std Z+8, r22 ; 0x08 |
| static |
| DWORD clust2sect ( /* !=0: sector number, 0: failed - invalid cluster# */ |
| CLUST clust /* Cluster# to be converted */ |
| ) |
| { |
| FATFS *fs = FatFs; |
| cec: c0 91 10 01 lds r28, 0x0110 |
| cf0: d0 91 11 01 lds r29, 0x0111 |
| |
| |
| clust -= 2; |
| cf4: 62 50 subi r22, 0x02 ; 2 |
| cf6: 70 40 sbci r23, 0x00 ; 0 |
| if (clust >= (fs->max_clust - 2)) return 0; /* Invalid cluster# */ |
| cf8: 8e 89 ldd r24, Y+22 ; 0x16 |
| cfa: 9f 89 ldd r25, Y+23 ; 0x17 |
| cfc: 02 97 sbiw r24, 0x02 ; 2 |
| cfe: 68 17 cp r22, r24 |
| d00: 79 07 cpc r23, r25 |
| d02: 28 f0 brcs .+10 ; 0xd0e <next_dir_entry+0xb6> |
| d04: 20 e0 ldi r18, 0x00 ; 0 |
| d06: 30 e0 ldi r19, 0x00 ; 0 |
| d08: 40 e0 ldi r20, 0x00 ; 0 |
| d0a: 50 e0 ldi r21, 0x00 ; 0 |
| d0c: 12 c0 rjmp .+36 ; 0xd32 <next_dir_entry+0xda> |
| return (DWORD)clust * fs->sects_clust + fs->database; |
| d0e: 80 e0 ldi r24, 0x00 ; 0 |
| d10: 90 e0 ldi r25, 0x00 ; 0 |
| d12: 2d 8d ldd r18, Y+29 ; 0x1d |
| d14: 30 e0 ldi r19, 0x00 ; 0 |
| d16: 40 e0 ldi r20, 0x00 ; 0 |
| d18: 50 e0 ldi r21, 0x00 ; 0 |
| d1a: 0e 94 86 14 call 0x290c ; 0x290c <__mulsi3> |
| d1e: 9b 01 movw r18, r22 |
| d20: ac 01 movw r20, r24 |
| d22: 88 89 ldd r24, Y+16 ; 0x10 |
| d24: 99 89 ldd r25, Y+17 ; 0x11 |
| d26: aa 89 ldd r26, Y+18 ; 0x12 |
| d28: bb 89 ldd r27, Y+19 ; 0x13 |
| d2a: 28 0f add r18, r24 |
| d2c: 39 1f adc r19, r25 |
| d2e: 4a 1f adc r20, r26 |
| d30: 5b 1f adc r21, r27 |
| if (((idx / 16) & (fs->sects_clust - 1)) == 0) { /* Cluster changed? */ |
| clust = get_cluster(dirobj->clust); /* Get next cluster */ |
| if (clust < 2 || clust >= fs->max_clust) /* Reached to end of table */ |
| return FALSE; |
| dirobj->clust = clust; /* Initialize for new cluster */ |
| dirobj->sect = clust2sect(clust); |
| d32: f8 01 movw r30, r16 |
| d34: 22 87 std Z+10, r18 ; 0x0a |
| d36: 33 87 std Z+11, r19 ; 0x0b |
| d38: 44 87 std Z+12, r20 ; 0x0c |
| d3a: 55 87 std Z+13, r21 ; 0x0d |
| } |
| } |
| } |
| dirobj->index = idx; /* Lower 4 bit of dirobj->index indicates offset in dirobj->sect */ |
| d3c: f8 01 movw r30, r16 |
| d3e: f3 82 std Z+3, r15 ; 0x03 |
| d40: e2 82 std Z+2, r14 ; 0x02 |
| d42: 81 e0 ldi r24, 0x01 ; 1 |
| d44: 01 c0 rjmp .+2 ; 0xd48 <next_dir_entry+0xf0> |
| return TRUE; |
| d46: 80 e0 ldi r24, 0x00 ; 0 |
| } |
| d48: cd b7 in r28, 0x3d ; 61 |
| d4a: de b7 in r29, 0x3e ; 62 |
| d4c: e6 e0 ldi r30, 0x06 ; 6 |
| d4e: 0c 94 ef 14 jmp 0x29de ; 0x29de <__epilogue_restores__+0x18> |
| |
| 00000d52 <f_sync>: |
| /*-----------------------------------------------------------------------*/ |
| |
| FRESULT f_sync ( |
| FIL *fp /* Pointer to the file object */ |
| ) |
| { |
| d52: ef 92 push r14 |
| d54: ff 92 push r15 |
| d56: 0f 93 push r16 |
| d58: 1f 93 push r17 |
| d5a: cf 93 push r28 |
| d5c: df 93 push r29 |
| d5e: ec 01 movw r28, r24 |
| BYTE *dir; |
| FRESULT res; |
| FATFS *fs = fp->fs; |
| |
| |
| res = validate(fs, fp->id); /* Check validity of the object */ |
| d60: 68 81 ld r22, Y |
| d62: 79 81 ldd r23, Y+1 ; 0x01 |
| d64: 8c 81 ldd r24, Y+4 ; 0x04 |
| d66: 9d 81 ldd r25, Y+5 ; 0x05 |
| d68: 0e 94 46 03 call 0x68c ; 0x68c <validate> |
| d6c: 7c 01 movw r14, r24 |
| if (res == FR_OK) { |
| d6e: 00 97 sbiw r24, 0x00 ; 0 |
| d70: 09 f0 breq .+2 ; 0xd74 <f_sync+0x22> |
| d72: 40 c0 rjmp .+128 ; 0xdf4 <f_sync+0xa2> |
| if (fp->flag & FA__WRITTEN) { /* Has the file been written? */ |
| d74: 8a 81 ldd r24, Y+2 ; 0x02 |
| d76: 85 ff sbrs r24, 5 |
| d78: 3d c0 rjmp .+122 ; 0xdf4 <f_sync+0xa2> |
| /* Update the directory entry */ |
| if (!move_window(fp->dir_sect)) |
| d7a: 6e 89 ldd r22, Y+22 ; 0x16 |
| d7c: 7f 89 ldd r23, Y+23 ; 0x17 |
| d7e: 88 8d ldd r24, Y+24 ; 0x18 |
| d80: 99 8d ldd r25, Y+25 ; 0x19 |
| d82: 0e 94 5a 03 call 0x6b4 ; 0x6b4 <move_window> |
| d86: 88 23 and r24, r24 |
| d88: 91 f1 breq .+100 ; 0xdee <f_sync+0x9c> |
| return FR_RW_ERROR; |
| dir = fp->dir_ptr; |
| d8a: 0a 8d ldd r16, Y+26 ; 0x1a |
| d8c: 1b 8d ldd r17, Y+27 ; 0x1b |
| dir[DIR_Attr] |= AM_ARC; /* Set archive bit */ |
| d8e: f8 01 movw r30, r16 |
| d90: 83 85 ldd r24, Z+11 ; 0x0b |
| d92: 80 62 ori r24, 0x20 ; 32 |
| d94: 83 87 std Z+11, r24 ; 0x0b |
| ST_DWORD(&dir[DIR_FileSize], fp->fsize); /* Update file size */ |
| d96: 8a 85 ldd r24, Y+10 ; 0x0a |
| d98: 9b 85 ldd r25, Y+11 ; 0x0b |
| d9a: ac 85 ldd r26, Y+12 ; 0x0c |
| d9c: bd 85 ldd r27, Y+13 ; 0x0d |
| d9e: 84 8f std Z+28, r24 ; 0x1c |
| da0: 95 8f std Z+29, r25 ; 0x1d |
| da2: a6 8f std Z+30, r26 ; 0x1e |
| da4: b7 8f std Z+31, r27 ; 0x1f |
| ST_WORD(&dir[DIR_FstClusLO], fp->org_clust); /* Update start cluster */ |
| da6: 8e 85 ldd r24, Y+14 ; 0x0e |
| da8: 9f 85 ldd r25, Y+15 ; 0x0f |
| daa: 93 8f std Z+27, r25 ; 0x1b |
| dac: 82 8f std Z+26, r24 ; 0x1a |
| #if _FAT32 |
| ST_WORD(&dir[DIR_FstClusHI], fp->org_clust >> 16); |
| #endif |
| tim = get_fattime(); /* Updated time */ |
| dae: 0e 94 b0 00 call 0x160 ; 0x160 <get_fattime> |
| ST_DWORD(&dir[DIR_WrtTime], tim); |
| db2: f8 01 movw r30, r16 |
| db4: 66 8b std Z+22, r22 ; 0x16 |
| db6: 77 8b std Z+23, r23 ; 0x17 |
| db8: 80 8f std Z+24, r24 ; 0x18 |
| dba: 91 8f std Z+25, r25 ; 0x19 |
| fp->flag &= ~FA__WRITTEN; |
| dbc: 8a 81 ldd r24, Y+2 ; 0x02 |
| dbe: 8f 7d andi r24, 0xDF ; 223 |
| dc0: 8a 83 std Y+2, r24 ; 0x02 |
| FRESULT sync (void) /* FR_OK: successful, FR_RW_ERROR: failed */ |
| { |
| FATFS *fs = FatFs; |
| |
| |
| fs->winflag = 1; |
| dc2: e0 91 10 01 lds r30, 0x0110 |
| dc6: f0 91 11 01 lds r31, 0x0111 |
| dca: 81 e0 ldi r24, 0x01 ; 1 |
| dcc: 87 8f std Z+31, r24 ; 0x1f |
| if (!move_window(0)) return FR_RW_ERROR; |
| dce: 60 e0 ldi r22, 0x00 ; 0 |
| dd0: 70 e0 ldi r23, 0x00 ; 0 |
| dd2: 80 e0 ldi r24, 0x00 ; 0 |
| dd4: 90 e0 ldi r25, 0x00 ; 0 |
| dd6: 0e 94 5a 03 call 0x6b4 ; 0x6b4 <move_window> |
| dda: 88 23 and r24, r24 |
| ddc: 41 f0 breq .+16 ; 0xdee <f_sync+0x9c> |
| ST_DWORD(&fs->win[FSI_Nxt_Free], fs->last_clust); |
| disk_write(0, fs->win, fs->fsi_sector, 1); |
| fs->fsi_flag = 0; |
| } |
| #endif |
| if (disk_ioctl(0, CTRL_SYNC, NULL) != RES_OK) return FR_RW_ERROR; |
| dde: 40 e0 ldi r20, 0x00 ; 0 |
| de0: 50 e0 ldi r21, 0x00 ; 0 |
| de2: 63 e0 ldi r22, 0x03 ; 3 |
| de4: 80 e0 ldi r24, 0x00 ; 0 |
| de6: 0e 94 77 10 call 0x20ee ; 0x20ee <disk_ioctl> |
| dea: 89 2b or r24, r25 |
| dec: 19 f0 breq .+6 ; 0xdf4 <f_sync+0xa2> |
| dee: b8 e0 ldi r27, 0x08 ; 8 |
| df0: eb 2e mov r14, r27 |
| df2: f1 2c mov r15, r1 |
| fp->flag &= ~FA__WRITTEN; |
| res = sync(); |
| } |
| } |
| return res; |
| } |
| df4: c7 01 movw r24, r14 |
| df6: cd b7 in r28, 0x3d ; 61 |
| df8: de b7 in r29, 0x3e ; 62 |
| dfa: e6 e0 ldi r30, 0x06 ; 6 |
| dfc: 0c 94 ef 14 jmp 0x29de ; 0x29de <__epilogue_restores__+0x18> |
| |
| 00000e00 <f_close>: |
| /*-----------------------------------------------------------------------*/ |
| |
| FRESULT f_close ( |
| FIL *fp /* Pointer to the file object to be closed */ |
| ) |
| { |
| e00: cf 93 push r28 |
| e02: df 93 push r29 |
| e04: ec 01 movw r28, r24 |
| FRESULT res; |
| |
| |
| #if !_FS_READONLY |
| res = f_sync(fp); |
| e06: 0e 94 a9 06 call 0xd52 ; 0xd52 <f_sync> |
| e0a: 9c 01 movw r18, r24 |
| #else |
| res = validate(fp->fs, fp->id); |
| #endif |
| if (res == FR_OK) |
| e0c: 00 97 sbiw r24, 0x00 ; 0 |
| e0e: 11 f4 brne .+4 ; 0xe14 <f_close+0x14> |
| fp->fs = NULL; |
| e10: 1d 82 std Y+5, r1 ; 0x05 |
| e12: 1c 82 std Y+4, r1 ; 0x04 |
| |
| return res; |
| } |
| e14: c9 01 movw r24, r18 |
| e16: df 91 pop r29 |
| e18: cf 91 pop r28 |
| e1a: 08 95 ret |
| |
| 00000e1c <f_write>: |
| FIL *fp, /* Pointer to the file object */ |
| const void *buff, /* Pointer to the data to be written */ |
| WORD btw, /* Number of bytes to write */ |
| WORD *bw /* Pointer to number of bytes written */ |
| ) |
| { |
| e1c: a0 e0 ldi r26, 0x00 ; 0 |
| e1e: b0 e0 ldi r27, 0x00 ; 0 |
| e20: e4 e1 ldi r30, 0x14 ; 20 |
| e22: f7 e0 ldi r31, 0x07 ; 7 |
| e24: 0c 94 c8 14 jmp 0x2990 ; 0x2990 <__prologue_saves__+0x2> |
| e28: ec 01 movw r28, r24 |
| e2a: 16 2f mov r17, r22 |
| e2c: 07 2f mov r16, r23 |
| e2e: 7a 01 movw r14, r20 |
| e30: 39 01 movw r6, r18 |
| WORD wcnt; |
| CLUST clust; |
| BYTE cc; |
| FRESULT res; |
| const BYTE *wbuff = buff; |
| FATFS *fs = fp->fs; |
| e32: ac 80 ldd r10, Y+4 ; 0x04 |
| e34: bd 80 ldd r11, Y+5 ; 0x05 |
| |
| |
| *bw = 0; |
| e36: f9 01 movw r30, r18 |
| e38: 11 82 std Z+1, r1 ; 0x01 |
| e3a: 10 82 st Z, r1 |
| res = validate(fs, fp->id); /* Check validity of the object */ |
| e3c: 68 81 ld r22, Y |
| e3e: 79 81 ldd r23, Y+1 ; 0x01 |
| e40: c5 01 movw r24, r10 |
| e42: 0e 94 46 03 call 0x68c ; 0x68c <validate> |
| e46: 4c 01 movw r8, r24 |
| if (res) return res; |
| e48: 00 97 sbiw r24, 0x00 ; 0 |
| e4a: 09 f0 breq .+2 ; 0xe4e <f_write+0x32> |
| e4c: 3b c1 rjmp .+630 ; 0x10c4 <f_write+0x2a8> |
| if (fp->flag & FA__ERROR) return FR_RW_ERROR; /* Check error flag */ |
| e4e: 8a 81 ldd r24, Y+2 ; 0x02 |
| e50: 87 fd sbrc r24, 7 |
| e52: 35 c1 rjmp .+618 ; 0x10be <f_write+0x2a2> |
| if (!(fp->flag & FA_WRITE)) return FR_DENIED; /* Check access mode */ |
| e54: 81 fd sbrc r24, 1 |
| e56: 04 c0 rjmp .+8 ; 0xe60 <f_write+0x44> |
| e58: 36 e0 ldi r19, 0x06 ; 6 |
| e5a: 83 2e mov r8, r19 |
| e5c: 91 2c mov r9, r1 |
| e5e: 32 c1 rjmp .+612 ; 0x10c4 <f_write+0x2a8> |
| if (fp->fsize + btw < fp->fsize) return FR_OK; /* File size cannot reach 4GB */ |
| e60: 2a 85 ldd r18, Y+10 ; 0x0a |
| e62: 3b 85 ldd r19, Y+11 ; 0x0b |
| e64: 4c 85 ldd r20, Y+12 ; 0x0c |
| e66: 5d 85 ldd r21, Y+13 ; 0x0d |
| e68: c7 01 movw r24, r14 |
| e6a: a0 e0 ldi r26, 0x00 ; 0 |
| e6c: b0 e0 ldi r27, 0x00 ; 0 |
| e6e: 82 0f add r24, r18 |
| e70: 93 1f adc r25, r19 |
| e72: a4 1f adc r26, r20 |
| e74: b5 1f adc r27, r21 |
| e76: 82 17 cp r24, r18 |
| e78: 93 07 cpc r25, r19 |
| e7a: a4 07 cpc r26, r20 |
| e7c: b5 07 cpc r27, r21 |
| e7e: 08 f4 brcc .+2 ; 0xe82 <f_write+0x66> |
| e80: 21 c1 rjmp .+578 ; 0x10c4 <f_write+0x2a8> |
| DWORD sect; |
| WORD wcnt; |
| CLUST clust; |
| BYTE cc; |
| FRESULT res; |
| const BYTE *wbuff = buff; |
| e82: 81 2f mov r24, r17 |
| e84: 90 2f mov r25, r16 |
| e86: 9c 01 movw r18, r24 |
| e88: 69 01 movw r12, r18 |
| fs->winsect = fp->curr_sect; |
| } |
| } |
| if (!move_window(fp->curr_sect)) /* Move sector window */ |
| goto fw_error; |
| wcnt = 512 - (WORD)(fp->fptr % 512); /* Copy fractional bytes bytes to sector window */ |
| e8a: 41 2c mov r4, r1 |
| e8c: 22 e0 ldi r18, 0x02 ; 2 |
| e8e: 52 2e mov r5, r18 |
| if (wcnt > btw) wcnt = btw; |
| memcpy(&fs->win[(WORD)fp->fptr % 512], wbuff, wcnt); |
| fs->winflag = 1; |
| e90: 33 24 eor r3, r3 |
| e92: 33 94 inc r3 |
| e94: f8 c0 rjmp .+496 ; 0x1086 <f_write+0x26a> |
| if (!(fp->flag & FA_WRITE)) return FR_DENIED; /* Check access mode */ |
| if (fp->fsize + btw < fp->fsize) return FR_OK; /* File size cannot reach 4GB */ |
| |
| for ( ; btw; /* Repeat until all data transferred */ |
| wbuff += wcnt, fp->fptr += wcnt, *bw += wcnt, btw -= wcnt) { |
| if ((fp->fptr % 512) == 0) { /* On the sector boundary */ |
| e96: 2e 81 ldd r18, Y+6 ; 0x06 |
| e98: 3f 81 ldd r19, Y+7 ; 0x07 |
| e9a: 48 85 ldd r20, Y+8 ; 0x08 |
| e9c: 59 85 ldd r21, Y+9 ; 0x09 |
| e9e: da 01 movw r26, r20 |
| ea0: c9 01 movw r24, r18 |
| ea2: 91 70 andi r25, 0x01 ; 1 |
| ea4: a0 70 andi r26, 0x00 ; 0 |
| ea6: b0 70 andi r27, 0x00 ; 0 |
| ea8: 00 97 sbiw r24, 0x00 ; 0 |
| eaa: a1 05 cpc r26, r1 |
| eac: b1 05 cpc r27, r1 |
| eae: 09 f0 breq .+2 ; 0xeb2 <f_write+0x96> |
| eb0: b1 c0 rjmp .+354 ; 0x1014 <f_write+0x1f8> |
| if (--(fp->sect_clust)) { /* Decrement left sector counter */ |
| eb2: 8b 81 ldd r24, Y+3 ; 0x03 |
| eb4: 81 50 subi r24, 0x01 ; 1 |
| eb6: 8b 83 std Y+3, r24 ; 0x03 |
| eb8: 88 23 and r24, r24 |
| eba: 49 f0 breq .+18 ; 0xece <f_write+0xb2> |
| sect = fp->curr_sect + 1; /* Get current sector */ |
| ebc: 2a 89 ldd r18, Y+18 ; 0x12 |
| ebe: 3b 89 ldd r19, Y+19 ; 0x13 |
| ec0: 4c 89 ldd r20, Y+20 ; 0x14 |
| ec2: 5d 89 ldd r21, Y+21 ; 0x15 |
| ec4: 2f 5f subi r18, 0xFF ; 255 |
| ec6: 3f 4f sbci r19, 0xFF ; 255 |
| ec8: 4f 4f sbci r20, 0xFF ; 255 |
| eca: 5f 4f sbci r21, 0xFF ; 255 |
| ecc: 51 c0 rjmp .+162 ; 0xf70 <f_write+0x154> |
| } else { /* On the cluster boundary, get next cluster */ |
| if (fp->fptr == 0) { /* Is top of the file */ |
| ece: 21 15 cp r18, r1 |
| ed0: 31 05 cpc r19, r1 |
| ed2: 41 05 cpc r20, r1 |
| ed4: 51 05 cpc r21, r1 |
| ed6: 69 f4 brne .+26 ; 0xef2 <f_write+0xd6> |
| clust = fp->org_clust; |
| ed8: 6e 85 ldd r22, Y+14 ; 0x0e |
| eda: 7f 85 ldd r23, Y+15 ; 0x0f |
| if (clust == 0) /* No cluster is created yet */ |
| edc: 61 15 cp r22, r1 |
| ede: 71 05 cpc r23, r1 |
| ee0: 89 f4 brne .+34 ; 0xf04 <f_write+0xe8> |
| fp->org_clust = clust = create_chain(0); /* Create a new cluster chain */ |
| ee2: 80 e0 ldi r24, 0x00 ; 0 |
| ee4: 90 e0 ldi r25, 0x00 ; 0 |
| ee6: 0e 94 d1 04 call 0x9a2 ; 0x9a2 <create_chain> |
| eea: bc 01 movw r22, r24 |
| eec: 9f 87 std Y+15, r25 ; 0x0f |
| eee: 8e 87 std Y+14, r24 ; 0x0e |
| ef0: 05 c0 rjmp .+10 ; 0xefc <f_write+0xe0> |
| } else { /* Middle or end of file */ |
| clust = create_chain(fp->curr_clust); /* Trace or streach cluster chain */ |
| ef2: 88 89 ldd r24, Y+16 ; 0x10 |
| ef4: 99 89 ldd r25, Y+17 ; 0x11 |
| ef6: 0e 94 d1 04 call 0x9a2 ; 0x9a2 <create_chain> |
| efa: bc 01 movw r22, r24 |
| } |
| if (clust == 0) break; /* Disk full */ |
| efc: 61 15 cp r22, r1 |
| efe: 71 05 cpc r23, r1 |
| f00: 09 f4 brne .+2 ; 0xf04 <f_write+0xe8> |
| f02: c5 c0 rjmp .+394 ; 0x108e <f_write+0x272> |
| if (clust == 1 || clust >= fs->max_clust) goto fw_error; |
| f04: 61 30 cpi r22, 0x01 ; 1 |
| f06: 71 05 cpc r23, r1 |
| f08: 09 f4 brne .+2 ; 0xf0c <f_write+0xf0> |
| f0a: d6 c0 rjmp .+428 ; 0x10b8 <f_write+0x29c> |
| f0c: f5 01 movw r30, r10 |
| f0e: 86 89 ldd r24, Z+22 ; 0x16 |
| f10: 97 89 ldd r25, Z+23 ; 0x17 |
| f12: 68 17 cp r22, r24 |
| f14: 79 07 cpc r23, r25 |
| f16: 08 f0 brcs .+2 ; 0xf1a <f_write+0xfe> |
| f18: cf c0 rjmp .+414 ; 0x10b8 <f_write+0x29c> |
| fp->curr_clust = clust; /* Current cluster */ |
| f1a: 79 8b std Y+17, r23 ; 0x11 |
| f1c: 68 8b std Y+16, r22 ; 0x10 |
| static |
| DWORD clust2sect ( /* !=0: sector number, 0: failed - invalid cluster# */ |
| CLUST clust /* Cluster# to be converted */ |
| ) |
| { |
| FATFS *fs = FatFs; |
| f1e: 00 91 10 01 lds r16, 0x0110 |
| f22: 10 91 11 01 lds r17, 0x0111 |
| |
| |
| clust -= 2; |
| f26: 62 50 subi r22, 0x02 ; 2 |
| f28: 70 40 sbci r23, 0x00 ; 0 |
| if (clust >= (fs->max_clust - 2)) return 0; /* Invalid cluster# */ |
| f2a: f8 01 movw r30, r16 |
| f2c: 86 89 ldd r24, Z+22 ; 0x16 |
| f2e: 97 89 ldd r25, Z+23 ; 0x17 |
| f30: 02 97 sbiw r24, 0x02 ; 2 |
| f32: 68 17 cp r22, r24 |
| f34: 79 07 cpc r23, r25 |
| f36: 28 f0 brcs .+10 ; 0xf42 <f_write+0x126> |
| f38: 20 e0 ldi r18, 0x00 ; 0 |
| f3a: 30 e0 ldi r19, 0x00 ; 0 |
| f3c: 40 e0 ldi r20, 0x00 ; 0 |
| f3e: 50 e0 ldi r21, 0x00 ; 0 |
| f40: 14 c0 rjmp .+40 ; 0xf6a <f_write+0x14e> |
| return (DWORD)clust * fs->sects_clust + fs->database; |
| f42: 80 e0 ldi r24, 0x00 ; 0 |
| f44: 90 e0 ldi r25, 0x00 ; 0 |
| f46: f8 01 movw r30, r16 |
| f48: 25 8d ldd r18, Z+29 ; 0x1d |
| f4a: 30 e0 ldi r19, 0x00 ; 0 |
| f4c: 40 e0 ldi r20, 0x00 ; 0 |
| f4e: 50 e0 ldi r21, 0x00 ; 0 |
| f50: 0e 94 86 14 call 0x290c ; 0x290c <__mulsi3> |
| f54: 9b 01 movw r18, r22 |
| f56: ac 01 movw r20, r24 |
| f58: f8 01 movw r30, r16 |
| f5a: 80 89 ldd r24, Z+16 ; 0x10 |
| f5c: 91 89 ldd r25, Z+17 ; 0x11 |
| f5e: a2 89 ldd r26, Z+18 ; 0x12 |
| f60: b3 89 ldd r27, Z+19 ; 0x13 |
| f62: 28 0f add r18, r24 |
| f64: 39 1f adc r19, r25 |
| f66: 4a 1f adc r20, r26 |
| f68: 5b 1f adc r21, r27 |
| } |
| if (clust == 0) break; /* Disk full */ |
| if (clust == 1 || clust >= fs->max_clust) goto fw_error; |
| fp->curr_clust = clust; /* Current cluster */ |
| sect = clust2sect(clust); /* Get current sector */ |
| fp->sect_clust = fs->sects_clust; /* Re-initialize the left sector counter */ |
| f6a: f5 01 movw r30, r10 |
| f6c: 85 8d ldd r24, Z+29 ; 0x1d |
| f6e: 8b 83 std Y+3, r24 ; 0x03 |
| } |
| fp->curr_sect = sect; /* Update current sector */ |
| f70: 2a 8b std Y+18, r18 ; 0x12 |
| f72: 3b 8b std Y+19, r19 ; 0x13 |
| f74: 4c 8b std Y+20, r20 ; 0x14 |
| f76: 5d 8b std Y+21, r21 ; 0x15 |
| cc = btw / 512; /* When left bytes >= 512, */ |
| f78: 0f 2d mov r16, r15 |
| f7a: 06 95 lsr r16 |
| if (cc) { /* Write maximum contiguous sectors directly */ |
| f7c: 61 f1 breq .+88 ; 0xfd6 <f_write+0x1ba> |
| f7e: 6b 81 ldd r22, Y+3 ; 0x03 |
| f80: 10 2f mov r17, r16 |
| f82: 60 17 cp r22, r16 |
| f84: 08 f4 brcc .+2 ; 0xf88 <f_write+0x16c> |
| f86: 16 2f mov r17, r22 |
| if (cc > fp->sect_clust) cc = fp->sect_clust; |
| if (disk_write(0, wbuff, sect, cc) != RES_OK) |
| f88: 01 2f mov r16, r17 |
| f8a: b6 01 movw r22, r12 |
| f8c: 80 e0 ldi r24, 0x00 ; 0 |
| f8e: 0e 94 fb 0f call 0x1ff6 ; 0x1ff6 <disk_write> |
| f92: 89 2b or r24, r25 |
| f94: 09 f0 breq .+2 ; 0xf98 <f_write+0x17c> |
| f96: 90 c0 rjmp .+288 ; 0x10b8 <f_write+0x29c> |
| goto fw_error; |
| fp->sect_clust -= cc - 1; |
| f98: 8b 81 ldd r24, Y+3 ; 0x03 |
| f9a: 8f 5f subi r24, 0xFF ; 255 |
| f9c: 81 1b sub r24, r17 |
| f9e: 8b 83 std Y+3, r24 ; 0x03 |
| fp->curr_sect += cc - 1; |
| fa0: 81 2f mov r24, r17 |
| fa2: 90 e0 ldi r25, 0x00 ; 0 |
| fa4: 01 97 sbiw r24, 0x01 ; 1 |
| fa6: 9c 01 movw r18, r24 |
| fa8: 44 27 eor r20, r20 |
| faa: 37 fd sbrc r19, 7 |
| fac: 40 95 com r20 |
| fae: 54 2f mov r21, r20 |
| fb0: 8c 01 movw r16, r24 |
| fb2: 0f 5f subi r16, 0xFF ; 255 |
| fb4: 1f 4f sbci r17, 0xFF ; 255 |
| fb6: 8a 89 ldd r24, Y+18 ; 0x12 |
| fb8: 9b 89 ldd r25, Y+19 ; 0x13 |
| fba: ac 89 ldd r26, Y+20 ; 0x14 |
| fbc: bd 89 ldd r27, Y+21 ; 0x15 |
| fbe: 82 0f add r24, r18 |
| fc0: 93 1f adc r25, r19 |
| fc2: a4 1f adc r26, r20 |
| fc4: b5 1f adc r27, r21 |
| fc6: 8a 8b std Y+18, r24 ; 0x12 |
| fc8: 9b 8b std Y+19, r25 ; 0x13 |
| fca: ac 8b std Y+20, r26 ; 0x14 |
| fcc: bd 8b std Y+21, r27 ; 0x15 |
| wcnt = cc * 512; continue; |
| fce: 10 2f mov r17, r16 |
| fd0: 00 27 eor r16, r16 |
| fd2: 11 0f add r17, r17 |
| fd4: 3e c0 rjmp .+124 ; 0x1052 <f_write+0x236> |
| } |
| if (fp->fptr >= fp->fsize) { /* Flush R/W window if needed */ |
| fd6: 2e 81 ldd r18, Y+6 ; 0x06 |
| fd8: 3f 81 ldd r19, Y+7 ; 0x07 |
| fda: 48 85 ldd r20, Y+8 ; 0x08 |
| fdc: 59 85 ldd r21, Y+9 ; 0x09 |
| fde: 8a 85 ldd r24, Y+10 ; 0x0a |
| fe0: 9b 85 ldd r25, Y+11 ; 0x0b |
| fe2: ac 85 ldd r26, Y+12 ; 0x0c |
| fe4: bd 85 ldd r27, Y+13 ; 0x0d |
| fe6: 28 17 cp r18, r24 |
| fe8: 39 07 cpc r19, r25 |
| fea: 4a 07 cpc r20, r26 |
| fec: 5b 07 cpc r21, r27 |
| fee: 90 f0 brcs .+36 ; 0x1014 <f_write+0x1f8> |
| if (!move_window(0)) goto fw_error; |
| ff0: 60 e0 ldi r22, 0x00 ; 0 |
| ff2: 70 e0 ldi r23, 0x00 ; 0 |
| ff4: 80 e0 ldi r24, 0x00 ; 0 |
| ff6: 90 e0 ldi r25, 0x00 ; 0 |
| ff8: 0e 94 5a 03 call 0x6b4 ; 0x6b4 <move_window> |
| ffc: 88 23 and r24, r24 |
| ffe: 09 f4 brne .+2 ; 0x1002 <f_write+0x1e6> |
| 1000: 5b c0 rjmp .+182 ; 0x10b8 <f_write+0x29c> |
| fs->winsect = fp->curr_sect; |
| 1002: 8a 89 ldd r24, Y+18 ; 0x12 |
| 1004: 9b 89 ldd r25, Y+19 ; 0x13 |
| 1006: ac 89 ldd r26, Y+20 ; 0x14 |
| 1008: bd 89 ldd r27, Y+21 ; 0x15 |
| 100a: f5 01 movw r30, r10 |
| 100c: 84 83 std Z+4, r24 ; 0x04 |
| 100e: 95 83 std Z+5, r25 ; 0x05 |
| 1010: a6 83 std Z+6, r26 ; 0x06 |
| 1012: b7 83 std Z+7, r27 ; 0x07 |
| } |
| } |
| if (!move_window(fp->curr_sect)) /* Move sector window */ |
| 1014: 6a 89 ldd r22, Y+18 ; 0x12 |
| 1016: 7b 89 ldd r23, Y+19 ; 0x13 |
| 1018: 8c 89 ldd r24, Y+20 ; 0x14 |
| 101a: 9d 89 ldd r25, Y+21 ; 0x15 |
| 101c: 0e 94 5a 03 call 0x6b4 ; 0x6b4 <move_window> |
| 1020: 88 23 and r24, r24 |
| 1022: 09 f4 brne .+2 ; 0x1026 <f_write+0x20a> |
| 1024: 49 c0 rjmp .+146 ; 0x10b8 <f_write+0x29c> |
| goto fw_error; |
| wcnt = 512 - (WORD)(fp->fptr % 512); /* Copy fractional bytes bytes to sector window */ |
| 1026: 2e 81 ldd r18, Y+6 ; 0x06 |
| 1028: 3f 81 ldd r19, Y+7 ; 0x07 |
| 102a: 31 70 andi r19, 0x01 ; 1 |
| 102c: c2 01 movw r24, r4 |
| 102e: 82 1b sub r24, r18 |
| 1030: 93 0b sbc r25, r19 |
| 1032: 87 01 movw r16, r14 |
| 1034: 8e 15 cp r24, r14 |
| 1036: 9f 05 cpc r25, r15 |
| 1038: 08 f4 brcc .+2 ; 0x103c <f_write+0x220> |
| 103a: 8c 01 movw r16, r24 |
| if (wcnt > btw) wcnt = btw; |
| memcpy(&fs->win[(WORD)fp->fptr % 512], wbuff, wcnt); |
| 103c: 20 5e subi r18, 0xE0 ; 224 |
| 103e: 3f 4f sbci r19, 0xFF ; 255 |
| 1040: 2a 0d add r18, r10 |
| 1042: 3b 1d adc r19, r11 |
| 1044: a8 01 movw r20, r16 |
| 1046: b6 01 movw r22, r12 |
| 1048: c9 01 movw r24, r18 |
| 104a: 0e 94 a3 11 call 0x2346 ; 0x2346 <memcpy> |
| fs->winflag = 1; |
| 104e: f5 01 movw r30, r10 |
| 1050: 37 8e std Z+31, r3 ; 0x1f |
| if (fp->flag & FA__ERROR) return FR_RW_ERROR; /* Check error flag */ |
| if (!(fp->flag & FA_WRITE)) return FR_DENIED; /* Check access mode */ |
| if (fp->fsize + btw < fp->fsize) return FR_OK; /* File size cannot reach 4GB */ |
| |
| for ( ; btw; /* Repeat until all data transferred */ |
| wbuff += wcnt, fp->fptr += wcnt, *bw += wcnt, btw -= wcnt) { |
| 1052: c0 0e add r12, r16 |
| 1054: d1 1e adc r13, r17 |
| 1056: c8 01 movw r24, r16 |
| 1058: a0 e0 ldi r26, 0x00 ; 0 |
| 105a: b0 e0 ldi r27, 0x00 ; 0 |
| 105c: 2e 81 ldd r18, Y+6 ; 0x06 |
| 105e: 3f 81 ldd r19, Y+7 ; 0x07 |
| 1060: 48 85 ldd r20, Y+8 ; 0x08 |
| 1062: 59 85 ldd r21, Y+9 ; 0x09 |
| 1064: 28 0f add r18, r24 |
| 1066: 39 1f adc r19, r25 |
| 1068: 4a 1f adc r20, r26 |
| 106a: 5b 1f adc r21, r27 |
| 106c: 2e 83 std Y+6, r18 ; 0x06 |
| 106e: 3f 83 std Y+7, r19 ; 0x07 |
| 1070: 48 87 std Y+8, r20 ; 0x08 |
| 1072: 59 87 std Y+9, r21 ; 0x09 |
| 1074: f3 01 movw r30, r6 |
| 1076: 80 81 ld r24, Z |
| 1078: 91 81 ldd r25, Z+1 ; 0x01 |
| 107a: 80 0f add r24, r16 |
| 107c: 91 1f adc r25, r17 |
| 107e: 91 83 std Z+1, r25 ; 0x01 |
| 1080: 80 83 st Z, r24 |
| 1082: e0 1a sub r14, r16 |
| 1084: f1 0a sbc r15, r17 |
| if (res) return res; |
| if (fp->flag & FA__ERROR) return FR_RW_ERROR; /* Check error flag */ |
| if (!(fp->flag & FA_WRITE)) return FR_DENIED; /* Check access mode */ |
| if (fp->fsize + btw < fp->fsize) return FR_OK; /* File size cannot reach 4GB */ |
| |
| for ( ; btw; /* Repeat until all data transferred */ |
| 1086: e1 14 cp r14, r1 |
| 1088: f1 04 cpc r15, r1 |
| 108a: 09 f0 breq .+2 ; 0x108e <f_write+0x272> |
| 108c: 04 cf rjmp .-504 ; 0xe96 <f_write+0x7a> |
| if (wcnt > btw) wcnt = btw; |
| memcpy(&fs->win[(WORD)fp->fptr % 512], wbuff, wcnt); |
| fs->winflag = 1; |
| } |
| |
| if (fp->fptr > fp->fsize) fp->fsize = fp->fptr; /* Update file size if needed */ |
| 108e: 2e 81 ldd r18, Y+6 ; 0x06 |
| 1090: 3f 81 ldd r19, Y+7 ; 0x07 |
| 1092: 48 85 ldd r20, Y+8 ; 0x08 |
| 1094: 59 85 ldd r21, Y+9 ; 0x09 |
| 1096: 8a 85 ldd r24, Y+10 ; 0x0a |
| 1098: 9b 85 ldd r25, Y+11 ; 0x0b |
| 109a: ac 85 ldd r26, Y+12 ; 0x0c |
| 109c: bd 85 ldd r27, Y+13 ; 0x0d |
| 109e: 82 17 cp r24, r18 |
| 10a0: 93 07 cpc r25, r19 |
| 10a2: a4 07 cpc r26, r20 |
| 10a4: b5 07 cpc r27, r21 |
| 10a6: 20 f4 brcc .+8 ; 0x10b0 <f_write+0x294> |
| 10a8: 2a 87 std Y+10, r18 ; 0x0a |
| 10aa: 3b 87 std Y+11, r19 ; 0x0b |
| 10ac: 4c 87 std Y+12, r20 ; 0x0c |
| 10ae: 5d 87 std Y+13, r21 ; 0x0d |
| fp->flag |= FA__WRITTEN; /* Set file changed flag */ |
| 10b0: 8a 81 ldd r24, Y+2 ; 0x02 |
| 10b2: 80 62 ori r24, 0x20 ; 32 |
| 10b4: 8a 83 std Y+2, r24 ; 0x02 |
| 10b6: 06 c0 rjmp .+12 ; 0x10c4 <f_write+0x2a8> |
| return FR_OK; |
| |
| fw_error: /* Abort this function due to an unrecoverable error */ |
| fp->flag |= FA__ERROR; |
| 10b8: 8a 81 ldd r24, Y+2 ; 0x02 |
| 10ba: 80 68 ori r24, 0x80 ; 128 |
| 10bc: 8a 83 std Y+2, r24 ; 0x02 |
| 10be: 88 e0 ldi r24, 0x08 ; 8 |
| 10c0: 88 2e mov r8, r24 |
| 10c2: 91 2c mov r9, r1 |
| return FR_RW_ERROR; |
| } |
| 10c4: c4 01 movw r24, r8 |
| 10c6: cd b7 in r28, 0x3d ; 61 |
| 10c8: de b7 in r29, 0x3e ; 62 |
| 10ca: e1 e1 ldi r30, 0x11 ; 17 |
| 10cc: 0c 94 e4 14 jmp 0x29c8 ; 0x29c8 <__epilogue_restores__+0x2> |
| |
| 000010d0 <f_read>: |
| FIL *fp, /* Pointer to the file object */ |
| void *buff, /* Pointer to data buffer */ |
| WORD btr, /* Number of bytes to read */ |
| WORD *br /* Pointer to number of bytes read */ |
| ) |
| { |
| 10d0: a0 e0 ldi r26, 0x00 ; 0 |
| 10d2: b0 e0 ldi r27, 0x00 ; 0 |
| 10d4: ee e6 ldi r30, 0x6E ; 110 |
| 10d6: f8 e0 ldi r31, 0x08 ; 8 |
| 10d8: 0c 94 c9 14 jmp 0x2992 ; 0x2992 <__prologue_saves__+0x4> |
| 10dc: ec 01 movw r28, r24 |
| 10de: 16 2f mov r17, r22 |
| 10e0: 07 2f mov r16, r23 |
| 10e2: 7a 01 movw r14, r20 |
| 10e4: 39 01 movw r6, r18 |
| DWORD sect, remain; |
| WORD rcnt; |
| CLUST clust; |
| BYTE cc, *rbuff = buff; |
| FRESULT res; |
| FATFS *fs = fp->fs; |
| 10e6: 8c 80 ldd r8, Y+4 ; 0x04 |
| 10e8: 9d 80 ldd r9, Y+5 ; 0x05 |
| |
| |
| *br = 0; |
| 10ea: f9 01 movw r30, r18 |
| 10ec: 11 82 std Z+1, r1 ; 0x01 |
| 10ee: 10 82 st Z, r1 |
| res = validate(fs, fp->id); /* Check validity of the object */ |
| 10f0: 68 81 ld r22, Y |
| 10f2: 79 81 ldd r23, Y+1 ; 0x01 |
| 10f4: c4 01 movw r24, r8 |
| 10f6: 0e 94 46 03 call 0x68c ; 0x68c <validate> |
| 10fa: 5c 01 movw r10, r24 |
| if (res) return res; |
| 10fc: 00 97 sbiw r24, 0x00 ; 0 |
| 10fe: 09 f0 breq .+2 ; 0x1102 <f_read+0x32> |
| 1100: f8 c0 rjmp .+496 ; 0x12f2 <f_read+0x222> |
| if (fp->flag & FA__ERROR) return FR_RW_ERROR; /* Check error flag */ |
| 1102: 8a 81 ldd r24, Y+2 ; 0x02 |
| 1104: 87 fd sbrc r24, 7 |
| 1106: f2 c0 rjmp .+484 ; 0x12ec <f_read+0x21c> |
| if (!(fp->flag & FA_READ)) return FR_DENIED; /* Check access mode */ |
| 1108: 80 fd sbrc r24, 0 |
| 110a: 04 c0 rjmp .+8 ; 0x1114 <f_read+0x44> |
| 110c: 76 e0 ldi r23, 0x06 ; 6 |
| 110e: a7 2e mov r10, r23 |
| 1110: b1 2c mov r11, r1 |
| 1112: ef c0 rjmp .+478 ; 0x12f2 <f_read+0x222> |
| remain = fp->fsize - fp->fptr; |
| 1114: 2a 85 ldd r18, Y+10 ; 0x0a |
| 1116: 3b 85 ldd r19, Y+11 ; 0x0b |
| 1118: 4c 85 ldd r20, Y+12 ; 0x0c |
| 111a: 5d 85 ldd r21, Y+13 ; 0x0d |
| 111c: 8e 81 ldd r24, Y+6 ; 0x06 |
| 111e: 9f 81 ldd r25, Y+7 ; 0x07 |
| 1120: a8 85 ldd r26, Y+8 ; 0x08 |
| 1122: b9 85 ldd r27, Y+9 ; 0x09 |
| 1124: 28 1b sub r18, r24 |
| 1126: 39 0b sbc r19, r25 |
| 1128: 4a 0b sbc r20, r26 |
| 112a: 5b 0b sbc r21, r27 |
| if (btr > remain) btr = (WORD)remain; /* Truncate read count by number of bytes left */ |
| 112c: c7 01 movw r24, r14 |
| 112e: a0 e0 ldi r26, 0x00 ; 0 |
| 1130: b0 e0 ldi r27, 0x00 ; 0 |
| 1132: 28 17 cp r18, r24 |
| 1134: 39 07 cpc r19, r25 |
| 1136: 4a 07 cpc r20, r26 |
| 1138: 5b 07 cpc r21, r27 |
| 113a: 08 f4 brcc .+2 ; 0x113e <f_read+0x6e> |
| 113c: 79 01 movw r14, r18 |
| ) |
| { |
| DWORD sect, remain; |
| WORD rcnt; |
| CLUST clust; |
| BYTE cc, *rbuff = buff; |
| 113e: 81 2f mov r24, r17 |
| 1140: 90 2f mov r25, r16 |
| 1142: 9c 01 movw r18, r24 |
| 1144: 69 01 movw r12, r18 |
| fp->curr_sect += cc - 1; |
| rcnt = cc * 512; continue; |
| } |
| } |
| if (!move_window(fp->curr_sect)) goto fr_error; /* Move sector window */ |
| rcnt = 512 - (WORD)(fp->fptr % 512); /* Copy fractional bytes from sector window */ |
| 1146: 41 2c mov r4, r1 |
| 1148: 62 e0 ldi r22, 0x02 ; 2 |
| 114a: 56 2e mov r5, r22 |
| 114c: c7 c0 rjmp .+398 ; 0x12dc <f_read+0x20c> |
| remain = fp->fsize - fp->fptr; |
| if (btr > remain) btr = (WORD)remain; /* Truncate read count by number of bytes left */ |
| |
| for ( ; btr; /* Repeat until all data transferred */ |
| rbuff += rcnt, fp->fptr += rcnt, *br += rcnt, btr -= rcnt) { |
| if ((fp->fptr % 512) == 0) { /* On the sector boundary */ |
| 114e: 2e 81 ldd r18, Y+6 ; 0x06 |
| 1150: 3f 81 ldd r19, Y+7 ; 0x07 |
| 1152: 48 85 ldd r20, Y+8 ; 0x08 |
| 1154: 59 85 ldd r21, Y+9 ; 0x09 |
| 1156: da 01 movw r26, r20 |
| 1158: c9 01 movw r24, r18 |
| 115a: 91 70 andi r25, 0x01 ; 1 |
| 115c: a0 70 andi r26, 0x00 ; 0 |
| 115e: b0 70 andi r27, 0x00 ; 0 |
| 1160: 00 97 sbiw r24, 0x00 ; 0 |
| 1162: a1 05 cpc r26, r1 |
| 1164: b1 05 cpc r27, r1 |
| 1166: 09 f0 breq .+2 ; 0x116a <f_read+0x9a> |
| 1168: 84 c0 rjmp .+264 ; 0x1272 <f_read+0x1a2> |
| if (--fp->sect_clust) { /* Decrement left sector counter */ |
| 116a: 8b 81 ldd r24, Y+3 ; 0x03 |
| 116c: 81 50 subi r24, 0x01 ; 1 |
| 116e: 8b 83 std Y+3, r24 ; 0x03 |
| 1170: 88 23 and r24, r24 |
| 1172: 49 f0 breq .+18 ; 0x1186 <f_read+0xb6> |
| sect = fp->curr_sect + 1; /* Get current sector */ |
| 1174: 2a 89 ldd r18, Y+18 ; 0x12 |
| 1176: 3b 89 ldd r19, Y+19 ; 0x13 |
| 1178: 4c 89 ldd r20, Y+20 ; 0x14 |
| 117a: 5d 89 ldd r21, Y+21 ; 0x15 |
| 117c: 2f 5f subi r18, 0xFF ; 255 |
| 117e: 3f 4f sbci r19, 0xFF ; 255 |
| 1180: 4f 4f sbci r20, 0xFF ; 255 |
| 1182: 5f 4f sbci r21, 0xFF ; 255 |
| 1184: 43 c0 rjmp .+134 ; 0x120c <f_read+0x13c> |
| } else { /* On the cluster boundary, get next cluster */ |
| clust = (fp->fptr == 0) ? |
| 1186: 21 15 cp r18, r1 |
| 1188: 31 05 cpc r19, r1 |
| 118a: 41 05 cpc r20, r1 |
| 118c: 51 05 cpc r21, r1 |
| 118e: 19 f4 brne .+6 ; 0x1196 <f_read+0xc6> |
| 1190: 6e 85 ldd r22, Y+14 ; 0x0e |
| 1192: 7f 85 ldd r23, Y+15 ; 0x0f |
| 1194: 05 c0 rjmp .+10 ; 0x11a0 <f_read+0xd0> |
| 1196: 88 89 ldd r24, Y+16 ; 0x10 |
| 1198: 99 89 ldd r25, Y+17 ; 0x11 |
| 119a: 0e 94 53 04 call 0x8a6 ; 0x8a6 <get_cluster> |
| 119e: bc 01 movw r22, r24 |
| fp->org_clust : get_cluster(fp->curr_clust); |
| if (clust < 2 || clust >= fs->max_clust) |
| 11a0: 62 30 cpi r22, 0x02 ; 2 |
| 11a2: 71 05 cpc r23, r1 |
| 11a4: 08 f4 brcc .+2 ; 0x11a8 <f_read+0xd8> |
| 11a6: 9f c0 rjmp .+318 ; 0x12e6 <f_read+0x216> |
| 11a8: f4 01 movw r30, r8 |
| 11aa: 86 89 ldd r24, Z+22 ; 0x16 |
| 11ac: 97 89 ldd r25, Z+23 ; 0x17 |
| 11ae: 68 17 cp r22, r24 |
| 11b0: 79 07 cpc r23, r25 |
| 11b2: 08 f0 brcs .+2 ; 0x11b6 <f_read+0xe6> |
| 11b4: 98 c0 rjmp .+304 ; 0x12e6 <f_read+0x216> |
| goto fr_error; |
| fp->curr_clust = clust; /* Current cluster */ |
| 11b6: 79 8b std Y+17, r23 ; 0x11 |
| 11b8: 68 8b std Y+16, r22 ; 0x10 |
| static |
| DWORD clust2sect ( /* !=0: sector number, 0: failed - invalid cluster# */ |
| CLUST clust /* Cluster# to be converted */ |
| ) |
| { |
| FATFS *fs = FatFs; |
| 11ba: 00 91 10 01 lds r16, 0x0110 |
| 11be: 10 91 11 01 lds r17, 0x0111 |
| |
| |
| clust -= 2; |
| 11c2: 62 50 subi r22, 0x02 ; 2 |
| 11c4: 70 40 sbci r23, 0x00 ; 0 |
| if (clust >= (fs->max_clust - 2)) return 0; /* Invalid cluster# */ |
| 11c6: f8 01 movw r30, r16 |
| 11c8: 86 89 ldd r24, Z+22 ; 0x16 |
| 11ca: 97 89 ldd r25, Z+23 ; 0x17 |
| 11cc: 02 97 sbiw r24, 0x02 ; 2 |
| 11ce: 68 17 cp r22, r24 |
| 11d0: 79 07 cpc r23, r25 |
| 11d2: 28 f0 brcs .+10 ; 0x11de <f_read+0x10e> |
| 11d4: 20 e0 ldi r18, 0x00 ; 0 |
| 11d6: 30 e0 ldi r19, 0x00 ; 0 |
| 11d8: 40 e0 ldi r20, 0x00 ; 0 |
| 11da: 50 e0 ldi r21, 0x00 ; 0 |
| 11dc: 14 c0 rjmp .+40 ; 0x1206 <f_read+0x136> |
| return (DWORD)clust * fs->sects_clust + fs->database; |
| 11de: 80 e0 ldi r24, 0x00 ; 0 |
| 11e0: 90 e0 ldi r25, 0x00 ; 0 |
| 11e2: f8 01 movw r30, r16 |
| 11e4: 25 8d ldd r18, Z+29 ; 0x1d |
| 11e6: 30 e0 ldi r19, 0x00 ; 0 |
| 11e8: 40 e0 ldi r20, 0x00 ; 0 |
| 11ea: 50 e0 ldi r21, 0x00 ; 0 |
| 11ec: 0e 94 86 14 call 0x290c ; 0x290c <__mulsi3> |
| 11f0: 9b 01 movw r18, r22 |
| 11f2: ac 01 movw r20, r24 |
| 11f4: f8 01 movw r30, r16 |
| 11f6: 80 89 ldd r24, Z+16 ; 0x10 |
| 11f8: 91 89 ldd r25, Z+17 ; 0x11 |
| 11fa: a2 89 ldd r26, Z+18 ; 0x12 |
| 11fc: b3 89 ldd r27, Z+19 ; 0x13 |
| 11fe: 28 0f add r18, r24 |
| 1200: 39 1f adc r19, r25 |
| 1202: 4a 1f adc r20, r26 |
| 1204: 5b 1f adc r21, r27 |
| fp->org_clust : get_cluster(fp->curr_clust); |
| if (clust < 2 || clust >= fs->max_clust) |
| goto fr_error; |
| fp->curr_clust = clust; /* Current cluster */ |
| sect = clust2sect(clust); /* Get current sector */ |
| fp->sect_clust = fs->sects_clust; /* Re-initialize the left sector counter */ |
| 1206: f4 01 movw r30, r8 |
| 1208: 85 8d ldd r24, Z+29 ; 0x1d |
| 120a: 8b 83 std Y+3, r24 ; 0x03 |
| } |
| fp->curr_sect = sect; /* Update current sector */ |
| 120c: 2a 8b std Y+18, r18 ; 0x12 |
| 120e: 3b 8b std Y+19, r19 ; 0x13 |
| 1210: 4c 8b std Y+20, r20 ; 0x14 |
| 1212: 5d 8b std Y+21, r21 ; 0x15 |
| cc = btr / 512; /* When left bytes >= 512, */ |
| 1214: 0f 2d mov r16, r15 |
| 1216: 06 95 lsr r16 |
| if (cc) { /* Read maximum contiguous sectors directly */ |
| 1218: 61 f1 breq .+88 ; 0x1272 <f_read+0x1a2> |
| 121a: 6b 81 ldd r22, Y+3 ; 0x03 |
| 121c: 10 2f mov r17, r16 |
| 121e: 60 17 cp r22, r16 |
| 1220: 08 f4 brcc .+2 ; 0x1224 <f_read+0x154> |
| 1222: 16 2f mov r17, r22 |
| if (cc > fp->sect_clust) cc = fp->sect_clust; |
| if (disk_read(0, rbuff, sect, cc) != RES_OK) |
| 1224: 01 2f mov r16, r17 |
| 1226: b6 01 movw r22, r12 |
| 1228: 80 e0 ldi r24, 0x00 ; 0 |
| 122a: 0e 94 9c 0f call 0x1f38 ; 0x1f38 <disk_read> |
| 122e: 89 2b or r24, r25 |
| 1230: 09 f0 breq .+2 ; 0x1234 <f_read+0x164> |
| 1232: 59 c0 rjmp .+178 ; 0x12e6 <f_read+0x216> |
| goto fr_error; |
| fp->sect_clust -= cc - 1; |
| 1234: 8b 81 ldd r24, Y+3 ; 0x03 |
| 1236: 8f 5f subi r24, 0xFF ; 255 |
| 1238: 81 1b sub r24, r17 |
| 123a: 8b 83 std Y+3, r24 ; 0x03 |
| fp->curr_sect += cc - 1; |
| 123c: 81 2f mov r24, r17 |
| 123e: 90 e0 ldi r25, 0x00 ; 0 |
| 1240: 01 97 sbiw r24, 0x01 ; 1 |
| 1242: 9c 01 movw r18, r24 |
| 1244: 44 27 eor r20, r20 |
| 1246: 37 fd sbrc r19, 7 |
| 1248: 40 95 com r20 |
| 124a: 54 2f mov r21, r20 |
| 124c: 8c 01 movw r16, r24 |
| 124e: 0f 5f subi r16, 0xFF ; 255 |
| 1250: 1f 4f sbci r17, 0xFF ; 255 |
| 1252: 8a 89 ldd r24, Y+18 ; 0x12 |
| 1254: 9b 89 ldd r25, Y+19 ; 0x13 |
| 1256: ac 89 ldd r26, Y+20 ; 0x14 |
| 1258: bd 89 ldd r27, Y+21 ; 0x15 |
| 125a: 82 0f add r24, r18 |
| 125c: 93 1f adc r25, r19 |
| 125e: a4 1f adc r26, r20 |
| 1260: b5 1f adc r27, r21 |
| 1262: 8a 8b std Y+18, r24 ; 0x12 |
| 1264: 9b 8b std Y+19, r25 ; 0x13 |
| 1266: ac 8b std Y+20, r26 ; 0x14 |
| 1268: bd 8b std Y+21, r27 ; 0x15 |
| rcnt = cc * 512; continue; |
| 126a: 10 2f mov r17, r16 |
| 126c: 00 27 eor r16, r16 |
| 126e: 11 0f add r17, r17 |
| 1270: 1b c0 rjmp .+54 ; 0x12a8 <f_read+0x1d8> |
| } |
| } |
| if (!move_window(fp->curr_sect)) goto fr_error; /* Move sector window */ |
| 1272: 6a 89 ldd r22, Y+18 ; 0x12 |
| 1274: 7b 89 ldd r23, Y+19 ; 0x13 |
| 1276: 8c 89 ldd r24, Y+20 ; 0x14 |
| 1278: 9d 89 ldd r25, Y+21 ; 0x15 |
| 127a: 0e 94 5a 03 call 0x6b4 ; 0x6b4 <move_window> |
| 127e: 88 23 and r24, r24 |
| 1280: 91 f1 breq .+100 ; 0x12e6 <f_read+0x216> |
| rcnt = 512 - (WORD)(fp->fptr % 512); /* Copy fractional bytes from sector window */ |
| 1282: 8e 81 ldd r24, Y+6 ; 0x06 |
| 1284: 9f 81 ldd r25, Y+7 ; 0x07 |
| 1286: 91 70 andi r25, 0x01 ; 1 |
| 1288: 92 01 movw r18, r4 |
| 128a: 28 1b sub r18, r24 |
| 128c: 39 0b sbc r19, r25 |
| 128e: 87 01 movw r16, r14 |
| 1290: 2e 15 cp r18, r14 |
| 1292: 3f 05 cpc r19, r15 |
| 1294: 08 f4 brcc .+2 ; 0x1298 <f_read+0x1c8> |
| 1296: 89 01 movw r16, r18 |
| if (rcnt > btr) rcnt = btr; |
| memcpy(rbuff, &fs->win[(WORD)fp->fptr % 512], rcnt); |
| 1298: 80 96 adiw r24, 0x20 ; 32 |
| 129a: 88 0d add r24, r8 |
| 129c: 99 1d adc r25, r9 |
| 129e: a8 01 movw r20, r16 |
| 12a0: bc 01 movw r22, r24 |
| 12a2: c6 01 movw r24, r12 |
| 12a4: 0e 94 a3 11 call 0x2346 ; 0x2346 <memcpy> |
| if (!(fp->flag & FA_READ)) return FR_DENIED; /* Check access mode */ |
| remain = fp->fsize - fp->fptr; |
| if (btr > remain) btr = (WORD)remain; /* Truncate read count by number of bytes left */ |
| |
| for ( ; btr; /* Repeat until all data transferred */ |
| rbuff += rcnt, fp->fptr += rcnt, *br += rcnt, btr -= rcnt) { |
| 12a8: c0 0e add r12, r16 |
| 12aa: d1 1e adc r13, r17 |
| 12ac: c8 01 movw r24, r16 |
| 12ae: a0 e0 ldi r26, 0x00 ; 0 |
| 12b0: b0 e0 ldi r27, 0x00 ; 0 |
| 12b2: 2e 81 ldd r18, Y+6 ; 0x06 |
| 12b4: 3f 81 ldd r19, Y+7 ; 0x07 |
| 12b6: 48 85 ldd r20, Y+8 ; 0x08 |
| 12b8: 59 85 ldd r21, Y+9 ; 0x09 |
| 12ba: 28 0f add r18, r24 |
| 12bc: 39 1f adc r19, r25 |
| 12be: 4a 1f adc r20, r26 |
| 12c0: 5b 1f adc r21, r27 |
| 12c2: 2e 83 std Y+6, r18 ; 0x06 |
| 12c4: 3f 83 std Y+7, r19 ; 0x07 |
| 12c6: 48 87 std Y+8, r20 ; 0x08 |
| 12c8: 59 87 std Y+9, r21 ; 0x09 |
| 12ca: f3 01 movw r30, r6 |
| 12cc: 80 81 ld r24, Z |
| 12ce: 91 81 ldd r25, Z+1 ; 0x01 |
| 12d0: 80 0f add r24, r16 |
| 12d2: 91 1f adc r25, r17 |
| 12d4: 91 83 std Z+1, r25 ; 0x01 |
| 12d6: 80 83 st Z, r24 |
| 12d8: e0 1a sub r14, r16 |
| 12da: f1 0a sbc r15, r17 |
| if (fp->flag & FA__ERROR) return FR_RW_ERROR; /* Check error flag */ |
| if (!(fp->flag & FA_READ)) return FR_DENIED; /* Check access mode */ |
| remain = fp->fsize - fp->fptr; |
| if (btr > remain) btr = (WORD)remain; /* Truncate read count by number of bytes left */ |
| |
| for ( ; btr; /* Repeat until all data transferred */ |
| 12dc: e1 14 cp r14, r1 |
| 12de: f1 04 cpc r15, r1 |
| 12e0: 09 f0 breq .+2 ; 0x12e4 <f_read+0x214> |
| 12e2: 35 cf rjmp .-406 ; 0x114e <f_read+0x7e> |
| 12e4: 06 c0 rjmp .+12 ; 0x12f2 <f_read+0x222> |
| } |
| |
| return FR_OK; |
| |
| fr_error: /* Abort this function due to an unrecoverable error */ |
| fp->flag |= FA__ERROR; |
| 12e6: 8a 81 ldd r24, Y+2 ; 0x02 |
| 12e8: 80 68 ori r24, 0x80 ; 128 |
| 12ea: 8a 83 std Y+2, r24 ; 0x02 |
| 12ec: 48 e0 ldi r20, 0x08 ; 8 |
| 12ee: a4 2e mov r10, r20 |
| 12f0: b1 2c mov r11, r1 |
| return FR_RW_ERROR; |
| } |
| 12f2: c5 01 movw r24, r10 |
| 12f4: cd b7 in r28, 0x3d ; 61 |
| 12f6: de b7 in r29, 0x3e ; 62 |
| 12f8: e0 e1 ldi r30, 0x10 ; 16 |
| 12fa: 0c 94 e5 14 jmp 0x29ca ; 0x29ca <__epilogue_restores__+0x4> |
| |
| 000012fe <f_mount>: |
| |
| FRESULT f_mount ( |
| BYTE drv, /* Logical drive number to be mounted/unmounted */ |
| FATFS *fs /* Pointer to new file system object (NULL for unmount)*/ |
| ) |
| { |
| 12fe: cf 93 push r28 |
| 1300: df 93 push r29 |
| 1302: fb 01 movw r30, r22 |
| FATFS *fsobj; |
| |
| |
| if (drv) return FR_INVALID_DRIVE; |
| 1304: 88 23 and r24, r24 |
| 1306: 19 f0 breq .+6 ; 0x130e <f_mount+0x10> |
| 1308: 25 e0 ldi r18, 0x05 ; 5 |
| 130a: 30 e0 ldi r19, 0x00 ; 0 |
| 130c: 1d c0 rjmp .+58 ; 0x1348 <f_mount+0x4a> |
| fsobj = FatFs; |
| 130e: a0 91 10 01 lds r26, 0x0110 |
| 1312: b0 91 11 01 lds r27, 0x0111 |
| FatFs = fs; |
| 1316: 70 93 11 01 sts 0x0111, r23 |
| 131a: 60 93 10 01 sts 0x0110, r22 |
| if (fsobj) memset(fsobj, 0, sizeof(FATFS)); |
| 131e: 10 97 sbiw r26, 0x00 ; 0 |
| 1320: 41 f0 breq .+16 ; 0x1332 <f_mount+0x34> |
| 1322: 80 e2 ldi r24, 0x20 ; 32 |
| 1324: 92 e0 ldi r25, 0x02 ; 2 |
| 1326: ed 01 movw r28, r26 |
| 1328: 9c 01 movw r18, r24 |
| 132a: 19 92 st Y+, r1 |
| 132c: 21 50 subi r18, 0x01 ; 1 |
| 132e: 30 40 sbci r19, 0x00 ; 0 |
| 1330: e1 f7 brne .-8 ; 0x132a <f_mount+0x2c> |
| if (fs) memset(fs, 0, sizeof(FATFS)); |
| 1332: 30 97 sbiw r30, 0x00 ; 0 |
| 1334: 39 f0 breq .+14 ; 0x1344 <f_mount+0x46> |
| 1336: 80 e2 ldi r24, 0x20 ; 32 |
| 1338: 92 e0 ldi r25, 0x02 ; 2 |
| 133a: df 01 movw r26, r30 |
| 133c: ec 01 movw r28, r24 |
| 133e: 1d 92 st X+, r1 |
| 1340: 21 97 sbiw r28, 0x01 ; 1 |
| 1342: e9 f7 brne .-6 ; 0x133e <f_mount+0x40> |
| 1344: 20 e0 ldi r18, 0x00 ; 0 |
| 1346: 30 e0 ldi r19, 0x00 ; 0 |
| |
| return FR_OK; |
| } |
| 1348: c9 01 movw r24, r18 |
| 134a: df 91 pop r29 |
| 134c: cf 91 pop r28 |
| 134e: 08 95 ret |
| |
| 00001350 <check_fs>: |
| |
| static |
| BYTE check_fs ( /* 0:The FAT boot record, 1:Valid boot record but not an FAT, 2:Not a boot record or error */ |
| DWORD sect /* Sector# to check if it is a FAT boot record or not */ |
| ) |
| { |
| 1350: 0f 93 push r16 |
| 1352: cf 93 push r28 |
| 1354: df 93 push r29 |
| 1356: 9b 01 movw r18, r22 |
| 1358: ac 01 movw r20, r24 |
| FATFS *fs = FatFs; |
| 135a: c0 91 10 01 lds r28, 0x0110 |
| 135e: d0 91 11 01 lds r29, 0x0111 |
| |
| if (disk_read(0, fs->win, sect, 1) != RES_OK) /* Load boot record */ |
| 1362: be 01 movw r22, r28 |
| 1364: 60 5e subi r22, 0xE0 ; 224 |
| 1366: 7f 4f sbci r23, 0xFF ; 255 |
| 1368: 01 e0 ldi r16, 0x01 ; 1 |
| 136a: 80 e0 ldi r24, 0x00 ; 0 |
| 136c: 0e 94 9c 0f call 0x1f38 ; 0x1f38 <disk_read> |
| 1370: 89 2b or r24, r25 |
| 1372: c1 f4 brne .+48 ; 0x13a4 <check_fs+0x54> |
| return 2; |
| if (LD_WORD(&fs->win[BS_55AA]) != 0xAA55) /* Check record signature */ |
| 1374: c2 5e subi r28, 0xE2 ; 226 |
| 1376: dd 4f sbci r29, 0xFD ; 253 |
| 1378: 88 81 ld r24, Y |
| 137a: 99 81 ldd r25, Y+1 ; 0x01 |
| 137c: ce 51 subi r28, 0x1E ; 30 |
| 137e: d2 40 sbci r29, 0x02 ; 2 |
| 1380: 85 55 subi r24, 0x55 ; 85 |
| 1382: 9a 4a sbci r25, 0xAA ; 170 |
| 1384: 79 f4 brne .+30 ; 0x13a4 <check_fs+0x54> |
| return 2; |
| |
| if (!memcmp(&fs->win[BS_FilSysType], "FAT", 3)) /* Check FAT signature */ |
| 1386: 43 e0 ldi r20, 0x03 ; 3 |
| 1388: 50 e0 ldi r21, 0x00 ; 0 |
| 138a: 67 e0 ldi r22, 0x07 ; 7 |
| 138c: 71 e0 ldi r23, 0x01 ; 1 |
| 138e: ce 01 movw r24, r28 |
| 1390: 8a 5a subi r24, 0xAA ; 170 |
| 1392: 9f 4f sbci r25, 0xFF ; 255 |
| 1394: 0e 94 96 11 call 0x232c ; 0x232c <memcmp> |
| 1398: 9c 01 movw r18, r24 |
| 139a: 80 e0 ldi r24, 0x00 ; 0 |
| 139c: 23 2b or r18, r19 |
| 139e: 19 f0 breq .+6 ; 0x13a6 <check_fs+0x56> |
| 13a0: 81 e0 ldi r24, 0x01 ; 1 |
| 13a2: 01 c0 rjmp .+2 ; 0x13a6 <check_fs+0x56> |
| 13a4: 82 e0 ldi r24, 0x02 ; 2 |
| #if _FAT32 |
| if (!memcmp(&fs->win[BS_FilSysType32], "FAT32", 5) && !(fs->win[BPB_ExtFlags] & 0x80)) |
| return 0; |
| #endif |
| return 1; |
| } |
| 13a6: df 91 pop r29 |
| 13a8: cf 91 pop r28 |
| 13aa: 0f 91 pop r16 |
| 13ac: 08 95 ret |
| |
| 000013ae <f_open>: |
| FRESULT f_open ( |
| FIL *fp, /* Pointer to the blank file object */ |
| const char *path, /* Pointer to the file name */ |
| BYTE mode /* Access mode and file open mode flags */ |
| ) |
| { |
| 13ae: ad e1 ldi r26, 0x1D ; 29 |
| 13b0: b0 e0 ldi r27, 0x00 ; 0 |
| 13b2: ed ed ldi r30, 0xDD ; 221 |
| 13b4: f9 e0 ldi r31, 0x09 ; 9 |
| 13b6: 0c 94 c7 14 jmp 0x298e ; 0x298e <__prologue_saves__> |
| 13ba: 9d 8f std Y+29, r25 ; 0x1d |
| 13bc: 8c 8f std Y+28, r24 ; 0x1c |
| 13be: 3b 01 movw r6, r22 |
| FRESULT res; |
| BYTE *dir; |
| DIR dirobj; |
| char fn[8+3+1]; |
| FATFS *fs = FatFs; |
| 13c0: 80 90 10 01 lds r8, 0x0110 |
| 13c4: 90 90 11 01 lds r9, 0x0111 |
| |
| |
| fp->fs = NULL; |
| 13c8: fc 01 movw r30, r24 |
| 13ca: 15 82 std Z+5, r1 ; 0x05 |
| 13cc: 14 82 std Z+4, r1 ; 0x04 |
| 13ce: 03 c0 rjmp .+6 ; 0x13d6 <f_open+0x28> |
| const char *p = *path; |
| FATFS *fs = FatFs; |
| |
| |
| |
| while (*p == ' ') p++; /* Strip leading spaces */ |
| 13d0: 08 94 sec |
| 13d2: 61 1c adc r6, r1 |
| 13d4: 71 1c adc r7, r1 |
| 13d6: f3 01 movw r30, r6 |
| 13d8: 80 81 ld r24, Z |
| 13da: 80 32 cpi r24, 0x20 ; 32 |
| 13dc: c9 f3 breq .-14 ; 0x13d0 <f_open+0x22> |
| if (*p == '/') p++; /* Strip heading slash */ |
| 13de: 8f 32 cpi r24, 0x2F ; 47 |
| 13e0: 19 f4 brne .+6 ; 0x13e8 <f_open+0x3a> |
| 13e2: 08 94 sec |
| 13e4: 61 1c adc r6, r1 |
| 13e6: 71 1c adc r7, r1 |
| *path = p; /* Return pointer to the path name */ |
| |
| /* Is the file system object registered? */ |
| if (!fs) return FR_NOT_ENABLED; |
| 13e8: 81 14 cp r8, r1 |
| 13ea: 91 04 cpc r9, r1 |
| 13ec: 09 f4 brne .+2 ; 0x13f0 <f_open+0x42> |
| 13ee: 17 c1 rjmp .+558 ; 0x161e <f_open+0x270> |
| FATFS *fs = FatFs; |
| |
| |
| fp->fs = NULL; |
| #if !_FS_READONLY |
| mode &= (FA_READ|FA_WRITE|FA_CREATE_ALWAYS|FA_OPEN_ALWAYS|FA_CREATE_NEW); |
| 13f0: f4 2f mov r31, r20 |
| 13f2: ff 71 andi r31, 0x1F ; 31 |
| 13f4: fb 8f std Y+27, r31 ; 0x1b |
| res = auto_mount(&path, (BYTE)(mode & (FA_WRITE|FA_CREATE_ALWAYS|FA_OPEN_ALWAYS|FA_CREATE_NEW))); |
| 13f6: 14 2f mov r17, r20 |
| 13f8: 1e 71 andi r17, 0x1E ; 30 |
| |
| /* Is the file system object registered? */ |
| if (!fs) return FR_NOT_ENABLED; |
| |
| /* Chekck if the logical drive has been mounted or not */ |
| if (fs->fs_type) { |
| 13fa: f4 01 movw r30, r8 |
| 13fc: 84 8d ldd r24, Z+28 ; 0x1c |
| 13fe: 88 23 and r24, r24 |
| 1400: 59 f0 breq .+22 ; 0x1418 <f_open+0x6a> |
| stat = disk_status(0); |
| 1402: 80 e0 ldi r24, 0x00 ; 0 |
| 1404: 0e 94 95 0f call 0x1f2a ; 0x1f2a <disk_status> |
| if (!(stat & STA_NOINIT)) { /* If the physical drive is kept initialized */ |
| 1408: 80 fd sbrc r24, 0 |
| 140a: 06 c0 rjmp .+12 ; 0x1418 <f_open+0x6a> |
| #if !_FS_READONLY |
| if (chk_wp && (stat & STA_PROTECT)) /* Check write protection if needed */ |
| 140c: 11 23 and r17, r17 |
| 140e: 09 f4 brne .+2 ; 0x1412 <f_open+0x64> |
| 1410: ab c3 rjmp .+1878 ; 0x1b68 <f_open+0x7ba> |
| 1412: 82 fd sbrc r24, 2 |
| 1414: 07 c1 rjmp .+526 ; 0x1624 <f_open+0x276> |
| 1416: a8 c3 rjmp .+1872 ; 0x1b68 <f_open+0x7ba> |
| } |
| } |
| |
| /* The logical drive has not been mounted, following code attempts to mount the logical drive */ |
| |
| memset(fs, 0, sizeof(FATFS)); /* Clean-up the file system object */ |
| 1418: 80 e2 ldi r24, 0x20 ; 32 |
| 141a: 92 e0 ldi r25, 0x02 ; 2 |
| 141c: f4 01 movw r30, r8 |
| 141e: 9c 01 movw r18, r24 |
| 1420: 11 92 st Z+, r1 |
| 1422: 21 50 subi r18, 0x01 ; 1 |
| 1424: 30 40 sbci r19, 0x00 ; 0 |
| 1426: e1 f7 brne .-8 ; 0x1420 <f_open+0x72> |
| stat = disk_initialize(0); /* Initialize low level disk I/O layer */ |
| 1428: 80 e0 ldi r24, 0x00 ; 0 |
| 142a: 0e 94 b8 0e call 0x1d70 ; 0x1d70 <disk_initialize> |
| if (stat & STA_NOINIT) /* Check if the drive is ready */ |
| 142e: 80 ff sbrs r24, 0 |
| 1430: 03 c0 rjmp .+6 ; 0x1438 <f_open+0x8a> |
| 1432: 21 e0 ldi r18, 0x01 ; 1 |
| 1434: 30 e0 ldi r19, 0x00 ; 0 |
| 1436: 8b c3 rjmp .+1814 ; 0x1b4e <f_open+0x7a0> |
| return FR_NOT_READY; |
| #if !_FS_READONLY |
| if (chk_wp && (stat & STA_PROTECT)) /* Check write protection if needed */ |
| 1438: 11 23 and r17, r17 |
| 143a: 11 f0 breq .+4 ; 0x1440 <f_open+0x92> |
| 143c: 82 fd sbrc r24, 2 |
| 143e: f2 c0 rjmp .+484 ; 0x1624 <f_open+0x276> |
| return FR_WRITE_PROTECTED; |
| #endif |
| |
| /* Search FAT partition on the drive */ |
| fmt = check_fs(bootsect = 0); /* Check sector 0 as an SFD format */ |
| 1440: 60 e0 ldi r22, 0x00 ; 0 |
| 1442: 70 e0 ldi r23, 0x00 ; 0 |
| 1444: 80 e0 ldi r24, 0x00 ; 0 |
| 1446: 90 e0 ldi r25, 0x00 ; 0 |
| 1448: 0e 94 a8 09 call 0x1350 ; 0x1350 <check_fs> |
| if (fmt == 1) { /* Not a FAT boot record, it may be patitioned */ |
| 144c: 81 30 cpi r24, 0x01 ; 1 |
| 144e: 21 f0 breq .+8 ; 0x1458 <f_open+0xaa> |
| 1450: ee 24 eor r14, r14 |
| 1452: ff 24 eor r15, r15 |
| 1454: 87 01 movw r16, r14 |
| 1456: 1e c0 rjmp .+60 ; 0x1494 <f_open+0xe6> |
| /* Check a partition listed in top of the partition table */ |
| if (fs->win[MBR_Table+4]) { /* Is the 1st partition existing? */ |
| 1458: 82 ee ldi r24, 0xE2 ; 226 |
| 145a: 91 e0 ldi r25, 0x01 ; 1 |
| 145c: 88 0e add r8, r24 |
| 145e: 99 1e adc r9, r25 |
| 1460: f4 01 movw r30, r8 |
| 1462: 80 81 ld r24, Z |
| 1464: 2e e1 ldi r18, 0x1E ; 30 |
| 1466: 3e ef ldi r19, 0xFE ; 254 |
| 1468: 82 0e add r8, r18 |
| 146a: 93 1e adc r9, r19 |
| 146c: 88 23 and r24, r24 |
| 146e: 09 f4 brne .+2 ; 0x1472 <f_open+0xc4> |
| 1470: dc c0 rjmp .+440 ; 0x162a <f_open+0x27c> |
| bootsect = LD_DWORD(&fs->win[MBR_Table+8]); /* Partition offset in LBA */ |
| 1472: 86 ee ldi r24, 0xE6 ; 230 |
| 1474: 91 e0 ldi r25, 0x01 ; 1 |
| 1476: 88 0e add r8, r24 |
| 1478: 99 1e adc r9, r25 |
| 147a: f4 01 movw r30, r8 |
| 147c: e0 80 ld r14, Z |
| 147e: f1 80 ldd r15, Z+1 ; 0x01 |
| 1480: 02 81 ldd r16, Z+2 ; 0x02 |
| 1482: 13 81 ldd r17, Z+3 ; 0x03 |
| 1484: 2a e1 ldi r18, 0x1A ; 26 |
| 1486: 3e ef ldi r19, 0xFE ; 254 |
| 1488: 82 0e add r8, r18 |
| 148a: 93 1e adc r9, r19 |
| fmt = check_fs(bootsect); /* Check the partition */ |
| 148c: c8 01 movw r24, r16 |
| 148e: b7 01 movw r22, r14 |
| 1490: 0e 94 a8 09 call 0x1350 ; 0x1350 <check_fs> |
| } |
| } |
| if (fmt || LD_WORD(&fs->win[BPB_BytsPerSec]) != 512) /* No valid FAT patition is found */ |
| 1494: 88 23 and r24, r24 |
| 1496: 09 f0 breq .+2 ; 0x149a <f_open+0xec> |
| 1498: c8 c0 rjmp .+400 ; 0x162a <f_open+0x27c> |
| 149a: f4 01 movw r30, r8 |
| 149c: 83 a5 ldd r24, Z+43 ; 0x2b |
| 149e: 94 a5 ldd r25, Z+44 ; 0x2c |
| 14a0: 80 50 subi r24, 0x00 ; 0 |
| 14a2: 92 40 sbci r25, 0x02 ; 2 |
| 14a4: 09 f0 breq .+2 ; 0x14a8 <f_open+0xfa> |
| 14a6: c1 c0 rjmp .+386 ; 0x162a <f_open+0x27c> |
| return FR_NO_FILESYSTEM; |
| |
| /* Initialize the file system object */ |
| fatsize = LD_WORD(&fs->win[BPB_FATSz16]); /* Number of sectors per FAT */ |
| 14a8: f4 01 movw r30, r8 |
| 14aa: 86 a9 ldd r24, Z+54 ; 0x36 |
| 14ac: 97 a9 ldd r25, Z+55 ; 0x37 |
| 14ae: bc 01 movw r22, r24 |
| 14b0: 80 e0 ldi r24, 0x00 ; 0 |
| 14b2: 90 e0 ldi r25, 0x00 ; 0 |
| if (!fatsize) fatsize = LD_DWORD(&fs->win[BPB_FATSz32]); |
| 14b4: 61 15 cp r22, r1 |
| 14b6: 71 05 cpc r23, r1 |
| 14b8: 81 05 cpc r24, r1 |
| 14ba: 91 05 cpc r25, r1 |
| 14bc: 69 f4 brne .+26 ; 0x14d8 <f_open+0x12a> |
| 14be: 24 e4 ldi r18, 0x44 ; 68 |
| 14c0: 30 e0 ldi r19, 0x00 ; 0 |
| 14c2: 82 0e add r8, r18 |
| 14c4: 93 1e adc r9, r19 |
| 14c6: f4 01 movw r30, r8 |
| 14c8: 60 81 ld r22, Z |
| 14ca: 71 81 ldd r23, Z+1 ; 0x01 |
| 14cc: 82 81 ldd r24, Z+2 ; 0x02 |
| 14ce: 93 81 ldd r25, Z+3 ; 0x03 |
| 14d0: 2c eb ldi r18, 0xBC ; 188 |
| 14d2: 3f ef ldi r19, 0xFF ; 255 |
| 14d4: 82 0e add r8, r18 |
| 14d6: 93 1e adc r9, r19 |
| fs->sects_fat = (CLUST)fatsize; |
| 14d8: f4 01 movw r30, r8 |
| 14da: 75 8b std Z+21, r23 ; 0x15 |
| 14dc: 64 8b std Z+20, r22 ; 0x14 |
| fs->n_fats = fs->win[BPB_NumFATs]; /* Number of FAT copies */ |
| 14de: 20 a9 ldd r18, Z+48 ; 0x30 |
| 14e0: 26 8f std Z+30, r18 ; 0x1e |
| fatsize *= fs->n_fats; /* (Number of sectors in FAT area) */ |
| 14e2: 30 e0 ldi r19, 0x00 ; 0 |
| 14e4: 40 e0 ldi r20, 0x00 ; 0 |
| 14e6: 50 e0 ldi r21, 0x00 ; 0 |
| 14e8: 0e 94 86 14 call 0x290c ; 0x290c <__mulsi3> |
| 14ec: 5b 01 movw r10, r22 |
| 14ee: 6c 01 movw r12, r24 |
| fs->fatbase = bootsect + LD_WORD(&fs->win[BPB_RsvdSecCnt]); /* FAT start sector (lba) */ |
| 14f0: f4 01 movw r30, r8 |
| 14f2: 86 a5 ldd r24, Z+46 ; 0x2e |
| 14f4: 97 a5 ldd r25, Z+47 ; 0x2f |
| 14f6: a0 e0 ldi r26, 0x00 ; 0 |
| 14f8: b0 e0 ldi r27, 0x00 ; 0 |
| 14fa: e8 0e add r14, r24 |
| 14fc: f9 1e adc r15, r25 |
| 14fe: 0a 1f adc r16, r26 |
| 1500: 1b 1f adc r17, r27 |
| 1502: e0 86 std Z+8, r14 ; 0x08 |
| 1504: f1 86 std Z+9, r15 ; 0x09 |
| 1506: 02 87 std Z+10, r16 ; 0x0a |
| 1508: 13 87 std Z+11, r17 ; 0x0b |
| fs->sects_clust = fs->win[BPB_SecPerClus]; /* Number of sectors per cluster */ |
| 150a: 85 a5 ldd r24, Z+45 ; 0x2d |
| 150c: 85 8f std Z+29, r24 ; 0x1d |
| fs->n_rootdir = LD_WORD(&fs->win[BPB_RootEntCnt]); /* Nmuber of root directory entries */ |
| 150e: 21 a9 ldd r18, Z+49 ; 0x31 |
| 1510: 32 a9 ldd r19, Z+50 ; 0x32 |
| 1512: 33 83 std Z+3, r19 ; 0x03 |
| 1514: 22 83 std Z+2, r18 ; 0x02 |
| totalsect = LD_WORD(&fs->win[BPB_TotSec16]); /* Number of sectors on the file system */ |
| 1516: 83 a9 ldd r24, Z+51 ; 0x33 |
| 1518: 94 a9 ldd r25, Z+52 ; 0x34 |
| 151a: 7c 01 movw r14, r24 |
| 151c: 00 e0 ldi r16, 0x00 ; 0 |
| 151e: 10 e0 ldi r17, 0x00 ; 0 |
| if (!totalsect) totalsect = LD_DWORD(&fs->win[BPB_TotSec32]); |
| 1520: e1 14 cp r14, r1 |
| 1522: f1 04 cpc r15, r1 |
| 1524: 01 05 cpc r16, r1 |
| 1526: 11 05 cpc r17, r1 |
| 1528: 69 f4 brne .+26 ; 0x1544 <f_open+0x196> |
| 152a: 80 e4 ldi r24, 0x40 ; 64 |
| 152c: 90 e0 ldi r25, 0x00 ; 0 |
| 152e: 88 0e add r8, r24 |
| 1530: 99 1e adc r9, r25 |
| 1532: f4 01 movw r30, r8 |
| 1534: e0 80 ld r14, Z |
| 1536: f1 80 ldd r15, Z+1 ; 0x01 |
| 1538: 02 81 ldd r16, Z+2 ; 0x02 |
| 153a: 13 81 ldd r17, Z+3 ; 0x03 |
| 153c: 80 ec ldi r24, 0xC0 ; 192 |
| 153e: 9f ef ldi r25, 0xFF ; 255 |
| 1540: 88 0e add r8, r24 |
| 1542: 99 1e adc r9, r25 |
| fs->max_clust = maxclust = (totalsect /* Last cluster# + 1 */ |
| 1544: f4 01 movw r30, r8 |
| 1546: 86 a5 ldd r24, Z+46 ; 0x2e |
| 1548: 97 a5 ldd r25, Z+47 ; 0x2f |
| 154a: a0 e0 ldi r26, 0x00 ; 0 |
| 154c: b0 e0 ldi r27, 0x00 ; 0 |
| 154e: e8 1a sub r14, r24 |
| 1550: f9 0a sbc r15, r25 |
| 1552: 0a 0b sbc r16, r26 |
| 1554: 1b 0b sbc r17, r27 |
| 1556: ea 18 sub r14, r10 |
| 1558: fb 08 sbc r15, r11 |
| 155a: 0c 09 sbc r16, r12 |
| 155c: 1d 09 sbc r17, r13 |
| 155e: a4 e0 ldi r26, 0x04 ; 4 |
| 1560: 36 95 lsr r19 |
| 1562: 27 95 ror r18 |
| 1564: aa 95 dec r26 |
| 1566: e1 f7 brne .-8 ; 0x1560 <f_open+0x1b2> |
| 1568: c9 01 movw r24, r18 |
| 156a: a0 e0 ldi r26, 0x00 ; 0 |
| 156c: b0 e0 ldi r27, 0x00 ; 0 |
| 156e: e8 1a sub r14, r24 |
| 1570: f9 0a sbc r15, r25 |
| 1572: 0a 0b sbc r16, r26 |
| 1574: 1b 0b sbc r17, r27 |
| 1576: 25 8d ldd r18, Z+29 ; 0x1d |
| 1578: 30 e0 ldi r19, 0x00 ; 0 |
| 157a: 40 e0 ldi r20, 0x00 ; 0 |
| 157c: 50 e0 ldi r21, 0x00 ; 0 |
| 157e: c8 01 movw r24, r16 |
| 1580: b7 01 movw r22, r14 |
| 1582: 0e 94 a5 14 call 0x294a ; 0x294a <__udivmodsi4> |
| 1586: 2e 5f subi r18, 0xFE ; 254 |
| 1588: 3f 4f sbci r19, 0xFF ; 255 |
| 158a: 4f 4f sbci r20, 0xFF ; 255 |
| 158c: 5f 4f sbci r21, 0xFF ; 255 |
| 158e: f4 01 movw r30, r8 |
| 1590: 37 8b std Z+23, r19 ; 0x17 |
| 1592: 26 8b std Z+22, r18 ; 0x16 |
| - LD_WORD(&fs->win[BPB_RsvdSecCnt]) - fatsize - fs->n_rootdir / 16 |
| ) / fs->sects_clust + 2; |
| |
| fmt = FS_FAT12; /* Determine the FAT sub type */ |
| if (maxclust > 0xFF7) fmt = FS_FAT16; |
| 1594: 28 3f cpi r18, 0xF8 ; 248 |
| 1596: ff e0 ldi r31, 0x0F ; 15 |
| 1598: 3f 07 cpc r19, r31 |
| 159a: f0 e0 ldi r31, 0x00 ; 0 |
| 159c: 4f 07 cpc r20, r31 |
| 159e: f0 e0 ldi r31, 0x00 ; 0 |
| 15a0: 5f 07 cpc r21, r31 |
| 15a2: 10 f4 brcc .+4 ; 0x15a8 <f_open+0x1fa> |
| 15a4: 61 e0 ldi r22, 0x01 ; 1 |
| 15a6: 06 c0 rjmp .+12 ; 0x15b4 <f_open+0x206> |
| if (maxclust > 0xFFF7) |
| 15a8: 28 5f subi r18, 0xF8 ; 248 |
| 15aa: 3f 4f sbci r19, 0xFF ; 255 |
| 15ac: 40 40 sbci r20, 0x00 ; 0 |
| 15ae: 50 40 sbci r21, 0x00 ; 0 |
| 15b0: e0 f5 brcc .+120 ; 0x162a <f_open+0x27c> |
| 15b2: 62 e0 ldi r22, 0x02 ; 2 |
| fmt = FS_FAT32; |
| if (fmt == FS_FAT32) |
| fs->dirbase = LD_DWORD(&fs->win[BPB_RootClus]); /* Root directory start cluster */ |
| else |
| #endif |
| fs->dirbase = fs->fatbase + fatsize; /* Root directory start sector (lba) */ |
| 15b4: f4 01 movw r30, r8 |
| 15b6: 20 85 ldd r18, Z+8 ; 0x08 |
| 15b8: 31 85 ldd r19, Z+9 ; 0x09 |
| 15ba: 42 85 ldd r20, Z+10 ; 0x0a |
| 15bc: 53 85 ldd r21, Z+11 ; 0x0b |
| 15be: d6 01 movw r26, r12 |
| 15c0: c5 01 movw r24, r10 |
| 15c2: 82 0f add r24, r18 |
| 15c4: 93 1f adc r25, r19 |
| 15c6: a4 1f adc r26, r20 |
| 15c8: b5 1f adc r27, r21 |
| 15ca: 84 87 std Z+12, r24 ; 0x0c |
| 15cc: 95 87 std Z+13, r25 ; 0x0d |
| 15ce: a6 87 std Z+14, r26 ; 0x0e |
| 15d0: b7 87 std Z+15, r27 ; 0x0f |
| fs->database = fs->fatbase + fatsize + fs->n_rootdir / 16; /* Data start sector (lba) */ |
| 15d2: 82 81 ldd r24, Z+2 ; 0x02 |
| 15d4: 93 81 ldd r25, Z+3 ; 0x03 |
| 15d6: 74 e0 ldi r23, 0x04 ; 4 |
| 15d8: 96 95 lsr r25 |
| 15da: 87 95 ror r24 |
| 15dc: 7a 95 dec r23 |
| 15de: e1 f7 brne .-8 ; 0x15d8 <f_open+0x22a> |
| 15e0: a0 e0 ldi r26, 0x00 ; 0 |
| 15e2: b0 e0 ldi r27, 0x00 ; 0 |
| 15e4: 82 0f add r24, r18 |
| 15e6: 93 1f adc r25, r19 |
| 15e8: a4 1f adc r26, r20 |
| 15ea: b5 1f adc r27, r21 |
| 15ec: 8a 0d add r24, r10 |
| 15ee: 9b 1d adc r25, r11 |
| 15f0: ac 1d adc r26, r12 |
| 15f2: bd 1d adc r27, r13 |
| 15f4: 80 8b std Z+16, r24 ; 0x10 |
| 15f6: 91 8b std Z+17, r25 ; 0x11 |
| 15f8: a2 8b std Z+18, r26 ; 0x12 |
| 15fa: b3 8b std Z+19, r27 ; 0x13 |
| fs->fs_type = fmt; /* FAT sub-type */ |
| 15fc: 64 8f std Z+28, r22 ; 0x1c |
| |
| #if !_FS_READONLY |
| fs->free_clust = (CLUST)0xFFFFFFFF; |
| 15fe: 8f ef ldi r24, 0xFF ; 255 |
| 1600: 9f ef ldi r25, 0xFF ; 255 |
| 1602: 93 8f std Z+27, r25 ; 0x1b |
| 1604: 82 8f std Z+26, r24 ; 0x1a |
| fs->free_clust = LD_DWORD(&fs->win[FSI_Free_Count]); |
| } |
| } |
| #endif |
| #endif |
| fs->id = ++fsid; /* File system mount ID */ |
| 1606: 80 91 12 01 lds r24, 0x0112 |
| 160a: 90 91 13 01 lds r25, 0x0113 |
| 160e: 01 96 adiw r24, 0x01 ; 1 |
| 1610: 90 93 13 01 sts 0x0113, r25 |
| 1614: 80 93 12 01 sts 0x0112, r24 |
| 1618: 91 83 std Z+1, r25 ; 0x01 |
| 161a: 80 83 st Z, r24 |
| 161c: a5 c2 rjmp .+1354 ; 0x1b68 <f_open+0x7ba> |
| 161e: 2a e0 ldi r18, 0x0A ; 10 |
| 1620: 30 e0 ldi r19, 0x00 ; 0 |
| 1622: 95 c2 rjmp .+1322 ; 0x1b4e <f_open+0x7a0> |
| 1624: 29 e0 ldi r18, 0x09 ; 9 |
| 1626: 30 e0 ldi r19, 0x00 ; 0 |
| 1628: 92 c2 rjmp .+1316 ; 0x1b4e <f_open+0x7a0> |
| 162a: 2b e0 ldi r18, 0x0B ; 11 |
| 162c: 30 e0 ldi r19, 0x00 ; 0 |
| 162e: 8f c2 rjmp .+1310 ; 0x1b4e <f_open+0x7a0> |
| ) |
| { |
| BYTE n, t, c, a, b; |
| |
| |
| memset(dirname, ' ', 8+3); /* Fill buffer with spaces */ |
| 1630: 2e 01 movw r4, r28 |
| 1632: 08 94 sec |
| 1634: 41 1c adc r4, r1 |
| 1636: 51 1c adc r5, r1 |
| ((DWORD)LD_WORD(&dptr[DIR_FstClusHI]) << 16) | |
| #endif |
| LD_WORD(&dptr[DIR_FstClusLO]); |
| dirobj->clust = dirobj->sclust = clust; /* Restart scannig with the new directory */ |
| dirobj->sect = clust2sect(clust); |
| dirobj->index = 2; |
| 1638: 92 e0 ldi r25, 0x02 ; 2 |
| 163a: 29 2e mov r2, r25 |
| 163c: 31 2c mov r3, r1 |
| ) |
| { |
| BYTE n, t, c, a, b; |
| |
| |
| memset(dirname, ' ', 8+3); /* Fill buffer with spaces */ |
| 163e: 4b e0 ldi r20, 0x0B ; 11 |
| 1640: 50 e0 ldi r21, 0x00 ; 0 |
| 1642: 60 e2 ldi r22, 0x20 ; 32 |
| 1644: 70 e0 ldi r23, 0x00 ; 0 |
| 1646: c2 01 movw r24, r4 |
| 1648: 0e 94 ac 11 call 0x2358 ; 0x2358 <memset> |
| 164c: 20 e0 ldi r18, 0x00 ; 0 |
| 164e: 48 e0 ldi r20, 0x08 ; 8 |
| 1650: 90 e0 ldi r25, 0x00 ; 0 |
| 1652: 38 e1 ldi r19, 0x18 ; 24 |
| 1654: 02 c0 rjmp .+4 ; 0x165a <f_open+0x2ac> |
| 1656: 28 e0 ldi r18, 0x08 ; 8 |
| 1658: 4b e0 ldi r20, 0x0B ; 11 |
| a = 0; b = 0x18; /* NT flag */ |
| n = 0; t = 8; |
| for (;;) { |
| c = *(*path)++; |
| 165a: f3 01 movw r30, r6 |
| 165c: 11 91 ld r17, Z+ |
| 165e: 3f 01 movw r6, r30 |
| if (c == '\0' || c == '/') { /* Reached to end of str or directory separator */ |
| 1660: 11 23 and r17, r17 |
| 1662: 11 f0 breq .+4 ; 0x1668 <f_open+0x2ba> |
| 1664: 1f 32 cpi r17, 0x2F ; 47 |
| 1666: 49 f4 brne .+18 ; 0x167a <f_open+0x2cc> |
| if (n == 0) break; |
| 1668: 22 23 and r18, r18 |
| 166a: 09 f4 brne .+2 ; 0x166e <f_open+0x2c0> |
| 166c: c7 c0 rjmp .+398 ; 0x17fc <f_open+0x44e> |
| dirname[11] = _USE_NTFLAG ? (a & b) : 0; |
| 166e: 39 23 and r19, r25 |
| 1670: 3c 87 std Y+12, r19 ; 0x0c |
| *dir = NULL; return FR_OK; |
| } |
| |
| for (;;) { |
| ds = make_dirfile(&path, fn); /* Get a paragraph into fn[] */ |
| if (ds == 1) return FR_INVALID_NAME; |
| 1672: 11 30 cpi r17, 0x01 ; 1 |
| 1674: 09 f0 breq .+2 ; 0x1678 <f_open+0x2ca> |
| 1676: 44 c0 rjmp .+136 ; 0x1700 <f_open+0x352> |
| 1678: c1 c0 rjmp .+386 ; 0x17fc <f_open+0x44e> |
| if (c == '\0' || c == '/') { /* Reached to end of str or directory separator */ |
| if (n == 0) break; |
| dirname[11] = _USE_NTFLAG ? (a & b) : 0; |
| return c; |
| } |
| if (c <= ' ' || c == 0x7F) break; /* Reject invisible chars */ |
| 167a: 11 32 cpi r17, 0x21 ; 33 |
| 167c: 08 f4 brcc .+2 ; 0x1680 <f_open+0x2d2> |
| 167e: be c0 rjmp .+380 ; 0x17fc <f_open+0x44e> |
| 1680: 1f 37 cpi r17, 0x7F ; 127 |
| 1682: 09 f4 brne .+2 ; 0x1686 <f_open+0x2d8> |
| 1684: bb c0 rjmp .+374 ; 0x17fc <f_open+0x44e> |
| if (c == '.') { |
| 1686: 1e 32 cpi r17, 0x2E ; 46 |
| 1688: 41 f4 brne .+16 ; 0x169a <f_open+0x2ec> |
| if (!(a & 1) && n >= 1 && n <= 8) { /* Enter extension part */ |
| 168a: 90 fd sbrc r25, 0 |
| 168c: b7 c0 rjmp .+366 ; 0x17fc <f_open+0x44e> |
| 168e: 22 23 and r18, r18 |
| 1690: 09 f4 brne .+2 ; 0x1694 <f_open+0x2e6> |
| 1692: b4 c0 rjmp .+360 ; 0x17fc <f_open+0x44e> |
| 1694: 29 30 cpi r18, 0x09 ; 9 |
| 1696: f8 f2 brcs .-66 ; 0x1656 <f_open+0x2a8> |
| 1698: b1 c0 rjmp .+354 ; 0x17fc <f_open+0x44e> |
| (c >= 0xE0 && c <= 0xFC))) { |
| if (n == 0 && c == 0xE5) /* Change heading \xE5 to \x05 */ |
| c = 0x05; |
| a ^= 1; goto md_l2; |
| } |
| if (c == '"') break; /* Reject " */ |
| 169a: 12 32 cpi r17, 0x22 ; 34 |
| 169c: 09 f4 brne .+2 ; 0x16a0 <f_open+0x2f2> |
| 169e: ae c0 rjmp .+348 ; 0x17fc <f_open+0x44e> |
| if (c <= ')') goto md_l1; /* Accept ! # $ % & ' ( ) */ |
| 16a0: 1a 32 cpi r17, 0x2A ; 42 |
| 16a2: 20 f1 brcs .+72 ; 0x16ec <f_open+0x33e> |
| if (c <= ',') break; /* Reject * + , */ |
| 16a4: 1d 32 cpi r17, 0x2D ; 45 |
| 16a6: 08 f4 brcc .+2 ; 0x16aa <f_open+0x2fc> |
| 16a8: a9 c0 rjmp .+338 ; 0x17fc <f_open+0x44e> |
| if (c <= '9') goto md_l1; /* Accept - 0-9 */ |
| 16aa: 1a 33 cpi r17, 0x3A ; 58 |
| 16ac: f8 f0 brcs .+62 ; 0x16ec <f_open+0x33e> |
| if (c <= '?') break; /* Reject : ; < = > ? */ |
| 16ae: 10 34 cpi r17, 0x40 ; 64 |
| 16b0: 08 f4 brcc .+2 ; 0x16b4 <f_open+0x306> |
| 16b2: a4 c0 rjmp .+328 ; 0x17fc <f_open+0x44e> |
| if (!(a & 1)) { /* These checks are not applied to S-JIS 2nd byte */ |
| 16b4: 90 fd sbrc r25, 0 |
| 16b6: 1a c0 rjmp .+52 ; 0x16ec <f_open+0x33e> |
| if (c == '|') break; /* Reject | */ |
| 16b8: 1c 37 cpi r17, 0x7C ; 124 |
| 16ba: 09 f4 brne .+2 ; 0x16be <f_open+0x310> |
| 16bc: 9f c0 rjmp .+318 ; 0x17fc <f_open+0x44e> |
| if (c >= '[' && c <= ']') break;/* Reject [ \ ] */ |
| 16be: 81 2f mov r24, r17 |
| 16c0: 8b 55 subi r24, 0x5B ; 91 |
| 16c2: 83 30 cpi r24, 0x03 ; 3 |
| 16c4: 08 f4 brcc .+2 ; 0x16c8 <f_open+0x31a> |
| 16c6: 9a c0 rjmp .+308 ; 0x17fc <f_open+0x44e> |
| if (_USE_NTFLAG && c >= 'A' && c <= 'Z') |
| 16c8: 86 5e subi r24, 0xE6 ; 230 |
| 16ca: 8a 31 cpi r24, 0x1A ; 26 |
| 16cc: 28 f4 brcc .+10 ; 0x16d8 <f_open+0x32a> |
| (t == 8) ? (b &= ~0x08) : (b &= ~0x10); |
| 16ce: 48 30 cpi r20, 0x08 ; 8 |
| 16d0: 11 f4 brne .+4 ; 0x16d6 <f_open+0x328> |
| 16d2: 37 7f andi r19, 0xF7 ; 247 |
| 16d4: 01 c0 rjmp .+2 ; 0x16d8 <f_open+0x32a> |
| 16d6: 3f 7e andi r19, 0xEF ; 239 |
| if (c >= 'a' && c <= 'z') { /* Convert to upper case */ |
| 16d8: 81 2f mov r24, r17 |
| 16da: 81 56 subi r24, 0x61 ; 97 |
| 16dc: 8a 31 cpi r24, 0x1A ; 26 |
| 16de: 30 f4 brcc .+12 ; 0x16ec <f_open+0x33e> |
| c -= 0x20; |
| 16e0: 10 52 subi r17, 0x20 ; 32 |
| if (_USE_NTFLAG) (t == 8) ? (a |= 0x08) : (a |= 0x10); |
| 16e2: 48 30 cpi r20, 0x08 ; 8 |
| 16e4: 11 f4 brne .+4 ; 0x16ea <f_open+0x33c> |
| 16e6: 98 60 ori r25, 0x08 ; 8 |
| 16e8: 01 c0 rjmp .+2 ; 0x16ec <f_open+0x33e> |
| 16ea: 90 61 ori r25, 0x10 ; 16 |
| } |
| } |
| md_l1: |
| a &= ~1; |
| md_l2: |
| if (n >= t) break; |
| 16ec: 24 17 cp r18, r20 |
| 16ee: 08 f0 brcs .+2 ; 0x16f2 <f_open+0x344> |
| 16f0: 85 c0 rjmp .+266 ; 0x17fc <f_open+0x44e> |
| c -= 0x20; |
| if (_USE_NTFLAG) (t == 8) ? (a |= 0x08) : (a |= 0x10); |
| } |
| } |
| md_l1: |
| a &= ~1; |
| 16f2: 9e 7f andi r25, 0xFE ; 254 |
| md_l2: |
| if (n >= t) break; |
| dirname[n++] = c; |
| 16f4: f2 01 movw r30, r4 |
| 16f6: e2 0f add r30, r18 |
| 16f8: f1 1d adc r31, r1 |
| 16fa: 10 83 st Z, r17 |
| 16fc: 2f 5f subi r18, 0xFF ; 255 |
| 16fe: ad cf rjmp .-166 ; 0x165a <f_open+0x2ac> |
| |
| for (;;) { |
| ds = make_dirfile(&path, fn); /* Get a paragraph into fn[] */ |
| if (ds == 1) return FR_INVALID_NAME; |
| for (;;) { |
| if (!move_window(dirobj->sect)) return FR_RW_ERROR; |
| 1700: 6f 89 ldd r22, Y+23 ; 0x17 |
| 1702: 78 8d ldd r23, Y+24 ; 0x18 |
| 1704: 89 8d ldd r24, Y+25 ; 0x19 |
| 1706: 9a 8d ldd r25, Y+26 ; 0x1a |
| 1708: 0e 94 5a 03 call 0x6b4 ; 0x6b4 <move_window> |
| 170c: 88 23 and r24, r24 |
| 170e: 31 f4 brne .+12 ; 0x171c <f_open+0x36e> |
| 1710: 90 e0 ldi r25, 0x00 ; 0 |
| 1712: 9c 01 movw r18, r24 |
| 1714: 59 01 movw r10, r18 |
| 1716: 28 e0 ldi r18, 0x08 ; 8 |
| 1718: 30 e0 ldi r19, 0x00 ; 0 |
| 171a: 84 c0 rjmp .+264 ; 0x1824 <f_open+0x476> |
| dptr = &fs->win[(dirobj->index & 15) * 32]; /* Pointer to the directory entry */ |
| 171c: 2f 85 ldd r18, Y+15 ; 0x0f |
| 171e: 38 89 ldd r19, Y+16 ; 0x10 |
| 1720: 2f 70 andi r18, 0x0F ; 15 |
| 1722: 30 70 andi r19, 0x00 ; 0 |
| 1724: 85 e0 ldi r24, 0x05 ; 5 |
| 1726: 22 0f add r18, r18 |
| 1728: 33 1f adc r19, r19 |
| 172a: 8a 95 dec r24 |
| 172c: e1 f7 brne .-8 ; 0x1726 <f_open+0x378> |
| if (dptr[DIR_Name] == 0) /* Has it reached to end of dir? */ |
| 172e: f6 01 movw r30, r12 |
| 1730: e2 0f add r30, r18 |
| 1732: f3 1f adc r31, r19 |
| 1734: 80 a1 ldd r24, Z+32 ; 0x20 |
| 1736: 88 23 and r24, r24 |
| 1738: e1 f0 breq .+56 ; 0x1772 <f_open+0x3c4> |
| return !ds ? FR_NO_FILE : FR_NO_PATH; |
| if (dptr[DIR_Name] != 0xE5 /* Matched? */ |
| 173a: 85 3e cpi r24, 0xE5 ; 229 |
| 173c: a1 f0 breq .+40 ; 0x1766 <f_open+0x3b8> |
| for (;;) { |
| ds = make_dirfile(&path, fn); /* Get a paragraph into fn[] */ |
| if (ds == 1) return FR_INVALID_NAME; |
| for (;;) { |
| if (!move_window(dirobj->sect)) return FR_RW_ERROR; |
| dptr = &fs->win[(dirobj->index & 15) * 32]; /* Pointer to the directory entry */ |
| 173e: 00 e2 ldi r16, 0x20 ; 32 |
| 1740: a0 2e mov r10, r16 |
| 1742: b1 2c mov r11, r1 |
| 1744: a2 0e add r10, r18 |
| 1746: b3 1e adc r11, r19 |
| 1748: ac 0c add r10, r12 |
| 174a: bd 1c adc r11, r13 |
| if (dptr[DIR_Name] == 0) /* Has it reached to end of dir? */ |
| return !ds ? FR_NO_FILE : FR_NO_PATH; |
| if (dptr[DIR_Name] != 0xE5 /* Matched? */ |
| 174c: f5 01 movw r30, r10 |
| 174e: 83 85 ldd r24, Z+11 ; 0x0b |
| 1750: 08 2f mov r16, r24 |
| 1752: 83 fd sbrc r24, 3 |
| 1754: 08 c0 rjmp .+16 ; 0x1766 <f_open+0x3b8> |
| 1756: 4b e0 ldi r20, 0x0B ; 11 |
| 1758: 50 e0 ldi r21, 0x00 ; 0 |
| 175a: b2 01 movw r22, r4 |
| 175c: c5 01 movw r24, r10 |
| 175e: 0e 94 96 11 call 0x232c ; 0x232c <memcmp> |
| 1762: 00 97 sbiw r24, 0x00 ; 0 |
| 1764: 51 f0 breq .+20 ; 0x177a <f_open+0x3cc> |
| && !(dptr[DIR_Attr] & AM_VOL) |
| && !memcmp(&dptr[DIR_Name], fn, 8+3) ) break; |
| if (!next_dir_entry(dirobj)) /* Next directory pointer */ |
| 1766: ce 01 movw r24, r28 |
| 1768: 0d 96 adiw r24, 0x0d ; 13 |
| 176a: 0e 94 2c 06 call 0xc58 ; 0xc58 <next_dir_entry> |
| 176e: 88 23 and r24, r24 |
| 1770: 39 f6 brne .-114 ; 0x1700 <f_open+0x352> |
| return !ds ? FR_NO_FILE : FR_NO_PATH; |
| 1772: 11 23 and r17, r17 |
| 1774: 09 f0 breq .+2 ; 0x1778 <f_open+0x3ca> |
| 1776: 49 c0 rjmp .+146 ; 0x180a <f_open+0x45c> |
| 1778: 4f c0 rjmp .+158 ; 0x1818 <f_open+0x46a> |
| } |
| if (!ds) { *dir = dptr; return FR_OK; } /* Matched with end of path */ |
| 177a: 11 23 and r17, r17 |
| 177c: 19 f4 brne .+6 ; 0x1784 <f_open+0x3d6> |
| 177e: 20 e0 ldi r18, 0x00 ; 0 |
| 1780: 30 e0 ldi r19, 0x00 ; 0 |
| 1782: 50 c0 rjmp .+160 ; 0x1824 <f_open+0x476> |
| if (!(dptr[DIR_Attr] & AM_DIR)) return FR_NO_PATH; /* Cannot trace because it is a file */ |
| 1784: 04 ff sbrs r16, 4 |
| 1786: 41 c0 rjmp .+130 ; 0x180a <f_open+0x45c> |
| clust = /* Get cluster# of the directory */ |
| 1788: f5 01 movw r30, r10 |
| 178a: e2 8c ldd r14, Z+26 ; 0x1a |
| 178c: f3 8c ldd r15, Z+27 ; 0x1b |
| #if _FAT32 |
| ((DWORD)LD_WORD(&dptr[DIR_FstClusHI]) << 16) | |
| #endif |
| LD_WORD(&dptr[DIR_FstClusLO]); |
| dirobj->clust = dirobj->sclust = clust; /* Restart scannig with the new directory */ |
| 178e: fe 8a std Y+22, r15 ; 0x16 |
| 1790: ed 8a std Y+21, r14 ; 0x15 |
| static |
| DWORD clust2sect ( /* !=0: sector number, 0: failed - invalid cluster# */ |
| CLUST clust /* Cluster# to be converted */ |
| ) |
| { |
| FATFS *fs = FatFs; |
| 1792: 00 91 10 01 lds r16, 0x0110 |
| 1796: 10 91 11 01 lds r17, 0x0111 |
| |
| |
| clust -= 2; |
| 179a: b7 01 movw r22, r14 |
| 179c: 62 50 subi r22, 0x02 ; 2 |
| 179e: 70 40 sbci r23, 0x00 ; 0 |
| if (clust >= (fs->max_clust - 2)) return 0; /* Invalid cluster# */ |
| 17a0: f8 01 movw r30, r16 |
| 17a2: 86 89 ldd r24, Z+22 ; 0x16 |
| 17a4: 97 89 ldd r25, Z+23 ; 0x17 |
| 17a6: 02 97 sbiw r24, 0x02 ; 2 |
| 17a8: 68 17 cp r22, r24 |
| 17aa: 79 07 cpc r23, r25 |
| 17ac: 28 f0 brcs .+10 ; 0x17b8 <f_open+0x40a> |
| 17ae: 20 e0 ldi r18, 0x00 ; 0 |
| 17b0: 30 e0 ldi r19, 0x00 ; 0 |
| 17b2: 40 e0 ldi r20, 0x00 ; 0 |
| 17b4: 50 e0 ldi r21, 0x00 ; 0 |
| 17b6: 14 c0 rjmp .+40 ; 0x17e0 <f_open+0x432> |
| return (DWORD)clust * fs->sects_clust + fs->database; |
| 17b8: 80 e0 ldi r24, 0x00 ; 0 |
| 17ba: 90 e0 ldi r25, 0x00 ; 0 |
| 17bc: f8 01 movw r30, r16 |
| 17be: 25 8d ldd r18, Z+29 ; 0x1d |
| 17c0: 30 e0 ldi r19, 0x00 ; 0 |
| 17c2: 40 e0 ldi r20, 0x00 ; 0 |
| 17c4: 50 e0 ldi r21, 0x00 ; 0 |
| 17c6: 0e 94 86 14 call 0x290c ; 0x290c <__mulsi3> |
| 17ca: 9b 01 movw r18, r22 |
| 17cc: ac 01 movw r20, r24 |
| 17ce: f8 01 movw r30, r16 |
| 17d0: 80 89 ldd r24, Z+16 ; 0x10 |
| 17d2: 91 89 ldd r25, Z+17 ; 0x11 |
| 17d4: a2 89 ldd r26, Z+18 ; 0x12 |
| 17d6: b3 89 ldd r27, Z+19 ; 0x13 |
| 17d8: 28 0f add r18, r24 |
| 17da: 39 1f adc r19, r25 |
| 17dc: 4a 1f adc r20, r26 |
| 17de: 5b 1f adc r21, r27 |
| clust = /* Get cluster# of the directory */ |
| #if _FAT32 |
| ((DWORD)LD_WORD(&dptr[DIR_FstClusHI]) << 16) | |
| #endif |
| LD_WORD(&dptr[DIR_FstClusLO]); |
| dirobj->clust = dirobj->sclust = clust; /* Restart scannig with the new directory */ |
| 17e0: fc 8a std Y+20, r15 ; 0x14 |
| 17e2: eb 8a std Y+19, r14 ; 0x13 |
| dirobj->sect = clust2sect(clust); |
| 17e4: 2f 8b std Y+23, r18 ; 0x17 |
| 17e6: 38 8f std Y+24, r19 ; 0x18 |
| 17e8: 49 8f std Y+25, r20 ; 0x19 |
| 17ea: 5a 8f std Y+26, r21 ; 0x1a |
| dirobj->index = 2; |
| 17ec: 38 8a std Y+16, r3 ; 0x10 |
| 17ee: 2f 86 std Y+15, r2 ; 0x0f |
| 17f0: 26 cf rjmp .-436 ; 0x163e <f_open+0x290> |
| 17f2: 20 e0 ldi r18, 0x00 ; 0 |
| 17f4: 30 e0 ldi r19, 0x00 ; 0 |
| 17f6: aa 24 eor r10, r10 |
| 17f8: bb 24 eor r11, r11 |
| 17fa: 14 c0 rjmp .+40 ; 0x1824 <f_open+0x476> |
| 17fc: 80 e0 ldi r24, 0x00 ; 0 |
| 17fe: 90 e0 ldi r25, 0x00 ; 0 |
| 1800: 9c 01 movw r18, r24 |
| 1802: 59 01 movw r10, r18 |
| 1804: 24 e0 ldi r18, 0x04 ; 4 |
| 1806: 30 e0 ldi r19, 0x00 ; 0 |
| 1808: 0d c0 rjmp .+26 ; 0x1824 <f_open+0x476> |
| 180a: 80 e0 ldi r24, 0x00 ; 0 |
| 180c: 90 e0 ldi r25, 0x00 ; 0 |
| 180e: 9c 01 movw r18, r24 |
| 1810: 59 01 movw r10, r18 |
| 1812: 23 e0 ldi r18, 0x03 ; 3 |
| 1814: 30 e0 ldi r19, 0x00 ; 0 |
| 1816: 06 c0 rjmp .+12 ; 0x1824 <f_open+0x476> |
| 1818: 80 e0 ldi r24, 0x00 ; 0 |
| 181a: 90 e0 ldi r25, 0x00 ; 0 |
| 181c: 9c 01 movw r18, r24 |
| 181e: 59 01 movw r10, r18 |
| 1820: 22 e0 ldi r18, 0x02 ; 2 |
| 1822: 30 e0 ldi r19, 0x00 ; 0 |
| /* Trace the file path */ |
| res = trace_path(&dirobj, fn, path, &dir); /* Trace the file path */ |
| |
| #if !_FS_READONLY |
| /* Create or Open a File */ |
| if (mode & (FA_CREATE_ALWAYS|FA_OPEN_ALWAYS|FA_CREATE_NEW)) { |
| 1824: fb 8d ldd r31, Y+27 ; 0x1b |
| 1826: 4f 2f mov r20, r31 |
| 1828: 50 e0 ldi r21, 0x00 ; 0 |
| 182a: ca 01 movw r24, r20 |
| 182c: 8c 71 andi r24, 0x1C ; 28 |
| 182e: 90 70 andi r25, 0x00 ; 0 |
| 1830: 89 2b or r24, r25 |
| 1832: 09 f4 brne .+2 ; 0x1836 <f_open+0x488> |
| 1834: 41 c1 rjmp .+642 ; 0x1ab8 <f_open+0x70a> |
| CLUST rs; |
| DWORD dw; |
| if (res != FR_OK) { /* No file, create new */ |
| 1836: 21 15 cp r18, r1 |
| 1838: 31 05 cpc r19, r1 |
| 183a: 09 f4 brne .+2 ; 0x183e <f_open+0x490> |
| 183c: d6 c0 rjmp .+428 ; 0x19ea <f_open+0x63c> |
| if (res != FR_NO_FILE) return res; |
| 183e: 22 30 cpi r18, 0x02 ; 2 |
| 1840: 31 05 cpc r19, r1 |
| 1842: 09 f0 breq .+2 ; 0x1846 <f_open+0x498> |
| 1844: 84 c1 rjmp .+776 ; 0x1b4e <f_open+0x7a0> |
| ) |
| { |
| CLUST clust; |
| DWORD sector; |
| BYTE c, n, *dptr; |
| FATFS *fs = FatFs; |
| 1846: 60 90 10 01 lds r6, 0x0110 |
| 184a: 70 90 11 01 lds r7, 0x0111 |
| |
| |
| /* Re-initialize directory object */ |
| clust = dirobj->sclust; |
| 184e: 0b 89 ldd r16, Y+19 ; 0x13 |
| 1850: 1c 89 ldd r17, Y+20 ; 0x14 |
| if (clust) { /* Dyanmic directory table */ |
| 1852: 01 15 cp r16, r1 |
| 1854: 11 05 cpc r17, r1 |
| 1856: 51 f1 breq .+84 ; 0x18ac <f_open+0x4fe> |
| dirobj->clust = clust; |
| 1858: 1e 8b std Y+22, r17 ; 0x16 |
| 185a: 0d 8b std Y+21, r16 ; 0x15 |
| ) |
| { |
| FATFS *fs = FatFs; |
| |
| |
| clust -= 2; |
| 185c: b8 01 movw r22, r16 |
| 185e: 62 50 subi r22, 0x02 ; 2 |
| 1860: 70 40 sbci r23, 0x00 ; 0 |
| if (clust >= (fs->max_clust - 2)) return 0; /* Invalid cluster# */ |
| 1862: f3 01 movw r30, r6 |
| 1864: 86 89 ldd r24, Z+22 ; 0x16 |
| 1866: 97 89 ldd r25, Z+23 ; 0x17 |
| 1868: 02 97 sbiw r24, 0x02 ; 2 |
| 186a: 68 17 cp r22, r24 |
| 186c: 79 07 cpc r23, r25 |
| 186e: 28 f0 brcs .+10 ; 0x187a <f_open+0x4cc> |
| 1870: 20 e0 ldi r18, 0x00 ; 0 |
| 1872: 30 e0 ldi r19, 0x00 ; 0 |
| 1874: 40 e0 ldi r20, 0x00 ; 0 |
| 1876: 50 e0 ldi r21, 0x00 ; 0 |
| 1878: 14 c0 rjmp .+40 ; 0x18a2 <f_open+0x4f4> |
| return (DWORD)clust * fs->sects_clust + fs->database; |
| 187a: 80 e0 ldi r24, 0x00 ; 0 |
| 187c: 90 e0 ldi r25, 0x00 ; 0 |
| 187e: f3 01 movw r30, r6 |
| 1880: 25 8d ldd r18, Z+29 ; 0x1d |
| 1882: 30 e0 ldi r19, 0x00 ; 0 |
| 1884: 40 e0 ldi r20, 0x00 ; 0 |
| 1886: 50 e0 ldi r21, 0x00 ; 0 |
| 1888: 0e 94 86 14 call 0x290c ; 0x290c <__mulsi3> |
| 188c: 9b 01 movw r18, r22 |
| 188e: ac 01 movw r20, r24 |
| 1890: f3 01 movw r30, r6 |
| 1892: 80 89 ldd r24, Z+16 ; 0x10 |
| 1894: 91 89 ldd r25, Z+17 ; 0x11 |
| 1896: a2 89 ldd r26, Z+18 ; 0x12 |
| 1898: b3 89 ldd r27, Z+19 ; 0x13 |
| 189a: 28 0f add r18, r24 |
| 189c: 39 1f adc r19, r25 |
| 189e: 4a 1f adc r20, r26 |
| 18a0: 5b 1f adc r21, r27 |
| |
| /* Re-initialize directory object */ |
| clust = dirobj->sclust; |
| if (clust) { /* Dyanmic directory table */ |
| dirobj->clust = clust; |
| dirobj->sect = clust2sect(clust); |
| 18a2: 2f 8b std Y+23, r18 ; 0x17 |
| 18a4: 38 8f std Y+24, r19 ; 0x18 |
| 18a6: 49 8f std Y+25, r20 ; 0x19 |
| 18a8: 5a 8f std Y+26, r21 ; 0x1a |
| 18aa: 09 c0 rjmp .+18 ; 0x18be <f_open+0x510> |
| } else { /* Static directory table */ |
| dirobj->sect = fs->dirbase; |
| 18ac: f3 01 movw r30, r6 |
| 18ae: 84 85 ldd r24, Z+12 ; 0x0c |
| 18b0: 95 85 ldd r25, Z+13 ; 0x0d |
| 18b2: a6 85 ldd r26, Z+14 ; 0x0e |
| 18b4: b7 85 ldd r27, Z+15 ; 0x0f |
| 18b6: 8f 8b std Y+23, r24 ; 0x17 |
| 18b8: 98 8f std Y+24, r25 ; 0x18 |
| 18ba: a9 8f std Y+25, r26 ; 0x19 |
| 18bc: ba 8f std Y+26, r27 ; 0x1a |
| } |
| dirobj->index = 0; |
| 18be: 18 8a std Y+16, r1 ; 0x10 |
| 18c0: 1f 86 std Y+15, r1 ; 0x0f |
| dptr = &fs->win[(dirobj->index & 15) * 32]; /* Pointer to the directory entry */ |
| c = dptr[DIR_Name]; |
| if (c == 0 || c == 0xE5) { /* Found an empty entry! */ |
| *dir = dptr; return FR_OK; |
| } |
| } while (next_dir_entry(dirobj)); /* Next directory pointer */ |
| 18c2: bd e0 ldi r27, 0x0D ; 13 |
| 18c4: eb 2e mov r14, r27 |
| 18c6: f1 2c mov r15, r1 |
| 18c8: ec 0e add r14, r28 |
| 18ca: fd 1e adc r15, r29 |
| dirobj->sect = fs->dirbase; |
| } |
| dirobj->index = 0; |
| |
| do { |
| if (!move_window(dirobj->sect)) return FR_RW_ERROR; |
| 18cc: 6f 89 ldd r22, Y+23 ; 0x17 |
| 18ce: 78 8d ldd r23, Y+24 ; 0x18 |
| 18d0: 89 8d ldd r24, Y+25 ; 0x19 |
| 18d2: 9a 8d ldd r25, Y+26 ; 0x1a |
| 18d4: 0e 94 5a 03 call 0x6b4 ; 0x6b4 <move_window> |
| 18d8: 88 23 and r24, r24 |
| 18da: 09 f4 brne .+2 ; 0x18de <f_open+0x530> |
| 18dc: 33 c1 rjmp .+614 ; 0x1b44 <f_open+0x796> |
| dptr = &fs->win[(dirobj->index & 15) * 32]; /* Pointer to the directory entry */ |
| 18de: ef 85 ldd r30, Y+15 ; 0x0f |
| 18e0: f8 89 ldd r31, Y+16 ; 0x10 |
| 18e2: ef 70 andi r30, 0x0F ; 15 |
| 18e4: f0 70 andi r31, 0x00 ; 0 |
| 18e6: a5 e0 ldi r26, 0x05 ; 5 |
| 18e8: ee 0f add r30, r30 |
| 18ea: ff 1f adc r31, r31 |
| 18ec: aa 95 dec r26 |
| 18ee: e1 f7 brne .-8 ; 0x18e8 <f_open+0x53a> |
| 18f0: b0 96 adiw r30, 0x20 ; 32 |
| 18f2: 53 01 movw r10, r6 |
| 18f4: ae 0e add r10, r30 |
| 18f6: bf 1e adc r11, r31 |
| 18f8: b0 97 sbiw r30, 0x20 ; 32 |
| c = dptr[DIR_Name]; |
| 18fa: e6 0d add r30, r6 |
| 18fc: f7 1d adc r31, r7 |
| 18fe: 80 a1 ldd r24, Z+32 ; 0x20 |
| if (c == 0 || c == 0xE5) { /* Found an empty entry! */ |
| 1900: 88 23 and r24, r24 |
| 1902: 09 f4 brne .+2 ; 0x1906 <f_open+0x558> |
| 1904: 4c c1 rjmp .+664 ; 0x1b9e <f_open+0x7f0> |
| 1906: 85 3e cpi r24, 0xE5 ; 229 |
| 1908: 09 f4 brne .+2 ; 0x190c <f_open+0x55e> |
| 190a: 49 c1 rjmp .+658 ; 0x1b9e <f_open+0x7f0> |
| *dir = dptr; return FR_OK; |
| } |
| } while (next_dir_entry(dirobj)); /* Next directory pointer */ |
| 190c: c7 01 movw r24, r14 |
| 190e: 0e 94 2c 06 call 0xc58 ; 0xc58 <next_dir_entry> |
| 1912: 88 23 and r24, r24 |
| 1914: d9 f6 brne .-74 ; 0x18cc <f_open+0x51e> |
| /* Reached to end of the directory table */ |
| |
| /* Abort when static table or could not stretch dynamic table */ |
| if (!clust || !(clust = create_chain(dirobj->clust))) return FR_DENIED; |
| 1916: 01 15 cp r16, r1 |
| 1918: 11 05 cpc r17, r1 |
| 191a: 09 f4 brne .+2 ; 0x191e <f_open+0x570> |
| 191c: 10 c1 rjmp .+544 ; 0x1b3e <f_open+0x790> |
| 191e: 8d 89 ldd r24, Y+21 ; 0x15 |
| 1920: 9e 89 ldd r25, Y+22 ; 0x16 |
| 1922: 0e 94 d1 04 call 0x9a2 ; 0x9a2 <create_chain> |
| 1926: 8c 01 movw r16, r24 |
| 1928: 00 97 sbiw r24, 0x00 ; 0 |
| 192a: 09 f4 brne .+2 ; 0x192e <f_open+0x580> |
| 192c: 08 c1 rjmp .+528 ; 0x1b3e <f_open+0x790> |
| if (clust == 1 || !move_window(0)) return FR_RW_ERROR; |
| 192e: 81 30 cpi r24, 0x01 ; 1 |
| 1930: 91 05 cpc r25, r1 |
| 1932: 09 f4 brne .+2 ; 0x1936 <f_open+0x588> |
| 1934: 07 c1 rjmp .+526 ; 0x1b44 <f_open+0x796> |
| 1936: 60 e0 ldi r22, 0x00 ; 0 |
| 1938: 70 e0 ldi r23, 0x00 ; 0 |
| 193a: 80 e0 ldi r24, 0x00 ; 0 |
| 193c: 90 e0 ldi r25, 0x00 ; 0 |
| 193e: 0e 94 5a 03 call 0x6b4 ; 0x6b4 <move_window> |
| 1942: 88 23 and r24, r24 |
| 1944: 09 f4 brne .+2 ; 0x1948 <f_open+0x59a> |
| 1946: fe c0 rjmp .+508 ; 0x1b44 <f_open+0x796> |
| static |
| DWORD clust2sect ( /* !=0: sector number, 0: failed - invalid cluster# */ |
| CLUST clust /* Cluster# to be converted */ |
| ) |
| { |
| FATFS *fs = FatFs; |
| 1948: a0 90 10 01 lds r10, 0x0110 |
| 194c: b0 90 11 01 lds r11, 0x0111 |
| |
| |
| clust -= 2; |
| 1950: b8 01 movw r22, r16 |
| 1952: 62 50 subi r22, 0x02 ; 2 |
| 1954: 70 40 sbci r23, 0x00 ; 0 |
| if (clust >= (fs->max_clust - 2)) return 0; /* Invalid cluster# */ |
| 1956: f5 01 movw r30, r10 |
| 1958: 86 89 ldd r24, Z+22 ; 0x16 |
| 195a: 97 89 ldd r25, Z+23 ; 0x17 |
| 195c: 02 97 sbiw r24, 0x02 ; 2 |
| 195e: 68 17 cp r22, r24 |
| 1960: 79 07 cpc r23, r25 |
| 1962: 20 f0 brcs .+8 ; 0x196c <f_open+0x5be> |
| 1964: cc 24 eor r12, r12 |
| 1966: dd 24 eor r13, r13 |
| 1968: 76 01 movw r14, r12 |
| 196a: 14 c0 rjmp .+40 ; 0x1994 <f_open+0x5e6> |
| return (DWORD)clust * fs->sects_clust + fs->database; |
| 196c: 80 e0 ldi r24, 0x00 ; 0 |
| 196e: 90 e0 ldi r25, 0x00 ; 0 |
| 1970: f5 01 movw r30, r10 |
| 1972: 25 8d ldd r18, Z+29 ; 0x1d |
| 1974: 30 e0 ldi r19, 0x00 ; 0 |
| 1976: 40 e0 ldi r20, 0x00 ; 0 |
| 1978: 50 e0 ldi r21, 0x00 ; 0 |
| 197a: 0e 94 86 14 call 0x290c ; 0x290c <__mulsi3> |
| 197e: 6b 01 movw r12, r22 |
| 1980: 7c 01 movw r14, r24 |
| 1982: f5 01 movw r30, r10 |
| 1984: 80 89 ldd r24, Z+16 ; 0x10 |
| 1986: 91 89 ldd r25, Z+17 ; 0x11 |
| 1988: a2 89 ldd r26, Z+18 ; 0x12 |
| 198a: b3 89 ldd r27, Z+19 ; 0x13 |
| 198c: c8 0e add r12, r24 |
| 198e: d9 1e adc r13, r25 |
| 1990: ea 1e adc r14, r26 |
| 1992: fb 1e adc r15, r27 |
| |
| /* Abort when static table or could not stretch dynamic table */ |
| if (!clust || !(clust = create_chain(dirobj->clust))) return FR_DENIED; |
| if (clust == 1 || !move_window(0)) return FR_RW_ERROR; |
| |
| fs->winsect = sector = clust2sect(clust); /* Cleanup the expanded table */ |
| 1994: f3 01 movw r30, r6 |
| 1996: c4 82 std Z+4, r12 ; 0x04 |
| 1998: d5 82 std Z+5, r13 ; 0x05 |
| 199a: e6 82 std Z+6, r14 ; 0x06 |
| 199c: f7 82 std Z+7, r15 ; 0x07 |
| memset(fs->win, 0, 512); |
| 199e: e0 e2 ldi r30, 0x20 ; 32 |
| 19a0: ae 2e mov r10, r30 |
| 19a2: b1 2c mov r11, r1 |
| 19a4: a6 0c add r10, r6 |
| 19a6: b7 1c adc r11, r7 |
| 19a8: 80 e0 ldi r24, 0x00 ; 0 |
| 19aa: 92 e0 ldi r25, 0x02 ; 2 |
| 19ac: f5 01 movw r30, r10 |
| 19ae: 9c 01 movw r18, r24 |
| 19b0: 11 92 st Z+, r1 |
| 19b2: 21 50 subi r18, 0x01 ; 1 |
| 19b4: 30 40 sbci r19, 0x00 ; 0 |
| 19b6: e1 f7 brne .-8 ; 0x19b0 <f_open+0x602> |
| for (n = fs->sects_clust; n; n--) { |
| 19b8: f3 01 movw r30, r6 |
| 19ba: 15 8d ldd r17, Z+29 ; 0x1d |
| 19bc: 10 c0 rjmp .+32 ; 0x19de <f_open+0x630> |
| if (disk_write(0, fs->win, sector, 1) != RES_OK) |
| 19be: 01 e0 ldi r16, 0x01 ; 1 |
| 19c0: a7 01 movw r20, r14 |
| 19c2: 96 01 movw r18, r12 |
| 19c4: b5 01 movw r22, r10 |
| 19c6: 80 e0 ldi r24, 0x00 ; 0 |
| 19c8: 0e 94 fb 0f call 0x1ff6 ; 0x1ff6 <disk_write> |
| 19cc: 89 2b or r24, r25 |
| 19ce: 09 f0 breq .+2 ; 0x19d2 <f_open+0x624> |
| 19d0: b9 c0 rjmp .+370 ; 0x1b44 <f_open+0x796> |
| return FR_RW_ERROR; |
| sector++; |
| 19d2: 08 94 sec |
| 19d4: c1 1c adc r12, r1 |
| 19d6: d1 1c adc r13, r1 |
| 19d8: e1 1c adc r14, r1 |
| 19da: f1 1c adc r15, r1 |
| if (!clust || !(clust = create_chain(dirobj->clust))) return FR_DENIED; |
| if (clust == 1 || !move_window(0)) return FR_RW_ERROR; |
| |
| fs->winsect = sector = clust2sect(clust); /* Cleanup the expanded table */ |
| memset(fs->win, 0, 512); |
| for (n = fs->sects_clust; n; n--) { |
| 19dc: 11 50 subi r17, 0x01 ; 1 |
| 19de: 11 23 and r17, r17 |
| 19e0: 71 f7 brne .-36 ; 0x19be <f_open+0x610> |
| if (disk_write(0, fs->win, sector, 1) != RES_OK) |
| return FR_RW_ERROR; |
| sector++; |
| } |
| fs->winflag = 1; |
| 19e2: 81 e0 ldi r24, 0x01 ; 1 |
| 19e4: f3 01 movw r30, r6 |
| 19e6: 87 8f std Z+31, r24 ; 0x1f |
| 19e8: da c0 rjmp .+436 ; 0x1b9e <f_open+0x7f0> |
| memset(dir, 0, 32); /* Initialize the new entry */ |
| memcpy(&dir[DIR_Name], fn, 8+3); |
| dir[DIR_NTres] = fn[11]; |
| mode |= FA_CREATE_ALWAYS; |
| } else { /* Any object is already existing */ |
| if (mode & FA_CREATE_NEW) /* Cannot create new */ |
| 19ea: f2 ff sbrs r31, 2 |
| 19ec: 03 c0 rjmp .+6 ; 0x19f4 <f_open+0x646> |
| 19ee: 27 e0 ldi r18, 0x07 ; 7 |
| 19f0: 30 e0 ldi r19, 0x00 ; 0 |
| 19f2: ad c0 rjmp .+346 ; 0x1b4e <f_open+0x7a0> |
| return FR_EXIST; |
| if (dir == NULL || (dir[DIR_Attr] & (AM_RDO|AM_DIR))) /* Cannot overwrite (R/O or DIR) */ |
| 19f4: a1 14 cp r10, r1 |
| 19f6: b1 04 cpc r11, r1 |
| 19f8: 09 f4 brne .+2 ; 0x19fc <f_open+0x64e> |
| 19fa: a1 c0 rjmp .+322 ; 0x1b3e <f_open+0x790> |
| 19fc: f5 01 movw r30, r10 |
| 19fe: 83 85 ldd r24, Z+11 ; 0x0b |
| 1a00: 81 71 andi r24, 0x11 ; 17 |
| 1a02: 09 f0 breq .+2 ; 0x1a06 <f_open+0x658> |
| 1a04: 9c c0 rjmp .+312 ; 0x1b3e <f_open+0x790> |
| return FR_DENIED; |
| if (mode & FA_CREATE_ALWAYS) { /* Resize it to zero */ |
| 1a06: 43 ff sbrs r20, 3 |
| 1a08: 42 c0 rjmp .+132 ; 0x1a8e <f_open+0x6e0> |
| #if _FAT32 |
| rs = ((DWORD)LD_WORD(&dir[DIR_FstClusHI]) << 16) | LD_WORD(&dir[DIR_FstClusLO]); |
| ST_WORD(&dir[DIR_FstClusHI], 0); |
| #else |
| rs = LD_WORD(&dir[DIR_FstClusLO]); |
| 1a0a: c2 8c ldd r12, Z+26 ; 0x1a |
| 1a0c: d3 8c ldd r13, Z+27 ; 0x1b |
| #endif |
| ST_WORD(&dir[DIR_FstClusLO], 0); /* cluster = 0 */ |
| 1a0e: 13 8e std Z+27, r1 ; 0x1b |
| 1a10: 12 8e std Z+26, r1 ; 0x1a |
| ST_DWORD(&dir[DIR_FileSize], 0); /* size = 0 */ |
| 1a12: 14 8e std Z+28, r1 ; 0x1c |
| 1a14: 15 8e std Z+29, r1 ; 0x1d |
| 1a16: 16 8e std Z+30, r1 ; 0x1e |
| 1a18: 17 8e std Z+31, r1 ; 0x1f |
| fs->winflag = 1; |
| 1a1a: 81 e0 ldi r24, 0x01 ; 1 |
| 1a1c: f4 01 movw r30, r8 |
| 1a1e: 87 8f std Z+31, r24 ; 0x1f |
| dw = fs->winsect; /* Remove the cluster chain */ |
| 1a20: 24 80 ldd r2, Z+4 ; 0x04 |
| 1a22: 35 80 ldd r3, Z+5 ; 0x05 |
| 1a24: 46 80 ldd r4, Z+6 ; 0x06 |
| 1a26: 57 80 ldd r5, Z+7 ; 0x07 |
| BOOL remove_chain ( /* TRUE: successful, FALSE: failed */ |
| CLUST clust /* Cluster# to remove chain from */ |
| ) |
| { |
| CLUST nxt; |
| FATFS *fs = FatFs; |
| 1a28: e0 90 10 01 lds r14, 0x0110 |
| 1a2c: f0 90 11 01 lds r15, 0x0111 |
| 1a30: 86 01 movw r16, r12 |
| 1a32: 1c c0 rjmp .+56 ; 0x1a6c <f_open+0x6be> |
| |
| |
| while (clust >= 2 && clust < fs->max_clust) { |
| nxt = get_cluster(clust); |
| 1a34: c8 01 movw r24, r16 |
| 1a36: 0e 94 53 04 call 0x8a6 ; 0x8a6 <get_cluster> |
| 1a3a: 3c 01 movw r6, r24 |
| if (nxt == 1) return FALSE; |
| 1a3c: 81 30 cpi r24, 0x01 ; 1 |
| 1a3e: 91 05 cpc r25, r1 |
| 1a40: 09 f4 brne .+2 ; 0x1a44 <f_open+0x696> |
| 1a42: 80 c0 rjmp .+256 ; 0x1b44 <f_open+0x796> |
| if (!put_cluster(clust, 0)) return FALSE; |
| 1a44: 60 e0 ldi r22, 0x00 ; 0 |
| 1a46: 70 e0 ldi r23, 0x00 ; 0 |
| 1a48: c8 01 movw r24, r16 |
| 1a4a: 0e 94 c4 03 call 0x788 ; 0x788 <put_cluster> |
| 1a4e: 88 23 and r24, r24 |
| 1a50: 09 f4 brne .+2 ; 0x1a54 <f_open+0x6a6> |
| 1a52: 78 c0 rjmp .+240 ; 0x1b44 <f_open+0x796> |
| if (fs->free_clust != (CLUST)0xFFFFFFFF) { |
| 1a54: f7 01 movw r30, r14 |
| 1a56: 82 8d ldd r24, Z+26 ; 0x1a |
| 1a58: 93 8d ldd r25, Z+27 ; 0x1b |
| 1a5a: ff ef ldi r31, 0xFF ; 255 |
| 1a5c: 8f 3f cpi r24, 0xFF ; 255 |
| 1a5e: 9f 07 cpc r25, r31 |
| 1a60: 21 f0 breq .+8 ; 0x1a6a <f_open+0x6bc> |
| fs->free_clust++; |
| 1a62: 01 96 adiw r24, 0x01 ; 1 |
| 1a64: f7 01 movw r30, r14 |
| 1a66: 93 8f std Z+27, r25 ; 0x1b |
| 1a68: 82 8f std Z+26, r24 ; 0x1a |
| 1a6a: 83 01 movw r16, r6 |
| { |
| CLUST nxt; |
| FATFS *fs = FatFs; |
| |
| |
| while (clust >= 2 && clust < fs->max_clust) { |
| 1a6c: 02 30 cpi r16, 0x02 ; 2 |
| 1a6e: 11 05 cpc r17, r1 |
| 1a70: 08 f4 brcc .+2 ; 0x1a74 <f_open+0x6c6> |
| 1a72: 72 c0 rjmp .+228 ; 0x1b58 <f_open+0x7aa> |
| 1a74: f7 01 movw r30, r14 |
| 1a76: 86 89 ldd r24, Z+22 ; 0x16 |
| 1a78: 97 89 ldd r25, Z+23 ; 0x17 |
| 1a7a: 08 17 cp r16, r24 |
| 1a7c: 19 07 cpc r17, r25 |
| 1a7e: d0 f2 brcs .-76 ; 0x1a34 <f_open+0x686> |
| 1a80: 6b c0 rjmp .+214 ; 0x1b58 <f_open+0x7aa> |
| ST_DWORD(&dir[DIR_FileSize], 0); /* size = 0 */ |
| fs->winflag = 1; |
| dw = fs->winsect; /* Remove the cluster chain */ |
| if (!remove_chain(rs) || !move_window(dw)) |
| return FR_RW_ERROR; |
| fs->last_clust = rs - 1; /* Reuse the cluster hole */ |
| 1a82: 08 94 sec |
| 1a84: c1 08 sbc r12, r1 |
| 1a86: d1 08 sbc r13, r1 |
| 1a88: f4 01 movw r30, r8 |
| 1a8a: d1 8e std Z+25, r13 ; 0x19 |
| 1a8c: c0 8e std Z+24, r12 ; 0x18 |
| } |
| } |
| if (mode & FA_CREATE_ALWAYS) { |
| 1a8e: fb 8d ldd r31, Y+27 ; 0x1b |
| 1a90: f3 ff sbrs r31, 3 |
| 1a92: 22 c0 rjmp .+68 ; 0x1ad8 <f_open+0x72a> |
| dir[DIR_Attr] = AM_ARC; /* New attribute */ |
| 1a94: 80 e2 ldi r24, 0x20 ; 32 |
| 1a96: f5 01 movw r30, r10 |
| 1a98: 83 87 std Z+11, r24 ; 0x0b |
| dw = get_fattime(); |
| 1a9a: 0e 94 b0 00 call 0x160 ; 0x160 <get_fattime> |
| ST_DWORD(&dir[DIR_WrtTime], dw); /* Updated time */ |
| 1a9e: f5 01 movw r30, r10 |
| 1aa0: 66 8b std Z+22, r22 ; 0x16 |
| 1aa2: 77 8b std Z+23, r23 ; 0x17 |
| 1aa4: 80 8f std Z+24, r24 ; 0x18 |
| 1aa6: 91 8f std Z+25, r25 ; 0x19 |
| ST_DWORD(&dir[DIR_CrtTime], dw); /* Created time */ |
| 1aa8: 66 87 std Z+14, r22 ; 0x0e |
| 1aaa: 77 87 std Z+15, r23 ; 0x0f |
| 1aac: 80 8b std Z+16, r24 ; 0x10 |
| 1aae: 91 8b std Z+17, r25 ; 0x11 |
| fs->winflag = 1; |
| 1ab0: 81 e0 ldi r24, 0x01 ; 1 |
| 1ab2: f4 01 movw r30, r8 |
| 1ab4: 87 8f std Z+31, r24 ; 0x1f |
| 1ab6: 10 c0 rjmp .+32 ; 0x1ad8 <f_open+0x72a> |
| } |
| } |
| /* Open a File */ |
| else { |
| #endif /* !_FS_READONLY */ |
| if (res != FR_OK) return res; /* Trace failed */ |
| 1ab8: 21 15 cp r18, r1 |
| 1aba: 31 05 cpc r19, r1 |
| 1abc: 09 f0 breq .+2 ; 0x1ac0 <f_open+0x712> |
| 1abe: 47 c0 rjmp .+142 ; 0x1b4e <f_open+0x7a0> |
| if (dir == NULL || (dir[DIR_Attr] & AM_DIR)) /* It is a directory */ |
| 1ac0: a1 14 cp r10, r1 |
| 1ac2: b1 04 cpc r11, r1 |
| 1ac4: 09 f4 brne .+2 ; 0x1ac8 <f_open+0x71a> |
| 1ac6: 41 c0 rjmp .+130 ; 0x1b4a <f_open+0x79c> |
| 1ac8: f5 01 movw r30, r10 |
| 1aca: 83 85 ldd r24, Z+11 ; 0x0b |
| 1acc: 84 fd sbrc r24, 4 |
| 1ace: 3d c0 rjmp .+122 ; 0x1b4a <f_open+0x79c> |
| return FR_NO_FILE; |
| #if !_FS_READONLY |
| if ((mode & FA_WRITE) && (dir[DIR_Attr] & AM_RDO)) /* R/O violation */ |
| 1ad0: 41 ff sbrs r20, 1 |
| 1ad2: 02 c0 rjmp .+4 ; 0x1ad8 <f_open+0x72a> |
| 1ad4: 80 fd sbrc r24, 0 |
| 1ad6: 33 c0 rjmp .+102 ; 0x1b3e <f_open+0x790> |
| return FR_DENIED; |
| } |
| |
| fp->dir_sect = fs->winsect; /* Pointer to the directory entry */ |
| 1ad8: f4 01 movw r30, r8 |
| 1ada: 84 81 ldd r24, Z+4 ; 0x04 |
| 1adc: 95 81 ldd r25, Z+5 ; 0x05 |
| 1ade: a6 81 ldd r26, Z+6 ; 0x06 |
| 1ae0: b7 81 ldd r27, Z+7 ; 0x07 |
| 1ae2: ec 8d ldd r30, Y+28 ; 0x1c |
| 1ae4: fd 8d ldd r31, Y+29 ; 0x1d |
| 1ae6: 86 8b std Z+22, r24 ; 0x16 |
| 1ae8: 97 8b std Z+23, r25 ; 0x17 |
| 1aea: a0 8f std Z+24, r26 ; 0x18 |
| 1aec: b1 8f std Z+25, r27 ; 0x19 |
| fp->dir_ptr = dir; |
| 1aee: b3 8e std Z+27, r11 ; 0x1b |
| 1af0: a2 8e std Z+26, r10 ; 0x1a |
| #endif |
| fp->flag = mode; /* File access mode */ |
| 1af2: 2b 8d ldd r18, Y+27 ; 0x1b |
| 1af4: 22 83 std Z+2, r18 ; 0x02 |
| fp->org_clust = /* File start cluster */ |
| 1af6: f5 01 movw r30, r10 |
| 1af8: 82 8d ldd r24, Z+26 ; 0x1a |
| 1afa: 93 8d ldd r25, Z+27 ; 0x1b |
| 1afc: ec 8d ldd r30, Y+28 ; 0x1c |
| 1afe: fd 8d ldd r31, Y+29 ; 0x1d |
| 1b00: 97 87 std Z+15, r25 ; 0x0f |
| 1b02: 86 87 std Z+14, r24 ; 0x0e |
| #if _FAT32 |
| ((DWORD)LD_WORD(&dir[DIR_FstClusHI]) << 16) | |
| #endif |
| LD_WORD(&dir[DIR_FstClusLO]); |
| fp->fsize = LD_DWORD(&dir[DIR_FileSize]); /* File size */ |
| 1b04: f5 01 movw r30, r10 |
| 1b06: 84 8d ldd r24, Z+28 ; 0x1c |
| 1b08: 95 8d ldd r25, Z+29 ; 0x1d |
| 1b0a: a6 8d ldd r26, Z+30 ; 0x1e |
| 1b0c: b7 8d ldd r27, Z+31 ; 0x1f |
| 1b0e: ec 8d ldd r30, Y+28 ; 0x1c |
| 1b10: fd 8d ldd r31, Y+29 ; 0x1d |
| 1b12: 82 87 std Z+10, r24 ; 0x0a |
| 1b14: 93 87 std Z+11, r25 ; 0x0b |
| 1b16: a4 87 std Z+12, r26 ; 0x0c |
| 1b18: b5 87 std Z+13, r27 ; 0x0d |
| fp->fptr = 0; /* File ptr */ |
| 1b1a: 16 82 std Z+6, r1 ; 0x06 |
| 1b1c: 17 82 std Z+7, r1 ; 0x07 |
| 1b1e: 10 86 std Z+8, r1 ; 0x08 |
| 1b20: 11 86 std Z+9, r1 ; 0x09 |
| fp->sect_clust = 1; /* Sector counter */ |
| 1b22: 81 e0 ldi r24, 0x01 ; 1 |
| 1b24: 83 83 std Z+3, r24 ; 0x03 |
| fp->fs = fs; fp->id = fs->id; /* Owner file system object of the file */ |
| 1b26: 95 82 std Z+5, r9 ; 0x05 |
| 1b28: 84 82 std Z+4, r8 ; 0x04 |
| 1b2a: f4 01 movw r30, r8 |
| 1b2c: 80 81 ld r24, Z |
| 1b2e: 91 81 ldd r25, Z+1 ; 0x01 |
| 1b30: ec 8d ldd r30, Y+28 ; 0x1c |
| 1b32: fd 8d ldd r31, Y+29 ; 0x1d |
| 1b34: 91 83 std Z+1, r25 ; 0x01 |
| 1b36: 80 83 st Z, r24 |
| 1b38: 20 e0 ldi r18, 0x00 ; 0 |
| 1b3a: 30 e0 ldi r19, 0x00 ; 0 |
| 1b3c: 08 c0 rjmp .+16 ; 0x1b4e <f_open+0x7a0> |
| |
| return FR_OK; |
| 1b3e: 26 e0 ldi r18, 0x06 ; 6 |
| 1b40: 30 e0 ldi r19, 0x00 ; 0 |
| 1b42: 05 c0 rjmp .+10 ; 0x1b4e <f_open+0x7a0> |
| 1b44: 28 e0 ldi r18, 0x08 ; 8 |
| 1b46: 30 e0 ldi r19, 0x00 ; 0 |
| 1b48: 02 c0 rjmp .+4 ; 0x1b4e <f_open+0x7a0> |
| 1b4a: 22 e0 ldi r18, 0x02 ; 2 |
| 1b4c: 30 e0 ldi r19, 0x00 ; 0 |
| } |
| 1b4e: c9 01 movw r24, r18 |
| 1b50: 6d 96 adiw r28, 0x1d ; 29 |
| 1b52: e2 e1 ldi r30, 0x12 ; 18 |
| 1b54: 0c 94 e3 14 jmp 0x29c6 ; 0x29c6 <__epilogue_restores__> |
| #endif |
| ST_WORD(&dir[DIR_FstClusLO], 0); /* cluster = 0 */ |
| ST_DWORD(&dir[DIR_FileSize], 0); /* size = 0 */ |
| fs->winflag = 1; |
| dw = fs->winsect; /* Remove the cluster chain */ |
| if (!remove_chain(rs) || !move_window(dw)) |
| 1b58: c2 01 movw r24, r4 |
| 1b5a: b1 01 movw r22, r2 |
| 1b5c: 0e 94 5a 03 call 0x6b4 ; 0x6b4 <move_window> |
| 1b60: 88 23 and r24, r24 |
| 1b62: 09 f0 breq .+2 ; 0x1b66 <f_open+0x7b8> |
| 1b64: 8e cf rjmp .-228 ; 0x1a82 <f_open+0x6d4> |
| 1b66: ee cf rjmp .-36 ; 0x1b44 <f_open+0x796> |
| ) |
| { |
| CLUST clust; |
| char ds; |
| BYTE *dptr = NULL; |
| FATFS *fs = FatFs; |
| 1b68: c0 90 10 01 lds r12, 0x0110 |
| 1b6c: d0 90 11 01 lds r13, 0x0111 |
| |
| /* Initialize directory object */ |
| clust = fs->dirbase; |
| 1b70: f6 01 movw r30, r12 |
| 1b72: 84 85 ldd r24, Z+12 ; 0x0c |
| 1b74: 95 85 ldd r25, Z+13 ; 0x0d |
| dirobj->clust = dirobj->sclust = clust; |
| dirobj->sect = clust2sect(clust); |
| } else |
| #endif |
| { |
| dirobj->clust = dirobj->sclust = 0; |
| 1b76: 1c 8a std Y+20, r1 ; 0x14 |
| 1b78: 1b 8a std Y+19, r1 ; 0x13 |
| 1b7a: 1e 8a std Y+22, r1 ; 0x16 |
| 1b7c: 1d 8a std Y+21, r1 ; 0x15 |
| dirobj->sect = clust; |
| 1b7e: a0 e0 ldi r26, 0x00 ; 0 |
| 1b80: b0 e0 ldi r27, 0x00 ; 0 |
| 1b82: 8f 8b std Y+23, r24 ; 0x17 |
| 1b84: 98 8f std Y+24, r25 ; 0x18 |
| 1b86: a9 8f std Y+25, r26 ; 0x19 |
| 1b88: ba 8f std Y+26, r27 ; 0x1a |
| } |
| dirobj->index = 0; |
| 1b8a: 18 8a std Y+16, r1 ; 0x10 |
| 1b8c: 1f 86 std Y+15, r1 ; 0x0f |
| dirobj->fs = fs; |
| 1b8e: da 8a std Y+18, r13 ; 0x12 |
| 1b90: c9 8a std Y+17, r12 ; 0x11 |
| |
| if (*path == '\0') { /* Null path means the root directory */ |
| 1b92: f3 01 movw r30, r6 |
| 1b94: 80 81 ld r24, Z |
| 1b96: 88 23 and r24, r24 |
| 1b98: 09 f0 breq .+2 ; 0x1b9c <f_open+0x7ee> |
| 1b9a: 4a cd rjmp .-1388 ; 0x1630 <f_open+0x282> |
| 1b9c: 2a ce rjmp .-940 ; 0x17f2 <f_open+0x444> |
| DWORD dw; |
| if (res != FR_OK) { /* No file, create new */ |
| if (res != FR_NO_FILE) return res; |
| res = reserve_direntry(&dirobj, &dir); |
| if (res != FR_OK) return res; |
| memset(dir, 0, 32); /* Initialize the new entry */ |
| 1b9e: 80 e2 ldi r24, 0x20 ; 32 |
| 1ba0: f5 01 movw r30, r10 |
| 1ba2: 11 92 st Z+, r1 |
| 1ba4: 8a 95 dec r24 |
| 1ba6: e9 f7 brne .-6 ; 0x1ba2 <f_open+0x7f4> |
| memcpy(&dir[DIR_Name], fn, 8+3); |
| 1ba8: d5 01 movw r26, r10 |
| 1baa: fe 01 movw r30, r28 |
| 1bac: 31 96 adiw r30, 0x01 ; 1 |
| 1bae: 8b e0 ldi r24, 0x0B ; 11 |
| 1bb0: 01 90 ld r0, Z+ |
| 1bb2: 0d 92 st X+, r0 |
| 1bb4: 81 50 subi r24, 0x01 ; 1 |
| 1bb6: e1 f7 brne .-8 ; 0x1bb0 <f_open+0x802> |
| dir[DIR_NTres] = fn[11]; |
| 1bb8: 8c 85 ldd r24, Y+12 ; 0x0c |
| 1bba: f5 01 movw r30, r10 |
| 1bbc: 84 87 std Z+12, r24 ; 0x0c |
| mode |= FA_CREATE_ALWAYS; |
| 1bbe: fb 8d ldd r31, Y+27 ; 0x1b |
| 1bc0: f8 60 ori r31, 0x08 ; 8 |
| 1bc2: fb 8f std Y+27, r31 ; 0x1b |
| 1bc4: 64 cf rjmp .-312 ; 0x1a8e <f_open+0x6e0> |
| |
| 00001bc6 <rcvr_datablock>: |
| static |
| BOOL rcvr_datablock ( |
| BYTE *buff, /* Data buffer to store received data */ |
| UINT btr /* Byte count (must be even number) */ |
| ) |
| { |
| 1bc6: fc 01 movw r30, r24 |
| BYTE token; |
| |
| |
| Timer1 = 10; |
| 1bc8: 8a e0 ldi r24, 0x0A ; 10 |
| 1bca: 80 93 15 01 sts 0x0115, r24 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 1bce: 9f ef ldi r25, 0xFF ; 255 |
| 1bd0: 9e bd out 0x2e, r25 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 1bd2: 0d b4 in r0, 0x2d ; 45 |
| 1bd4: 07 fe sbrs r0, 7 |
| 1bd6: fd cf rjmp .-6 ; 0x1bd2 <rcvr_datablock+0xc> |
| return SPDR; |
| 1bd8: 8e b5 in r24, 0x2e ; 46 |
| |
| |
| Timer1 = 10; |
| do { /* Wait for data packet in timeout of 100ms */ |
| token = rcvr_spi(); |
| } while ((token == 0xFF) && Timer1); |
| 1bda: 8f 3f cpi r24, 0xFF ; 255 |
| 1bdc: 29 f4 brne .+10 ; 0x1be8 <rcvr_datablock+0x22> |
| 1bde: 80 91 15 01 lds r24, 0x0115 |
| 1be2: 88 23 and r24, r24 |
| 1be4: a9 f7 brne .-22 ; 0x1bd0 <rcvr_datablock+0xa> |
| 1be6: 22 c0 rjmp .+68 ; 0x1c2c <rcvr_datablock+0x66> |
| if(token != 0xFE) return FALSE; /* If not valid data token, retutn with error */ |
| 1be8: 8e 3f cpi r24, 0xFE ; 254 |
| 1bea: 01 f5 brne .+64 ; 0x1c2c <rcvr_datablock+0x66> |
| |
| do { /* Receive the data block into buffer */ |
| rcvr_spi_m(buff++); |
| 1bec: 9f ef ldi r25, 0xFF ; 255 |
| 1bee: 9e bd out 0x2e, r25 ; 46 |
| 1bf0: 0d b4 in r0, 0x2d ; 45 |
| 1bf2: 07 fe sbrs r0, 7 |
| 1bf4: fd cf rjmp .-6 ; 0x1bf0 <rcvr_datablock+0x2a> |
| 1bf6: 8e b5 in r24, 0x2e ; 46 |
| 1bf8: 80 83 st Z, r24 |
| rcvr_spi_m(buff++); |
| 1bfa: 9e bd out 0x2e, r25 ; 46 |
| 1bfc: 0d b4 in r0, 0x2d ; 45 |
| 1bfe: 07 fe sbrs r0, 7 |
| 1c00: fd cf rjmp .-6 ; 0x1bfc <rcvr_datablock+0x36> |
| 1c02: 8e b5 in r24, 0x2e ; 46 |
| 1c04: 81 83 std Z+1, r24 ; 0x01 |
| } while (btr -= 2); |
| 1c06: 62 50 subi r22, 0x02 ; 2 |
| 1c08: 70 40 sbci r23, 0x00 ; 0 |
| 1c0a: 11 f0 breq .+4 ; 0x1c10 <rcvr_datablock+0x4a> |
| static |
| BOOL rcvr_datablock ( |
| BYTE *buff, /* Data buffer to store received data */ |
| UINT btr /* Byte count (must be even number) */ |
| ) |
| { |
| 1c0c: 32 96 adiw r30, 0x02 ; 2 |
| 1c0e: ef cf rjmp .-34 ; 0x1bee <rcvr_datablock+0x28> |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 1c10: 8f ef ldi r24, 0xFF ; 255 |
| 1c12: 8e bd out 0x2e, r24 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 1c14: 0d b4 in r0, 0x2d ; 45 |
| 1c16: 07 fe sbrs r0, 7 |
| 1c18: fd cf rjmp .-6 ; 0x1c14 <rcvr_datablock+0x4e> |
| return SPDR; |
| 1c1a: 8e b5 in r24, 0x2e ; 46 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 1c1c: 8f ef ldi r24, 0xFF ; 255 |
| 1c1e: 8e bd out 0x2e, r24 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 1c20: 0d b4 in r0, 0x2d ; 45 |
| 1c22: 07 fe sbrs r0, 7 |
| 1c24: fd cf rjmp .-6 ; 0x1c20 <rcvr_datablock+0x5a> |
| return SPDR; |
| 1c26: 8e b5 in r24, 0x2e ; 46 |
| 1c28: 81 e0 ldi r24, 0x01 ; 1 |
| 1c2a: 08 95 ret |
| rcvr_spi_m(buff++); |
| } while (btr -= 2); |
| rcvr_spi(); /* Discard CRC */ |
| rcvr_spi(); |
| |
| return TRUE; /* Return with success */ |
| 1c2c: 80 e0 ldi r24, 0x00 ; 0 |
| } |
| 1c2e: 08 95 ret |
| |
| 00001c30 <xmit_datablock>: |
| static |
| BOOL xmit_datablock ( |
| const BYTE *buff, /* 512 byte data block to be transmitted */ |
| BYTE token /* Data/Stop token */ |
| ) |
| { |
| 1c30: fc 01 movw r30, r24 |
| BYTE wait_ready (void) |
| { |
| BYTE res; |
| |
| |
| Timer2 = 50; /* Wait for ready in timeout of 500ms */ |
| 1c32: 82 e3 ldi r24, 0x32 ; 50 |
| 1c34: 80 93 16 01 sts 0x0116, r24 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 1c38: 8f ef ldi r24, 0xFF ; 255 |
| 1c3a: 8e bd out 0x2e, r24 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 1c3c: 0d b4 in r0, 0x2d ; 45 |
| 1c3e: 07 fe sbrs r0, 7 |
| 1c40: fd cf rjmp .-6 ; 0x1c3c <xmit_datablock+0xc> |
| return SPDR; |
| 1c42: 8e b5 in r24, 0x2e ; 46 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 1c44: 9f ef ldi r25, 0xFF ; 255 |
| 1c46: 9e bd out 0x2e, r25 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 1c48: 0d b4 in r0, 0x2d ; 45 |
| 1c4a: 07 fe sbrs r0, 7 |
| 1c4c: fd cf rjmp .-6 ; 0x1c48 <xmit_datablock+0x18> |
| return SPDR; |
| 1c4e: 8e b5 in r24, 0x2e ; 46 |
| |
| Timer2 = 50; /* Wait for ready in timeout of 500ms */ |
| rcvr_spi(); |
| do |
| res = rcvr_spi(); |
| while ((res != 0xFF) && Timer2); |
| 1c50: 8f 3f cpi r24, 0xFF ; 255 |
| 1c52: 31 f0 breq .+12 ; 0x1c60 <xmit_datablock+0x30> |
| 1c54: 80 91 16 01 lds r24, 0x0116 |
| 1c58: 88 23 and r24, r24 |
| 1c5a: a9 f7 brne .-22 ; 0x1c46 <xmit_datablock+0x16> |
| 1c5c: 90 e0 ldi r25, 0x00 ; 0 |
| 1c5e: 2e c0 rjmp .+92 ; 0x1cbc <xmit_datablock+0x8c> |
| BYTE resp, wc; |
| |
| |
| if (wait_ready() != 0xFF) return FALSE; |
| |
| xmit_spi(token); /* Xmit data token */ |
| 1c60: 6e bd out 0x2e, r22 ; 46 |
| 1c62: 0d b4 in r0, 0x2d ; 45 |
| 1c64: 07 fe sbrs r0, 7 |
| 1c66: fd cf rjmp .-6 ; 0x1c62 <xmit_datablock+0x32> |
| if (token != 0xFD) { /* Is data token */ |
| 1c68: 6d 3f cpi r22, 0xFD ; 253 |
| 1c6a: 11 f4 brne .+4 ; 0x1c70 <xmit_datablock+0x40> |
| 1c6c: 91 e0 ldi r25, 0x01 ; 1 |
| 1c6e: 26 c0 rjmp .+76 ; 0x1cbc <xmit_datablock+0x8c> |
| 1c70: 90 e0 ldi r25, 0x00 ; 0 |
| wc = 0; |
| do { /* Xmit the 512 byte data block to MMC */ |
| xmit_spi(*buff++); |
| 1c72: 80 81 ld r24, Z |
| 1c74: 8e bd out 0x2e, r24 ; 46 |
| 1c76: 0d b4 in r0, 0x2d ; 45 |
| 1c78: 07 fe sbrs r0, 7 |
| 1c7a: fd cf rjmp .-6 ; 0x1c76 <xmit_datablock+0x46> |
| xmit_spi(*buff++); |
| 1c7c: 81 81 ldd r24, Z+1 ; 0x01 |
| 1c7e: 8e bd out 0x2e, r24 ; 46 |
| 1c80: 0d b4 in r0, 0x2d ; 45 |
| 1c82: 07 fe sbrs r0, 7 |
| 1c84: fd cf rjmp .-6 ; 0x1c80 <xmit_datablock+0x50> |
| } while (--wc); |
| 1c86: 91 50 subi r25, 0x01 ; 1 |
| 1c88: 11 f0 breq .+4 ; 0x1c8e <xmit_datablock+0x5e> |
| static |
| BOOL xmit_datablock ( |
| const BYTE *buff, /* 512 byte data block to be transmitted */ |
| BYTE token /* Data/Stop token */ |
| ) |
| { |
| 1c8a: 32 96 adiw r30, 0x02 ; 2 |
| 1c8c: f2 cf rjmp .-28 ; 0x1c72 <xmit_datablock+0x42> |
| wc = 0; |
| do { /* Xmit the 512 byte data block to MMC */ |
| xmit_spi(*buff++); |
| xmit_spi(*buff++); |
| } while (--wc); |
| xmit_spi(0xFF); /* CRC (Dummy) */ |
| 1c8e: 8f ef ldi r24, 0xFF ; 255 |
| 1c90: 8e bd out 0x2e, r24 ; 46 |
| 1c92: 0d b4 in r0, 0x2d ; 45 |
| 1c94: 07 fe sbrs r0, 7 |
| 1c96: fd cf rjmp .-6 ; 0x1c92 <xmit_datablock+0x62> |
| xmit_spi(0xFF); |
| 1c98: 8f ef ldi r24, 0xFF ; 255 |
| 1c9a: 8e bd out 0x2e, r24 ; 46 |
| 1c9c: 0d b4 in r0, 0x2d ; 45 |
| 1c9e: 07 fe sbrs r0, 7 |
| 1ca0: fd cf rjmp .-6 ; 0x1c9c <xmit_datablock+0x6c> |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 1ca2: 8f ef ldi r24, 0xFF ; 255 |
| 1ca4: 8e bd out 0x2e, r24 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 1ca6: 0d b4 in r0, 0x2d ; 45 |
| 1ca8: 07 fe sbrs r0, 7 |
| 1caa: fd cf rjmp .-6 ; 0x1ca6 <xmit_datablock+0x76> |
| return SPDR; |
| 1cac: 8e b5 in r24, 0x2e ; 46 |
| 1cae: 90 e0 ldi r25, 0x00 ; 0 |
| 1cb0: 8f 71 andi r24, 0x1F ; 31 |
| 1cb2: 85 30 cpi r24, 0x05 ; 5 |
| 1cb4: 09 f0 breq .+2 ; 0x1cb8 <xmit_datablock+0x88> |
| 1cb6: 91 e0 ldi r25, 0x01 ; 1 |
| 1cb8: 81 e0 ldi r24, 0x01 ; 1 |
| 1cba: 98 27 eor r25, r24 |
| if ((resp & 0x1F) != 0x05) /* If not accepted, return with error */ |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| 1cbc: 89 2f mov r24, r25 |
| 1cbe: 08 95 ret |
| |
| 00001cc0 <send_cmd>: |
| static |
| BYTE send_cmd ( |
| BYTE cmd, /* Command byte */ |
| DWORD arg /* Argument */ |
| ) |
| { |
| 1cc0: 28 2f mov r18, r24 |
| BYTE wait_ready (void) |
| { |
| BYTE res; |
| |
| |
| Timer2 = 50; /* Wait for ready in timeout of 500ms */ |
| 1cc2: 82 e3 ldi r24, 0x32 ; 50 |
| 1cc4: 80 93 16 01 sts 0x0116, r24 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 1cc8: 8f ef ldi r24, 0xFF ; 255 |
| 1cca: 8e bd out 0x2e, r24 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 1ccc: 0d b4 in r0, 0x2d ; 45 |
| 1cce: 07 fe sbrs r0, 7 |
| 1cd0: fd cf rjmp .-6 ; 0x1ccc <send_cmd+0xc> |
| return SPDR; |
| 1cd2: 8e b5 in r24, 0x2e ; 46 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 1cd4: 9f ef ldi r25, 0xFF ; 255 |
| 1cd6: 9e bd out 0x2e, r25 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 1cd8: 0d b4 in r0, 0x2d ; 45 |
| 1cda: 07 fe sbrs r0, 7 |
| 1cdc: fd cf rjmp .-6 ; 0x1cd8 <send_cmd+0x18> |
| return SPDR; |
| 1cde: 8e b5 in r24, 0x2e ; 46 |
| |
| Timer2 = 50; /* Wait for ready in timeout of 500ms */ |
| rcvr_spi(); |
| do |
| res = rcvr_spi(); |
| while ((res != 0xFF) && Timer2); |
| 1ce0: 8f 3f cpi r24, 0xFF ; 255 |
| 1ce2: 31 f0 breq .+12 ; 0x1cf0 <send_cmd+0x30> |
| 1ce4: 80 91 16 01 lds r24, 0x0116 |
| 1ce8: 88 23 and r24, r24 |
| 1cea: a9 f7 brne .-22 ; 0x1cd6 <send_cmd+0x16> |
| 1cec: 8f ef ldi r24, 0xFF ; 255 |
| 1cee: 08 95 ret |
| |
| |
| if (wait_ready() != 0xFF) return 0xFF; |
| |
| /* Send command packet */ |
| xmit_spi(cmd); /* Command */ |
| 1cf0: 2e bd out 0x2e, r18 ; 46 |
| 1cf2: 0d b4 in r0, 0x2d ; 45 |
| 1cf4: 07 fe sbrs r0, 7 |
| 1cf6: fd cf rjmp .-6 ; 0x1cf2 <send_cmd+0x32> |
| xmit_spi((BYTE)(arg >> 24)); /* Argument[31..24] */ |
| 1cf8: 87 2f mov r24, r23 |
| 1cfa: 99 27 eor r25, r25 |
| 1cfc: aa 27 eor r26, r26 |
| 1cfe: bb 27 eor r27, r27 |
| 1d00: 8e bd out 0x2e, r24 ; 46 |
| 1d02: 0d b4 in r0, 0x2d ; 45 |
| 1d04: 07 fe sbrs r0, 7 |
| 1d06: fd cf rjmp .-6 ; 0x1d02 <send_cmd+0x42> |
| xmit_spi((BYTE)(arg >> 16)); /* Argument[23..16] */ |
| 1d08: cb 01 movw r24, r22 |
| 1d0a: aa 27 eor r26, r26 |
| 1d0c: bb 27 eor r27, r27 |
| 1d0e: 8e bd out 0x2e, r24 ; 46 |
| 1d10: 0d b4 in r0, 0x2d ; 45 |
| 1d12: 07 fe sbrs r0, 7 |
| 1d14: fd cf rjmp .-6 ; 0x1d10 <send_cmd+0x50> |
| xmit_spi((BYTE)(arg >> 8)); /* Argument[15..8] */ |
| 1d16: bb 27 eor r27, r27 |
| 1d18: a7 2f mov r26, r23 |
| 1d1a: 96 2f mov r25, r22 |
| 1d1c: 85 2f mov r24, r21 |
| 1d1e: 8e bd out 0x2e, r24 ; 46 |
| 1d20: 0d b4 in r0, 0x2d ; 45 |
| 1d22: 07 fe sbrs r0, 7 |
| 1d24: fd cf rjmp .-6 ; 0x1d20 <send_cmd+0x60> |
| xmit_spi((BYTE)arg); /* Argument[7..0] */ |
| 1d26: 4e bd out 0x2e, r20 ; 46 |
| 1d28: 0d b4 in r0, 0x2d ; 45 |
| 1d2a: 07 fe sbrs r0, 7 |
| 1d2c: fd cf rjmp .-6 ; 0x1d28 <send_cmd+0x68> |
| n = 0; |
| if (cmd == CMD0) n = 0x95; /* CRC for CMD0(0) */ |
| 1d2e: 20 34 cpi r18, 0x40 ; 64 |
| 1d30: 11 f4 brne .+4 ; 0x1d36 <send_cmd+0x76> |
| 1d32: 85 e9 ldi r24, 0x95 ; 149 |
| 1d34: 05 c0 rjmp .+10 ; 0x1d40 <send_cmd+0x80> |
| if (cmd == CMD8) n = 0x87; /* CRC for CMD8(0x1AA) */ |
| 1d36: 28 34 cpi r18, 0x48 ; 72 |
| 1d38: 11 f4 brne .+4 ; 0x1d3e <send_cmd+0x7e> |
| 1d3a: 87 e8 ldi r24, 0x87 ; 135 |
| 1d3c: 01 c0 rjmp .+2 ; 0x1d40 <send_cmd+0x80> |
| 1d3e: 80 e0 ldi r24, 0x00 ; 0 |
| xmit_spi(n); |
| 1d40: 8e bd out 0x2e, r24 ; 46 |
| 1d42: 0d b4 in r0, 0x2d ; 45 |
| 1d44: 07 fe sbrs r0, 7 |
| 1d46: fd cf rjmp .-6 ; 0x1d42 <send_cmd+0x82> |
| |
| /* Receive command response */ |
| if (cmd == CMD12) rcvr_spi(); /* Skip a stuff byte when stop reading */ |
| 1d48: 2c 34 cpi r18, 0x4C ; 76 |
| 1d4a: 31 f4 brne .+12 ; 0x1d58 <send_cmd+0x98> |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 1d4c: 8f ef ldi r24, 0xFF ; 255 |
| 1d4e: 8e bd out 0x2e, r24 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 1d50: 0d b4 in r0, 0x2d ; 45 |
| 1d52: 07 fe sbrs r0, 7 |
| 1d54: fd cf rjmp .-6 ; 0x1d50 <send_cmd+0x90> |
| return SPDR; |
| 1d56: 8e b5 in r24, 0x2e ; 46 |
| 1d58: 9a e0 ldi r25, 0x0A ; 10 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 1d5a: 2f ef ldi r18, 0xFF ; 255 |
| 1d5c: 2e bd out 0x2e, r18 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 1d5e: 0d b4 in r0, 0x2d ; 45 |
| 1d60: 07 fe sbrs r0, 7 |
| 1d62: fd cf rjmp .-6 ; 0x1d5e <send_cmd+0x9e> |
| return SPDR; |
| 1d64: 8e b5 in r24, 0x2e ; 46 |
| /* Receive command response */ |
| if (cmd == CMD12) rcvr_spi(); /* Skip a stuff byte when stop reading */ |
| n = 10; /* Wait for a valid response in timeout of 10 attempts */ |
| do |
| res = rcvr_spi(); |
| while ((res & 0x80) && --n); |
| 1d66: 87 ff sbrs r24, 7 |
| 1d68: 02 c0 rjmp .+4 ; 0x1d6e <send_cmd+0xae> |
| 1d6a: 91 50 subi r25, 0x01 ; 1 |
| 1d6c: b9 f7 brne .-18 ; 0x1d5c <send_cmd+0x9c> |
| |
| return res; /* Return with the response value */ |
| } |
| 1d6e: 08 95 ret |
| |
| 00001d70 <disk_initialize>: |
| /*-----------------------------------------------------------------------*/ |
| |
| DSTATUS disk_initialize ( |
| BYTE drv /* Physical drive nmuber (0) */ |
| ) |
| { |
| 1d70: a4 e0 ldi r26, 0x04 ; 4 |
| 1d72: b0 e0 ldi r27, 0x00 ; 0 |
| 1d74: ee eb ldi r30, 0xBE ; 190 |
| 1d76: fe e0 ldi r31, 0x0E ; 14 |
| 1d78: 0c 94 d3 14 jmp 0x29a6 ; 0x29a6 <__prologue_saves__+0x18> |
| BYTE n, ty, ocr[4]; |
| |
| |
| if (drv) return STA_NOINIT; /* Supports only single drive */ |
| 1d7c: 88 23 and r24, r24 |
| 1d7e: 11 f0 breq .+4 ; 0x1d84 <disk_initialize+0x14> |
| 1d80: 81 e0 ldi r24, 0x01 ; 1 |
| 1d82: cf c0 rjmp .+414 ; 0x1f22 <disk_initialize+0x1b2> |
| if (Stat & STA_NODISK) return Stat; /* No card in the socket */ |
| 1d84: 80 91 0b 01 lds r24, 0x010B |
| 1d88: 81 fd sbrc r24, 1 |
| 1d8a: c9 c0 rjmp .+402 ; 0x1f1e <disk_initialize+0x1ae> |
| 1d8c: 8a e0 ldi r24, 0x0A ; 10 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 1d8e: 9f ef ldi r25, 0xFF ; 255 |
| 1d90: 9e bd out 0x2e, r25 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 1d92: 0d b4 in r0, 0x2d ; 45 |
| 1d94: 07 fe sbrs r0, 7 |
| 1d96: fd cf rjmp .-6 ; 0x1d92 <disk_initialize+0x22> |
| return SPDR; |
| 1d98: 2e b5 in r18, 0x2e ; 46 |
| |
| |
| if (drv) return STA_NOINIT; /* Supports only single drive */ |
| if (Stat & STA_NODISK) return Stat; /* No card in the socket */ |
| |
| for (n = 10; n; n--) rcvr_spi(); /* 80 dummy clocks */ |
| 1d9a: 81 50 subi r24, 0x01 ; 1 |
| 1d9c: c9 f7 brne .-14 ; 0x1d90 <disk_initialize+0x20> |
| |
| SELECT(); /* CS = L */ |
| 1d9e: 2a 98 cbi 0x05, 2 ; 5 |
| ty = 0; |
| if (send_cmd(CMD0, 0) == 1) { /* Enter Idle state */ |
| 1da0: 40 e0 ldi r20, 0x00 ; 0 |
| 1da2: 50 e0 ldi r21, 0x00 ; 0 |
| 1da4: 60 e0 ldi r22, 0x00 ; 0 |
| 1da6: 70 e0 ldi r23, 0x00 ; 0 |
| 1da8: 80 e4 ldi r24, 0x40 ; 64 |
| 1daa: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 1dae: 81 30 cpi r24, 0x01 ; 1 |
| 1db0: 09 f0 breq .+2 ; 0x1db4 <disk_initialize+0x44> |
| 1db2: a0 c0 rjmp .+320 ; 0x1ef4 <disk_initialize+0x184> |
| Timer1 = 100; /* Initialization timeout of 1000 msec */ |
| 1db4: 84 e6 ldi r24, 0x64 ; 100 |
| 1db6: 80 93 15 01 sts 0x0115, r24 |
| if (send_cmd(CMD8, 0x1AA) == 1) { /* SDC Ver2+ */ |
| 1dba: 4a ea ldi r20, 0xAA ; 170 |
| 1dbc: 51 e0 ldi r21, 0x01 ; 1 |
| 1dbe: 60 e0 ldi r22, 0x00 ; 0 |
| 1dc0: 70 e0 ldi r23, 0x00 ; 0 |
| 1dc2: 88 e4 ldi r24, 0x48 ; 72 |
| 1dc4: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 1dc8: 81 30 cpi r24, 0x01 ; 1 |
| 1dca: 09 f0 breq .+2 ; 0x1dce <disk_initialize+0x5e> |
| 1dcc: 54 c0 rjmp .+168 ; 0x1e76 <disk_initialize+0x106> |
| 1dce: 7e 01 movw r14, r28 |
| 1dd0: 08 94 sec |
| 1dd2: e1 1c adc r14, r1 |
| 1dd4: f1 1c adc r15, r1 |
| 1dd6: 87 01 movw r16, r14 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 1dd8: 9f ef ldi r25, 0xFF ; 255 |
| SELECT(); /* CS = L */ |
| ty = 0; |
| if (send_cmd(CMD0, 0) == 1) { /* Enter Idle state */ |
| Timer1 = 100; /* Initialization timeout of 1000 msec */ |
| if (send_cmd(CMD8, 0x1AA) == 1) { /* SDC Ver2+ */ |
| for (n = 0; n < 4; n++) ocr[n] = rcvr_spi(); |
| 1dda: 9e 01 movw r18, r28 |
| 1ddc: 2b 5f subi r18, 0xFB ; 251 |
| 1dde: 3f 4f sbci r19, 0xFF ; 255 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 1de0: 9e bd out 0x2e, r25 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 1de2: 0d b4 in r0, 0x2d ; 45 |
| 1de4: 07 fe sbrs r0, 7 |
| 1de6: fd cf rjmp .-6 ; 0x1de2 <disk_initialize+0x72> |
| return SPDR; |
| 1de8: 8e b5 in r24, 0x2e ; 46 |
| SELECT(); /* CS = L */ |
| ty = 0; |
| if (send_cmd(CMD0, 0) == 1) { /* Enter Idle state */ |
| Timer1 = 100; /* Initialization timeout of 1000 msec */ |
| if (send_cmd(CMD8, 0x1AA) == 1) { /* SDC Ver2+ */ |
| for (n = 0; n < 4; n++) ocr[n] = rcvr_spi(); |
| 1dea: f8 01 movw r30, r16 |
| 1dec: 81 93 st Z+, r24 |
| 1dee: 8f 01 movw r16, r30 |
| 1df0: e2 17 cp r30, r18 |
| 1df2: f3 07 cpc r31, r19 |
| 1df4: a9 f7 brne .-22 ; 0x1de0 <disk_initialize+0x70> |
| if (ocr[2] == 0x01 && ocr[3] == 0xAA) { /* The card can work at vdd range of 2.7-3.6V */ |
| 1df6: 8b 81 ldd r24, Y+3 ; 0x03 |
| 1df8: 81 30 cpi r24, 0x01 ; 1 |
| 1dfa: 09 f0 breq .+2 ; 0x1dfe <disk_initialize+0x8e> |
| 1dfc: 7b c0 rjmp .+246 ; 0x1ef4 <disk_initialize+0x184> |
| 1dfe: 8c 81 ldd r24, Y+4 ; 0x04 |
| 1e00: 8a 3a cpi r24, 0xAA ; 170 |
| 1e02: 09 f0 breq .+2 ; 0x1e06 <disk_initialize+0x96> |
| 1e04: 77 c0 rjmp .+238 ; 0x1ef4 <disk_initialize+0x184> |
| do { |
| if (send_cmd(CMD55, 0) <= 1 && send_cmd(CMD41, 1UL << 30) == 0) break; /* ACMD41 with HCS bit */ |
| 1e06: 40 e0 ldi r20, 0x00 ; 0 |
| 1e08: 50 e0 ldi r21, 0x00 ; 0 |
| 1e0a: 60 e0 ldi r22, 0x00 ; 0 |
| 1e0c: 70 e0 ldi r23, 0x00 ; 0 |
| 1e0e: 87 e7 ldi r24, 0x77 ; 119 |
| 1e10: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 1e14: 82 30 cpi r24, 0x02 ; 2 |
| 1e16: 48 f4 brcc .+18 ; 0x1e2a <disk_initialize+0xba> |
| 1e18: 40 e0 ldi r20, 0x00 ; 0 |
| 1e1a: 50 e0 ldi r21, 0x00 ; 0 |
| 1e1c: 60 e0 ldi r22, 0x00 ; 0 |
| 1e1e: 70 e4 ldi r23, 0x40 ; 64 |
| 1e20: 89 e6 ldi r24, 0x69 ; 105 |
| 1e22: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 1e26: 88 23 and r24, r24 |
| 1e28: 21 f0 breq .+8 ; 0x1e32 <disk_initialize+0xc2> |
| } while (Timer1); |
| 1e2a: 80 91 15 01 lds r24, 0x0115 |
| 1e2e: 88 23 and r24, r24 |
| 1e30: 51 f7 brne .-44 ; 0x1e06 <disk_initialize+0x96> |
| if (Timer1 && send_cmd(CMD58, 0) == 0) { /* Check CCS bit */ |
| 1e32: 80 91 15 01 lds r24, 0x0115 |
| 1e36: 88 23 and r24, r24 |
| 1e38: 09 f4 brne .+2 ; 0x1e3c <disk_initialize+0xcc> |
| 1e3a: 5c c0 rjmp .+184 ; 0x1ef4 <disk_initialize+0x184> |
| 1e3c: 40 e0 ldi r20, 0x00 ; 0 |
| 1e3e: 50 e0 ldi r21, 0x00 ; 0 |
| 1e40: 60 e0 ldi r22, 0x00 ; 0 |
| 1e42: 70 e0 ldi r23, 0x00 ; 0 |
| 1e44: 8a e7 ldi r24, 0x7A ; 122 |
| 1e46: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 1e4a: 88 23 and r24, r24 |
| 1e4c: 09 f0 breq .+2 ; 0x1e50 <disk_initialize+0xe0> |
| 1e4e: 52 c0 rjmp .+164 ; 0x1ef4 <disk_initialize+0x184> |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 1e50: 9f ef ldi r25, 0xFF ; 255 |
| 1e52: 9e bd out 0x2e, r25 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 1e54: 0d b4 in r0, 0x2d ; 45 |
| 1e56: 07 fe sbrs r0, 7 |
| 1e58: fd cf rjmp .-6 ; 0x1e54 <disk_initialize+0xe4> |
| return SPDR; |
| 1e5a: 8e b5 in r24, 0x2e ; 46 |
| if (ocr[2] == 0x01 && ocr[3] == 0xAA) { /* The card can work at vdd range of 2.7-3.6V */ |
| do { |
| if (send_cmd(CMD55, 0) <= 1 && send_cmd(CMD41, 1UL << 30) == 0) break; /* ACMD41 with HCS bit */ |
| } while (Timer1); |
| if (Timer1 && send_cmd(CMD58, 0) == 0) { /* Check CCS bit */ |
| for (n = 0; n < 4; n++) ocr[n] = rcvr_spi(); |
| 1e5c: f7 01 movw r30, r14 |
| 1e5e: 81 93 st Z+, r24 |
| 1e60: 7f 01 movw r14, r30 |
| 1e62: e0 17 cp r30, r16 |
| 1e64: f1 07 cpc r31, r17 |
| 1e66: a9 f7 brne .-22 ; 0x1e52 <disk_initialize+0xe2> |
| ty = (ocr[0] & 0x40) ? 6 : 2; |
| 1e68: 89 81 ldd r24, Y+1 ; 0x01 |
| 1e6a: 86 fd sbrc r24, 6 |
| 1e6c: 02 c0 rjmp .+4 ; 0x1e72 <disk_initialize+0x102> |
| 1e6e: 12 e0 ldi r17, 0x02 ; 2 |
| 1e70: 42 c0 rjmp .+132 ; 0x1ef6 <disk_initialize+0x186> |
| 1e72: 16 e0 ldi r17, 0x06 ; 6 |
| 1e74: 40 c0 rjmp .+128 ; 0x1ef6 <disk_initialize+0x186> |
| } |
| } |
| } else { /* SDC Ver1 or MMC */ |
| ty = (send_cmd(CMD55, 0) <= 1 && send_cmd(CMD41, 0) <= 1) ? 2 : 1; /* SDC : MMC */ |
| 1e76: 40 e0 ldi r20, 0x00 ; 0 |
| 1e78: 50 e0 ldi r21, 0x00 ; 0 |
| 1e7a: 60 e0 ldi r22, 0x00 ; 0 |
| 1e7c: 70 e0 ldi r23, 0x00 ; 0 |
| 1e7e: 87 e7 ldi r24, 0x77 ; 119 |
| 1e80: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 1e84: 82 30 cpi r24, 0x02 ; 2 |
| 1e86: 58 f4 brcc .+22 ; 0x1e9e <disk_initialize+0x12e> |
| 1e88: 40 e0 ldi r20, 0x00 ; 0 |
| 1e8a: 50 e0 ldi r21, 0x00 ; 0 |
| 1e8c: 60 e0 ldi r22, 0x00 ; 0 |
| 1e8e: 70 e0 ldi r23, 0x00 ; 0 |
| 1e90: 89 e6 ldi r24, 0x69 ; 105 |
| 1e92: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 1e96: 82 30 cpi r24, 0x02 ; 2 |
| 1e98: 10 f4 brcc .+4 ; 0x1e9e <disk_initialize+0x12e> |
| 1e9a: 12 e0 ldi r17, 0x02 ; 2 |
| 1e9c: 01 c0 rjmp .+2 ; 0x1ea0 <disk_initialize+0x130> |
| 1e9e: 11 e0 ldi r17, 0x01 ; 1 |
| do { |
| if (ty == 2) { |
| 1ea0: 12 30 cpi r17, 0x02 ; 2 |
| 1ea2: 79 f4 brne .+30 ; 0x1ec2 <disk_initialize+0x152> |
| if (send_cmd(CMD55, 0) <= 1 && send_cmd(CMD41, 0) == 0) break; /* ACMD41 */ |
| 1ea4: 40 e0 ldi r20, 0x00 ; 0 |
| 1ea6: 50 e0 ldi r21, 0x00 ; 0 |
| 1ea8: 60 e0 ldi r22, 0x00 ; 0 |
| 1eaa: 70 e0 ldi r23, 0x00 ; 0 |
| 1eac: 87 e7 ldi r24, 0x77 ; 119 |
| 1eae: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 1eb2: 82 30 cpi r24, 0x02 ; 2 |
| 1eb4: 78 f4 brcc .+30 ; 0x1ed4 <disk_initialize+0x164> |
| 1eb6: 40 e0 ldi r20, 0x00 ; 0 |
| 1eb8: 50 e0 ldi r21, 0x00 ; 0 |
| 1eba: 60 e0 ldi r22, 0x00 ; 0 |
| 1ebc: 70 e0 ldi r23, 0x00 ; 0 |
| 1ebe: 89 e6 ldi r24, 0x69 ; 105 |
| 1ec0: 05 c0 rjmp .+10 ; 0x1ecc <disk_initialize+0x15c> |
| } else { |
| if (send_cmd(CMD1, 0) == 0) break; /* CMD1 */ |
| 1ec2: 40 e0 ldi r20, 0x00 ; 0 |
| 1ec4: 50 e0 ldi r21, 0x00 ; 0 |
| 1ec6: 60 e0 ldi r22, 0x00 ; 0 |
| 1ec8: 70 e0 ldi r23, 0x00 ; 0 |
| 1eca: 81 e4 ldi r24, 0x41 ; 65 |
| 1ecc: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 1ed0: 88 23 and r24, r24 |
| 1ed2: 21 f0 breq .+8 ; 0x1edc <disk_initialize+0x16c> |
| } |
| } while (Timer1); |
| 1ed4: 80 91 15 01 lds r24, 0x0115 |
| 1ed8: 88 23 and r24, r24 |
| 1eda: 11 f7 brne .-60 ; 0x1ea0 <disk_initialize+0x130> |
| if (!Timer1 || send_cmd(CMD16, 512) != 0) /* Select R/W block length */ |
| 1edc: 80 91 15 01 lds r24, 0x0115 |
| 1ee0: 88 23 and r24, r24 |
| 1ee2: 41 f0 breq .+16 ; 0x1ef4 <disk_initialize+0x184> |
| 1ee4: 40 e0 ldi r20, 0x00 ; 0 |
| 1ee6: 52 e0 ldi r21, 0x02 ; 2 |
| 1ee8: 60 e0 ldi r22, 0x00 ; 0 |
| 1eea: 70 e0 ldi r23, 0x00 ; 0 |
| 1eec: 80 e5 ldi r24, 0x50 ; 80 |
| 1eee: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 1ef2: 81 11 cpse r24, r1 |
| 1ef4: 10 e0 ldi r17, 0x00 ; 0 |
| ty = 0; |
| } |
| } |
| CardType = ty; |
| 1ef6: 10 93 17 01 sts 0x0117, r17 |
| DESELECT(); /* CS = H */ |
| 1efa: 2a 9a sbi 0x05, 2 ; 5 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 1efc: 8f ef ldi r24, 0xFF ; 255 |
| 1efe: 8e bd out 0x2e, r24 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 1f00: 0d b4 in r0, 0x2d ; 45 |
| 1f02: 07 fe sbrs r0, 7 |
| 1f04: fd cf rjmp .-6 ; 0x1f00 <disk_initialize+0x190> |
| return SPDR; |
| 1f06: 8e b5 in r24, 0x2e ; 46 |
| } |
| CardType = ty; |
| DESELECT(); /* CS = H */ |
| rcvr_spi(); /* Idle (Release DO) */ |
| |
| if (ty) { /* Initialization succeded */ |
| 1f08: 11 23 and r17, r17 |
| 1f0a: 21 f0 breq .+8 ; 0x1f14 <disk_initialize+0x1a4> |
| Stat &= ~STA_NOINIT; /* Clear STA_NOINIT */ |
| 1f0c: 80 91 0b 01 lds r24, 0x010B |
| 1f10: 8e 7f andi r24, 0xFE ; 254 |
| 1f12: 03 c0 rjmp .+6 ; 0x1f1a <disk_initialize+0x1aa> |
| } else { /* Initialization failed */ |
| Stat |= STA_NOINIT; /* Set STA_NOINIT */ |
| 1f14: 80 91 0b 01 lds r24, 0x010B |
| 1f18: 81 60 ori r24, 0x01 ; 1 |
| 1f1a: 80 93 0b 01 sts 0x010B, r24 |
| } |
| |
| return Stat; |
| 1f1e: 80 91 0b 01 lds r24, 0x010B |
| } |
| 1f22: 24 96 adiw r28, 0x04 ; 4 |
| 1f24: e6 e0 ldi r30, 0x06 ; 6 |
| 1f26: 0c 94 ef 14 jmp 0x29de ; 0x29de <__epilogue_restores__+0x18> |
| |
| 00001f2a <disk_status>: |
| /*-----------------------------------------------------------------------*/ |
| |
| DSTATUS disk_status ( |
| BYTE drv /* Physical drive nmuber (0) */ |
| ) |
| { |
| 1f2a: 88 23 and r24, r24 |
| 1f2c: 11 f0 breq .+4 ; 0x1f32 <disk_status+0x8> |
| 1f2e: 81 e0 ldi r24, 0x01 ; 1 |
| 1f30: 08 95 ret |
| if (drv) return STA_NOINIT; /* Supports only single drive */ |
| return Stat; |
| 1f32: 80 91 0b 01 lds r24, 0x010B |
| } |
| 1f36: 08 95 ret |
| |
| 00001f38 <disk_read>: |
| BYTE drv, /* Physical drive nmuber (0) */ |
| BYTE *buff, /* Pointer to the data buffer to store read data */ |
| DWORD sector, /* Start sector number (LBA) */ |
| BYTE count /* Sector count (1..255) */ |
| ) |
| { |
| 1f38: 0f 93 push r16 |
| 1f3a: cf 93 push r28 |
| 1f3c: df 93 push r29 |
| 1f3e: eb 01 movw r28, r22 |
| if (drv || !count) return RES_PARERR; |
| 1f40: 88 23 and r24, r24 |
| 1f42: 09 f0 breq .+2 ; 0x1f46 <disk_read+0xe> |
| 1f44: 51 c0 rjmp .+162 ; 0x1fe8 <disk_read+0xb0> |
| 1f46: 00 23 and r16, r16 |
| 1f48: 09 f4 brne .+2 ; 0x1f4c <disk_read+0x14> |
| 1f4a: 4e c0 rjmp .+156 ; 0x1fe8 <disk_read+0xb0> |
| if (Stat & STA_NOINIT) return RES_NOTRDY; |
| 1f4c: 80 91 0b 01 lds r24, 0x010B |
| 1f50: 80 ff sbrs r24, 0 |
| 1f52: 03 c0 rjmp .+6 ; 0x1f5a <disk_read+0x22> |
| 1f54: 23 e0 ldi r18, 0x03 ; 3 |
| 1f56: 30 e0 ldi r19, 0x00 ; 0 |
| 1f58: 49 c0 rjmp .+146 ; 0x1fec <disk_read+0xb4> |
| |
| if (!(CardType & 4)) sector *= 512; /* Convert to byte address if needed */ |
| 1f5a: 80 91 17 01 lds r24, 0x0117 |
| 1f5e: 82 fd sbrc r24, 2 |
| 1f60: 07 c0 rjmp .+14 ; 0x1f70 <disk_read+0x38> |
| 1f62: 69 e0 ldi r22, 0x09 ; 9 |
| 1f64: 22 0f add r18, r18 |
| 1f66: 33 1f adc r19, r19 |
| 1f68: 44 1f adc r20, r20 |
| 1f6a: 55 1f adc r21, r21 |
| 1f6c: 6a 95 dec r22 |
| 1f6e: d1 f7 brne .-12 ; 0x1f64 <disk_read+0x2c> |
| |
| SELECT(); /* CS = L */ |
| 1f70: 2a 98 cbi 0x05, 2 ; 5 |
| |
| if (count == 1) { /* Single block read */ |
| 1f72: 01 30 cpi r16, 0x01 ; 1 |
| 1f74: 89 f4 brne .+34 ; 0x1f98 <disk_read+0x60> |
| if ((send_cmd(CMD17, sector) == 0) /* READ_SINGLE_BLOCK */ |
| 1f76: ba 01 movw r22, r20 |
| 1f78: a9 01 movw r20, r18 |
| 1f7a: 81 e5 ldi r24, 0x51 ; 81 |
| 1f7c: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 1f80: 88 23 and r24, r24 |
| 1f82: 21 f5 brne .+72 ; 0x1fcc <disk_read+0x94> |
| 1f84: 60 e0 ldi r22, 0x00 ; 0 |
| 1f86: 72 e0 ldi r23, 0x02 ; 2 |
| 1f88: ce 01 movw r24, r28 |
| 1f8a: 0e 94 e3 0d call 0x1bc6 ; 0x1bc6 <rcvr_datablock> |
| 1f8e: 00 e0 ldi r16, 0x00 ; 0 |
| 1f90: 88 23 and r24, r24 |
| 1f92: e1 f4 brne .+56 ; 0x1fcc <disk_read+0x94> |
| 1f94: 01 e0 ldi r16, 0x01 ; 1 |
| 1f96: 1a c0 rjmp .+52 ; 0x1fcc <disk_read+0x94> |
| && rcvr_datablock(buff, 512)) |
| count = 0; |
| } |
| else { /* Multiple block read */ |
| if (send_cmd(CMD18, sector) == 0) { /* READ_MULTIPLE_BLOCK */ |
| 1f98: ba 01 movw r22, r20 |
| 1f9a: a9 01 movw r20, r18 |
| 1f9c: 82 e5 ldi r24, 0x52 ; 82 |
| 1f9e: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 1fa2: 88 23 and r24, r24 |
| 1fa4: 99 f4 brne .+38 ; 0x1fcc <disk_read+0x94> |
| do { |
| if (!rcvr_datablock(buff, 512)) break; |
| 1fa6: 60 e0 ldi r22, 0x00 ; 0 |
| 1fa8: 72 e0 ldi r23, 0x02 ; 2 |
| 1faa: ce 01 movw r24, r28 |
| 1fac: 0e 94 e3 0d call 0x1bc6 ; 0x1bc6 <rcvr_datablock> |
| 1fb0: 88 23 and r24, r24 |
| 1fb2: 29 f0 breq .+10 ; 0x1fbe <disk_read+0x86> |
| buff += 512; |
| } while (--count); |
| 1fb4: 01 50 subi r16, 0x01 ; 1 |
| 1fb6: 19 f0 breq .+6 ; 0x1fbe <disk_read+0x86> |
| } |
| else { /* Multiple block read */ |
| if (send_cmd(CMD18, sector) == 0) { /* READ_MULTIPLE_BLOCK */ |
| do { |
| if (!rcvr_datablock(buff, 512)) break; |
| buff += 512; |
| 1fb8: c0 50 subi r28, 0x00 ; 0 |
| 1fba: de 4f sbci r29, 0xFE ; 254 |
| 1fbc: f4 cf rjmp .-24 ; 0x1fa6 <disk_read+0x6e> |
| } while (--count); |
| send_cmd(CMD12, 0); /* STOP_TRANSMISSION */ |
| 1fbe: 40 e0 ldi r20, 0x00 ; 0 |
| 1fc0: 50 e0 ldi r21, 0x00 ; 0 |
| 1fc2: 60 e0 ldi r22, 0x00 ; 0 |
| 1fc4: 70 e0 ldi r23, 0x00 ; 0 |
| 1fc6: 8c e4 ldi r24, 0x4C ; 76 |
| 1fc8: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| } |
| } |
| |
| DESELECT(); /* CS = H */ |
| 1fcc: 2a 9a sbi 0x05, 2 ; 5 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 1fce: 8f ef ldi r24, 0xFF ; 255 |
| 1fd0: 8e bd out 0x2e, r24 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 1fd2: 0d b4 in r0, 0x2d ; 45 |
| 1fd4: 07 fe sbrs r0, 7 |
| 1fd6: fd cf rjmp .-6 ; 0x1fd2 <disk_read+0x9a> |
| return SPDR; |
| 1fd8: 8e b5 in r24, 0x2e ; 46 |
| } |
| |
| DESELECT(); /* CS = H */ |
| rcvr_spi(); /* Idle (Release DO) */ |
| |
| return count ? RES_ERROR : RES_OK; |
| 1fda: 20 e0 ldi r18, 0x00 ; 0 |
| 1fdc: 30 e0 ldi r19, 0x00 ; 0 |
| 1fde: 00 23 and r16, r16 |
| 1fe0: 29 f0 breq .+10 ; 0x1fec <disk_read+0xb4> |
| 1fe2: 21 e0 ldi r18, 0x01 ; 1 |
| 1fe4: 30 e0 ldi r19, 0x00 ; 0 |
| 1fe6: 02 c0 rjmp .+4 ; 0x1fec <disk_read+0xb4> |
| 1fe8: 24 e0 ldi r18, 0x04 ; 4 |
| 1fea: 30 e0 ldi r19, 0x00 ; 0 |
| } |
| 1fec: c9 01 movw r24, r18 |
| 1fee: df 91 pop r29 |
| 1ff0: cf 91 pop r28 |
| 1ff2: 0f 91 pop r16 |
| 1ff4: 08 95 ret |
| |
| 00001ff6 <disk_write>: |
| BYTE drv, /* Physical drive nmuber (0) */ |
| const BYTE *buff, /* Pointer to the data to be written */ |
| DWORD sector, /* Start sector number (LBA) */ |
| BYTE count /* Sector count (1..255) */ |
| ) |
| { |
| 1ff6: cf 92 push r12 |
| 1ff8: df 92 push r13 |
| 1ffa: ef 92 push r14 |
| 1ffc: ff 92 push r15 |
| 1ffe: 0f 93 push r16 |
| 2000: cf 93 push r28 |
| 2002: df 93 push r29 |
| 2004: eb 01 movw r28, r22 |
| 2006: 69 01 movw r12, r18 |
| 2008: 7a 01 movw r14, r20 |
| if (drv || !count) return RES_PARERR; |
| 200a: 88 23 and r24, r24 |
| 200c: 09 f0 breq .+2 ; 0x2010 <disk_write+0x1a> |
| 200e: 64 c0 rjmp .+200 ; 0x20d8 <disk_write+0xe2> |
| 2010: 00 23 and r16, r16 |
| 2012: 09 f4 brne .+2 ; 0x2016 <disk_write+0x20> |
| 2014: 61 c0 rjmp .+194 ; 0x20d8 <disk_write+0xe2> |
| if (Stat & STA_NOINIT) return RES_NOTRDY; |
| 2016: 80 91 0b 01 lds r24, 0x010B |
| 201a: 80 ff sbrs r24, 0 |
| 201c: 03 c0 rjmp .+6 ; 0x2024 <disk_write+0x2e> |
| 201e: 23 e0 ldi r18, 0x03 ; 3 |
| 2020: 30 e0 ldi r19, 0x00 ; 0 |
| 2022: 5c c0 rjmp .+184 ; 0x20dc <disk_write+0xe6> |
| if (Stat & STA_PROTECT) return RES_WRPRT; |
| 2024: 80 91 0b 01 lds r24, 0x010B |
| 2028: 82 ff sbrs r24, 2 |
| 202a: 03 c0 rjmp .+6 ; 0x2032 <disk_write+0x3c> |
| 202c: 22 e0 ldi r18, 0x02 ; 2 |
| 202e: 30 e0 ldi r19, 0x00 ; 0 |
| 2030: 55 c0 rjmp .+170 ; 0x20dc <disk_write+0xe6> |
| |
| if (!(CardType & 4)) sector *= 512; /* Convert to byte address if needed */ |
| 2032: 80 91 17 01 lds r24, 0x0117 |
| 2036: 82 fd sbrc r24, 2 |
| 2038: 07 c0 rjmp .+14 ; 0x2048 <disk_write+0x52> |
| 203a: 79 e0 ldi r23, 0x09 ; 9 |
| 203c: cc 0c add r12, r12 |
| 203e: dd 1c adc r13, r13 |
| 2040: ee 1c adc r14, r14 |
| 2042: ff 1c adc r15, r15 |
| 2044: 7a 95 dec r23 |
| 2046: d1 f7 brne .-12 ; 0x203c <disk_write+0x46> |
| |
| SELECT(); /* CS = L */ |
| 2048: 2a 98 cbi 0x05, 2 ; 5 |
| |
| if (count == 1) { /* Single block write */ |
| 204a: 01 30 cpi r16, 0x01 ; 1 |
| 204c: 69 f4 brne .+26 ; 0x2068 <disk_write+0x72> |
| if ((send_cmd(CMD24, sector) == 0) /* WRITE_BLOCK */ |
| 204e: b7 01 movw r22, r14 |
| 2050: a6 01 movw r20, r12 |
| 2052: 88 e5 ldi r24, 0x58 ; 88 |
| 2054: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 2058: 88 23 and r24, r24 |
| 205a: 81 f5 brne .+96 ; 0x20bc <disk_write+0xc6> |
| 205c: 6e ef ldi r22, 0xFE ; 254 |
| 205e: ce 01 movw r24, r28 |
| 2060: 0e 94 18 0e call 0x1c30 ; 0x1c30 <xmit_datablock> |
| 2064: 00 e0 ldi r16, 0x00 ; 0 |
| 2066: 27 c0 rjmp .+78 ; 0x20b6 <disk_write+0xc0> |
| && xmit_datablock(buff, 0xFE)) |
| count = 0; |
| } |
| else { /* Multiple block write */ |
| if (CardType & 2) { |
| 2068: 81 ff sbrs r24, 1 |
| 206a: 0e c0 rjmp .+28 ; 0x2088 <disk_write+0x92> |
| send_cmd(CMD55, 0); send_cmd(CMD23, count); /* ACMD23 */ |
| 206c: 40 e0 ldi r20, 0x00 ; 0 |
| 206e: 50 e0 ldi r21, 0x00 ; 0 |
| 2070: 60 e0 ldi r22, 0x00 ; 0 |
| 2072: 70 e0 ldi r23, 0x00 ; 0 |
| 2074: 87 e7 ldi r24, 0x77 ; 119 |
| 2076: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 207a: 40 2f mov r20, r16 |
| 207c: 50 e0 ldi r21, 0x00 ; 0 |
| 207e: 60 e0 ldi r22, 0x00 ; 0 |
| 2080: 70 e0 ldi r23, 0x00 ; 0 |
| 2082: 87 e5 ldi r24, 0x57 ; 87 |
| 2084: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| } |
| if (send_cmd(CMD25, sector) == 0) { /* WRITE_MULTIPLE_BLOCK */ |
| 2088: b7 01 movw r22, r14 |
| 208a: a6 01 movw r20, r12 |
| 208c: 89 e5 ldi r24, 0x59 ; 89 |
| 208e: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 2092: 88 23 and r24, r24 |
| 2094: 99 f4 brne .+38 ; 0x20bc <disk_write+0xc6> |
| do { |
| if (!xmit_datablock(buff, 0xFC)) break; |
| 2096: 6c ef ldi r22, 0xFC ; 252 |
| 2098: ce 01 movw r24, r28 |
| 209a: 0e 94 18 0e call 0x1c30 ; 0x1c30 <xmit_datablock> |
| 209e: 88 23 and r24, r24 |
| 20a0: 29 f0 breq .+10 ; 0x20ac <disk_write+0xb6> |
| buff += 512; |
| } while (--count); |
| 20a2: 01 50 subi r16, 0x01 ; 1 |
| 20a4: 19 f0 breq .+6 ; 0x20ac <disk_write+0xb6> |
| send_cmd(CMD55, 0); send_cmd(CMD23, count); /* ACMD23 */ |
| } |
| if (send_cmd(CMD25, sector) == 0) { /* WRITE_MULTIPLE_BLOCK */ |
| do { |
| if (!xmit_datablock(buff, 0xFC)) break; |
| buff += 512; |
| 20a6: c0 50 subi r28, 0x00 ; 0 |
| 20a8: de 4f sbci r29, 0xFE ; 254 |
| 20aa: f5 cf rjmp .-22 ; 0x2096 <disk_write+0xa0> |
| } while (--count); |
| if (!xmit_datablock(0, 0xFD)) /* STOP_TRAN token */ |
| 20ac: 6d ef ldi r22, 0xFD ; 253 |
| 20ae: 80 e0 ldi r24, 0x00 ; 0 |
| 20b0: 90 e0 ldi r25, 0x00 ; 0 |
| 20b2: 0e 94 18 0e call 0x1c30 ; 0x1c30 <xmit_datablock> |
| 20b6: 88 23 and r24, r24 |
| 20b8: 09 f4 brne .+2 ; 0x20bc <disk_write+0xc6> |
| 20ba: 01 e0 ldi r16, 0x01 ; 1 |
| count = 1; |
| } |
| } |
| |
| DESELECT(); /* CS = H */ |
| 20bc: 2a 9a sbi 0x05, 2 ; 5 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 20be: 8f ef ldi r24, 0xFF ; 255 |
| 20c0: 8e bd out 0x2e, r24 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 20c2: 0d b4 in r0, 0x2d ; 45 |
| 20c4: 07 fe sbrs r0, 7 |
| 20c6: fd cf rjmp .-6 ; 0x20c2 <disk_write+0xcc> |
| return SPDR; |
| 20c8: 8e b5 in r24, 0x2e ; 46 |
| } |
| |
| DESELECT(); /* CS = H */ |
| rcvr_spi(); /* Idle (Release DO) */ |
| |
| return count ? RES_ERROR : RES_OK; |
| 20ca: 20 e0 ldi r18, 0x00 ; 0 |
| 20cc: 30 e0 ldi r19, 0x00 ; 0 |
| 20ce: 00 23 and r16, r16 |
| 20d0: 29 f0 breq .+10 ; 0x20dc <disk_write+0xe6> |
| 20d2: 21 e0 ldi r18, 0x01 ; 1 |
| 20d4: 30 e0 ldi r19, 0x00 ; 0 |
| 20d6: 02 c0 rjmp .+4 ; 0x20dc <disk_write+0xe6> |
| 20d8: 24 e0 ldi r18, 0x04 ; 4 |
| 20da: 30 e0 ldi r19, 0x00 ; 0 |
| } |
| 20dc: c9 01 movw r24, r18 |
| 20de: df 91 pop r29 |
| 20e0: cf 91 pop r28 |
| 20e2: 0f 91 pop r16 |
| 20e4: ff 90 pop r15 |
| 20e6: ef 90 pop r14 |
| 20e8: df 90 pop r13 |
| 20ea: cf 90 pop r12 |
| 20ec: 08 95 ret |
| |
| 000020ee <disk_ioctl>: |
| DRESULT disk_ioctl ( |
| BYTE drv, /* Physical drive nmuber (0) */ |
| BYTE ctrl, /* Control code */ |
| void *buff /* Buffer to send/receive data block */ |
| ) |
| { |
| 20ee: a0 e1 ldi r26, 0x10 ; 16 |
| 20f0: b0 e0 ldi r27, 0x00 ; 0 |
| 20f2: ed e7 ldi r30, 0x7D ; 125 |
| 20f4: f0 e1 ldi r31, 0x10 ; 16 |
| 20f6: 0c 94 d5 14 jmp 0x29aa ; 0x29aa <__prologue_saves__+0x1c> |
| 20fa: 8a 01 movw r16, r20 |
| DRESULT res; |
| BYTE n, csd[16], *ptr = buff; |
| WORD csize; |
| |
| |
| if (drv) return RES_PARERR; |
| 20fc: 88 23 and r24, r24 |
| 20fe: 19 f0 breq .+6 ; 0x2106 <disk_ioctl+0x18> |
| 2100: 24 e0 ldi r18, 0x04 ; 4 |
| 2102: 30 e0 ldi r19, 0x00 ; 0 |
| 2104: e7 c0 rjmp .+462 ; 0x22d4 <disk_ioctl+0x1e6> |
| |
| SELECT(); /* CS = L */ |
| 2106: 2a 98 cbi 0x05, 2 ; 5 |
| |
| res = RES_ERROR; |
| switch (ctrl) { |
| 2108: 63 30 cpi r22, 0x03 ; 3 |
| 210a: 09 f4 brne .+2 ; 0x210e <disk_ioctl+0x20> |
| 210c: 7f c0 rjmp .+254 ; 0x220c <disk_ioctl+0x11e> |
| 210e: 64 30 cpi r22, 0x04 ; 4 |
| 2110: 28 f4 brcc .+10 ; 0x211c <disk_ioctl+0x2e> |
| 2112: 61 30 cpi r22, 0x01 ; 1 |
| 2114: 79 f0 breq .+30 ; 0x2134 <disk_ioctl+0x46> |
| 2116: 62 30 cpi r22, 0x02 ; 2 |
| 2118: 51 f4 brne .+20 ; 0x212e <disk_ioctl+0x40> |
| 211a: 72 c0 rjmp .+228 ; 0x2200 <disk_ioctl+0x112> |
| 211c: 6b 30 cpi r22, 0x0B ; 11 |
| 211e: 09 f4 brne .+2 ; 0x2122 <disk_ioctl+0x34> |
| 2120: 96 c0 rjmp .+300 ; 0x224e <disk_ioctl+0x160> |
| 2122: 6c 30 cpi r22, 0x0C ; 12 |
| 2124: 09 f4 brne .+2 ; 0x2128 <disk_ioctl+0x3a> |
| 2126: aa c0 rjmp .+340 ; 0x227c <disk_ioctl+0x18e> |
| 2128: 6a 30 cpi r22, 0x0A ; 10 |
| 212a: 09 f4 brne .+2 ; 0x212e <disk_ioctl+0x40> |
| 212c: 86 c0 rjmp .+268 ; 0x223a <disk_ioctl+0x14c> |
| 212e: 24 e0 ldi r18, 0x04 ; 4 |
| 2130: 30 e0 ldi r19, 0x00 ; 0 |
| 2132: c6 c0 rjmp .+396 ; 0x22c0 <disk_ioctl+0x1d2> |
| case GET_SECTOR_COUNT : /* Get number of sectors on the disk (DWORD) */ |
| if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) { |
| 2134: 40 e0 ldi r20, 0x00 ; 0 |
| 2136: 50 e0 ldi r21, 0x00 ; 0 |
| 2138: 60 e0 ldi r22, 0x00 ; 0 |
| 213a: 70 e0 ldi r23, 0x00 ; 0 |
| 213c: 89 e4 ldi r24, 0x49 ; 73 |
| 213e: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 2142: 88 23 and r24, r24 |
| 2144: 09 f0 breq .+2 ; 0x2148 <disk_ioctl+0x5a> |
| 2146: b7 c0 rjmp .+366 ; 0x22b6 <disk_ioctl+0x1c8> |
| 2148: 60 e1 ldi r22, 0x10 ; 16 |
| 214a: 70 e0 ldi r23, 0x00 ; 0 |
| 214c: ce 01 movw r24, r28 |
| 214e: 01 96 adiw r24, 0x01 ; 1 |
| 2150: 0e 94 e3 0d call 0x1bc6 ; 0x1bc6 <rcvr_datablock> |
| 2154: 88 23 and r24, r24 |
| 2156: 09 f4 brne .+2 ; 0x215a <disk_ioctl+0x6c> |
| 2158: ae c0 rjmp .+348 ; 0x22b6 <disk_ioctl+0x1c8> |
| if ((csd[0] >> 6) == 1) { /* SDC ver 2.00 */ |
| 215a: 89 81 ldd r24, Y+1 ; 0x01 |
| 215c: 82 95 swap r24 |
| 215e: 86 95 lsr r24 |
| 2160: 86 95 lsr r24 |
| 2162: 83 70 andi r24, 0x03 ; 3 |
| 2164: 7a 85 ldd r23, Y+10 ; 0x0a |
| 2166: 49 85 ldd r20, Y+9 ; 0x09 |
| 2168: 81 30 cpi r24, 0x01 ; 1 |
| 216a: b1 f4 brne .+44 ; 0x2198 <disk_ioctl+0xaa> |
| csize = csd[9] + ((WORD)csd[8] << 8) + 1; |
| *(DWORD*)buff = (DWORD)csize << 10; |
| 216c: 87 2f mov r24, r23 |
| 216e: 90 e0 ldi r25, 0x00 ; 0 |
| 2170: 01 96 adiw r24, 0x01 ; 1 |
| 2172: 34 2f mov r19, r20 |
| 2174: 20 e0 ldi r18, 0x00 ; 0 |
| 2176: 82 0f add r24, r18 |
| 2178: 93 1f adc r25, r19 |
| 217a: a0 e0 ldi r26, 0x00 ; 0 |
| 217c: b0 e0 ldi r27, 0x00 ; 0 |
| 217e: 2a e0 ldi r18, 0x0A ; 10 |
| 2180: 88 0f add r24, r24 |
| 2182: 99 1f adc r25, r25 |
| 2184: aa 1f adc r26, r26 |
| 2186: bb 1f adc r27, r27 |
| 2188: 2a 95 dec r18 |
| 218a: d1 f7 brne .-12 ; 0x2180 <disk_ioctl+0x92> |
| 218c: f8 01 movw r30, r16 |
| 218e: 80 83 st Z, r24 |
| 2190: 91 83 std Z+1, r25 ; 0x01 |
| 2192: a2 83 std Z+2, r26 ; 0x02 |
| 2194: b3 83 std Z+3, r27 ; 0x03 |
| 2196: 92 c0 rjmp .+292 ; 0x22bc <disk_ioctl+0x1ce> |
| } else { /* MMC or SDC ver 1.XX */ |
| n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2; |
| csize = (csd[8] >> 6) + ((WORD)csd[7] << 2) + ((WORD)(csd[6] & 3) << 10) + 1; |
| *(DWORD*)buff = (DWORD)csize << (n - 9); |
| 2198: 42 95 swap r20 |
| 219a: 46 95 lsr r20 |
| 219c: 46 95 lsr r20 |
| 219e: 43 70 andi r20, 0x03 ; 3 |
| 21a0: 28 85 ldd r18, Y+8 ; 0x08 |
| 21a2: 30 e0 ldi r19, 0x00 ; 0 |
| 21a4: 22 0f add r18, r18 |
| 21a6: 33 1f adc r19, r19 |
| 21a8: 22 0f add r18, r18 |
| 21aa: 33 1f adc r19, r19 |
| 21ac: 24 0f add r18, r20 |
| 21ae: 31 1d adc r19, r1 |
| 21b0: 2f 5f subi r18, 0xFF ; 255 |
| 21b2: 3f 4f sbci r19, 0xFF ; 255 |
| 21b4: 8f 81 ldd r24, Y+7 ; 0x07 |
| 21b6: 90 e0 ldi r25, 0x00 ; 0 |
| 21b8: 83 70 andi r24, 0x03 ; 3 |
| 21ba: 90 70 andi r25, 0x00 ; 0 |
| 21bc: 98 2f mov r25, r24 |
| 21be: 88 27 eor r24, r24 |
| 21c0: 99 0f add r25, r25 |
| 21c2: 99 0f add r25, r25 |
| 21c4: 28 0f add r18, r24 |
| 21c6: 39 1f adc r19, r25 |
| 21c8: 40 e0 ldi r20, 0x00 ; 0 |
| 21ca: 50 e0 ldi r21, 0x00 ; 0 |
| 21cc: 8e 81 ldd r24, Y+6 ; 0x06 |
| 21ce: 8f 70 andi r24, 0x0F ; 15 |
| 21d0: 6b 85 ldd r22, Y+11 ; 0x0b |
| 21d2: 66 1f adc r22, r22 |
| 21d4: 66 27 eor r22, r22 |
| 21d6: 66 1f adc r22, r22 |
| 21d8: 86 0f add r24, r22 |
| 21da: 8e 5f subi r24, 0xFE ; 254 |
| 21dc: 73 70 andi r23, 0x03 ; 3 |
| 21de: 77 0f add r23, r23 |
| 21e0: 87 0f add r24, r23 |
| 21e2: 90 e0 ldi r25, 0x00 ; 0 |
| 21e4: 09 97 sbiw r24, 0x09 ; 9 |
| 21e6: 04 c0 rjmp .+8 ; 0x21f0 <disk_ioctl+0x102> |
| 21e8: 22 0f add r18, r18 |
| 21ea: 33 1f adc r19, r19 |
| 21ec: 44 1f adc r20, r20 |
| 21ee: 55 1f adc r21, r21 |
| 21f0: 8a 95 dec r24 |
| 21f2: d2 f7 brpl .-12 ; 0x21e8 <disk_ioctl+0xfa> |
| 21f4: f8 01 movw r30, r16 |
| 21f6: 20 83 st Z, r18 |
| 21f8: 31 83 std Z+1, r19 ; 0x01 |
| 21fa: 42 83 std Z+2, r20 ; 0x02 |
| 21fc: 53 83 std Z+3, r21 ; 0x03 |
| 21fe: 5e c0 rjmp .+188 ; 0x22bc <disk_ioctl+0x1ce> |
| res = RES_OK; |
| } |
| break; |
| |
| case GET_SECTOR_SIZE : /* Get sectors on the disk (WORD) */ |
| *(WORD*)buff = 512; |
| 2200: 80 e0 ldi r24, 0x00 ; 0 |
| 2202: 92 e0 ldi r25, 0x02 ; 2 |
| 2204: fa 01 movw r30, r20 |
| 2206: 91 83 std Z+1, r25 ; 0x01 |
| 2208: 80 83 st Z, r24 |
| 220a: 58 c0 rjmp .+176 ; 0x22bc <disk_ioctl+0x1ce> |
| BYTE wait_ready (void) |
| { |
| BYTE res; |
| |
| |
| Timer2 = 50; /* Wait for ready in timeout of 500ms */ |
| 220c: 82 e3 ldi r24, 0x32 ; 50 |
| 220e: 80 93 16 01 sts 0x0116, r24 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 2212: 8f ef ldi r24, 0xFF ; 255 |
| 2214: 8e bd out 0x2e, r24 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 2216: 0d b4 in r0, 0x2d ; 45 |
| 2218: 07 fe sbrs r0, 7 |
| 221a: fd cf rjmp .-6 ; 0x2216 <disk_ioctl+0x128> |
| return SPDR; |
| 221c: 8e b5 in r24, 0x2e ; 46 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 221e: 9f ef ldi r25, 0xFF ; 255 |
| 2220: 9e bd out 0x2e, r25 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 2222: 0d b4 in r0, 0x2d ; 45 |
| 2224: 07 fe sbrs r0, 7 |
| 2226: fd cf rjmp .-6 ; 0x2222 <disk_ioctl+0x134> |
| return SPDR; |
| 2228: 8e b5 in r24, 0x2e ; 46 |
| |
| Timer2 = 50; /* Wait for ready in timeout of 500ms */ |
| rcvr_spi(); |
| do |
| res = rcvr_spi(); |
| while ((res != 0xFF) && Timer2); |
| 222a: 8f 3f cpi r24, 0xFF ; 255 |
| 222c: 09 f4 brne .+2 ; 0x2230 <disk_ioctl+0x142> |
| 222e: 46 c0 rjmp .+140 ; 0x22bc <disk_ioctl+0x1ce> |
| 2230: 80 91 16 01 lds r24, 0x0116 |
| 2234: 88 23 and r24, r24 |
| 2236: a1 f7 brne .-24 ; 0x2220 <disk_ioctl+0x132> |
| 2238: 3e c0 rjmp .+124 ; 0x22b6 <disk_ioctl+0x1c8> |
| if (wait_ready() == 0xFF) |
| res = RES_OK; |
| break; |
| |
| case MMC_GET_CSD : /* Receive CSD as a data block (16 bytes) */ |
| if (Stat & STA_NOINIT) return RES_NOTRDY; |
| 223a: 80 91 0b 01 lds r24, 0x010B |
| 223e: 80 fd sbrc r24, 0 |
| 2240: 47 c0 rjmp .+142 ; 0x22d0 <disk_ioctl+0x1e2> |
| if ((send_cmd(CMD9, 0) == 0) /* READ_CSD */ |
| 2242: 40 e0 ldi r20, 0x00 ; 0 |
| 2244: 50 e0 ldi r21, 0x00 ; 0 |
| 2246: 60 e0 ldi r22, 0x00 ; 0 |
| 2248: 70 e0 ldi r23, 0x00 ; 0 |
| 224a: 89 e4 ldi r24, 0x49 ; 73 |
| 224c: 09 c0 rjmp .+18 ; 0x2260 <disk_ioctl+0x172> |
| && rcvr_datablock(ptr, 16)) |
| res = RES_OK; |
| break; |
| |
| case MMC_GET_CID : /* Receive CID as a data block (16 bytes) */ |
| if (Stat & STA_NOINIT) return RES_NOTRDY; |
| 224e: 80 91 0b 01 lds r24, 0x010B |
| 2252: 80 fd sbrc r24, 0 |
| 2254: 3d c0 rjmp .+122 ; 0x22d0 <disk_ioctl+0x1e2> |
| if ((send_cmd(CMD10, 0) == 0) /* READ_CID */ |
| 2256: 40 e0 ldi r20, 0x00 ; 0 |
| 2258: 50 e0 ldi r21, 0x00 ; 0 |
| 225a: 60 e0 ldi r22, 0x00 ; 0 |
| 225c: 70 e0 ldi r23, 0x00 ; 0 |
| 225e: 8a e4 ldi r24, 0x4A ; 74 |
| 2260: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 2264: 88 23 and r24, r24 |
| 2266: 39 f5 brne .+78 ; 0x22b6 <disk_ioctl+0x1c8> |
| 2268: 60 e1 ldi r22, 0x10 ; 16 |
| 226a: 70 e0 ldi r23, 0x00 ; 0 |
| 226c: c8 01 movw r24, r16 |
| 226e: 0e 94 e3 0d call 0x1bc6 ; 0x1bc6 <rcvr_datablock> |
| 2272: 20 e0 ldi r18, 0x00 ; 0 |
| 2274: 30 e0 ldi r19, 0x00 ; 0 |
| 2276: 88 23 and r24, r24 |
| 2278: 19 f5 brne .+70 ; 0x22c0 <disk_ioctl+0x1d2> |
| 227a: 1d c0 rjmp .+58 ; 0x22b6 <disk_ioctl+0x1c8> |
| && rcvr_datablock(ptr, 16)) |
| res = RES_OK; |
| break; |
| |
| case MMC_GET_OCR : /* Receive OCR as an R3 resp (4 bytes) */ |
| if (Stat & STA_NOINIT) return RES_NOTRDY; |
| 227c: 80 91 0b 01 lds r24, 0x010B |
| 2280: 80 fd sbrc r24, 0 |
| 2282: 26 c0 rjmp .+76 ; 0x22d0 <disk_ioctl+0x1e2> |
| if (send_cmd(CMD58, 0) == 0) { /* READ_OCR */ |
| 2284: 40 e0 ldi r20, 0x00 ; 0 |
| 2286: 50 e0 ldi r21, 0x00 ; 0 |
| 2288: 60 e0 ldi r22, 0x00 ; 0 |
| 228a: 70 e0 ldi r23, 0x00 ; 0 |
| 228c: 8a e7 ldi r24, 0x7A ; 122 |
| 228e: 0e 94 60 0e call 0x1cc0 ; 0x1cc0 <send_cmd> |
| 2292: 88 23 and r24, r24 |
| 2294: 81 f4 brne .+32 ; 0x22b6 <disk_ioctl+0x1c8> |
| 2296: f8 01 movw r30, r16 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 2298: 9f ef ldi r25, 0xFF ; 255 |
| break; |
| |
| case MMC_GET_OCR : /* Receive OCR as an R3 resp (4 bytes) */ |
| if (Stat & STA_NOINIT) return RES_NOTRDY; |
| if (send_cmd(CMD58, 0) == 0) { /* READ_OCR */ |
| for (n = 0; n < 4; n++) |
| 229a: 98 01 movw r18, r16 |
| 229c: 2d 5f subi r18, 0xFD ; 253 |
| 229e: 3f 4f sbci r19, 0xFF ; 255 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 22a0: 9e bd out 0x2e, r25 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 22a2: 0d b4 in r0, 0x2d ; 45 |
| 22a4: 07 fe sbrs r0, 7 |
| 22a6: fd cf rjmp .-6 ; 0x22a2 <disk_ioctl+0x1b4> |
| return SPDR; |
| 22a8: 8e b5 in r24, 0x2e ; 46 |
| |
| case MMC_GET_OCR : /* Receive OCR as an R3 resp (4 bytes) */ |
| if (Stat & STA_NOINIT) return RES_NOTRDY; |
| if (send_cmd(CMD58, 0) == 0) { /* READ_OCR */ |
| for (n = 0; n < 4; n++) |
| *ptr++ = rcvr_spi(); |
| 22aa: 80 83 st Z, r24 |
| break; |
| |
| case MMC_GET_OCR : /* Receive OCR as an R3 resp (4 bytes) */ |
| if (Stat & STA_NOINIT) return RES_NOTRDY; |
| if (send_cmd(CMD58, 0) == 0) { /* READ_OCR */ |
| for (n = 0; n < 4; n++) |
| 22ac: e2 17 cp r30, r18 |
| 22ae: f3 07 cpc r31, r19 |
| 22b0: 29 f0 breq .+10 ; 0x22bc <disk_ioctl+0x1ce> |
| *ptr++ = rcvr_spi(); |
| 22b2: 31 96 adiw r30, 0x01 ; 1 |
| 22b4: f5 cf rjmp .-22 ; 0x22a0 <disk_ioctl+0x1b2> |
| 22b6: 21 e0 ldi r18, 0x01 ; 1 |
| 22b8: 30 e0 ldi r19, 0x00 ; 0 |
| 22ba: 02 c0 rjmp .+4 ; 0x22c0 <disk_ioctl+0x1d2> |
| 22bc: 20 e0 ldi r18, 0x00 ; 0 |
| 22be: 30 e0 ldi r19, 0x00 ; 0 |
| |
| default: |
| res = RES_PARERR; |
| } |
| |
| DESELECT(); /* CS = H */ |
| 22c0: 2a 9a sbi 0x05, 2 ; 5 |
| /*-----------------------------------------------------------------------*/ |
| |
| static |
| BYTE rcvr_spi (void) |
| { |
| SPDR = 0xFF; |
| 22c2: 8f ef ldi r24, 0xFF ; 255 |
| 22c4: 8e bd out 0x2e, r24 ; 46 |
| loop_until_bit_is_set(SPSR, SPIF); |
| 22c6: 0d b4 in r0, 0x2d ; 45 |
| 22c8: 07 fe sbrs r0, 7 |
| 22ca: fd cf rjmp .-6 ; 0x22c6 <disk_ioctl+0x1d8> |
| return SPDR; |
| 22cc: 8e b5 in r24, 0x2e ; 46 |
| 22ce: 02 c0 rjmp .+4 ; 0x22d4 <disk_ioctl+0x1e6> |
| } |
| |
| DESELECT(); /* CS = H */ |
| rcvr_spi(); /* Idle (Release DO) */ |
| |
| return res; |
| 22d0: 23 e0 ldi r18, 0x03 ; 3 |
| 22d2: 30 e0 ldi r19, 0x00 ; 0 |
| } |
| 22d4: c9 01 movw r24, r18 |
| 22d6: 60 96 adiw r28, 0x10 ; 16 |
| 22d8: e4 e0 ldi r30, 0x04 ; 4 |
| 22da: 0c 94 f1 14 jmp 0x29e2 ; 0x29e2 <__epilogue_restores__+0x1c> |
| |
| 000022de <disk_timerproc>: |
| /* Device timer interrupt procedure */ |
| /* This must be called in period of 10ms */ |
| /* (Platform dependent) */ |
| |
| void disk_timerproc (void) |
| { |
| 22de: 80 91 15 01 lds r24, 0x0115 |
| static BYTE pv; |
| BYTE n, s; |
| |
| |
| n = Timer1; /* 100Hz decrement timer */ |
| if (n) Timer1 = --n; |
| 22e2: 88 23 and r24, r24 |
| 22e4: 19 f0 breq .+6 ; 0x22ec <disk_timerproc+0xe> |
| 22e6: 81 50 subi r24, 0x01 ; 1 |
| 22e8: 80 93 15 01 sts 0x0115, r24 |
| n = Timer2; |
| 22ec: 80 91 16 01 lds r24, 0x0116 |
| if (n) Timer2 = --n; |
| 22f0: 88 23 and r24, r24 |
| 22f2: 19 f0 breq .+6 ; 0x22fa <disk_timerproc+0x1c> |
| 22f4: 81 50 subi r24, 0x01 ; 1 |
| 22f6: 80 93 16 01 sts 0x0116, r24 |
| |
| n = pv; |
| 22fa: 90 91 14 01 lds r25, 0x0114 |
| pv = SOCKPORT & (SOCKINS); /* Sample socket switch */ |
| 22fe: 83 b1 in r24, 0x03 ; 3 |
| 2300: 81 70 andi r24, 0x01 ; 1 |
| 2302: 80 93 14 01 sts 0x0114, r24 |
| |
| if (n == pv) { /* Have contacts stabled? */ |
| 2306: 98 17 cp r25, r24 |
| 2308: 49 f4 brne .+18 ; 0x231c <disk_timerproc+0x3e> |
| s = Stat; |
| 230a: 80 91 0b 01 lds r24, 0x010B |
| if (pv & SOCKINS) /* INS = H (Socket empty) */ |
| 230e: 90 ff sbrs r25, 0 |
| 2310: 02 c0 rjmp .+4 ; 0x2316 <disk_timerproc+0x38> |
| s |= (STA_NODISK | STA_NOINIT); |
| 2312: 83 60 ori r24, 0x03 ; 3 |
| 2314: 01 c0 rjmp .+2 ; 0x2318 <disk_timerproc+0x3a> |
| else /* INS = L (Card inserted) */ |
| s &= ~STA_NODISK; |
| 2316: 8d 7f andi r24, 0xFD ; 253 |
| |
| Stat = s; |
| 2318: 80 93 0b 01 sts 0x010B, r24 |
| 231c: 08 95 ret |
| |
| 0000231e <strcpy_P>: |
| 231e: fb 01 movw r30, r22 |
| 2320: dc 01 movw r26, r24 |
| 2322: 05 90 lpm r0, Z+ |
| 2324: 0d 92 st X+, r0 |
| 2326: 00 20 and r0, r0 |
| 2328: e1 f7 brne .-8 ; 0x2322 <strcpy_P+0x4> |
| 232a: 08 95 ret |
| |
| 0000232c <memcmp>: |
| 232c: fb 01 movw r30, r22 |
| 232e: dc 01 movw r26, r24 |
| 2330: 04 c0 rjmp .+8 ; 0x233a <memcmp+0xe> |
| 2332: 8d 91 ld r24, X+ |
| 2334: 01 90 ld r0, Z+ |
| 2336: 80 19 sub r24, r0 |
| 2338: 21 f4 brne .+8 ; 0x2342 <memcmp+0x16> |
| 233a: 41 50 subi r20, 0x01 ; 1 |
| 233c: 50 40 sbci r21, 0x00 ; 0 |
| 233e: c8 f7 brcc .-14 ; 0x2332 <memcmp+0x6> |
| 2340: 88 1b sub r24, r24 |
| 2342: 99 0b sbc r25, r25 |
| 2344: 08 95 ret |
| |
| 00002346 <memcpy>: |
| 2346: fb 01 movw r30, r22 |
| 2348: dc 01 movw r26, r24 |
| 234a: 02 c0 rjmp .+4 ; 0x2350 <memcpy+0xa> |
| 234c: 01 90 ld r0, Z+ |
| 234e: 0d 92 st X+, r0 |
| 2350: 41 50 subi r20, 0x01 ; 1 |
| 2352: 50 40 sbci r21, 0x00 ; 0 |
| 2354: d8 f7 brcc .-10 ; 0x234c <memcpy+0x6> |
| 2356: 08 95 ret |
| |
| 00002358 <memset>: |
| 2358: dc 01 movw r26, r24 |
| 235a: 01 c0 rjmp .+2 ; 0x235e <memset+0x6> |
| 235c: 6d 93 st X+, r22 |
| 235e: 41 50 subi r20, 0x01 ; 1 |
| 2360: 50 40 sbci r21, 0x00 ; 0 |
| 2362: e0 f7 brcc .-8 ; 0x235c <memset+0x4> |
| 2364: 08 95 ret |
| |
| 00002366 <itoa>: |
| 2366: fb 01 movw r30, r22 |
| 2368: 9f 01 movw r18, r30 |
| 236a: e8 94 clt |
| 236c: 42 30 cpi r20, 0x02 ; 2 |
| 236e: c4 f0 brlt .+48 ; 0x23a0 <itoa+0x3a> |
| 2370: 45 32 cpi r20, 0x25 ; 37 |
| 2372: b4 f4 brge .+44 ; 0x23a0 <itoa+0x3a> |
| 2374: 4a 30 cpi r20, 0x0A ; 10 |
| 2376: 29 f4 brne .+10 ; 0x2382 <itoa+0x1c> |
| 2378: 97 fb bst r25, 7 |
| 237a: 1e f4 brtc .+6 ; 0x2382 <itoa+0x1c> |
| 237c: 90 95 com r25 |
| 237e: 81 95 neg r24 |
| 2380: 9f 4f sbci r25, 0xFF ; 255 |
| 2382: 64 2f mov r22, r20 |
| 2384: 77 27 eor r23, r23 |
| 2386: 0e 94 fe 14 call 0x29fc ; 0x29fc <__udivmodhi4> |
| 238a: 80 5d subi r24, 0xD0 ; 208 |
| 238c: 8a 33 cpi r24, 0x3A ; 58 |
| 238e: 0c f0 brlt .+2 ; 0x2392 <itoa+0x2c> |
| 2390: 89 5d subi r24, 0xD9 ; 217 |
| 2392: 81 93 st Z+, r24 |
| 2394: cb 01 movw r24, r22 |
| 2396: 00 97 sbiw r24, 0x00 ; 0 |
| 2398: a1 f7 brne .-24 ; 0x2382 <itoa+0x1c> |
| 239a: 16 f4 brtc .+4 ; 0x23a0 <itoa+0x3a> |
| 239c: 5d e2 ldi r21, 0x2D ; 45 |
| 239e: 51 93 st Z+, r21 |
| 23a0: 10 82 st Z, r1 |
| 23a2: c9 01 movw r24, r18 |
| 23a4: 0c 94 ec 13 jmp 0x27d8 ; 0x27d8 <strrev> |
| |
| 000023a8 <sprintf>: |
| 23a8: ae e0 ldi r26, 0x0E ; 14 |
| 23aa: b0 e0 ldi r27, 0x00 ; 0 |
| 23ac: ea ed ldi r30, 0xDA ; 218 |
| 23ae: f1 e1 ldi r31, 0x11 ; 17 |
| 23b0: 0c 94 d5 14 jmp 0x29aa ; 0x29aa <__prologue_saves__+0x1c> |
| 23b4: 0d 89 ldd r16, Y+21 ; 0x15 |
| 23b6: 1e 89 ldd r17, Y+22 ; 0x16 |
| 23b8: 86 e0 ldi r24, 0x06 ; 6 |
| 23ba: 8c 83 std Y+4, r24 ; 0x04 |
| 23bc: 1a 83 std Y+2, r17 ; 0x02 |
| 23be: 09 83 std Y+1, r16 ; 0x01 |
| 23c0: 8f ef ldi r24, 0xFF ; 255 |
| 23c2: 9f e7 ldi r25, 0x7F ; 127 |
| 23c4: 9e 83 std Y+6, r25 ; 0x06 |
| 23c6: 8d 83 std Y+5, r24 ; 0x05 |
| 23c8: ce 01 movw r24, r28 |
| 23ca: 49 96 adiw r24, 0x19 ; 25 |
| 23cc: ac 01 movw r20, r24 |
| 23ce: 6f 89 ldd r22, Y+23 ; 0x17 |
| 23d0: 78 8d ldd r23, Y+24 ; 0x18 |
| 23d2: ce 01 movw r24, r28 |
| 23d4: 01 96 adiw r24, 0x01 ; 1 |
| 23d6: 0e 94 f7 11 call 0x23ee ; 0x23ee <vfprintf> |
| 23da: 2f 81 ldd r18, Y+7 ; 0x07 |
| 23dc: 38 85 ldd r19, Y+8 ; 0x08 |
| 23de: 02 0f add r16, r18 |
| 23e0: 13 1f adc r17, r19 |
| 23e2: f8 01 movw r30, r16 |
| 23e4: 10 82 st Z, r1 |
| 23e6: 2e 96 adiw r28, 0x0e ; 14 |
| 23e8: e4 e0 ldi r30, 0x04 ; 4 |
| 23ea: 0c 94 f1 14 jmp 0x29e2 ; 0x29e2 <__epilogue_restores__+0x1c> |
| |
| 000023ee <vfprintf>: |
| 23ee: ab e0 ldi r26, 0x0B ; 11 |
| 23f0: b0 e0 ldi r27, 0x00 ; 0 |
| 23f2: ed ef ldi r30, 0xFD ; 253 |
| 23f4: f1 e1 ldi r31, 0x11 ; 17 |
| 23f6: 0c 94 c7 14 jmp 0x298e ; 0x298e <__prologue_saves__> |
| 23fa: 3c 01 movw r6, r24 |
| 23fc: 2b 01 movw r4, r22 |
| 23fe: 5a 01 movw r10, r20 |
| 2400: fc 01 movw r30, r24 |
| 2402: 17 82 std Z+7, r1 ; 0x07 |
| 2404: 16 82 std Z+6, r1 ; 0x06 |
| 2406: 83 81 ldd r24, Z+3 ; 0x03 |
| 2408: 81 fd sbrc r24, 1 |
| 240a: 03 c0 rjmp .+6 ; 0x2412 <vfprintf+0x24> |
| 240c: 6f ef ldi r22, 0xFF ; 255 |
| 240e: 7f ef ldi r23, 0xFF ; 255 |
| 2410: c8 c1 rjmp .+912 ; 0x27a2 <vfprintf+0x3b4> |
| 2412: 9a e0 ldi r25, 0x0A ; 10 |
| 2414: 89 2e mov r8, r25 |
| 2416: 1e 01 movw r2, r28 |
| 2418: 08 94 sec |
| 241a: 21 1c adc r2, r1 |
| 241c: 31 1c adc r3, r1 |
| 241e: f3 01 movw r30, r6 |
| 2420: 23 81 ldd r18, Z+3 ; 0x03 |
| 2422: f2 01 movw r30, r4 |
| 2424: 23 fd sbrc r18, 3 |
| 2426: 85 91 lpm r24, Z+ |
| 2428: 23 ff sbrs r18, 3 |
| 242a: 81 91 ld r24, Z+ |
| 242c: 2f 01 movw r4, r30 |
| 242e: 88 23 and r24, r24 |
| 2430: 09 f4 brne .+2 ; 0x2434 <vfprintf+0x46> |
| 2432: b4 c1 rjmp .+872 ; 0x279c <vfprintf+0x3ae> |
| 2434: 85 32 cpi r24, 0x25 ; 37 |
| 2436: 39 f4 brne .+14 ; 0x2446 <vfprintf+0x58> |
| 2438: 23 fd sbrc r18, 3 |
| 243a: 85 91 lpm r24, Z+ |
| 243c: 23 ff sbrs r18, 3 |
| 243e: 81 91 ld r24, Z+ |
| 2440: 2f 01 movw r4, r30 |
| 2442: 85 32 cpi r24, 0x25 ; 37 |
| 2444: 29 f4 brne .+10 ; 0x2450 <vfprintf+0x62> |
| 2446: b3 01 movw r22, r6 |
| 2448: 90 e0 ldi r25, 0x00 ; 0 |
| 244a: 0e 94 fc 13 call 0x27f8 ; 0x27f8 <fputc> |
| 244e: e7 cf rjmp .-50 ; 0x241e <vfprintf+0x30> |
| 2450: 98 2f mov r25, r24 |
| 2452: dd 24 eor r13, r13 |
| 2454: cc 24 eor r12, r12 |
| 2456: 99 24 eor r9, r9 |
| 2458: ff e1 ldi r31, 0x1F ; 31 |
| 245a: fd 15 cp r31, r13 |
| 245c: d0 f0 brcs .+52 ; 0x2492 <vfprintf+0xa4> |
| 245e: 9b 32 cpi r25, 0x2B ; 43 |
| 2460: 69 f0 breq .+26 ; 0x247c <vfprintf+0x8e> |
| 2462: 9c 32 cpi r25, 0x2C ; 44 |
| 2464: 28 f4 brcc .+10 ; 0x2470 <vfprintf+0x82> |
| 2466: 90 32 cpi r25, 0x20 ; 32 |
| 2468: 59 f0 breq .+22 ; 0x2480 <vfprintf+0x92> |
| 246a: 93 32 cpi r25, 0x23 ; 35 |
| 246c: 91 f4 brne .+36 ; 0x2492 <vfprintf+0xa4> |
| 246e: 0e c0 rjmp .+28 ; 0x248c <vfprintf+0x9e> |
| 2470: 9d 32 cpi r25, 0x2D ; 45 |
| 2472: 49 f0 breq .+18 ; 0x2486 <vfprintf+0x98> |
| 2474: 90 33 cpi r25, 0x30 ; 48 |
| 2476: 69 f4 brne .+26 ; 0x2492 <vfprintf+0xa4> |
| 2478: 41 e0 ldi r20, 0x01 ; 1 |
| 247a: 24 c0 rjmp .+72 ; 0x24c4 <vfprintf+0xd6> |
| 247c: 52 e0 ldi r21, 0x02 ; 2 |
| 247e: d5 2a or r13, r21 |
| 2480: 84 e0 ldi r24, 0x04 ; 4 |
| 2482: d8 2a or r13, r24 |
| 2484: 28 c0 rjmp .+80 ; 0x24d6 <vfprintf+0xe8> |
| 2486: 98 e0 ldi r25, 0x08 ; 8 |
| 2488: d9 2a or r13, r25 |
| 248a: 25 c0 rjmp .+74 ; 0x24d6 <vfprintf+0xe8> |
| 248c: e0 e1 ldi r30, 0x10 ; 16 |
| 248e: de 2a or r13, r30 |
| 2490: 22 c0 rjmp .+68 ; 0x24d6 <vfprintf+0xe8> |
| 2492: d7 fc sbrc r13, 7 |
| 2494: 29 c0 rjmp .+82 ; 0x24e8 <vfprintf+0xfa> |
| 2496: 89 2f mov r24, r25 |
| 2498: 80 53 subi r24, 0x30 ; 48 |
| 249a: 8a 30 cpi r24, 0x0A ; 10 |
| 249c: 70 f4 brcc .+28 ; 0x24ba <vfprintf+0xcc> |
| 249e: d6 fe sbrs r13, 6 |
| 24a0: 05 c0 rjmp .+10 ; 0x24ac <vfprintf+0xbe> |
| 24a2: 98 9c mul r9, r8 |
| 24a4: 90 2c mov r9, r0 |
| 24a6: 11 24 eor r1, r1 |
| 24a8: 98 0e add r9, r24 |
| 24aa: 15 c0 rjmp .+42 ; 0x24d6 <vfprintf+0xe8> |
| 24ac: c8 9c mul r12, r8 |
| 24ae: c0 2c mov r12, r0 |
| 24b0: 11 24 eor r1, r1 |
| 24b2: c8 0e add r12, r24 |
| 24b4: f0 e2 ldi r31, 0x20 ; 32 |
| 24b6: df 2a or r13, r31 |
| 24b8: 0e c0 rjmp .+28 ; 0x24d6 <vfprintf+0xe8> |
| 24ba: 9e 32 cpi r25, 0x2E ; 46 |
| 24bc: 29 f4 brne .+10 ; 0x24c8 <vfprintf+0xda> |
| 24be: d6 fc sbrc r13, 6 |
| 24c0: 6d c1 rjmp .+730 ; 0x279c <vfprintf+0x3ae> |
| 24c2: 40 e4 ldi r20, 0x40 ; 64 |
| 24c4: d4 2a or r13, r20 |
| 24c6: 07 c0 rjmp .+14 ; 0x24d6 <vfprintf+0xe8> |
| 24c8: 9c 36 cpi r25, 0x6C ; 108 |
| 24ca: 19 f4 brne .+6 ; 0x24d2 <vfprintf+0xe4> |
| 24cc: 50 e8 ldi r21, 0x80 ; 128 |
| 24ce: d5 2a or r13, r21 |
| 24d0: 02 c0 rjmp .+4 ; 0x24d6 <vfprintf+0xe8> |
| 24d2: 98 36 cpi r25, 0x68 ; 104 |
| 24d4: 49 f4 brne .+18 ; 0x24e8 <vfprintf+0xfa> |
| 24d6: f2 01 movw r30, r4 |
| 24d8: 23 fd sbrc r18, 3 |
| 24da: 95 91 lpm r25, Z+ |
| 24dc: 23 ff sbrs r18, 3 |
| 24de: 91 91 ld r25, Z+ |
| 24e0: 2f 01 movw r4, r30 |
| 24e2: 99 23 and r25, r25 |
| 24e4: 09 f0 breq .+2 ; 0x24e8 <vfprintf+0xfa> |
| 24e6: b8 cf rjmp .-144 ; 0x2458 <vfprintf+0x6a> |
| 24e8: 89 2f mov r24, r25 |
| 24ea: 85 54 subi r24, 0x45 ; 69 |
| 24ec: 83 30 cpi r24, 0x03 ; 3 |
| 24ee: 18 f0 brcs .+6 ; 0x24f6 <vfprintf+0x108> |
| 24f0: 80 52 subi r24, 0x20 ; 32 |
| 24f2: 83 30 cpi r24, 0x03 ; 3 |
| 24f4: 38 f4 brcc .+14 ; 0x2504 <vfprintf+0x116> |
| 24f6: 44 e0 ldi r20, 0x04 ; 4 |
| 24f8: 50 e0 ldi r21, 0x00 ; 0 |
| 24fa: a4 0e add r10, r20 |
| 24fc: b5 1e adc r11, r21 |
| 24fe: 5f e3 ldi r21, 0x3F ; 63 |
| 2500: 59 83 std Y+1, r21 ; 0x01 |
| 2502: 0f c0 rjmp .+30 ; 0x2522 <vfprintf+0x134> |
| 2504: 93 36 cpi r25, 0x63 ; 99 |
| 2506: 31 f0 breq .+12 ; 0x2514 <vfprintf+0x126> |
| 2508: 93 37 cpi r25, 0x73 ; 115 |
| 250a: 79 f0 breq .+30 ; 0x252a <vfprintf+0x13c> |
| 250c: 93 35 cpi r25, 0x53 ; 83 |
| 250e: 09 f0 breq .+2 ; 0x2512 <vfprintf+0x124> |
| 2510: 56 c0 rjmp .+172 ; 0x25be <vfprintf+0x1d0> |
| 2512: 20 c0 rjmp .+64 ; 0x2554 <vfprintf+0x166> |
| 2514: f5 01 movw r30, r10 |
| 2516: 80 81 ld r24, Z |
| 2518: 89 83 std Y+1, r24 ; 0x01 |
| 251a: 42 e0 ldi r20, 0x02 ; 2 |
| 251c: 50 e0 ldi r21, 0x00 ; 0 |
| 251e: a4 0e add r10, r20 |
| 2520: b5 1e adc r11, r21 |
| 2522: 71 01 movw r14, r2 |
| 2524: 01 e0 ldi r16, 0x01 ; 1 |
| 2526: 10 e0 ldi r17, 0x00 ; 0 |
| 2528: 12 c0 rjmp .+36 ; 0x254e <vfprintf+0x160> |
| 252a: f5 01 movw r30, r10 |
| 252c: e0 80 ld r14, Z |
| 252e: f1 80 ldd r15, Z+1 ; 0x01 |
| 2530: d6 fc sbrc r13, 6 |
| 2532: 03 c0 rjmp .+6 ; 0x253a <vfprintf+0x14c> |
| 2534: 6f ef ldi r22, 0xFF ; 255 |
| 2536: 7f ef ldi r23, 0xFF ; 255 |
| 2538: 02 c0 rjmp .+4 ; 0x253e <vfprintf+0x150> |
| 253a: 69 2d mov r22, r9 |
| 253c: 70 e0 ldi r23, 0x00 ; 0 |
| 253e: 42 e0 ldi r20, 0x02 ; 2 |
| 2540: 50 e0 ldi r21, 0x00 ; 0 |
| 2542: a4 0e add r10, r20 |
| 2544: b5 1e adc r11, r21 |
| 2546: c7 01 movw r24, r14 |
| 2548: 0e 94 e1 13 call 0x27c2 ; 0x27c2 <strnlen> |
| 254c: 8c 01 movw r16, r24 |
| 254e: 5f e7 ldi r21, 0x7F ; 127 |
| 2550: d5 22 and r13, r21 |
| 2552: 14 c0 rjmp .+40 ; 0x257c <vfprintf+0x18e> |
| 2554: f5 01 movw r30, r10 |
| 2556: e0 80 ld r14, Z |
| 2558: f1 80 ldd r15, Z+1 ; 0x01 |
| 255a: d6 fc sbrc r13, 6 |
| 255c: 03 c0 rjmp .+6 ; 0x2564 <vfprintf+0x176> |
| 255e: 6f ef ldi r22, 0xFF ; 255 |
| 2560: 7f ef ldi r23, 0xFF ; 255 |
| 2562: 02 c0 rjmp .+4 ; 0x2568 <vfprintf+0x17a> |
| 2564: 69 2d mov r22, r9 |
| 2566: 70 e0 ldi r23, 0x00 ; 0 |
| 2568: 42 e0 ldi r20, 0x02 ; 2 |
| 256a: 50 e0 ldi r21, 0x00 ; 0 |
| 256c: a4 0e add r10, r20 |
| 256e: b5 1e adc r11, r21 |
| 2570: c7 01 movw r24, r14 |
| 2572: 0e 94 d6 13 call 0x27ac ; 0x27ac <strnlen_P> |
| 2576: 8c 01 movw r16, r24 |
| 2578: 50 e8 ldi r21, 0x80 ; 128 |
| 257a: d5 2a or r13, r21 |
| 257c: d3 fe sbrs r13, 3 |
| 257e: 07 c0 rjmp .+14 ; 0x258e <vfprintf+0x1a0> |
| 2580: 1a c0 rjmp .+52 ; 0x25b6 <vfprintf+0x1c8> |
| 2582: b3 01 movw r22, r6 |
| 2584: 80 e2 ldi r24, 0x20 ; 32 |
| 2586: 90 e0 ldi r25, 0x00 ; 0 |
| 2588: 0e 94 fc 13 call 0x27f8 ; 0x27f8 <fputc> |
| 258c: ca 94 dec r12 |
| 258e: 8c 2d mov r24, r12 |
| 2590: 90 e0 ldi r25, 0x00 ; 0 |
| 2592: 08 17 cp r16, r24 |
| 2594: 19 07 cpc r17, r25 |
| 2596: a8 f3 brcs .-22 ; 0x2582 <vfprintf+0x194> |
| 2598: 0e c0 rjmp .+28 ; 0x25b6 <vfprintf+0x1c8> |
| 259a: f7 01 movw r30, r14 |
| 259c: d7 fc sbrc r13, 7 |
| 259e: 85 91 lpm r24, Z+ |
| 25a0: d7 fe sbrs r13, 7 |
| 25a2: 81 91 ld r24, Z+ |
| 25a4: 7f 01 movw r14, r30 |
| 25a6: b3 01 movw r22, r6 |
| 25a8: 90 e0 ldi r25, 0x00 ; 0 |
| 25aa: 0e 94 fc 13 call 0x27f8 ; 0x27f8 <fputc> |
| 25ae: c1 10 cpse r12, r1 |
| 25b0: ca 94 dec r12 |
| 25b2: 01 50 subi r16, 0x01 ; 1 |
| 25b4: 10 40 sbci r17, 0x00 ; 0 |
| 25b6: 01 15 cp r16, r1 |
| 25b8: 11 05 cpc r17, r1 |
| 25ba: 79 f7 brne .-34 ; 0x259a <vfprintf+0x1ac> |
| 25bc: ec c0 rjmp .+472 ; 0x2796 <vfprintf+0x3a8> |
| 25be: 94 36 cpi r25, 0x64 ; 100 |
| 25c0: 11 f0 breq .+4 ; 0x25c6 <vfprintf+0x1d8> |
| 25c2: 99 36 cpi r25, 0x69 ; 105 |
| 25c4: 71 f5 brne .+92 ; 0x2622 <vfprintf+0x234> |
| 25c6: d7 fe sbrs r13, 7 |
| 25c8: 08 c0 rjmp .+16 ; 0x25da <vfprintf+0x1ec> |
| 25ca: f5 01 movw r30, r10 |
| 25cc: e0 80 ld r14, Z |
| 25ce: f1 80 ldd r15, Z+1 ; 0x01 |
| 25d0: 02 81 ldd r16, Z+2 ; 0x02 |
| 25d2: 13 81 ldd r17, Z+3 ; 0x03 |
| 25d4: 44 e0 ldi r20, 0x04 ; 4 |
| 25d6: 50 e0 ldi r21, 0x00 ; 0 |
| 25d8: 0a c0 rjmp .+20 ; 0x25ee <vfprintf+0x200> |
| 25da: f5 01 movw r30, r10 |
| 25dc: 80 81 ld r24, Z |
| 25de: 91 81 ldd r25, Z+1 ; 0x01 |
| 25e0: 7c 01 movw r14, r24 |
| 25e2: 00 27 eor r16, r16 |
| 25e4: f7 fc sbrc r15, 7 |
| 25e6: 00 95 com r16 |
| 25e8: 10 2f mov r17, r16 |
| 25ea: 42 e0 ldi r20, 0x02 ; 2 |
| 25ec: 50 e0 ldi r21, 0x00 ; 0 |
| 25ee: a4 0e add r10, r20 |
| 25f0: b5 1e adc r11, r21 |
| 25f2: 5f e6 ldi r21, 0x6F ; 111 |
| 25f4: d5 22 and r13, r21 |
| 25f6: 17 ff sbrs r17, 7 |
| 25f8: 0a c0 rjmp .+20 ; 0x260e <vfprintf+0x220> |
| 25fa: 10 95 com r17 |
| 25fc: 00 95 com r16 |
| 25fe: f0 94 com r15 |
| 2600: e0 94 com r14 |
| 2602: e1 1c adc r14, r1 |
| 2604: f1 1c adc r15, r1 |
| 2606: 01 1d adc r16, r1 |
| 2608: 11 1d adc r17, r1 |
| 260a: 80 e8 ldi r24, 0x80 ; 128 |
| 260c: d8 2a or r13, r24 |
| 260e: 2a e0 ldi r18, 0x0A ; 10 |
| 2610: 30 e0 ldi r19, 0x00 ; 0 |
| 2612: a1 01 movw r20, r2 |
| 2614: c8 01 movw r24, r16 |
| 2616: b7 01 movw r22, r14 |
| 2618: 0e 94 28 14 call 0x2850 ; 0x2850 <__ultoa_invert> |
| 261c: f8 2e mov r15, r24 |
| 261e: f2 18 sub r15, r2 |
| 2620: 40 c0 rjmp .+128 ; 0x26a2 <vfprintf+0x2b4> |
| 2622: 95 37 cpi r25, 0x75 ; 117 |
| 2624: 29 f4 brne .+10 ; 0x2630 <vfprintf+0x242> |
| 2626: 1d 2d mov r17, r13 |
| 2628: 1f 7e andi r17, 0xEF ; 239 |
| 262a: 2a e0 ldi r18, 0x0A ; 10 |
| 262c: 30 e0 ldi r19, 0x00 ; 0 |
| 262e: 1d c0 rjmp .+58 ; 0x266a <vfprintf+0x27c> |
| 2630: 1d 2d mov r17, r13 |
| 2632: 19 7f andi r17, 0xF9 ; 249 |
| 2634: 9f 36 cpi r25, 0x6F ; 111 |
| 2636: 61 f0 breq .+24 ; 0x2650 <vfprintf+0x262> |
| 2638: 90 37 cpi r25, 0x70 ; 112 |
| 263a: 20 f4 brcc .+8 ; 0x2644 <vfprintf+0x256> |
| 263c: 98 35 cpi r25, 0x58 ; 88 |
| 263e: 09 f0 breq .+2 ; 0x2642 <vfprintf+0x254> |
| 2640: ad c0 rjmp .+346 ; 0x279c <vfprintf+0x3ae> |
| 2642: 0f c0 rjmp .+30 ; 0x2662 <vfprintf+0x274> |
| 2644: 90 37 cpi r25, 0x70 ; 112 |
| 2646: 39 f0 breq .+14 ; 0x2656 <vfprintf+0x268> |
| 2648: 98 37 cpi r25, 0x78 ; 120 |
| 264a: 09 f0 breq .+2 ; 0x264e <vfprintf+0x260> |
| 264c: a7 c0 rjmp .+334 ; 0x279c <vfprintf+0x3ae> |
| 264e: 04 c0 rjmp .+8 ; 0x2658 <vfprintf+0x26a> |
| 2650: 28 e0 ldi r18, 0x08 ; 8 |
| 2652: 30 e0 ldi r19, 0x00 ; 0 |
| 2654: 0a c0 rjmp .+20 ; 0x266a <vfprintf+0x27c> |
| 2656: 10 61 ori r17, 0x10 ; 16 |
| 2658: 14 fd sbrc r17, 4 |
| 265a: 14 60 ori r17, 0x04 ; 4 |
| 265c: 20 e1 ldi r18, 0x10 ; 16 |
| 265e: 30 e0 ldi r19, 0x00 ; 0 |
| 2660: 04 c0 rjmp .+8 ; 0x266a <vfprintf+0x27c> |
| 2662: 14 fd sbrc r17, 4 |
| 2664: 16 60 ori r17, 0x06 ; 6 |
| 2666: 20 e1 ldi r18, 0x10 ; 16 |
| 2668: 32 e0 ldi r19, 0x02 ; 2 |
| 266a: 17 ff sbrs r17, 7 |
| 266c: 08 c0 rjmp .+16 ; 0x267e <vfprintf+0x290> |
| 266e: f5 01 movw r30, r10 |
| 2670: 60 81 ld r22, Z |
| 2672: 71 81 ldd r23, Z+1 ; 0x01 |
| 2674: 82 81 ldd r24, Z+2 ; 0x02 |
| 2676: 93 81 ldd r25, Z+3 ; 0x03 |
| 2678: 44 e0 ldi r20, 0x04 ; 4 |
| 267a: 50 e0 ldi r21, 0x00 ; 0 |
| 267c: 08 c0 rjmp .+16 ; 0x268e <vfprintf+0x2a0> |
| 267e: f5 01 movw r30, r10 |
| 2680: 80 81 ld r24, Z |
| 2682: 91 81 ldd r25, Z+1 ; 0x01 |
| 2684: bc 01 movw r22, r24 |
| 2686: 80 e0 ldi r24, 0x00 ; 0 |
| 2688: 90 e0 ldi r25, 0x00 ; 0 |
| 268a: 42 e0 ldi r20, 0x02 ; 2 |
| 268c: 50 e0 ldi r21, 0x00 ; 0 |
| 268e: a4 0e add r10, r20 |
| 2690: b5 1e adc r11, r21 |
| 2692: a1 01 movw r20, r2 |
| 2694: 0e 94 28 14 call 0x2850 ; 0x2850 <__ultoa_invert> |
| 2698: f8 2e mov r15, r24 |
| 269a: f2 18 sub r15, r2 |
| 269c: 8f e7 ldi r24, 0x7F ; 127 |
| 269e: d8 2e mov r13, r24 |
| 26a0: d1 22 and r13, r17 |
| 26a2: d6 fe sbrs r13, 6 |
| 26a4: 0b c0 rjmp .+22 ; 0x26bc <vfprintf+0x2ce> |
| 26a6: 5e ef ldi r21, 0xFE ; 254 |
| 26a8: d5 22 and r13, r21 |
| 26aa: f9 14 cp r15, r9 |
| 26ac: 38 f4 brcc .+14 ; 0x26bc <vfprintf+0x2ce> |
| 26ae: d4 fe sbrs r13, 4 |
| 26b0: 07 c0 rjmp .+14 ; 0x26c0 <vfprintf+0x2d2> |
| 26b2: d2 fc sbrc r13, 2 |
| 26b4: 05 c0 rjmp .+10 ; 0x26c0 <vfprintf+0x2d2> |
| 26b6: 8f ee ldi r24, 0xEF ; 239 |
| 26b8: d8 22 and r13, r24 |
| 26ba: 02 c0 rjmp .+4 ; 0x26c0 <vfprintf+0x2d2> |
| 26bc: 1f 2d mov r17, r15 |
| 26be: 01 c0 rjmp .+2 ; 0x26c2 <vfprintf+0x2d4> |
| 26c0: 19 2d mov r17, r9 |
| 26c2: d4 fe sbrs r13, 4 |
| 26c4: 0d c0 rjmp .+26 ; 0x26e0 <vfprintf+0x2f2> |
| 26c6: fe 01 movw r30, r28 |
| 26c8: ef 0d add r30, r15 |
| 26ca: f1 1d adc r31, r1 |
| 26cc: 80 81 ld r24, Z |
| 26ce: 80 33 cpi r24, 0x30 ; 48 |
| 26d0: 19 f4 brne .+6 ; 0x26d8 <vfprintf+0x2ea> |
| 26d2: 99 ee ldi r25, 0xE9 ; 233 |
| 26d4: d9 22 and r13, r25 |
| 26d6: 08 c0 rjmp .+16 ; 0x26e8 <vfprintf+0x2fa> |
| 26d8: 1f 5f subi r17, 0xFF ; 255 |
| 26da: d2 fe sbrs r13, 2 |
| 26dc: 05 c0 rjmp .+10 ; 0x26e8 <vfprintf+0x2fa> |
| 26de: 03 c0 rjmp .+6 ; 0x26e6 <vfprintf+0x2f8> |
| 26e0: 8d 2d mov r24, r13 |
| 26e2: 86 78 andi r24, 0x86 ; 134 |
| 26e4: 09 f0 breq .+2 ; 0x26e8 <vfprintf+0x2fa> |
| 26e6: 1f 5f subi r17, 0xFF ; 255 |
| 26e8: 0d 2d mov r16, r13 |
| 26ea: d3 fc sbrc r13, 3 |
| 26ec: 14 c0 rjmp .+40 ; 0x2716 <vfprintf+0x328> |
| 26ee: d0 fe sbrs r13, 0 |
| 26f0: 0f c0 rjmp .+30 ; 0x2710 <vfprintf+0x322> |
| 26f2: 1c 15 cp r17, r12 |
| 26f4: 10 f0 brcs .+4 ; 0x26fa <vfprintf+0x30c> |
| 26f6: 9f 2c mov r9, r15 |
| 26f8: 0b c0 rjmp .+22 ; 0x2710 <vfprintf+0x322> |
| 26fa: 9f 2c mov r9, r15 |
| 26fc: 9c 0c add r9, r12 |
| 26fe: 91 1a sub r9, r17 |
| 2700: 1c 2d mov r17, r12 |
| 2702: 06 c0 rjmp .+12 ; 0x2710 <vfprintf+0x322> |
| 2704: b3 01 movw r22, r6 |
| 2706: 80 e2 ldi r24, 0x20 ; 32 |
| 2708: 90 e0 ldi r25, 0x00 ; 0 |
| 270a: 0e 94 fc 13 call 0x27f8 ; 0x27f8 <fputc> |
| 270e: 1f 5f subi r17, 0xFF ; 255 |
| 2710: 1c 15 cp r17, r12 |
| 2712: c0 f3 brcs .-16 ; 0x2704 <vfprintf+0x316> |
| 2714: 04 c0 rjmp .+8 ; 0x271e <vfprintf+0x330> |
| 2716: 1c 15 cp r17, r12 |
| 2718: 10 f4 brcc .+4 ; 0x271e <vfprintf+0x330> |
| 271a: c1 1a sub r12, r17 |
| 271c: 01 c0 rjmp .+2 ; 0x2720 <vfprintf+0x332> |
| 271e: cc 24 eor r12, r12 |
| 2720: 04 ff sbrs r16, 4 |
| 2722: 10 c0 rjmp .+32 ; 0x2744 <vfprintf+0x356> |
| 2724: b3 01 movw r22, r6 |
| 2726: 80 e3 ldi r24, 0x30 ; 48 |
| 2728: 90 e0 ldi r25, 0x00 ; 0 |
| 272a: 0e 94 fc 13 call 0x27f8 ; 0x27f8 <fputc> |
| 272e: 02 ff sbrs r16, 2 |
| 2730: 1e c0 rjmp .+60 ; 0x276e <vfprintf+0x380> |
| 2732: 01 fd sbrc r16, 1 |
| 2734: 03 c0 rjmp .+6 ; 0x273c <vfprintf+0x34e> |
| 2736: 88 e7 ldi r24, 0x78 ; 120 |
| 2738: 90 e0 ldi r25, 0x00 ; 0 |
| 273a: 02 c0 rjmp .+4 ; 0x2740 <vfprintf+0x352> |
| 273c: 88 e5 ldi r24, 0x58 ; 88 |
| 273e: 90 e0 ldi r25, 0x00 ; 0 |
| 2740: b3 01 movw r22, r6 |
| 2742: 0c c0 rjmp .+24 ; 0x275c <vfprintf+0x36e> |
| 2744: 80 2f mov r24, r16 |
| 2746: 86 78 andi r24, 0x86 ; 134 |
| 2748: 91 f0 breq .+36 ; 0x276e <vfprintf+0x380> |
| 274a: 01 ff sbrs r16, 1 |
| 274c: 02 c0 rjmp .+4 ; 0x2752 <vfprintf+0x364> |
| 274e: 8b e2 ldi r24, 0x2B ; 43 |
| 2750: 01 c0 rjmp .+2 ; 0x2754 <vfprintf+0x366> |
| 2752: 80 e2 ldi r24, 0x20 ; 32 |
| 2754: d7 fc sbrc r13, 7 |
| 2756: 8d e2 ldi r24, 0x2D ; 45 |
| 2758: b3 01 movw r22, r6 |
| 275a: 90 e0 ldi r25, 0x00 ; 0 |
| 275c: 0e 94 fc 13 call 0x27f8 ; 0x27f8 <fputc> |
| 2760: 06 c0 rjmp .+12 ; 0x276e <vfprintf+0x380> |
| 2762: b3 01 movw r22, r6 |
| 2764: 80 e3 ldi r24, 0x30 ; 48 |
| 2766: 90 e0 ldi r25, 0x00 ; 0 |
| 2768: 0e 94 fc 13 call 0x27f8 ; 0x27f8 <fputc> |
| 276c: 9a 94 dec r9 |
| 276e: f9 14 cp r15, r9 |
| 2770: c0 f3 brcs .-16 ; 0x2762 <vfprintf+0x374> |
| 2772: fa 94 dec r15 |
| 2774: f1 01 movw r30, r2 |
| 2776: ef 0d add r30, r15 |
| 2778: f1 1d adc r31, r1 |
| 277a: b3 01 movw r22, r6 |
| 277c: 80 81 ld r24, Z |
| 277e: 90 e0 ldi r25, 0x00 ; 0 |
| 2780: 0e 94 fc 13 call 0x27f8 ; 0x27f8 <fputc> |
| 2784: ff 20 and r15, r15 |
| 2786: a9 f7 brne .-22 ; 0x2772 <vfprintf+0x384> |
| 2788: 06 c0 rjmp .+12 ; 0x2796 <vfprintf+0x3a8> |
| 278a: b3 01 movw r22, r6 |
| 278c: 80 e2 ldi r24, 0x20 ; 32 |
| 278e: 90 e0 ldi r25, 0x00 ; 0 |
| 2790: 0e 94 fc 13 call 0x27f8 ; 0x27f8 <fputc> |
| 2794: ca 94 dec r12 |
| 2796: cc 20 and r12, r12 |
| 2798: c1 f7 brne .-16 ; 0x278a <vfprintf+0x39c> |
| 279a: 41 ce rjmp .-894 ; 0x241e <vfprintf+0x30> |
| 279c: f3 01 movw r30, r6 |
| 279e: 66 81 ldd r22, Z+6 ; 0x06 |
| 27a0: 77 81 ldd r23, Z+7 ; 0x07 |
| 27a2: cb 01 movw r24, r22 |
| 27a4: 2b 96 adiw r28, 0x0b ; 11 |
| 27a6: e2 e1 ldi r30, 0x12 ; 18 |
| 27a8: 0c 94 e3 14 jmp 0x29c6 ; 0x29c6 <__epilogue_restores__> |
| |
| 000027ac <strnlen_P>: |
| 27ac: fc 01 movw r30, r24 |
| 27ae: 05 90 lpm r0, Z+ |
| 27b0: 61 50 subi r22, 0x01 ; 1 |
| 27b2: 70 40 sbci r23, 0x00 ; 0 |
| 27b4: 01 10 cpse r0, r1 |
| 27b6: d8 f7 brcc .-10 ; 0x27ae <strnlen_P+0x2> |
| 27b8: 80 95 com r24 |
| 27ba: 90 95 com r25 |
| 27bc: 8e 0f add r24, r30 |
| 27be: 9f 1f adc r25, r31 |
| 27c0: 08 95 ret |
| |
| 000027c2 <strnlen>: |
| 27c2: fc 01 movw r30, r24 |
| 27c4: 61 50 subi r22, 0x01 ; 1 |
| 27c6: 70 40 sbci r23, 0x00 ; 0 |
| 27c8: 01 90 ld r0, Z+ |
| 27ca: 01 10 cpse r0, r1 |
| 27cc: d8 f7 brcc .-10 ; 0x27c4 <strnlen+0x2> |
| 27ce: 80 95 com r24 |
| 27d0: 90 95 com r25 |
| 27d2: 8e 0f add r24, r30 |
| 27d4: 9f 1f adc r25, r31 |
| 27d6: 08 95 ret |
| |
| 000027d8 <strrev>: |
| 27d8: dc 01 movw r26, r24 |
| 27da: fc 01 movw r30, r24 |
| 27dc: 67 2f mov r22, r23 |
| 27de: 71 91 ld r23, Z+ |
| 27e0: 77 23 and r23, r23 |
| 27e2: e1 f7 brne .-8 ; 0x27dc <strrev+0x4> |
| 27e4: 32 97 sbiw r30, 0x02 ; 2 |
| 27e6: 04 c0 rjmp .+8 ; 0x27f0 <strrev+0x18> |
| 27e8: 7c 91 ld r23, X |
| 27ea: 6d 93 st X+, r22 |
| 27ec: 70 83 st Z, r23 |
| 27ee: 62 91 ld r22, -Z |
| 27f0: ae 17 cp r26, r30 |
| 27f2: bf 07 cpc r27, r31 |
| 27f4: c8 f3 brcs .-14 ; 0x27e8 <strrev+0x10> |
| 27f6: 08 95 ret |
| |
| 000027f8 <fputc>: |
| 27f8: 0f 93 push r16 |
| 27fa: 1f 93 push r17 |
| 27fc: cf 93 push r28 |
| 27fe: df 93 push r29 |
| 2800: 8c 01 movw r16, r24 |
| 2802: eb 01 movw r28, r22 |
| 2804: 8b 81 ldd r24, Y+3 ; 0x03 |
| 2806: 81 ff sbrs r24, 1 |
| 2808: 1b c0 rjmp .+54 ; 0x2840 <fputc+0x48> |
| 280a: 82 ff sbrs r24, 2 |
| 280c: 0d c0 rjmp .+26 ; 0x2828 <fputc+0x30> |
| 280e: 2e 81 ldd r18, Y+6 ; 0x06 |
| 2810: 3f 81 ldd r19, Y+7 ; 0x07 |
| 2812: 8c 81 ldd r24, Y+4 ; 0x04 |
| 2814: 9d 81 ldd r25, Y+5 ; 0x05 |
| 2816: 28 17 cp r18, r24 |
| 2818: 39 07 cpc r19, r25 |
| 281a: 64 f4 brge .+24 ; 0x2834 <fputc+0x3c> |
| 281c: e8 81 ld r30, Y |
| 281e: f9 81 ldd r31, Y+1 ; 0x01 |
| 2820: 01 93 st Z+, r16 |
| 2822: f9 83 std Y+1, r31 ; 0x01 |
| 2824: e8 83 st Y, r30 |
| 2826: 06 c0 rjmp .+12 ; 0x2834 <fputc+0x3c> |
| 2828: e8 85 ldd r30, Y+8 ; 0x08 |
| 282a: f9 85 ldd r31, Y+9 ; 0x09 |
| 282c: 80 2f mov r24, r16 |
| 282e: 09 95 icall |
| 2830: 89 2b or r24, r25 |
| 2832: 31 f4 brne .+12 ; 0x2840 <fputc+0x48> |
| 2834: 8e 81 ldd r24, Y+6 ; 0x06 |
| 2836: 9f 81 ldd r25, Y+7 ; 0x07 |
| 2838: 01 96 adiw r24, 0x01 ; 1 |
| 283a: 9f 83 std Y+7, r25 ; 0x07 |
| 283c: 8e 83 std Y+6, r24 ; 0x06 |
| 283e: 02 c0 rjmp .+4 ; 0x2844 <fputc+0x4c> |
| 2840: 0f ef ldi r16, 0xFF ; 255 |
| 2842: 1f ef ldi r17, 0xFF ; 255 |
| 2844: c8 01 movw r24, r16 |
| 2846: df 91 pop r29 |
| 2848: cf 91 pop r28 |
| 284a: 1f 91 pop r17 |
| 284c: 0f 91 pop r16 |
| 284e: 08 95 ret |
| |
| 00002850 <__ultoa_invert>: |
| 2850: fa 01 movw r30, r20 |
| 2852: aa 27 eor r26, r26 |
| 2854: 28 30 cpi r18, 0x08 ; 8 |
| 2856: 51 f1 breq .+84 ; 0x28ac <__ultoa_invert+0x5c> |
| 2858: 20 31 cpi r18, 0x10 ; 16 |
| 285a: 81 f1 breq .+96 ; 0x28bc <__ultoa_invert+0x6c> |
| 285c: e8 94 clt |
| 285e: 6f 93 push r22 |
| 2860: 6e 7f andi r22, 0xFE ; 254 |
| 2862: 6e 5f subi r22, 0xFE ; 254 |
| 2864: 7f 4f sbci r23, 0xFF ; 255 |
| 2866: 8f 4f sbci r24, 0xFF ; 255 |
| 2868: 9f 4f sbci r25, 0xFF ; 255 |
| 286a: af 4f sbci r26, 0xFF ; 255 |
| 286c: b1 e0 ldi r27, 0x01 ; 1 |
| 286e: 3e d0 rcall .+124 ; 0x28ec <__ultoa_invert+0x9c> |
| 2870: b4 e0 ldi r27, 0x04 ; 4 |
| 2872: 3c d0 rcall .+120 ; 0x28ec <__ultoa_invert+0x9c> |
| 2874: 67 0f add r22, r23 |
| 2876: 78 1f adc r23, r24 |
| 2878: 89 1f adc r24, r25 |
| 287a: 9a 1f adc r25, r26 |
| 287c: a1 1d adc r26, r1 |
| 287e: 68 0f add r22, r24 |
| 2880: 79 1f adc r23, r25 |
| 2882: 8a 1f adc r24, r26 |
| 2884: 91 1d adc r25, r1 |
| 2886: a1 1d adc r26, r1 |
| 2888: 6a 0f add r22, r26 |
| 288a: 71 1d adc r23, r1 |
| 288c: 81 1d adc r24, r1 |
| 288e: 91 1d adc r25, r1 |
| 2890: a1 1d adc r26, r1 |
| 2892: 20 d0 rcall .+64 ; 0x28d4 <__ultoa_invert+0x84> |
| 2894: 09 f4 brne .+2 ; 0x2898 <__ultoa_invert+0x48> |
| 2896: 68 94 set |
| 2898: 3f 91 pop r19 |
| 289a: 2a e0 ldi r18, 0x0A ; 10 |
| 289c: 26 9f mul r18, r22 |
| 289e: 11 24 eor r1, r1 |
| 28a0: 30 19 sub r19, r0 |
| 28a2: 30 5d subi r19, 0xD0 ; 208 |
| 28a4: 31 93 st Z+, r19 |
| 28a6: de f6 brtc .-74 ; 0x285e <__ultoa_invert+0xe> |
| 28a8: cf 01 movw r24, r30 |
| 28aa: 08 95 ret |
| 28ac: 46 2f mov r20, r22 |
| 28ae: 47 70 andi r20, 0x07 ; 7 |
| 28b0: 40 5d subi r20, 0xD0 ; 208 |
| 28b2: 41 93 st Z+, r20 |
| 28b4: b3 e0 ldi r27, 0x03 ; 3 |
| 28b6: 0f d0 rcall .+30 ; 0x28d6 <__ultoa_invert+0x86> |
| 28b8: c9 f7 brne .-14 ; 0x28ac <__ultoa_invert+0x5c> |
| 28ba: f6 cf rjmp .-20 ; 0x28a8 <__ultoa_invert+0x58> |
| 28bc: 46 2f mov r20, r22 |
| 28be: 4f 70 andi r20, 0x0F ; 15 |
| 28c0: 40 5d subi r20, 0xD0 ; 208 |
| 28c2: 4a 33 cpi r20, 0x3A ; 58 |
| 28c4: 18 f0 brcs .+6 ; 0x28cc <__ultoa_invert+0x7c> |
| 28c6: 49 5d subi r20, 0xD9 ; 217 |
| 28c8: 31 fd sbrc r19, 1 |
| 28ca: 40 52 subi r20, 0x20 ; 32 |
| 28cc: 41 93 st Z+, r20 |
| 28ce: 02 d0 rcall .+4 ; 0x28d4 <__ultoa_invert+0x84> |
| 28d0: a9 f7 brne .-22 ; 0x28bc <__ultoa_invert+0x6c> |
| 28d2: ea cf rjmp .-44 ; 0x28a8 <__ultoa_invert+0x58> |
| 28d4: b4 e0 ldi r27, 0x04 ; 4 |
| 28d6: a6 95 lsr r26 |
| 28d8: 97 95 ror r25 |
| 28da: 87 95 ror r24 |
| 28dc: 77 95 ror r23 |
| 28de: 67 95 ror r22 |
| 28e0: ba 95 dec r27 |
| 28e2: c9 f7 brne .-14 ; 0x28d6 <__ultoa_invert+0x86> |
| 28e4: 00 97 sbiw r24, 0x00 ; 0 |
| 28e6: 61 05 cpc r22, r1 |
| 28e8: 71 05 cpc r23, r1 |
| 28ea: 08 95 ret |
| 28ec: 9b 01 movw r18, r22 |
| 28ee: ac 01 movw r20, r24 |
| 28f0: 0a 2e mov r0, r26 |
| 28f2: 06 94 lsr r0 |
| 28f4: 57 95 ror r21 |
| 28f6: 47 95 ror r20 |
| 28f8: 37 95 ror r19 |
| 28fa: 27 95 ror r18 |
| 28fc: ba 95 dec r27 |
| 28fe: c9 f7 brne .-14 ; 0x28f2 <__ultoa_invert+0xa2> |
| 2900: 62 0f add r22, r18 |
| 2902: 73 1f adc r23, r19 |
| 2904: 84 1f adc r24, r20 |
| 2906: 95 1f adc r25, r21 |
| 2908: a0 1d adc r26, r0 |
| 290a: 08 95 ret |
| |
| 0000290c <__mulsi3>: |
| 290c: 62 9f mul r22, r18 |
| 290e: d0 01 movw r26, r0 |
| 2910: 73 9f mul r23, r19 |
| 2912: f0 01 movw r30, r0 |
| 2914: 82 9f mul r24, r18 |
| 2916: e0 0d add r30, r0 |
| 2918: f1 1d adc r31, r1 |
| 291a: 64 9f mul r22, r20 |
| 291c: e0 0d add r30, r0 |
| 291e: f1 1d adc r31, r1 |
| 2920: 92 9f mul r25, r18 |
| 2922: f0 0d add r31, r0 |
| 2924: 83 9f mul r24, r19 |
| 2926: f0 0d add r31, r0 |
| 2928: 74 9f mul r23, r20 |
| 292a: f0 0d add r31, r0 |
| 292c: 65 9f mul r22, r21 |
| 292e: f0 0d add r31, r0 |
| 2930: 99 27 eor r25, r25 |
| 2932: 72 9f mul r23, r18 |
| 2934: b0 0d add r27, r0 |
| 2936: e1 1d adc r30, r1 |
| 2938: f9 1f adc r31, r25 |
| 293a: 63 9f mul r22, r19 |
| 293c: b0 0d add r27, r0 |
| 293e: e1 1d adc r30, r1 |
| 2940: f9 1f adc r31, r25 |
| 2942: bd 01 movw r22, r26 |
| 2944: cf 01 movw r24, r30 |
| 2946: 11 24 eor r1, r1 |
| 2948: 08 95 ret |
| |
| 0000294a <__udivmodsi4>: |
| 294a: a1 e2 ldi r26, 0x21 ; 33 |
| 294c: 1a 2e mov r1, r26 |
| 294e: aa 1b sub r26, r26 |
| 2950: bb 1b sub r27, r27 |
| 2952: fd 01 movw r30, r26 |
| 2954: 0d c0 rjmp .+26 ; 0x2970 <__udivmodsi4_ep> |
| |
| 00002956 <__udivmodsi4_loop>: |
| 2956: aa 1f adc r26, r26 |
| 2958: bb 1f adc r27, r27 |
| 295a: ee 1f adc r30, r30 |
| 295c: ff 1f adc r31, r31 |
| 295e: a2 17 cp r26, r18 |
| 2960: b3 07 cpc r27, r19 |
| 2962: e4 07 cpc r30, r20 |
| 2964: f5 07 cpc r31, r21 |
| 2966: 20 f0 brcs .+8 ; 0x2970 <__udivmodsi4_ep> |
| 2968: a2 1b sub r26, r18 |
| 296a: b3 0b sbc r27, r19 |
| 296c: e4 0b sbc r30, r20 |
| 296e: f5 0b sbc r31, r21 |
| |
| 00002970 <__udivmodsi4_ep>: |
| 2970: 66 1f adc r22, r22 |
| 2972: 77 1f adc r23, r23 |
| 2974: 88 1f adc r24, r24 |
| 2976: 99 1f adc r25, r25 |
| 2978: 1a 94 dec r1 |
| 297a: 69 f7 brne .-38 ; 0x2956 <__udivmodsi4_loop> |
| 297c: 60 95 com r22 |
| 297e: 70 95 com r23 |
| 2980: 80 95 com r24 |
| 2982: 90 95 com r25 |
| 2984: 9b 01 movw r18, r22 |
| 2986: ac 01 movw r20, r24 |
| 2988: bd 01 movw r22, r26 |
| 298a: cf 01 movw r24, r30 |
| 298c: 08 95 ret |
| |
| 0000298e <__prologue_saves__>: |
| 298e: 2f 92 push r2 |
| 2990: 3f 92 push r3 |
| 2992: 4f 92 push r4 |
| 2994: 5f 92 push r5 |
| 2996: 6f 92 push r6 |
| 2998: 7f 92 push r7 |
| 299a: 8f 92 push r8 |
| 299c: 9f 92 push r9 |
| 299e: af 92 push r10 |
| 29a0: bf 92 push r11 |
| 29a2: cf 92 push r12 |
| 29a4: df 92 push r13 |
| 29a6: ef 92 push r14 |
| 29a8: ff 92 push r15 |
| 29aa: 0f 93 push r16 |
| 29ac: 1f 93 push r17 |
| 29ae: cf 93 push r28 |
| 29b0: df 93 push r29 |
| 29b2: cd b7 in r28, 0x3d ; 61 |
| 29b4: de b7 in r29, 0x3e ; 62 |
| 29b6: ca 1b sub r28, r26 |
| 29b8: db 0b sbc r29, r27 |
| 29ba: 0f b6 in r0, 0x3f ; 63 |
| 29bc: f8 94 cli |
| 29be: de bf out 0x3e, r29 ; 62 |
| 29c0: 0f be out 0x3f, r0 ; 63 |
| 29c2: cd bf out 0x3d, r28 ; 61 |
| 29c4: 09 94 ijmp |
| |
| 000029c6 <__epilogue_restores__>: |
| 29c6: 2a 88 ldd r2, Y+18 ; 0x12 |
| 29c8: 39 88 ldd r3, Y+17 ; 0x11 |
| 29ca: 48 88 ldd r4, Y+16 ; 0x10 |
| 29cc: 5f 84 ldd r5, Y+15 ; 0x0f |
| 29ce: 6e 84 ldd r6, Y+14 ; 0x0e |
| 29d0: 7d 84 ldd r7, Y+13 ; 0x0d |
| 29d2: 8c 84 ldd r8, Y+12 ; 0x0c |
| 29d4: 9b 84 ldd r9, Y+11 ; 0x0b |
| 29d6: aa 84 ldd r10, Y+10 ; 0x0a |
| 29d8: b9 84 ldd r11, Y+9 ; 0x09 |
| 29da: c8 84 ldd r12, Y+8 ; 0x08 |
| 29dc: df 80 ldd r13, Y+7 ; 0x07 |
| 29de: ee 80 ldd r14, Y+6 ; 0x06 |
| 29e0: fd 80 ldd r15, Y+5 ; 0x05 |
| 29e2: 0c 81 ldd r16, Y+4 ; 0x04 |
| 29e4: 1b 81 ldd r17, Y+3 ; 0x03 |
| 29e6: aa 81 ldd r26, Y+2 ; 0x02 |
| 29e8: b9 81 ldd r27, Y+1 ; 0x01 |
| 29ea: ce 0f add r28, r30 |
| 29ec: d1 1d adc r29, r1 |
| 29ee: 0f b6 in r0, 0x3f ; 63 |
| 29f0: f8 94 cli |
| 29f2: de bf out 0x3e, r29 ; 62 |
| 29f4: 0f be out 0x3f, r0 ; 63 |
| 29f6: cd bf out 0x3d, r28 ; 61 |
| 29f8: ed 01 movw r28, r26 |
| 29fa: 08 95 ret |
| |
| 000029fc <__udivmodhi4>: |
| 29fc: aa 1b sub r26, r26 |
| 29fe: bb 1b sub r27, r27 |
| 2a00: 51 e1 ldi r21, 0x11 ; 17 |
| 2a02: 07 c0 rjmp .+14 ; 0x2a12 <__udivmodhi4_ep> |
| |
| 00002a04 <__udivmodhi4_loop>: |
| 2a04: aa 1f adc r26, r26 |
| 2a06: bb 1f adc r27, r27 |
| 2a08: a6 17 cp r26, r22 |
| 2a0a: b7 07 cpc r27, r23 |
| 2a0c: 10 f0 brcs .+4 ; 0x2a12 <__udivmodhi4_ep> |
| 2a0e: a6 1b sub r26, r22 |
| 2a10: b7 0b sbc r27, r23 |
| |
| 00002a12 <__udivmodhi4_ep>: |
| 2a12: 88 1f adc r24, r24 |
| 2a14: 99 1f adc r25, r25 |
| 2a16: 5a 95 dec r21 |
| 2a18: a9 f7 brne .-22 ; 0x2a04 <__udivmodhi4_loop> |
| 2a1a: 80 95 com r24 |
| 2a1c: 90 95 com r25 |
| 2a1e: bc 01 movw r22, r24 |
| 2a20: cd 01 movw r24, r26 |
| 2a22: 08 95 ret |
| |
| 00002a24 <_exit>: |
| 2a24: f8 94 cli |
| |
| 00002a26 <__stop_program>: |
| 2a26: ff cf rjmp .-2 ; 0x2a26 <__stop_program> |
