Sections:
Idx Name Size VMA LMA File off Algn
- 0 .data 00000042 00800100 00001826 000018ba 2**0
+ 0 .data 00000048 00800100 000017a8 0000183c 2**0
CONTENTS, ALLOC, LOAD, DATA
- 1 .text 00001826 00000000 00000000 00000094 2**1
+ 1 .text 000017a8 00000000 00000000 00000094 2**1
CONTENTS, ALLOC, LOAD, READONLY, CODE
- 2 .bss 00000134 00800142 00800142 000018fc 2**0
+ 2 .bss 00000134 00800148 00800148 00001884 2**0
ALLOC
- 3 .stab 0000228c 00000000 00000000 000018fc 2**2
+ 3 .stab 0000228c 00000000 00000000 00001884 2**2
CONTENTS, READONLY, DEBUGGING
- 4 .stabstr 0000044f 00000000 00000000 00003b88 2**0
+ 4 .stabstr 0000044f 00000000 00000000 00003b10 2**0
CONTENTS, READONLY, DEBUGGING
- 5 .debug_aranges 00000538 00000000 00000000 00003fd7 2**0
+ 5 .debug_aranges 00000538 00000000 00000000 00003f5f 2**0
CONTENTS, READONLY, DEBUGGING
- 6 .debug_pubnames 00000e11 00000000 00000000 0000450f 2**0
+ 6 .debug_pubnames 00000e11 00000000 00000000 00004497 2**0
CONTENTS, READONLY, DEBUGGING
- 7 .debug_info 00008cb1 00000000 00000000 00005320 2**0
+ 7 .debug_info 00008d35 00000000 00000000 000052a8 2**0
CONTENTS, READONLY, DEBUGGING
- 8 .debug_abbrev 000021ca 00000000 00000000 0000dfd1 2**0
+ 8 .debug_abbrev 00002195 00000000 00000000 0000dfdd 2**0
CONTENTS, READONLY, DEBUGGING
- 9 .debug_line 0000757d 00000000 00000000 0001019b 2**0
+ 9 .debug_line 00007586 00000000 00000000 00010172 2**0
CONTENTS, READONLY, DEBUGGING
- 10 .debug_frame 00000830 00000000 00000000 00017718 2**2
+ 10 .debug_frame 00000830 00000000 00000000 000176f8 2**2
CONTENTS, READONLY, DEBUGGING
- 11 .debug_str 00003bf7 00000000 00000000 00017f48 2**0
+ 11 .debug_str 00003bf7 00000000 00000000 00017f28 2**0
CONTENTS, READONLY, DEBUGGING
- 12 .debug_loc 0000457e 00000000 00000000 0001bb3f 2**0
+ 12 .debug_loc 000045ea 00000000 00000000 0001bb1f 2**0
CONTENTS, READONLY, DEBUGGING
- 13 .debug_pubtypes 00001111 00000000 00000000 000200bd 2**0
+ 13 .debug_pubtypes 00001111 00000000 00000000 00020109 2**0
CONTENTS, READONLY, DEBUGGING
- 14 .debug_ranges 00000790 00000000 00000000 000211ce 2**0
+ 14 .debug_ranges 00000790 00000000 00000000 0002121a 2**0
CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:
26: 00 00 nop
28: a2 c0 rjmp .+324 ; 0x16e <__bad_interrupt>
2a: 00 00 nop
- 2c: 5a c6 rjmp .+3252 ; 0xce2 <__vector_11>
+ 2c: 29 c6 rjmp .+3154 ; 0xc80 <__vector_11>
2e: 00 00 nop
- 30: fc c6 rjmp .+3576 ; 0xe2a <__vector_12>
+ 30: cb c6 rjmp .+3478 ; 0xdc8 <__vector_12>
32: 00 00 nop
34: 9c c0 rjmp .+312 ; 0x16e <__bad_interrupt>
36: 00 00 nop
56: 00 00 nop
58: 8a c0 rjmp .+276 ; 0x16e <__bad_interrupt>
5a: 00 00 nop
- 5c: e2 c2 rjmp .+1476 ; 0x622 <__vector_23>
+ 5c: 2f c3 rjmp .+1630 ; 0x6bc <__vector_23>
5e: 00 00 nop
60: 86 c0 rjmp .+268 ; 0x16e <__bad_interrupt>
62: 00 00 nop
142: 11 e0 ldi r17, 0x01 ; 1
144: a0 e0 ldi r26, 0x00 ; 0
146: b1 e0 ldi r27, 0x01 ; 1
- 148: e6 e2 ldi r30, 0x26 ; 38
- 14a: f8 e1 ldi r31, 0x18 ; 24
+ 148: e8 ea ldi r30, 0xA8 ; 168
+ 14a: f7 e1 ldi r31, 0x17 ; 23
14c: 02 c0 rjmp .+4 ; 0x152 <__do_copy_data+0x10>
14e: 05 90 lpm r0, Z+
150: 0d 92 st X+, r0
- 152: a2 34 cpi r26, 0x42 ; 66
+ 152: a8 34 cpi r26, 0x48 ; 72
154: b1 07 cpc r27, r17
156: d9 f7 brne .-10 ; 0x14e <__do_copy_data+0xc>
00000158 <__do_clear_bss>:
158: 12 e0 ldi r17, 0x02 ; 2
- 15a: a2 e4 ldi r26, 0x42 ; 66
+ 15a: a8 e4 ldi r26, 0x48 ; 72
15c: b1 e0 ldi r27, 0x01 ; 1
15e: 01 c0 rjmp .+2 ; 0x162 <.do_clear_bss_start>
160: 1d 92 st X+, r1
00000162 <.do_clear_bss_start>:
- 162: a6 37 cpi r26, 0x76 ; 118
+ 162: ac 37 cpi r26, 0x7C ; 124
164: b1 07 cpc r27, r17
166: e1 f7 brne .-8 ; 0x160 <.do_clear_bss_loop>
- 168: 67 d3 rcall .+1742 ; 0x838 <main>
- 16a: 0c 94 11 0c jmp 0x1822 ; 0x1822 <_exit>
+ 168: 4e d3 rcall .+1692 ; 0x806 <main>
+ 16a: 0c 94 d2 0b jmp 0x17a4 ; 0x17a4 <_exit>
0000016e <__bad_interrupt>:
16e: 48 cf rjmp .-368 ; 0x0 <__vectors>
20a: 11 24 eor r1, r1
20c: 8f 93 push r24
t0ovfcount++;
- 20e: 80 91 68 02 lds r24, 0x0268
+ 20e: 80 91 6e 02 lds r24, 0x026E
212: 8f 5f subi r24, 0xFF ; 255
- 214: 80 93 68 02 sts 0x0268, r24
+ 214: 80 93 6e 02 sts 0x026E, r24
}
218: 8f 91 pop r24
21a: 0f 90 pop r0
uint16_t t0ext(void) {
return (t0ovfcount * 256 + (u16) TCNT0); // return current counter value
224: 86 b5 in r24, 0x26 ; 38
- 226: 30 91 68 02 lds r19, 0x0268
+ 226: 30 91 6e 02 lds r19, 0x026E
22a: 20 e0 ldi r18, 0x00 ; 0
22c: 28 0f add r18, r24
22e: 31 1d adc r19, r1
TCNT0 = 0; // set counter to zero
234: 16 bc out 0x26, r1 ; 38
t0ovfcount = 0; // set overflow counter to zero
- 236: 10 92 68 02 sts 0x0268, r1
+ 236: 10 92 6e 02 sts 0x026E, r1
}
23a: 08 95 ret
256: bc 01 movw r22, r24
258: 80 e0 ldi r24, 0x00 ; 0
25a: 90 e0 ldi r25, 0x00 ; 0
- 25c: 0e 94 39 0b call 0x1672 ; 0x1672 <__floatunsisf>
+ 25c: 0e 94 08 0b call 0x1610 ; 0x1610 <__floatunsisf>
260: 20 e0 ldi r18, 0x00 ; 0
262: 30 e8 ldi r19, 0x80 ; 128
264: 4e e0 ldi r20, 0x0E ; 14
266: 53 e4 ldi r21, 0x43 ; 67
- 268: 0e 94 a1 0a call 0x1542 ; 0x1542 <__cmpsf2>
+ 268: 0e 94 70 0a call 0x14e0 ; 0x14e0 <__cmpsf2>
26c: 87 fd sbrc r24, 7
26e: f2 cf rjmp .-28 ; 0x254 <adb+0x18>
; // Warteschleife
282: bc 01 movw r22, r24
284: 80 e0 ldi r24, 0x00 ; 0
286: 90 e0 ldi r25, 0x00 ; 0
- 288: 0e 94 39 0b call 0x1672 ; 0x1672 <__floatunsisf>
+ 288: 0e 94 08 0b call 0x1610 ; 0x1610 <__floatunsisf>
28c: 20 e0 ldi r18, 0x00 ; 0
28e: 30 e0 ldi r19, 0x00 ; 0
290: 4c e8 ldi r20, 0x8C ; 140
292: 52 e4 ldi r21, 0x42 ; 66
- 294: 0e 94 a1 0a call 0x1542 ; 0x1542 <__cmpsf2>
+ 294: 0e 94 70 0a call 0x14e0 ; 0x14e0 <__cmpsf2>
298: 87 fd sbrc r24, 7
29a: f2 cf rjmp .-28 ; 0x280 <adb+0x44>
;
2a2: bc 01 movw r22, r24
2a4: 80 e0 ldi r24, 0x00 ; 0
2a6: 90 e0 ldi r25, 0x00 ; 0
- 2a8: 0e 94 39 0b call 0x1672 ; 0x1672 <__floatunsisf>
+ 2a8: 0e 94 08 0b call 0x1610 ; 0x1610 <__floatunsisf>
2ac: 20 e0 ldi r18, 0x00 ; 0
2ae: 30 e0 ldi r19, 0x00 ; 0
2b0: 48 e4 ldi r20, 0x48 ; 72
2b2: 53 e4 ldi r21, 0x43 ; 67
- 2b4: 0e 94 a1 0a call 0x1542 ; 0x1542 <__cmpsf2>
+ 2b4: 0e 94 70 0a call 0x14e0 ; 0x14e0 <__cmpsf2>
2b8: 87 fd sbrc r24, 7
2ba: f2 cf rjmp .-28 ; 0x2a0 <adb+0x64>
2bc: 41 c0 rjmp .+130 ; 0x340 <adb+0x104>
if (adb_werte[z_byte] & bitpos)
2c4: e1 2e mov r14, r17
2c6: ff 24 eor r15, r15
- 2c8: 8f e5 ldi r24, 0x5F ; 95
+ 2c8: 85 e6 ldi r24, 0x65 ; 101
2ca: 92 e0 ldi r25, 0x02 ; 2
2cc: e8 0e add r14, r24
2ce: f9 1e adc r15, r25
2e0: bc 01 movw r22, r24
2e2: 80 e0 ldi r24, 0x00 ; 0
2e4: 90 e0 ldi r25, 0x00 ; 0
- 2e6: 0e 94 39 0b call 0x1672 ; 0x1672 <__floatunsisf>
+ 2e6: 0e 94 08 0b call 0x1610 ; 0x1610 <__floatunsisf>
2ea: 20 e0 ldi r18, 0x00 ; 0
2ec: 30 e0 ldi r19, 0x00 ; 0
2ee: 4c e8 ldi r20, 0x8C ; 140
2f0: 52 e4 ldi r21, 0x42 ; 66
- 2f2: 0e 94 a1 0a call 0x1542 ; 0x1542 <__cmpsf2>
+ 2f2: 0e 94 70 0a call 0x14e0 ; 0x14e0 <__cmpsf2>
2f6: 87 fd sbrc r24, 7
2f8: f2 cf rjmp .-28 ; 0x2de <adb+0xa2>
2fa: 0e c0 rjmp .+28 ; 0x318 <adb+0xdc>
2fe: bc 01 movw r22, r24
300: 80 e0 ldi r24, 0x00 ; 0
302: 90 e0 ldi r25, 0x00 ; 0
- 304: 0e 94 39 0b call 0x1672 ; 0x1672 <__floatunsisf>
+ 304: 0e 94 08 0b call 0x1610 ; 0x1610 <__floatunsisf>
308: 20 e0 ldi r18, 0x00 ; 0
30a: 30 e0 ldi r19, 0x00 ; 0
30c: 42 e0 ldi r20, 0x02 ; 2
30e: 53 e4 ldi r21, 0x43 ; 67
- 310: 0e 94 a1 0a call 0x1542 ; 0x1542 <__cmpsf2>
+ 310: 0e 94 70 0a call 0x14e0 ; 0x14e0 <__cmpsf2>
314: 87 fd sbrc r24, 7
316: f2 cf rjmp .-28 ; 0x2fc <adb+0xc0>
;
31e: bc 01 movw r22, r24
320: 80 e0 ldi r24, 0x00 ; 0
322: 90 e0 ldi r25, 0x00 ; 0
- 324: 0e 94 39 0b call 0x1672 ; 0x1672 <__floatunsisf>
+ 324: 0e 94 08 0b call 0x1610 ; 0x1610 <__floatunsisf>
328: 20 e0 ldi r18, 0x00 ; 0
32a: 30 e0 ldi r19, 0x00 ; 0
32c: 48 e4 ldi r20, 0x48 ; 72
32e: 53 e4 ldi r21, 0x43 ; 67
- 330: 0e 94 a1 0a call 0x1542 ; 0x1542 <__cmpsf2>
+ 330: 0e 94 70 0a call 0x14e0 ; 0x14e0 <__cmpsf2>
334: 87 fd sbrc r24, 7
336: f2 cf rjmp .-28 ; 0x31c <adb+0xe0>
ADB_POUT |= ADB_BIT;
34e: bc 01 movw r22, r24
350: 80 e0 ldi r24, 0x00 ; 0
352: 90 e0 ldi r25, 0x00 ; 0
- 354: 0e 94 39 0b call 0x1672 ; 0x1672 <__floatunsisf>
+ 354: 0e 94 08 0b call 0x1610 ; 0x1610 <__floatunsisf>
358: 20 e0 ldi r18, 0x00 ; 0
35a: 30 e0 ldi r19, 0x00 ; 0
35c: 42 e0 ldi r20, 0x02 ; 2
35e: 53 e4 ldi r21, 0x43 ; 67
- 360: 0e 94 a1 0a call 0x1542 ; 0x1542 <__cmpsf2>
+ 360: 0e 94 70 0a call 0x14e0 ; 0x14e0 <__cmpsf2>
364: 87 fd sbrc r24, 7
366: f2 cf rjmp .-28 ; 0x34c <adb+0x110>
;
36e: bc 01 movw r22, r24
370: 80 e0 ldi r24, 0x00 ; 0
372: 90 e0 ldi r25, 0x00 ; 0
- 374: 0e 94 39 0b call 0x1672 ; 0x1672 <__floatunsisf>
+ 374: 0e 94 08 0b call 0x1610 ; 0x1610 <__floatunsisf>
378: 20 e0 ldi r18, 0x00 ; 0
37a: 30 e0 ldi r19, 0x00 ; 0
37c: 48 e4 ldi r20, 0x48 ; 72
37e: 53 e4 ldi r21, 0x43 ; 67
- 380: 0e 94 a1 0a call 0x1542 ; 0x1542 <__cmpsf2>
+ 380: 0e 94 70 0a call 0x14e0 ; 0x14e0 <__cmpsf2>
384: 87 fd sbrc r24, 7
386: f2 cf rjmp .-28 ; 0x36c <adb+0x130>
;
// Entscheidung, ob noch weitere Daten übertragen werden
if (adb_werte[0] == COM_LISTEN3)
- 388: 80 91 5f 02 lds r24, 0x025F
+ 388: 80 91 65 02 lds r24, 0x0265
38c: 8b 33 cpi r24, 0x3B ; 59
38e: 29 f0 breq .+10 ; 0x39a <adb+0x15e>
anzahl_out = 2 + 1;
3a8: bc 01 movw r22, r24
3aa: 80 e0 ldi r24, 0x00 ; 0
3ac: 90 e0 ldi r25, 0x00 ; 0
- 3ae: 0e 94 39 0b call 0x1672 ; 0x1672 <__floatunsisf>
+ 3ae: 0e 94 08 0b call 0x1610 ; 0x1610 <__floatunsisf>
3b2: 20 e0 ldi r18, 0x00 ; 0
3b4: 30 e0 ldi r19, 0x00 ; 0
3b6: 4a ef ldi r20, 0xFA ; 250
3b8: 53 e4 ldi r21, 0x43 ; 67
- 3ba: 0e 94 eb 0b call 0x17d6 ; 0x17d6 <__gesf2>
+ 3ba: 0e 94 ba 0b call 0x1774 ; 0x1774 <__gesf2>
3be: 18 16 cp r1, r24
3c0: 0c f4 brge .+2 ; 0x3c4 <adb+0x188>
3c2: 42 c0 rjmp .+132 ; 0x448 <adb+0x20c>
while (!(ADB_PIN & ADB_BIT))
3c8: 48 9b sbis 0x09, 0 ; 9
3ca: fe cf rjmp .-4 ; 0x3c8 <adb+0x18c>
- 3cc: c0 e6 ldi r28, 0x60 ; 96
+ 3cc: c6 e6 ldi r28, 0x66 ; 102
3ce: d2 e0 ldi r29, 0x02 ; 2
3d0: 11 e0 ldi r17, 0x01 ; 1
3d2: 01 c0 rjmp .+2 ; 0x3d6 <adb+0x19a>
3e4: bc 01 movw r22, r24
3e6: 80 e0 ldi r24, 0x00 ; 0
3e8: 90 e0 ldi r25, 0x00 ; 0
- 3ea: 0e 94 39 0b call 0x1672 ; 0x1672 <__floatunsisf>
+ 3ea: 0e 94 08 0b call 0x1610 ; 0x1610 <__floatunsisf>
3ee: 20 e0 ldi r18, 0x00 ; 0
3f0: 30 e0 ldi r19, 0x00 ; 0
3f2: 48 e4 ldi r20, 0x48 ; 72
3f4: 53 e4 ldi r21, 0x43 ; 67
- 3f6: 0e 94 eb 0b call 0x17d6 ; 0x17d6 <__gesf2>
+ 3f6: 0e 94 ba 0b call 0x1774 ; 0x1774 <__gesf2>
3fa: 18 16 cp r1, r24
3fc: 14 f4 brge .+4 ; 0x402 <adb+0x1c6>
return (z_byte - 1);
40e: bc 01 movw r22, r24
410: 80 e0 ldi r24, 0x00 ; 0
412: 90 e0 ldi r25, 0x00 ; 0
- 414: 0e 94 39 0b call 0x1672 ; 0x1672 <__floatunsisf>
+ 414: 0e 94 08 0b call 0x1610 ; 0x1610 <__floatunsisf>
418: 20 e0 ldi r18, 0x00 ; 0
41a: 30 e0 ldi r19, 0x00 ; 0
41c: 48 ec ldi r20, 0xC8 ; 200
41e: 52 e4 ldi r21, 0x42 ; 66
- 420: 0e 94 a1 0a call 0x1542 ; 0x1542 <__cmpsf2>
+ 420: 0e 94 70 0a call 0x14e0 ; 0x14e0 <__cmpsf2>
424: 87 ff sbrs r24, 7
426: 03 c0 rjmp .+6 ; 0x42e <adb+0x1f2>
adb_werte[z_byte] += bitpos;
uint8_t touchpad_read(void) {
adb_werte[0] = COM_TALK0;
46c: 8c e3 ldi r24, 0x3C ; 60
- 46e: 80 93 5f 02 sts 0x025F, r24
+ 46e: 80 93 65 02 sts 0x0265, r24
adb_data_length = adb();
472: e4 de rcall .-568 ; 0x23c <adb>
- 474: 80 93 69 02 sts 0x0269, r24
+ 474: 80 93 6f 02 sts 0x026F, r24
return adb_data_length;
- 478: 80 91 69 02 lds r24, 0x0269
+ 478: 80 91 6f 02 lds r24, 0x026F
}
47c: 08 95 ret
// Auf Absolutmodus umschalten
adb_werte[0] = COM_LISTEN3;
47e: 8b e3 ldi r24, 0x3B ; 59
- 480: 80 93 5f 02 sts 0x025F, r24
+ 480: 80 93 65 02 sts 0x0265, r24
adb_werte[1] = BITS(0110,0011);
484: 83 e6 ldi r24, 0x63 ; 99
- 486: 80 93 60 02 sts 0x0260, r24
+ 486: 80 93 66 02 sts 0x0266, r24
adb_werte[2] = 4; //CDM Modus
48a: 84 e0 ldi r24, 0x04 ; 4
- 48c: 80 93 61 02 sts 0x0261, r24
+ 48c: 80 93 67 02 sts 0x0267, r24
adb();
490: d5 de rcall .-598 ; 0x23c <adb>
adb_werte[0] = COM_TALK1;
492: 8d e3 ldi r24, 0x3D ; 61
- 494: 80 93 5f 02 sts 0x025F, r24
+ 494: 80 93 65 02 sts 0x0265, r24
adb(); // Werte holen
498: d1 de rcall .-606 ; 0x23c <adb>
adb_werte[0] = COM_LISTEN1;
49a: 89 e3 ldi r24, 0x39 ; 57
- 49c: 80 93 5f 02 sts 0x025F, r24
+ 49c: 80 93 65 02 sts 0x0265, r24
adb_werte[7] = 0x00; //Absolutmodus
- 4a0: 10 92 66 02 sts 0x0266, r1
+ 4a0: 10 92 6c 02 sts 0x026C, r1
adb();
+ 4a4: cb de rcall .-618 ; 0x23c <adb>
+ #else
+ //round up by default
+ __ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
+ #endif
+
+ __builtin_avr_delay_cycles(__ticks_dc);
+ 4a6: 8f ef ldi r24, 0xFF ; 255
+ 4a8: 91 ee ldi r25, 0xE1 ; 225
+ 4aa: a4 e0 ldi r26, 0x04 ; 4
+ 4ac: 81 50 subi r24, 0x01 ; 1
+ 4ae: 90 40 sbci r25, 0x00 ; 0
+ 4b0: a0 40 sbci r26, 0x00 ; 0
+ 4b2: e1 f7 brne .-8 ; 0x4ac <touchpad_set_abs_mode+0x2e>
+ 4b4: 00 c0 rjmp .+0 ; 0x4b6 <touchpad_set_abs_mode+0x38>
+ 4b6: 00 00 nop
+ _delay_ms(100);
}
- 4a4: cb ce rjmp .-618 ; 0x23c <adb>
+ 4b8: 08 95 ret
-000004a6 <z_pressure>:
- adb();
+000004ba <z_pressure>:
+ _delay_ms(100);
}
uint8_t z_pressure(void) {
return ((adb_werte[5] & 0b01110000) >> 1) | (adb_werte[5] & 0b00000111);
- 4a6: 80 91 64 02 lds r24, 0x0264
- 4aa: 28 2f mov r18, r24
- 4ac: 30 e0 ldi r19, 0x00 ; 0
- 4ae: 20 77 andi r18, 0x70 ; 112
- 4b0: 30 70 andi r19, 0x00 ; 0
- 4b2: 35 95 asr r19
- 4b4: 27 95 ror r18
- 4b6: 87 70 andi r24, 0x07 ; 7
+ 4ba: 80 91 6a 02 lds r24, 0x026A
+ 4be: 28 2f mov r18, r24
+ 4c0: 30 e0 ldi r19, 0x00 ; 0
+ 4c2: 20 77 andi r18, 0x70 ; 112
+ 4c4: 30 70 andi r19, 0x00 ; 0
+ 4c6: 35 95 asr r19
+ 4c8: 27 95 ror r18
+ 4ca: 87 70 andi r24, 0x07 ; 7
}
- 4b8: 82 2b or r24, r18
- 4ba: 08 95 ret
+ 4cc: 82 2b or r24, r18
+ 4ce: 08 95 ret
-000004bc <x_abs>:
+000004d0 <x_abs>:
uint16_t x_abs(void) {
return ((adb_werte[4] & 0b111) << 10) | ((adb_werte[3] & 0b111) << 7)
- 4bc: 20 91 63 02 lds r18, 0x0263
- 4c0: 30 e0 ldi r19, 0x00 ; 0
- 4c2: 27 70 andi r18, 0x07 ; 7
- 4c4: 30 70 andi r19, 0x00 ; 0
- 4c6: 32 2f mov r19, r18
- 4c8: 22 27 eor r18, r18
- 4ca: 33 0f add r19, r19
- 4cc: 33 0f add r19, r19
- 4ce: 80 91 62 02 lds r24, 0x0262
- 4d2: 90 e0 ldi r25, 0x00 ; 0
- 4d4: 87 70 andi r24, 0x07 ; 7
- 4d6: 90 70 andi r25, 0x00 ; 0
- 4d8: 96 95 lsr r25
- 4da: 98 2f mov r25, r24
- 4dc: 88 27 eor r24, r24
- 4de: 97 95 ror r25
- 4e0: 87 95 ror r24
- 4e2: 28 2b or r18, r24
- 4e4: 39 2b or r19, r25
+ 4d0: 20 91 69 02 lds r18, 0x0269
+ 4d4: 30 e0 ldi r19, 0x00 ; 0
+ 4d6: 27 70 andi r18, 0x07 ; 7
+ 4d8: 30 70 andi r19, 0x00 ; 0
+ 4da: 32 2f mov r19, r18
+ 4dc: 22 27 eor r18, r18
+ 4de: 33 0f add r19, r19
+ 4e0: 33 0f add r19, r19
+ 4e2: 80 91 68 02 lds r24, 0x0268
+ 4e6: 90 e0 ldi r25, 0x00 ; 0
+ 4e8: 87 70 andi r24, 0x07 ; 7
+ 4ea: 90 70 andi r25, 0x00 ; 0
+ 4ec: 96 95 lsr r25
+ 4ee: 98 2f mov r25, r24
+ 4f0: 88 27 eor r24, r24
+ 4f2: 97 95 ror r25
+ 4f4: 87 95 ror r24
+ 4f6: 28 2b or r18, r24
+ 4f8: 39 2b or r19, r25
| (adb_werte[2] & 0b01111111);
- 4e6: 80 91 61 02 lds r24, 0x0261
- 4ea: 90 e0 ldi r25, 0x00 ; 0
- 4ec: 8f 77 andi r24, 0x7F ; 127
- 4ee: 90 70 andi r25, 0x00 ; 0
- 4f0: 28 2b or r18, r24
- 4f2: 39 2b or r19, r25
+ 4fa: 80 91 67 02 lds r24, 0x0267
+ 4fe: 90 e0 ldi r25, 0x00 ; 0
+ 500: 8f 77 andi r24, 0x7F ; 127
+ 502: 90 70 andi r25, 0x00 ; 0
+ 504: 28 2b or r18, r24
+ 506: 39 2b or r19, r25
}
- 4f4: c9 01 movw r24, r18
- 4f6: 08 95 ret
+ 508: c9 01 movw r24, r18
+ 50a: 08 95 ret
-000004f8 <y_abs>:
+0000050c <y_abs>:
uint16_t y_abs(void) {
return ((adb_werte[4] & 0b01110000) << 6)
- 4f8: 20 91 63 02 lds r18, 0x0263
- 4fc: 30 e0 ldi r19, 0x00 ; 0
- 4fe: 20 77 andi r18, 0x70 ; 112
- 500: 30 70 andi r19, 0x00 ; 0
- 502: e6 e0 ldi r30, 0x06 ; 6
- 504: 22 0f add r18, r18
- 506: 33 1f adc r19, r19
- 508: ea 95 dec r30
- 50a: e1 f7 brne .-8 ; 0x504 <__stack+0x5>
+ 50c: 20 91 69 02 lds r18, 0x0269
+ 510: 30 e0 ldi r19, 0x00 ; 0
+ 512: 20 77 andi r18, 0x70 ; 112
+ 514: 30 70 andi r19, 0x00 ; 0
+ 516: e6 e0 ldi r30, 0x06 ; 6
+ 518: 22 0f add r18, r18
+ 51a: 33 1f adc r19, r19
+ 51c: ea 95 dec r30
+ 51e: e1 f7 brne .-8 ; 0x518 <y_abs+0xc>
| ((adb_werte[3] & 0b01110000) << 3) | (adb_werte[1] & 0b01111111);
- 50c: 80 91 62 02 lds r24, 0x0262
- 510: 90 e0 ldi r25, 0x00 ; 0
- 512: 80 77 andi r24, 0x70 ; 112
- 514: 90 70 andi r25, 0x00 ; 0
- 516: 73 e0 ldi r23, 0x03 ; 3
- 518: 88 0f add r24, r24
- 51a: 99 1f adc r25, r25
- 51c: 7a 95 dec r23
- 51e: e1 f7 brne .-8 ; 0x518 <__stack+0x19>
- 520: 28 2b or r18, r24
- 522: 39 2b or r19, r25
- 524: 80 91 60 02 lds r24, 0x0260
- 528: 90 e0 ldi r25, 0x00 ; 0
- 52a: 8f 77 andi r24, 0x7F ; 127
- 52c: 90 70 andi r25, 0x00 ; 0
- 52e: 28 2b or r18, r24
- 530: 39 2b or r19, r25
+ 520: 80 91 68 02 lds r24, 0x0268
+ 524: 90 e0 ldi r25, 0x00 ; 0
+ 526: 80 77 andi r24, 0x70 ; 112
+ 528: 90 70 andi r25, 0x00 ; 0
+ 52a: 73 e0 ldi r23, 0x03 ; 3
+ 52c: 88 0f add r24, r24
+ 52e: 99 1f adc r25, r25
+ 530: 7a 95 dec r23
+ 532: e1 f7 brne .-8 ; 0x52c <y_abs+0x20>
+ 534: 28 2b or r18, r24
+ 536: 39 2b or r19, r25
+ 538: 80 91 66 02 lds r24, 0x0266
+ 53c: 90 e0 ldi r25, 0x00 ; 0
+ 53e: 8f 77 andi r24, 0x7F ; 127
+ 540: 90 70 andi r25, 0x00 ; 0
+ 542: 28 2b or r18, r24
+ 544: 39 2b or r19, r25
+}
+ 546: c9 01 movw r24, r18
+ 548: 08 95 ret
+
+0000054a <decode_field>:
+ }
+
+}
+*/
+
+uint8_t decode_field(void) {
+ 54a: 1f 93 push r17
+ 54c: cf 93 push r28
+ 54e: df 93 push r29
+ uint8_t pressure, i, j;
+ uint8_t return_val = 0;
+ static uint16_t x_mem, y_mem;
+ uint16_t x, y;
+
+ pressure = z_pressure();
+ 550: b4 df rcall .-152 ; 0x4ba <z_pressure>
+ 552: 18 2f mov r17, r24
+ x = x_abs();
+ 554: bd df rcall .-134 ; 0x4d0 <x_abs>
+ 556: ec 01 movw r28, r24
+ y = y_abs();
+ 558: d9 df rcall .-78 ; 0x50c <y_abs>
+ 55a: 9c 01 movw r18, r24
+
+ if (x) {
+ 55c: 20 97 sbiw r28, 0x00 ; 0
+ 55e: 29 f0 breq .+10 ; 0x56a <decode_field+0x20>
+ x_mem = x;
+ 560: d0 93 63 02 sts 0x0263, r29
+ 564: c0 93 62 02 sts 0x0262, r28
+ 568: 04 c0 rjmp .+8 ; 0x572 <decode_field+0x28>
+ } else {
+ x = x_mem;
+ 56a: c0 91 62 02 lds r28, 0x0262
+ 56e: d0 91 63 02 lds r29, 0x0263
+ }
+
+ if (y) {
+ 572: 21 15 cp r18, r1
+ 574: 31 05 cpc r19, r1
+ 576: 29 f0 breq .+10 ; 0x582 <decode_field+0x38>
+ y_mem = y;
+ 578: 30 93 61 02 sts 0x0261, r19
+ 57c: 20 93 60 02 sts 0x0260, r18
+ 580: 04 c0 rjmp .+8 ; 0x58a <decode_field+0x40>
+ } else {
+ y = y_mem;
+ 582: 20 91 60 02 lds r18, 0x0260
+ 586: 30 91 61 02 lds r19, 0x0261
+ }
+
+ if ((pressure == 0) && (last_pressure > 0)) {
+ 58a: 11 23 and r17, r17
+ 58c: c9 f4 brne .+50 ; 0x5c0 <decode_field+0x76>
+ 58e: 80 91 64 02 lds r24, 0x0264
+ 592: 88 23 and r24, r24
+ 594: a9 f0 breq .+42 ; 0x5c0 <decode_field+0x76>
+
+ i = (y - MIN_ABS_Y) / PAD_ROW_HEIGHT;
+ j = (x - MIN_ABS_X) / PAD_COL_WIDTH;
+ 596: c6 59 subi r28, 0x96 ; 150
+ 598: d0 40 sbci r29, 0x00 ; 0
+ 59a: ce 01 movw r24, r28
+ 59c: 61 eb ldi r22, 0xB1 ; 177
+ 59e: 71 e0 ldi r23, 0x01 ; 1
+ 5a0: 0e 94 be 0b call 0x177c ; 0x177c <__udivmodhi4>
+
+ return_val = i * PAD_COLS + j + 1;
+ 5a4: 46 2f mov r20, r22
+ 5a6: 4f 5f subi r20, 0xFF ; 255
+ y = y_mem;
+ }
+
+ if ((pressure == 0) && (last_pressure > 0)) {
+
+ i = (y - MIN_ABS_Y) / PAD_ROW_HEIGHT;
+ 5a8: 22 5d subi r18, 0xD2 ; 210
+ 5aa: 30 40 sbci r19, 0x00 ; 0
+ 5ac: c9 01 movw r24, r18
+ 5ae: 6c ec ldi r22, 0xCC ; 204
+ 5b0: 71 e0 ldi r23, 0x01 ; 1
+ 5b2: 0e 94 be 0b call 0x177c ; 0x177c <__udivmodhi4>
+ j = (x - MIN_ABS_X) / PAD_COL_WIDTH;
+
+ return_val = i * PAD_COLS + j + 1;
+ 5b6: 86 2f mov r24, r22
+ 5b8: 88 0f add r24, r24
+ 5ba: 86 0f add r24, r22
+ 5bc: 48 0f add r20, r24
+ 5be: 01 c0 rjmp .+2 ; 0x5c2 <decode_field+0x78>
+*/
+
+uint8_t decode_field(void) {
+ static uint8_t last_pressure = 0;
+ uint8_t pressure, i, j;
+ uint8_t return_val = 0;
+ 5c0: 40 e0 ldi r20, 0x00 ; 0
+
+ return_val = i * PAD_COLS + j + 1;
+
+ }
+
+ last_pressure = pressure;
+ 5c2: 10 93 64 02 sts 0x0264, r17
+ return return_val;
}
- 532: c9 01 movw r24, r18
- 534: 08 95 ret
+ 5c6: 84 2f mov r24, r20
+ 5c8: df 91 pop r29
+ 5ca: cf 91 pop r28
+ 5cc: 1f 91 pop r17
+ 5ce: 08 95 ret
-00000536 <Usb2SerialTask>:
+000005d0 <Usb2SerialTask>:
void Usb2SerialTask(void) {
- 536: 1f 93 push r17
+ 5d0: 1f 93 push r17
static inline uint_reg_t GetGlobalInterruptMask(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
return SREG;
- 538: 8f b7 in r24, 0x3f ; 63
+ 5d2: 8f b7 in r24, 0x3f ; 63
static inline void GlobalInterruptDisable(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
cli();
- 53a: f8 94 cli
+ 5d4: f8 94 cli
uint16_t Count;
uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
GlobalInterruptDisable();
Count = Buffer->Count;
- 53c: 20 91 4c 01 lds r18, 0x014C
- 540: 30 91 4d 01 lds r19, 0x014D
+ 5d6: 20 91 52 01 lds r18, 0x0152
+ 5da: 30 91 53 01 lds r19, 0x0153
static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
SREG = GlobalIntState;
- 544: 8f bf out 0x3f, r24 ; 63
+ 5de: 8f bf out 0x3f, r24 ; 63
/* Only try to read in bytes from the CDC interface if the transmit buffer is not full */
if (!(RingBuffer_IsFull(&USBtoUSART_Buffer)))
- 546: 80 91 4a 01 lds r24, 0x014A
- 54a: 90 91 4b 01 lds r25, 0x014B
- 54e: 28 17 cp r18, r24
- 550: 39 07 cpc r19, r25
- 552: 49 f0 breq .+18 ; 0x566 <Usb2SerialTask+0x30>
+ 5e0: 80 91 50 01 lds r24, 0x0150
+ 5e4: 90 91 51 01 lds r25, 0x0151
+ 5e8: 28 17 cp r18, r24
+ 5ea: 39 07 cpc r19, r25
+ 5ec: 49 f0 breq .+18 ; 0x600 <Usb2SerialTask+0x30>
{
int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
- 554: 85 e2 ldi r24, 0x25 ; 37
- 556: 91 e0 ldi r25, 0x01 ; 1
- 558: 61 d7 rcall .+3778 ; 0x141c <CDC_Device_ReceiveByte>
- 55a: bc 01 movw r22, r24
+ 5ee: 8a e2 ldi r24, 0x2A ; 42
+ 5f0: 91 e0 ldi r25, 0x01 ; 1
+ 5f2: e3 d6 rcall .+3526 ; 0x13ba <CDC_Device_ReceiveByte>
+ 5f4: bc 01 movw r22, r24
/* Read bytes from the USB OUT endpoint into the USART transmit buffer */
if (!(ReceivedByte < 0))
- 55c: 97 fd sbrc r25, 7
- 55e: 03 c0 rjmp .+6 ; 0x566 <Usb2SerialTask+0x30>
+ 5f6: 97 fd sbrc r25, 7
+ 5f8: 03 c0 rjmp .+6 ; 0x600 <Usb2SerialTask+0x30>
RingBuffer_Insert(&USBtoUSART_Buffer, ReceivedByte);
- 560: 82 e4 ldi r24, 0x42 ; 66
- 562: 91 e0 ldi r25, 0x01 ; 1
- 564: 05 de rcall .-1014 ; 0x170 <RingBuffer_Insert>
+ 5fa: 88 e4 ldi r24, 0x48 ; 72
+ 5fc: 91 e0 ldi r25, 0x01 ; 1
+ 5fe: b8 dd rcall .-1168 ; 0x170 <RingBuffer_Insert>
static inline uint_reg_t GetGlobalInterruptMask(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
return SREG;
- 566: 2f b7 in r18, 0x3f ; 63
+ 600: 2f b7 in r18, 0x3f ; 63
static inline void GlobalInterruptDisable(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
cli();
- 568: f8 94 cli
- 56a: 80 91 d8 01 lds r24, 0x01D8
- 56e: 90 91 d9 01 lds r25, 0x01D9
+ 602: f8 94 cli
+ 604: 80 91 de 01 lds r24, 0x01DE
+ 608: 90 91 df 01 lds r25, 0x01DF
static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
SREG = GlobalIntState;
- 572: 2f bf out 0x3f, r18 ; 63
+ 60c: 2f bf out 0x3f, r18 ; 63
}
/* Check if the UART receive buffer flush timer has expired or the buffer is nearly full */
uint16_t BufferCount = RingBuffer_GetCount(&USARTtoUSB_Buffer);
if (BufferCount)
- 574: 00 97 sbiw r24, 0x00 ; 0
- 576: 01 f1 breq .+64 ; 0x5b8 <Usb2SerialTask+0x82>
+ 60e: 00 97 sbiw r24, 0x00 ; 0
+ 610: 01 f1 breq .+64 ; 0x652 <Usb2SerialTask+0x82>
*/
static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void Endpoint_SelectEndpoint(const uint8_t Address)
{
#if !defined(CONTROL_ONLY_DEVICE)
UENUM = (Address & ENDPOINT_EPNUM_MASK);
- 578: 20 91 26 01 lds r18, 0x0126
- 57c: 2f 70 andi r18, 0x0F ; 15
- 57e: 20 93 e9 00 sts 0x00E9, r18
+ 612: 20 91 2b 01 lds r18, 0x012B
+ 616: 2f 70 andi r18, 0x0F ; 15
+ 618: 20 93 e9 00 sts 0x00E9, r18
* \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
*/
static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsINReady(void)
{
return ((UEINTX & (1 << TXINI)) ? true : false);
- 582: 20 91 e8 00 lds r18, 0x00E8
+ 61c: 20 91 e8 00 lds r18, 0x00E8
{
Endpoint_SelectEndpoint(VirtualSerial_CDC_Interface.Config.DataINEndpoint.Address);
/* Check if a packet is already enqueued to the host - if so, we shouldn't try to send more data
* until it completes as there is a chance nothing is listening and a lengthy timeout could occur */
if (Endpoint_IsINReady())
- 586: 20 ff sbrs r18, 0
- 588: 17 c0 rjmp .+46 ; 0x5b8 <Usb2SerialTask+0x82>
+ 620: 20 ff sbrs r18, 0
+ 622: 17 c0 rjmp .+46 ; 0x652 <Usb2SerialTask+0x82>
{
/* Never send more than one bank size less one byte to the host at a time, so that we don't block
* while a Zero Length Packet (ZLP) to terminate the transfer is sent if the host isn't listening */
uint8_t BytesToSend = MIN(BufferCount, (CDC_TXRX_EPSIZE - 1));
- 58a: 80 31 cpi r24, 0x10 ; 16
- 58c: 91 05 cpc r25, r1
- 58e: 10 f0 brcs .+4 ; 0x594 <Usb2SerialTask+0x5e>
- 590: 8f e0 ldi r24, 0x0F ; 15
- 592: 90 e0 ldi r25, 0x00 ; 0
- 594: 18 2f mov r17, r24
+ 624: 80 31 cpi r24, 0x10 ; 16
+ 626: 91 05 cpc r25, r1
+ 628: 10 f0 brcs .+4 ; 0x62e <Usb2SerialTask+0x5e>
+ 62a: 8f e0 ldi r24, 0x0F ; 15
+ 62c: 90 e0 ldi r25, 0x00 ; 0
+ 62e: 18 2f mov r17, r24
/* Read bytes from the USART receive buffer into the USB IN endpoint */
while (BytesToSend--)
- 596: 0e c0 rjmp .+28 ; 0x5b4 <Usb2SerialTask+0x7e>
+ 630: 0e c0 rjmp .+28 ; 0x64e <Usb2SerialTask+0x7e>
* \return Next data element stored in the buffer.
*/
static inline uint8_t RingBuffer_Peek(RingBuffer_t* const Buffer) ATTR_WARN_UNUSED_RESULT ATTR_NON_NULL_PTR_ARG(1);
static inline uint8_t RingBuffer_Peek(RingBuffer_t* const Buffer)
{
return *Buffer->Out;
- 598: e0 91 d0 01 lds r30, 0x01D0
- 59c: f0 91 d1 01 lds r31, 0x01D1
+ 632: e0 91 d6 01 lds r30, 0x01D6
+ 636: f0 91 d7 01 lds r31, 0x01D7
{
/* Try to send the next byte of data to the host, abort if there is an error without dequeuing */
if (CDC_Device_SendByte(&VirtualSerial_CDC_Interface,
- 5a0: 85 e2 ldi r24, 0x25 ; 37
- 5a2: 91 e0 ldi r25, 0x01 ; 1
- 5a4: 60 81 ld r22, Z
- 5a6: c9 d6 rcall .+3474 ; 0x133a <CDC_Device_SendByte>
- 5a8: 11 50 subi r17, 0x01 ; 1
- 5aa: 88 23 and r24, r24
- 5ac: 29 f4 brne .+10 ; 0x5b8 <Usb2SerialTask+0x82>
+ 63a: 8a e2 ldi r24, 0x2A ; 42
+ 63c: 91 e0 ldi r25, 0x01 ; 1
+ 63e: 60 81 ld r22, Z
+ 640: 4b d6 rcall .+3222 ; 0x12d8 <CDC_Device_SendByte>
+ 642: 11 50 subi r17, 0x01 ; 1
+ 644: 88 23 and r24, r24
+ 646: 29 f4 brne .+10 ; 0x652 <Usb2SerialTask+0x82>
{
break;
}
/* Dequeue the already sent byte from the buffer now we have confirmed that no transmission error occurred */
RingBuffer_Remove(&USARTtoUSB_Buffer);
- 5ae: 8e ec ldi r24, 0xCE ; 206
- 5b0: 91 e0 ldi r25, 0x01 ; 1
- 5b2: f9 dd rcall .-1038 ; 0x1a6 <RingBuffer_Remove>
+ 648: 84 ed ldi r24, 0xD4 ; 212
+ 64a: 91 e0 ldi r25, 0x01 ; 1
+ 64c: ac dd rcall .-1192 ; 0x1a6 <RingBuffer_Remove>
/* Never send more than one bank size less one byte to the host at a time, so that we don't block
* while a Zero Length Packet (ZLP) to terminate the transfer is sent if the host isn't listening */
uint8_t BytesToSend = MIN(BufferCount, (CDC_TXRX_EPSIZE - 1));
/* Read bytes from the USART receive buffer into the USB IN endpoint */
while (BytesToSend--)
- 5b4: 11 23 and r17, r17
- 5b6: 81 f7 brne .-32 ; 0x598 <Usb2SerialTask+0x62>
+ 64e: 11 23 and r17, r17
+ 650: 81 f7 brne .-32 ; 0x632 <Usb2SerialTask+0x62>
static inline uint_reg_t GetGlobalInterruptMask(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
return SREG;
- 5b8: 2f b7 in r18, 0x3f ; 63
+ 652: 2f b7 in r18, 0x3f ; 63
static inline void GlobalInterruptDisable(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
cli();
- 5ba: f8 94 cli
+ 654: f8 94 cli
uint16_t Count;
uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
GlobalInterruptDisable();
Count = Buffer->Count;
- 5bc: 80 91 4c 01 lds r24, 0x014C
- 5c0: 90 91 4d 01 lds r25, 0x014D
+ 656: 80 91 52 01 lds r24, 0x0152
+ 65a: 90 91 53 01 lds r25, 0x0153
static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
SREG = GlobalIntState;
- 5c4: 2f bf out 0x3f, r18 ; 63
+ 65e: 2f bf out 0x3f, r18 ; 63
}
}
}
/* Load the next byte from the USART transmit buffer into the USART */
if (!(RingBuffer_IsEmpty(&USBtoUSART_Buffer))) {
- 5c6: 00 97 sbiw r24, 0x00 ; 0
- 5c8: 49 f0 breq .+18 ; 0x5dc <Usb2SerialTask+0xa6>
+ 660: 00 97 sbiw r24, 0x00 ; 0
+ 662: 49 f0 breq .+18 ; 0x676 <Usb2SerialTask+0xa6>
Serial_SendByte(RingBuffer_Remove(&USBtoUSART_Buffer));
- 5ca: 82 e4 ldi r24, 0x42 ; 66
- 5cc: 91 e0 ldi r25, 0x01 ; 1
- 5ce: eb dd rcall .-1066 ; 0x1a6 <RingBuffer_Remove>
+ 664: 88 e4 ldi r24, 0x48 ; 72
+ 666: 91 e0 ldi r25, 0x01 ; 1
+ 668: 9e dd rcall .-1220 ; 0x1a6 <RingBuffer_Remove>
* \param[in] DataByte Byte to transmit through the USART.
*/
static inline void Serial_SendByte(const char DataByte) ATTR_ALWAYS_INLINE;
static inline void Serial_SendByte(const char DataByte)
{
while (!(UCSR1A & (1 << UDRE1)));
- 5d0: 90 91 c8 00 lds r25, 0x00C8
- 5d4: 95 ff sbrs r25, 5
- 5d6: fc cf rjmp .-8 ; 0x5d0 <Usb2SerialTask+0x9a>
+ 66a: 90 91 c8 00 lds r25, 0x00C8
+ 66e: 95 ff sbrs r25, 5
+ 670: fc cf rjmp .-8 ; 0x66a <Usb2SerialTask+0x9a>
UDR1 = DataByte;
- 5d8: 80 93 ce 00 sts 0x00CE, r24
+ 672: 80 93 ce 00 sts 0x00CE, r24
// dummy = RingBuffer_Remove(&USBtoUSART_Buffer);
// sendPayload(&dummy,1,0);
}
CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
- 5dc: 85 e2 ldi r24, 0x25 ; 37
- 5de: 91 e0 ldi r25, 0x01 ; 1
- 5e0: 06 d7 rcall .+3596 ; 0x13ee <CDC_Device_USBTask>
+ 676: 8a e2 ldi r24, 0x2A ; 42
+ 678: 91 e0 ldi r25, 0x01 ; 1
+ 67a: 88 d6 rcall .+3344 ; 0x138c <CDC_Device_USBTask>
USB_USBTask();
- 5e2: c0 d5 rcall .+2944 ; 0x1164 <USB_USBTask>
+ 67c: 42 d5 rcall .+2692 ; 0x1102 <USB_USBTask>
}
- 5e4: 1f 91 pop r17
- 5e6: 08 95 ret
+ 67e: 1f 91 pop r17
+ 680: 08 95 ret
-000005e8 <SetupHardware>:
+00000682 <SetupHardware>:
/** Configures the board hardware and chip peripherals for the demo's functionality. */
void SetupHardware(void)
{
/* Disable watchdog if enabled by bootloader/fuses */
MCUSR &= ~(1 << WDRF);
- 5e8: 84 b7 in r24, 0x34 ; 52
- 5ea: 87 7f andi r24, 0xF7 ; 247
- 5ec: 84 bf out 0x34, r24 ; 52
+ 682: 84 b7 in r24, 0x34 ; 52
+ 684: 87 7f andi r24, 0xF7 ; 247
+ 686: 84 bf out 0x34, r24 ; 52
wdt_disable();
- 5ee: 88 e1 ldi r24, 0x18 ; 24
- 5f0: 0f b6 in r0, 0x3f ; 63
- 5f2: f8 94 cli
- 5f4: 80 93 60 00 sts 0x0060, r24
- 5f8: 10 92 60 00 sts 0x0060, r1
- 5fc: 0f be out 0x3f, r0 ; 63
+ 688: 88 e1 ldi r24, 0x18 ; 24
+ 68a: 0f b6 in r0, 0x3f ; 63
+ 68c: f8 94 cli
+ 68e: 80 93 60 00 sts 0x0060, r24
+ 692: 10 92 60 00 sts 0x0060, r1
+ 696: 0f be out 0x3f, r0 ; 63
The type of x is clock_div_t.
*/
void clock_prescale_set(clock_div_t __x)
{
uint8_t __tmp = _BV(CLKPCE);
__asm__ __volatile__ (
- 5fe: 90 e0 ldi r25, 0x00 ; 0
- 600: 80 e8 ldi r24, 0x80 ; 128
- 602: 0f b6 in r0, 0x3f ; 63
- 604: f8 94 cli
- 606: 80 93 61 00 sts 0x0061, r24
- 60a: 90 93 61 00 sts 0x0061, r25
- 60e: 0f be out 0x3f, r0 ; 63
+ 698: 90 e0 ldi r25, 0x00 ; 0
+ 69a: 80 e8 ldi r24, 0x80 ; 128
+ 69c: 0f b6 in r0, 0x3f ; 63
+ 69e: f8 94 cli
+ 6a0: 80 93 61 00 sts 0x0061, r24
+ 6a4: 90 93 61 00 sts 0x0061, r25
+ 6a8: 0f be out 0x3f, r0 ; 63
clock_prescale_set(clock_div_1);
/* Hardware Initialization */
// LEDs_Init();
USB_Init();
}
- 610: 59 c3 rjmp .+1714 ; 0xcc4 <USB_Init>
+ 6aa: db c2 rjmp .+1462 ; 0xc62 <USB_Init>
-00000612 <EVENT_USB_Device_Connect>:
+000006ac <EVENT_USB_Device_Connect>:
/** Event handler for the library USB Connection event. */
void EVENT_USB_Device_Connect(void)
{
// LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
}
- 612: 08 95 ret
+ 6ac: 08 95 ret
-00000614 <EVENT_USB_Device_Disconnect>:
+000006ae <EVENT_USB_Device_Disconnect>:
/** Event handler for the library USB Disconnection event. */
void EVENT_USB_Device_Disconnect(void)
{
// LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
}
- 614: 08 95 ret
+ 6ae: 08 95 ret
-00000616 <EVENT_USB_Device_ConfigurationChanged>:
+000006b0 <EVENT_USB_Device_ConfigurationChanged>:
/** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void)
{
bool ConfigSuccess = true;
ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface);
- 616: 85 e2 ldi r24, 0x25 ; 37
- 618: 91 e0 ldi r25, 0x01 ; 1
+ 6b0: 8a e2 ldi r24, 0x2A ; 42
+ 6b2: 91 e0 ldi r25, 0x01 ; 1
// LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
}
- 61a: 6b c6 rjmp .+3286 ; 0x12f2 <CDC_Device_ConfigureEndpoints>
+ 6b4: ed c5 rjmp .+3034 ; 0x1290 <CDC_Device_ConfigureEndpoints>
-0000061c <EVENT_USB_Device_ControlRequest>:
+000006b6 <EVENT_USB_Device_ControlRequest>:
/** Event handler for the library USB Control Request reception event. */
void EVENT_USB_Device_ControlRequest(void)
{
CDC_Device_ProcessControlRequest(&VirtualSerial_CDC_Interface);
- 61c: 85 e2 ldi r24, 0x25 ; 37
- 61e: 91 e0 ldi r25, 0x01 ; 1
+ 6b6: 8a e2 ldi r24, 0x2A ; 42
+ 6b8: 91 e0 ldi r25, 0x01 ; 1
}
- 620: bc c5 rjmp .+2936 ; 0x119a <CDC_Device_ProcessControlRequest>
+ 6ba: 3e c5 rjmp .+2684 ; 0x1138 <CDC_Device_ProcessControlRequest>
-00000622 <__vector_23>:
+000006bc <__vector_23>:
/** ISR to manage the reception of data from the serial port, placing received bytes into a circular buffer
* for later transmission to the host.
*/
ISR(USART1_RX_vect, ISR_BLOCK)
{
- 622: 1f 92 push r1
- 624: 0f 92 push r0
- 626: 0f b6 in r0, 0x3f ; 63
- 628: 0f 92 push r0
- 62a: 11 24 eor r1, r1
- 62c: 2f 93 push r18
- 62e: 3f 93 push r19
- 630: 4f 93 push r20
- 632: 5f 93 push r21
- 634: 6f 93 push r22
- 636: 7f 93 push r23
- 638: 8f 93 push r24
- 63a: 9f 93 push r25
- 63c: af 93 push r26
- 63e: bf 93 push r27
- 640: ef 93 push r30
- 642: ff 93 push r31
+ 6bc: 1f 92 push r1
+ 6be: 0f 92 push r0
+ 6c0: 0f b6 in r0, 0x3f ; 63
+ 6c2: 0f 92 push r0
+ 6c4: 11 24 eor r1, r1
+ 6c6: 2f 93 push r18
+ 6c8: 3f 93 push r19
+ 6ca: 4f 93 push r20
+ 6cc: 5f 93 push r21
+ 6ce: 6f 93 push r22
+ 6d0: 7f 93 push r23
+ 6d2: 8f 93 push r24
+ 6d4: 9f 93 push r25
+ 6d6: af 93 push r26
+ 6d8: bf 93 push r27
+ 6da: ef 93 push r30
+ 6dc: ff 93 push r31
uint8_t ReceivedByte = UDR1;
- 644: 60 91 ce 00 lds r22, 0x00CE
+ 6de: 60 91 ce 00 lds r22, 0x00CE
if (USB_DeviceState == DEVICE_STATE_Configured)
- 648: 8e b3 in r24, 0x1e ; 30
- 64a: 84 30 cpi r24, 0x04 ; 4
- 64c: 19 f4 brne .+6 ; 0x654 <__vector_23+0x32>
+ 6e2: 8e b3 in r24, 0x1e ; 30
+ 6e4: 84 30 cpi r24, 0x04 ; 4
+ 6e6: 19 f4 brne .+6 ; 0x6ee <__vector_23+0x32>
RingBuffer_Insert(&USARTtoUSB_Buffer, ReceivedByte);
- 64e: 8e ec ldi r24, 0xCE ; 206
- 650: 91 e0 ldi r25, 0x01 ; 1
- 652: 8e dd rcall .-1252 ; 0x170 <RingBuffer_Insert>
+ 6e8: 84 ed ldi r24, 0xD4 ; 212
+ 6ea: 91 e0 ldi r25, 0x01 ; 1
+ 6ec: 41 dd rcall .-1406 ; 0x170 <RingBuffer_Insert>
}
- 654: ff 91 pop r31
- 656: ef 91 pop r30
- 658: bf 91 pop r27
- 65a: af 91 pop r26
- 65c: 9f 91 pop r25
- 65e: 8f 91 pop r24
- 660: 7f 91 pop r23
- 662: 6f 91 pop r22
- 664: 5f 91 pop r21
- 666: 4f 91 pop r20
- 668: 3f 91 pop r19
- 66a: 2f 91 pop r18
- 66c: 0f 90 pop r0
- 66e: 0f be out 0x3f, r0 ; 63
- 670: 0f 90 pop r0
- 672: 1f 90 pop r1
- 674: 18 95 reti
-
-00000676 <EVENT_CDC_Device_LineEncodingChanged>:
+ 6ee: ff 91 pop r31
+ 6f0: ef 91 pop r30
+ 6f2: bf 91 pop r27
+ 6f4: af 91 pop r26
+ 6f6: 9f 91 pop r25
+ 6f8: 8f 91 pop r24
+ 6fa: 7f 91 pop r23
+ 6fc: 6f 91 pop r22
+ 6fe: 5f 91 pop r21
+ 700: 4f 91 pop r20
+ 702: 3f 91 pop r19
+ 704: 2f 91 pop r18
+ 706: 0f 90 pop r0
+ 708: 0f be out 0x3f, r0 ; 63
+ 70a: 0f 90 pop r0
+ 70c: 1f 90 pop r1
+ 70e: 18 95 reti
+
+00000710 <EVENT_CDC_Device_LineEncodingChanged>:
/** Event handler for the CDC Class driver Line Encoding Changed event.
*
* \param[in] CDCInterfaceInfo Pointer to the CDC class interface configuration structure being referenced
*/
void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{
- 676: 8f 92 push r8
- 678: 9f 92 push r9
- 67a: af 92 push r10
- 67c: bf 92 push r11
- 67e: cf 92 push r12
- 680: df 92 push r13
- 682: ef 92 push r14
- 684: ff 92 push r15
- 686: 1f 93 push r17
- 688: fc 01 movw r30, r24
+ 710: 8f 92 push r8
+ 712: 9f 92 push r9
+ 714: af 92 push r10
+ 716: bf 92 push r11
+ 718: cf 92 push r12
+ 71a: df 92 push r13
+ 71c: ef 92 push r14
+ 71e: ff 92 push r15
+ 720: 1f 93 push r17
+ 722: fc 01 movw r30, r24
uint8_t ConfigMask = 0;
switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
- 68a: a1 8d ldd r26, Z+25 ; 0x19
- 68c: a1 50 subi r26, 0x01 ; 1
- 68e: a2 30 cpi r26, 0x02 ; 2
- 690: 28 f4 brcc .+10 ; 0x69c <EVENT_CDC_Device_LineEncodingChanged+0x26>
- 692: b0 e0 ldi r27, 0x00 ; 0
- 694: a0 5c subi r26, 0xC0 ; 192
- 696: be 4f sbci r27, 0xFE ; 254
- 698: 1c 91 ld r17, X
- 69a: 01 c0 rjmp .+2 ; 0x69e <EVENT_CDC_Device_LineEncodingChanged+0x28>
- 69c: 10 e0 ldi r17, 0x00 ; 0
+ 724: a1 8d ldd r26, Z+25 ; 0x19
+ 726: a1 50 subi r26, 0x01 ; 1
+ 728: a2 30 cpi r26, 0x02 ; 2
+ 72a: 28 f4 brcc .+10 ; 0x736 <EVENT_CDC_Device_LineEncodingChanged+0x26>
+ 72c: b0 e0 ldi r27, 0x00 ; 0
+ 72e: ab 5b subi r26, 0xBB ; 187
+ 730: be 4f sbci r27, 0xFE ; 254
+ 732: 1c 91 ld r17, X
+ 734: 01 c0 rjmp .+2 ; 0x738 <EVENT_CDC_Device_LineEncodingChanged+0x28>
+ 736: 10 e0 ldi r17, 0x00 ; 0
case CDC_PARITY_Even:
ConfigMask = (1 << UPM11);
break;
}
if (CDCInterfaceInfo->State.LineEncoding.CharFormat == CDC_LINEENCODING_TwoStopBits)
- 69e: 80 8d ldd r24, Z+24 ; 0x18
- 6a0: 82 30 cpi r24, 0x02 ; 2
- 6a2: 09 f4 brne .+2 ; 0x6a6 <EVENT_CDC_Device_LineEncodingChanged+0x30>
+ 738: 80 8d ldd r24, Z+24 ; 0x18
+ 73a: 82 30 cpi r24, 0x02 ; 2
+ 73c: 09 f4 brne .+2 ; 0x740 <EVENT_CDC_Device_LineEncodingChanged+0x30>
ConfigMask |= (1 << USBS1);
- 6a4: 18 60 ori r17, 0x08 ; 8
+ 73e: 18 60 ori r17, 0x08 ; 8
switch (CDCInterfaceInfo->State.LineEncoding.DataBits)
- 6a6: 82 8d ldd r24, Z+26 ; 0x1a
- 6a8: 87 30 cpi r24, 0x07 ; 7
- 6aa: 31 f0 breq .+12 ; 0x6b8 <EVENT_CDC_Device_LineEncodingChanged+0x42>
- 6ac: 88 30 cpi r24, 0x08 ; 8
- 6ae: 31 f0 breq .+12 ; 0x6bc <EVENT_CDC_Device_LineEncodingChanged+0x46>
- 6b0: 86 30 cpi r24, 0x06 ; 6
- 6b2: 29 f4 brne .+10 ; 0x6be <EVENT_CDC_Device_LineEncodingChanged+0x48>
+ 740: 82 8d ldd r24, Z+26 ; 0x1a
+ 742: 87 30 cpi r24, 0x07 ; 7
+ 744: 31 f0 breq .+12 ; 0x752 <EVENT_CDC_Device_LineEncodingChanged+0x42>
+ 746: 88 30 cpi r24, 0x08 ; 8
+ 748: 31 f0 breq .+12 ; 0x756 <EVENT_CDC_Device_LineEncodingChanged+0x46>
+ 74a: 86 30 cpi r24, 0x06 ; 6
+ 74c: 29 f4 brne .+10 ; 0x758 <EVENT_CDC_Device_LineEncodingChanged+0x48>
{
case 6:
ConfigMask |= (1 << UCSZ10);
- 6b4: 12 60 ori r17, 0x02 ; 2
+ 74e: 12 60 ori r17, 0x02 ; 2
break;
- 6b6: 03 c0 rjmp .+6 ; 0x6be <EVENT_CDC_Device_LineEncodingChanged+0x48>
+ 750: 03 c0 rjmp .+6 ; 0x758 <EVENT_CDC_Device_LineEncodingChanged+0x48>
case 7:
ConfigMask |= (1 << UCSZ11);
- 6b8: 14 60 ori r17, 0x04 ; 4
+ 752: 14 60 ori r17, 0x04 ; 4
break;
- 6ba: 01 c0 rjmp .+2 ; 0x6be <EVENT_CDC_Device_LineEncodingChanged+0x48>
+ 754: 01 c0 rjmp .+2 ; 0x758 <EVENT_CDC_Device_LineEncodingChanged+0x48>
case 8:
ConfigMask |= ((1 << UCSZ11) | (1 << UCSZ10));
- 6bc: 16 60 ori r17, 0x06 ; 6
+ 756: 16 60 ori r17, 0x06 ; 6
break;
}
/* Must turn off USART before reconfiguring it, otherwise incorrect operation may occur */
UCSR1B = 0;
- 6be: 10 92 c9 00 sts 0x00C9, r1
+ 758: 10 92 c9 00 sts 0x00C9, r1
UCSR1A = 0;
- 6c2: 10 92 c8 00 sts 0x00C8, r1
+ 75c: 10 92 c8 00 sts 0x00C8, r1
UCSR1C = 0;
- 6c6: 10 92 ca 00 sts 0x00CA, r1
+ 760: 10 92 ca 00 sts 0x00CA, r1
/* Set the new baud rate before configuring the USART */
UBRR1 = SERIAL_2X_UBBRVAL(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
- 6ca: c4 88 ldd r12, Z+20 ; 0x14
- 6cc: d5 88 ldd r13, Z+21 ; 0x15
- 6ce: e6 88 ldd r14, Z+22 ; 0x16
- 6d0: f7 88 ldd r15, Z+23 ; 0x17
- 6d2: c7 01 movw r24, r14
- 6d4: b6 01 movw r22, r12
- 6d6: 96 95 lsr r25
- 6d8: 87 95 ror r24
- 6da: 77 95 ror r23
- 6dc: 67 95 ror r22
- 6de: c9 d7 rcall .+3986 ; 0x1672 <__floatunsisf>
- 6e0: 20 e0 ldi r18, 0x00 ; 0
- 6e2: 34 e2 ldi r19, 0x24 ; 36
- 6e4: 44 ef ldi r20, 0xF4 ; 244
- 6e6: 59 e4 ldi r21, 0x49 ; 73
- 6e8: c8 d6 rcall .+3472 ; 0x147a <__addsf3>
- 6ea: 4b 01 movw r8, r22
- 6ec: 5c 01 movw r10, r24
- 6ee: c7 01 movw r24, r14
- 6f0: b6 01 movw r22, r12
- 6f2: bf d7 rcall .+3966 ; 0x1672 <__floatunsisf>
- 6f4: 9b 01 movw r18, r22
- 6f6: ac 01 movw r20, r24
- 6f8: c5 01 movw r24, r10
- 6fa: b4 01 movw r22, r8
- 6fc: 26 d7 rcall .+3660 ; 0x154a <__divsf3>
- 6fe: 20 e0 ldi r18, 0x00 ; 0
- 700: 30 e0 ldi r19, 0x00 ; 0
- 702: 40 e8 ldi r20, 0x80 ; 128
- 704: 5f e3 ldi r21, 0x3F ; 63
- 706: b8 d6 rcall .+3440 ; 0x1478 <__subsf3>
- 708: 88 d7 rcall .+3856 ; 0x161a <__fixunssfsi>
- 70a: 70 93 cd 00 sts 0x00CD, r23
- 70e: 60 93 cc 00 sts 0x00CC, r22
+ 764: c4 88 ldd r12, Z+20 ; 0x14
+ 766: d5 88 ldd r13, Z+21 ; 0x15
+ 768: e6 88 ldd r14, Z+22 ; 0x16
+ 76a: f7 88 ldd r15, Z+23 ; 0x17
+ 76c: c7 01 movw r24, r14
+ 76e: b6 01 movw r22, r12
+ 770: 96 95 lsr r25
+ 772: 87 95 ror r24
+ 774: 77 95 ror r23
+ 776: 67 95 ror r22
+ 778: 4b d7 rcall .+3734 ; 0x1610 <__floatunsisf>
+ 77a: 20 e0 ldi r18, 0x00 ; 0
+ 77c: 34 e2 ldi r19, 0x24 ; 36
+ 77e: 44 ef ldi r20, 0xF4 ; 244
+ 780: 59 e4 ldi r21, 0x49 ; 73
+ 782: 4a d6 rcall .+3220 ; 0x1418 <__addsf3>
+ 784: 4b 01 movw r8, r22
+ 786: 5c 01 movw r10, r24
+ 788: c7 01 movw r24, r14
+ 78a: b6 01 movw r22, r12
+ 78c: 41 d7 rcall .+3714 ; 0x1610 <__floatunsisf>
+ 78e: 9b 01 movw r18, r22
+ 790: ac 01 movw r20, r24
+ 792: c5 01 movw r24, r10
+ 794: b4 01 movw r22, r8
+ 796: a8 d6 rcall .+3408 ; 0x14e8 <__divsf3>
+ 798: 20 e0 ldi r18, 0x00 ; 0
+ 79a: 30 e0 ldi r19, 0x00 ; 0
+ 79c: 40 e8 ldi r20, 0x80 ; 128
+ 79e: 5f e3 ldi r21, 0x3F ; 63
+ 7a0: 3a d6 rcall .+3188 ; 0x1416 <__subsf3>
+ 7a2: 0a d7 rcall .+3604 ; 0x15b8 <__fixunssfsi>
+ 7a4: 70 93 cd 00 sts 0x00CD, r23
+ 7a8: 60 93 cc 00 sts 0x00CC, r22
/* Reconfigure the USART in double speed mode for a wider baud rate range at the expense of accuracy */
UCSR1C = ConfigMask;
- 712: 10 93 ca 00 sts 0x00CA, r17
+ 7ac: 10 93 ca 00 sts 0x00CA, r17
UCSR1A = (1 << U2X1);
- 716: 82 e0 ldi r24, 0x02 ; 2
- 718: 80 93 c8 00 sts 0x00C8, r24
+ 7b0: 82 e0 ldi r24, 0x02 ; 2
+ 7b2: 80 93 c8 00 sts 0x00C8, r24
UCSR1B = ((1 << RXCIE1) | (1 << TXEN1) | (1 << RXEN1));
- 71c: 88 e9 ldi r24, 0x98 ; 152
- 71e: 80 93 c9 00 sts 0x00C9, r24
+ 7b6: 88 e9 ldi r24, 0x98 ; 152
+ 7b8: 80 93 c9 00 sts 0x00C9, r24
}
- 722: 1f 91 pop r17
- 724: ff 90 pop r15
- 726: ef 90 pop r14
- 728: df 90 pop r13
- 72a: cf 90 pop r12
- 72c: bf 90 pop r11
- 72e: af 90 pop r10
- 730: 9f 90 pop r9
- 732: 8f 90 pop r8
- 734: 08 95 ret
+ 7bc: 1f 91 pop r17
+ 7be: ff 90 pop r15
+ 7c0: ef 90 pop r14
+ 7c2: df 90 pop r13
+ 7c4: cf 90 pop r12
+ 7c6: bf 90 pop r11
+ 7c8: af 90 pop r10
+ 7ca: 9f 90 pop r9
+ 7cc: 8f 90 pop r8
+ 7ce: 08 95 ret
-00000736 <uart_putc>:
+000007d0 <uart_putc>:
void uart_putc(unsigned char data)
{
- 736: 68 2f mov r22, r24
+ 7d0: 68 2f mov r22, r24
if (USB_DeviceState == DEVICE_STATE_Configured){
- 738: 8e b3 in r24, 0x1e ; 30
- 73a: 84 30 cpi r24, 0x04 ; 4
- 73c: 19 f4 brne .+6 ; 0x744 <uart_putc+0xe>
+ 7d2: 8e b3 in r24, 0x1e ; 30
+ 7d4: 84 30 cpi r24, 0x04 ; 4
+ 7d6: 19 f4 brne .+6 ; 0x7de <uart_putc+0xe>
RingBuffer_Insert(&USARTtoUSB_Buffer, data);
- 73e: 8e ec ldi r24, 0xCE ; 206
- 740: 91 e0 ldi r25, 0x01 ; 1
- 742: 16 cd rjmp .-1492 ; 0x170 <RingBuffer_Insert>
- 744: 08 95 ret
+ 7d8: 84 ed ldi r24, 0xD4 ; 212
+ 7da: 91 e0 ldi r25, 0x01 ; 1
+ 7dc: c9 cc rjmp .-1646 ; 0x170 <RingBuffer_Insert>
+ 7de: 08 95 ret
-00000746 <uart_puts>:
+000007e0 <uart_puts>:
}
}
void uart_puts(const char *s )
{
- 746: ef 92 push r14
- 748: ff 92 push r15
- 74a: cf 93 push r28
- 74c: df 93 push r29
- 74e: e8 2e mov r14, r24
- 750: e7 01 movw r28, r14
- 752: 7e 01 movw r14, r28
- 754: f9 2e mov r15, r25
- 756: e7 01 movw r28, r14
+ 7e0: ef 92 push r14
+ 7e2: ff 92 push r15
+ 7e4: cf 93 push r28
+ 7e6: df 93 push r29
+ 7e8: e8 2e mov r14, r24
+ 7ea: e7 01 movw r28, r14
+ 7ec: 7e 01 movw r14, r28
+ 7ee: f9 2e mov r15, r25
+ 7f0: e7 01 movw r28, r14
while (*s)
- 758: 01 c0 rjmp .+2 ; 0x75c <uart_puts+0x16>
+ 7f2: 01 c0 rjmp .+2 ; 0x7f6 <uart_puts+0x16>
uart_putc(*s++);
- 75a: ed df rcall .-38 ; 0x736 <uart_putc>
+ 7f4: ed df rcall .-38 ; 0x7d0 <uart_putc>
}
void uart_puts(const char *s )
{
while (*s)
- 75c: 89 91 ld r24, Y+
- 75e: 88 23 and r24, r24
- 760: e1 f7 brne .-8 ; 0x75a <uart_puts+0x14>
+ 7f6: 89 91 ld r24, Y+
+ 7f8: 88 23 and r24, r24
+ 7fa: e1 f7 brne .-8 ; 0x7f4 <uart_puts+0x14>
uart_putc(*s++);
}/* uart_puts */
- 762: df 91 pop r29
- 764: cf 91 pop r28
- 766: ff 90 pop r15
- 768: ef 90 pop r14
- 76a: 08 95 ret
-
-0000076c <my_uitoa>:
-
-
-// convert an unsigned integer to string
-void my_uitoa(uint32_t zahl, char* string, uint8_t no_digits) {
- 76c: 2f 92 push r2
- 76e: 3f 92 push r3
- 770: 4f 92 push r4
- 772: 5f 92 push r5
- 774: 6f 92 push r6
- 776: 7f 92 push r7
- 778: 8f 92 push r8
- 77a: 9f 92 push r9
- 77c: af 92 push r10
- 77e: bf 92 push r11
- 780: cf 92 push r12
- 782: df 92 push r13
- 784: ef 92 push r14
- 786: ff 92 push r15
- 788: 0f 93 push r16
- 78a: 1f 93 push r17
- 78c: cf 93 push r28
- 78e: df 93 push r29
- 790: 7b 01 movw r14, r22
- 792: 8c 01 movw r16, r24
- int8_t i; // schleifenzähler
-
- string[no_digits] = '\0'; // String Terminator
- 794: 82 2f mov r24, r18
- 796: 90 e0 ldi r25, 0x00 ; 0
- 798: fa 01 movw r30, r20
- 79a: e8 0f add r30, r24
- 79c: f9 1f adc r31, r25
- 79e: 10 82 st Z, r1
- for (i = (no_digits - 1); i >= 0; i--) {
- 7a0: d2 2e mov r13, r18
- 7a2: da 94 dec r13
-
-}/* uart_puts */
+ 7fc: df 91 pop r29
+ 7fe: cf 91 pop r28
+ 800: ff 90 pop r15
+ 802: ef 90 pop r14
+ 804: 08 95 ret
-
-// convert an unsigned integer to string
-void my_uitoa(uint32_t zahl, char* string, uint8_t no_digits) {
- 7a4: 4d 2c mov r4, r13
- 7a6: 55 24 eor r5, r5
- 7a8: 47 fc sbrc r4, 7
- 7aa: 50 94 com r5
- 7ac: ea 01 movw r28, r20
- 7ae: c4 0d add r28, r4
- 7b0: d5 1d adc r29, r5
- int8_t i; // schleifenzähler
-
- string[no_digits] = '\0'; // String Terminator
- for (i = (no_digits - 1); i >= 0; i--) {
- 7b2: aa 24 eor r10, r10
- 7b4: bb 24 eor r11, r11
- if (zahl == 0 && i < (no_digits - 1)) {
- string[i] = ' ';
- } else {
- string[i] = (zahl % 10) + '0';
- 7b6: ba e0 ldi r27, 0x0A ; 10
- 7b8: 6b 2e mov r6, r27
- 7ba: 71 2c mov r7, r1
- 7bc: 81 2c mov r8, r1
- 7be: 91 2c mov r9, r1
-void my_uitoa(uint32_t zahl, char* string, uint8_t no_digits) {
- int8_t i; // schleifenzähler
-
- string[no_digits] = '\0'; // String Terminator
- for (i = (no_digits - 1); i >= 0; i--) {
- if (zahl == 0 && i < (no_digits - 1)) {
- 7c0: 1c 01 movw r2, r24
- 7c2: 08 94 sec
- 7c4: 21 08 sbc r2, r1
- 7c6: 31 08 sbc r3, r1
- string[i] = ' ';
- 7c8: a0 e2 ldi r26, 0x20 ; 32
- 7ca: ca 2e mov r12, r26
-// convert an unsigned integer to string
-void my_uitoa(uint32_t zahl, char* string, uint8_t no_digits) {
- int8_t i; // schleifenzähler
-
- string[no_digits] = '\0'; // String Terminator
- for (i = (no_digits - 1); i >= 0; i--) {
- 7cc: 20 c0 rjmp .+64 ; 0x80e <my_uitoa+0xa2>
- if (zahl == 0 && i < (no_digits - 1)) {
- 7ce: e1 14 cp r14, r1
- 7d0: f1 04 cpc r15, r1
- 7d2: 01 05 cpc r16, r1
- 7d4: 11 05 cpc r17, r1
- 7d6: 41 f4 brne .+16 ; 0x7e8 <my_uitoa+0x7c>
-
-}/* uart_puts */
-
-
-// convert an unsigned integer to string
-void my_uitoa(uint32_t zahl, char* string, uint8_t no_digits) {
- 7d8: c5 01 movw r24, r10
- 7da: 84 0d add r24, r4
- 7dc: 95 1d adc r25, r5
- int8_t i; // schleifenzähler
-
- string[no_digits] = '\0'; // String Terminator
- for (i = (no_digits - 1); i >= 0; i--) {
- if (zahl == 0 && i < (no_digits - 1)) {
- 7de: 82 15 cp r24, r2
- 7e0: 93 05 cpc r25, r3
- 7e2: 14 f4 brge .+4 ; 0x7e8 <my_uitoa+0x7c>
- string[i] = ' ';
- 7e4: c8 82 st Y, r12
- 7e6: 07 c0 rjmp .+14 ; 0x7f6 <my_uitoa+0x8a>
- } else {
- string[i] = (zahl % 10) + '0';
- 7e8: c8 01 movw r24, r16
- 7ea: b7 01 movw r22, r14
- 7ec: a4 01 movw r20, r8
- 7ee: 93 01 movw r18, r6
- 7f0: f6 d7 rcall .+4076 ; 0x17de <__udivmodsi4>
- 7f2: 60 5d subi r22, 0xD0 ; 208
- 7f4: 68 83 st Y, r22
- } // Modulo rechnen, dann den ASCII-Code von '0' addieren
- zahl /= 10;
- 7f6: c8 01 movw r24, r16
- 7f8: b7 01 movw r22, r14
- 7fa: a4 01 movw r20, r8
- 7fc: 93 01 movw r18, r6
- 7fe: ef d7 rcall .+4062 ; 0x17de <__udivmodsi4>
- 800: 79 01 movw r14, r18
- 802: 8a 01 movw r16, r20
-// convert an unsigned integer to string
-void my_uitoa(uint32_t zahl, char* string, uint8_t no_digits) {
- int8_t i; // schleifenzähler
-
- string[no_digits] = '\0'; // String Terminator
- for (i = (no_digits - 1); i >= 0; i--) {
- 804: da 94 dec r13
- 806: 21 97 sbiw r28, 0x01 ; 1
- 808: 08 94 sec
- 80a: a1 08 sbc r10, r1
- 80c: b1 08 sbc r11, r1
- 80e: d7 fe sbrs r13, 7
- 810: de cf rjmp .-68 ; 0x7ce <my_uitoa+0x62>
- string[i] = (zahl % 10) + '0';
- } // Modulo rechnen, dann den ASCII-Code von '0' addieren
- zahl /= 10;
- }
-
-}
- 812: df 91 pop r29
- 814: cf 91 pop r28
- 816: 1f 91 pop r17
- 818: 0f 91 pop r16
- 81a: ff 90 pop r15
- 81c: ef 90 pop r14
- 81e: df 90 pop r13
- 820: cf 90 pop r12
- 822: bf 90 pop r11
- 824: af 90 pop r10
- 826: 9f 90 pop r9
- 828: 8f 90 pop r8
- 82a: 7f 90 pop r7
- 82c: 6f 90 pop r6
- 82e: 5f 90 pop r5
- 830: 4f 90 pop r4
- 832: 3f 90 pop r3
- 834: 2f 90 pop r2
- 836: 08 95 ret
-
-00000838 <main>:
+00000806 <main>:
/** Main program entry point. This routine contains the overall program flow, including initial
* setup of all components and the main program loop.
*/
int main(void)
{
- 838: ff 92 push r15
- 83a: 0f 93 push r16
- 83c: 1f 93 push r17
- 83e: df 93 push r29
- 840: cf 93 push r28
- 842: cd b7 in r28, 0x3d ; 61
- 844: de b7 in r29, 0x3e ; 62
- 846: 60 97 sbiw r28, 0x10 ; 16
- 848: 0f b6 in r0, 0x3f ; 63
- 84a: f8 94 cli
- 84c: de bf out 0x3e, r29 ; 62
- 84e: 0f be out 0x3f, r0 ; 63
- 850: cd bf out 0x3d, r28 ; 61
+ 806: cf 93 push r28
+ 808: df 93 push r29
char dummy;
uint8_t field_val = 0;
SetupHardware();
- 852: ca de rcall .-620 ; 0x5e8 <SetupHardware>
+ 80a: 3b df rcall .-394 ; 0x682 <SetupHardware>
RingBuffer_InitBuffer(&USBtoUSART_Buffer, USBtoUSART_Buffer_Data, sizeof(USBtoUSART_Buffer_Data));
- 854: 82 e4 ldi r24, 0x42 ; 66
- 856: 91 e0 ldi r25, 0x01 ; 1
- 858: 6e e4 ldi r22, 0x4E ; 78
- 85a: 71 e0 ldi r23, 0x01 ; 1
- 85c: bd dc rcall .-1670 ; 0x1d8 <RingBuffer_InitBuffer.clone.0>
+ 80c: 88 e4 ldi r24, 0x48 ; 72
+ 80e: 91 e0 ldi r25, 0x01 ; 1
+ 810: 64 e5 ldi r22, 0x54 ; 84
+ 812: 71 e0 ldi r23, 0x01 ; 1
+ 814: e1 dc rcall .-1598 ; 0x1d8 <RingBuffer_InitBuffer.clone.0>
RingBuffer_InitBuffer(&USARTtoUSB_Buffer, USARTtoUSB_Buffer_Data, sizeof(USARTtoUSB_Buffer_Data));
- 85e: 8e ec ldi r24, 0xCE ; 206
- 860: 91 e0 ldi r25, 0x01 ; 1
- 862: 6a ed ldi r22, 0xDA ; 218
- 864: 71 e0 ldi r23, 0x01 ; 1
- 866: b8 dc rcall .-1680 ; 0x1d8 <RingBuffer_InitBuffer.clone.0>
+ 816: 84 ed ldi r24, 0xD4 ; 212
+ 818: 91 e0 ldi r25, 0x01 ; 1
+ 81a: 60 ee ldi r22, 0xE0 ; 224
+ 81c: 71 e0 ldi r23, 0x01 ; 1
+ 81e: dc dc rcall .-1608 ; 0x1d8 <RingBuffer_InitBuffer.clone.0>
static inline void GlobalInterruptEnable(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
sei();
- 868: 78 94 sei
+ 820: 78 94 sei
// LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
GlobalInterruptEnable();
touchpad_init(); // you need to call this to setup the I/O pin!
- 86a: f8 dd rcall .-1040 ; 0x45c <touchpad_init>
- #else
- //round up by default
- __ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
- #endif
-
- __builtin_avr_delay_cycles(__ticks_dc);
- 86c: 8f ef ldi r24, 0xFF ; 255
- 86e: 99 e6 ldi r25, 0x69 ; 105
- 870: a8 e1 ldi r26, 0x18 ; 24
- 872: 81 50 subi r24, 0x01 ; 1
- 874: 90 40 sbci r25, 0x00 ; 0
- 876: a0 40 sbci r26, 0x00 ; 0
- 878: e1 f7 brne .-8 ; 0x872 <main+0x3a>
- 87a: 00 c0 rjmp .+0 ; 0x87c <main+0x44>
- 87c: 00 00 nop
+ 822: 1c de rcall .-968 ; 0x45c <touchpad_init>
+ 824: 8f ef ldi r24, 0xFF ; 255
+ 826: 99 e6 ldi r25, 0x69 ; 105
+ 828: a8 e1 ldi r26, 0x18 ; 24
+ 82a: 81 50 subi r24, 0x01 ; 1
+ 82c: 90 40 sbci r25, 0x00 ; 0
+ 82e: a0 40 sbci r26, 0x00 ; 0
+ 830: e1 f7 brne .-8 ; 0x82a <main+0x24>
+ 832: 00 c0 rjmp .+0 ; 0x834 <main+0x2e>
+ 834: 00 00 nop
_delay_ms(500);
sei();
- 87e: 78 94 sei
-// // end of keypad mode demo block
-//
-// #elif DEMO_MODE == ABSOLUTE_MODE
- // begin of keypad mode demo block
-// uart_puts("you selected the absolute position demo modus:\n\r");
- touchpad_set_abs_mode();// tell the touchpad you want to use it in the "absolute mode"
- 880: fe dd rcall .-1028 ; 0x47e <touchpad_set_abs_mode>
- 882: 8f ef ldi r24, 0xFF ; 255
- 884: 99 e6 ldi r25, 0x69 ; 105
- 886: a8 e1 ldi r26, 0x18 ; 24
- 888: 81 50 subi r24, 0x01 ; 1
- 88a: 90 40 sbci r25, 0x00 ; 0
- 88c: a0 40 sbci r26, 0x00 ; 0
- 88e: e1 f7 brne .-8 ; 0x888 <main+0x50>
- 890: 00 c0 rjmp .+0 ; 0x892 <main+0x5a>
- 892: 00 00 nop
-// _delay_ms(1000);
-
-
-// end
-
- uint8_t loopcounter=0;
- 894: ff 24 eor r15, r15
- continue;
- }
+ 836: 78 94 sei
+ // -------------------------
+ // | left | down | right |
+ // -------------------------
- touchpad_read(); // read data from the touchpad
- uart_puts("x_pos: ");
- my_uitoa(x_abs(),stringbuffer,4);// x_abs returns current x position of your finger
- 896: 8e 01 movw r16, r28
- 898: 0f 5f subi r16, 0xFF ; 255
- 89a: 1f 4f sbci r17, 0xFF ; 255
-// uart_puts("you selected the absolute position demo modus:\n\r");
- touchpad_set_abs_mode();// tell the touchpad you want to use it in the "absolute mode"
- _delay_ms(500);
- while (1) {
+// uart_puts("you selected the keypad demo modus:\n\r");
+ touchpad_set_abs_mode(); // keypad functionality uses the "absolute mode"
+ 838: 22 de rcall .-956 ; 0x47e <touchpad_set_abs_mode>
+/** Main program entry point. This routine contains the overall program flow, including initial
+ * setup of all components and the main program loop.
+ */
+int main(void)
+{
+ 83a: c0 e0 ldi r28, 0x00 ; 0
+ 83c: d0 e0 ldi r29, 0x00 ; 0
+// uart_puts("you selected the keypad demo modus:\n\r");
+ touchpad_set_abs_mode(); // keypad functionality uses the "absolute mode"
+ while (1) {
+
+
Usb2SerialTask();
- 89c: 4c de rcall .-872 ; 0x536 <Usb2SerialTask>
+ 83e: c8 de rcall .-624 ; 0x5d0 <Usb2SerialTask>
loopcounter++;
- 89e: f3 94 inc r15
- if(loopcounter) {
- 8a0: e9 f7 brne .-6 ; 0x89c <main+0x64>
+ 840: 21 96 adiw r28, 0x01 ; 1
+ if(loopcounter<2000) {
+ 842: 97 e0 ldi r25, 0x07 ; 7
+ 844: c0 3d cpi r28, 0xD0 ; 208
+ 846: d9 07 cpc r29, r25
+ 848: d1 f7 brne .-12 ; 0x83e <main+0x38>
continue;
}
-
- touchpad_read(); // read data from the touchpad
- 8a2: e4 dd rcall .-1080 ; 0x46c <touchpad_read>
- uart_puts("x_pos: ");
- 8a4: 80 e0 ldi r24, 0x00 ; 0
- 8a6: 91 e0 ldi r25, 0x01 ; 1
- 8a8: 4e df rcall .-356 ; 0x746 <uart_puts>
- my_uitoa(x_abs(),stringbuffer,4);// x_abs returns current x position of your finger
- 8aa: 08 de rcall .-1008 ; 0x4bc <x_abs>
- 8ac: bc 01 movw r22, r24
- 8ae: 80 e0 ldi r24, 0x00 ; 0
- 8b0: 90 e0 ldi r25, 0x00 ; 0
- 8b2: a8 01 movw r20, r16
- 8b4: 24 e0 ldi r18, 0x04 ; 4
- 8b6: 5a df rcall .-332 ; 0x76c <my_uitoa>
- uart_puts(stringbuffer);
- 8b8: c8 01 movw r24, r16
- 8ba: 45 df rcall .-374 ; 0x746 <uart_puts>
- uart_puts(" y_pos: ");
- 8bc: 88 e0 ldi r24, 0x08 ; 8
- 8be: 91 e0 ldi r25, 0x01 ; 1
- 8c0: 42 df rcall .-380 ; 0x746 <uart_puts>
- my_uitoa(y_abs(),stringbuffer,4);// y_abs returns current y position of your finger
- 8c2: 1a de rcall .-972 ; 0x4f8 <y_abs>
- 8c4: bc 01 movw r22, r24
- 8c6: 80 e0 ldi r24, 0x00 ; 0
- 8c8: 90 e0 ldi r25, 0x00 ; 0
- 8ca: a8 01 movw r20, r16
- 8cc: 24 e0 ldi r18, 0x04 ; 4
- 8ce: 4e df rcall .-356 ; 0x76c <my_uitoa>
- uart_puts(stringbuffer);
- 8d0: c8 01 movw r24, r16
- 8d2: 39 df rcall .-398 ; 0x746 <uart_puts>
- uart_puts(" z_pressure: ");// z_pressure returns current "pressure" (contact area) of your finger
- 8d4: 83 e1 ldi r24, 0x13 ; 19
- 8d6: 91 e0 ldi r25, 0x01 ; 1
- 8d8: 36 df rcall .-404 ; 0x746 <uart_puts>
- my_uitoa(z_pressure(),stringbuffer,4);
- 8da: e5 dd rcall .-1078 ; 0x4a6 <z_pressure>
- 8dc: 68 2f mov r22, r24
- 8de: 70 e0 ldi r23, 0x00 ; 0
- 8e0: 80 e0 ldi r24, 0x00 ; 0
- 8e2: 90 e0 ldi r25, 0x00 ; 0
- 8e4: a8 01 movw r20, r16
- 8e6: 24 e0 ldi r18, 0x04 ; 4
- 8e8: 41 df rcall .-382 ; 0x76c <my_uitoa>
- uart_puts(stringbuffer);
- 8ea: c8 01 movw r24, r16
- 8ec: 2c df rcall .-424 ; 0x746 <uart_puts>
- uart_puts("\r");
- 8ee: 83 e2 ldi r24, 0x23 ; 35
- 8f0: 91 e0 ldi r25, 0x01 ; 1
- 8f2: 29 df rcall .-430 ; 0x746 <uart_puts>
- 8f4: d3 cf rjmp .-90 ; 0x89c <main+0x64>
-
-000008f6 <CALLBACK_USB_GetDescriptor>:
+ loopcounter=0;
+
+ touchpad_read(); // read values from the touchpad
+ 84a: 10 de rcall .-992 ; 0x46c <touchpad_read>
+
+ field_val = decode_field(); // decode_field returns the number of the
+ 84c: 7e de rcall .-772 ; 0x54a <decode_field>
+ // touch button that was pressed last. or zero if nothing happened
+
+ switch (field_val) {
+ 84e: 83 30 cpi r24, 0x03 ; 3
+ 850: e9 f0 breq .+58 ; 0x88c <main+0x86>
+ 852: 84 30 cpi r24, 0x04 ; 4
+ 854: 28 f4 brcc .+10 ; 0x860 <main+0x5a>
+ 856: 81 30 cpi r24, 0x01 ; 1
+ 858: b1 f0 breq .+44 ; 0x886 <main+0x80>
+ 85a: 82 30 cpi r24, 0x02 ; 2
+ 85c: 71 f7 brne .-36 ; 0x83a <main+0x34>
+ 85e: 0d c0 rjmp .+26 ; 0x87a <main+0x74>
+ 860: 85 30 cpi r24, 0x05 ; 5
+ 862: 71 f0 breq .+28 ; 0x880 <main+0x7a>
+ 864: 85 30 cpi r24, 0x05 ; 5
+ 866: 18 f0 brcs .+6 ; 0x86e <main+0x68>
+ 868: 86 30 cpi r24, 0x06 ; 6
+ 86a: 39 f7 brne .-50 ; 0x83a <main+0x34>
+ 86c: 03 c0 rjmp .+6 ; 0x874 <main+0x6e>
+
+ case 4:
+ uart_puts("left\n\r");
+ 86e: 80 e0 ldi r24, 0x00 ; 0
+ 870: 91 e0 ldi r25, 0x01 ; 1
+ 872: 0e c0 rjmp .+28 ; 0x890 <main+0x8a>
+ break;
+ case 6:
+ uart_puts("right\n\r");
+ 874: 87 e0 ldi r24, 0x07 ; 7
+ 876: 91 e0 ldi r25, 0x01 ; 1
+ 878: 0b c0 rjmp .+22 ; 0x890 <main+0x8a>
+ break;
+ case 2:
+ uart_puts("up\n\r");
+ 87a: 8f e0 ldi r24, 0x0F ; 15
+ 87c: 91 e0 ldi r25, 0x01 ; 1
+ 87e: 08 c0 rjmp .+16 ; 0x890 <main+0x8a>
+ break;
+ case 5:
+ uart_puts("down\n\r");
+ 880: 84 e1 ldi r24, 0x14 ; 20
+ 882: 91 e0 ldi r25, 0x01 ; 1
+ 884: 05 c0 rjmp .+10 ; 0x890 <main+0x8a>
+ break;
+ case 1:
+ uart_puts("back\n\r");
+ 886: 8b e1 ldi r24, 0x1B ; 27
+ 888: 91 e0 ldi r25, 0x01 ; 1
+ 88a: 02 c0 rjmp .+4 ; 0x890 <main+0x8a>
+ break;
+ case 3:
+ uart_puts("enter\n\r");
+ 88c: 82 e2 ldi r24, 0x22 ; 34
+ 88e: 91 e0 ldi r25, 0x01 ; 1
+ 890: a7 df rcall .-178 ; 0x7e0 <uart_puts>
+ 892: d3 cf rjmp .-90 ; 0x83a <main+0x34>
+
+00000894 <CALLBACK_USB_GetDescriptor>:
const uint8_t DescriptorNumber = (wValue & 0xFF);
const void* Address = NULL;
uint16_t Size = NO_DESCRIPTOR;
switch (DescriptorType)
- 8f6: 92 30 cpi r25, 0x02 ; 2
- 8f8: 29 f0 breq .+10 ; 0x904 <CALLBACK_USB_GetDescriptor+0xe>
- 8fa: 93 30 cpi r25, 0x03 ; 3
- 8fc: 41 f0 breq .+16 ; 0x90e <CALLBACK_USB_GetDescriptor+0x18>
- 8fe: 91 30 cpi r25, 0x01 ; 1
- 900: e9 f4 brne .+58 ; 0x93c <CALLBACK_USB_GetDescriptor+0x46>
- 902: 17 c0 rjmp .+46 ; 0x932 <CALLBACK_USB_GetDescriptor+0x3c>
+ 894: 92 30 cpi r25, 0x02 ; 2
+ 896: 29 f0 breq .+10 ; 0x8a2 <CALLBACK_USB_GetDescriptor+0xe>
+ 898: 93 30 cpi r25, 0x03 ; 3
+ 89a: 41 f0 breq .+16 ; 0x8ac <CALLBACK_USB_GetDescriptor+0x18>
+ 89c: 91 30 cpi r25, 0x01 ; 1
+ 89e: e9 f4 brne .+58 ; 0x8da <CALLBACK_USB_GetDescriptor+0x46>
+ 8a0: 17 c0 rjmp .+46 ; 0x8d0 <CALLBACK_USB_GetDescriptor+0x3c>
Address = &DeviceDescriptor;
Size = sizeof(USB_Descriptor_Device_t);
break;
case DTYPE_Configuration:
Address = &ConfigurationDescriptor;
Size = sizeof(USB_Descriptor_Configuration_t);
- 904: 2e e3 ldi r18, 0x3E ; 62
- 906: 30 e0 ldi r19, 0x00 ; 0
+ 8a2: 2e e3 ldi r18, 0x3E ; 62
+ 8a4: 30 e0 ldi r19, 0x00 ; 0
case DTYPE_Device:
Address = &DeviceDescriptor;
Size = sizeof(USB_Descriptor_Device_t);
break;
case DTYPE_Configuration:
Address = &ConfigurationDescriptor;
- 908: ea ea ldi r30, 0xAA ; 170
- 90a: f0 e0 ldi r31, 0x00 ; 0
+ 8a6: ea ea ldi r30, 0xAA ; 170
+ 8a8: f0 e0 ldi r31, 0x00 ; 0
Size = sizeof(USB_Descriptor_Configuration_t);
break;
- 90c: 1b c0 rjmp .+54 ; 0x944 <CALLBACK_USB_GetDescriptor+0x4e>
+ 8aa: 1b c0 rjmp .+54 ; 0x8e2 <CALLBACK_USB_GetDescriptor+0x4e>
case DTYPE_String:
switch (DescriptorNumber)
- 90e: 81 30 cpi r24, 0x01 ; 1
- 910: 41 f0 breq .+16 ; 0x922 <CALLBACK_USB_GetDescriptor+0x2c>
- 912: 81 30 cpi r24, 0x01 ; 1
- 914: 18 f0 brcs .+6 ; 0x91c <CALLBACK_USB_GetDescriptor+0x26>
- 916: 82 30 cpi r24, 0x02 ; 2
- 918: 89 f4 brne .+34 ; 0x93c <CALLBACK_USB_GetDescriptor+0x46>
- 91a: 06 c0 rjmp .+12 ; 0x928 <CALLBACK_USB_GetDescriptor+0x32>
+ 8ac: 81 30 cpi r24, 0x01 ; 1
+ 8ae: 41 f0 breq .+16 ; 0x8c0 <CALLBACK_USB_GetDescriptor+0x2c>
+ 8b0: 81 30 cpi r24, 0x01 ; 1
+ 8b2: 18 f0 brcs .+6 ; 0x8ba <CALLBACK_USB_GetDescriptor+0x26>
+ 8b4: 82 30 cpi r24, 0x02 ; 2
+ 8b6: 89 f4 brne .+34 ; 0x8da <CALLBACK_USB_GetDescriptor+0x46>
+ 8b8: 06 c0 rjmp .+12 ; 0x8c6 <CALLBACK_USB_GetDescriptor+0x32>
{
case 0x00:
Address = &LanguageString;
Size = pgm_read_byte(&LanguageString.Header.Size);
- 91c: e8 ee ldi r30, 0xE8 ; 232
- 91e: f0 e0 ldi r31, 0x00 ; 0
- 920: 05 c0 rjmp .+10 ; 0x92c <CALLBACK_USB_GetDescriptor+0x36>
+ 8ba: e8 ee ldi r30, 0xE8 ; 232
+ 8bc: f0 e0 ldi r31, 0x00 ; 0
+ 8be: 05 c0 rjmp .+10 ; 0x8ca <CALLBACK_USB_GetDescriptor+0x36>
break;
case 0x01:
Address = &ManufacturerString;
Size = pgm_read_byte(&ManufacturerString.Header.Size);
- 922: ec ee ldi r30, 0xEC ; 236
- 924: f0 e0 ldi r31, 0x00 ; 0
- 926: 02 c0 rjmp .+4 ; 0x92c <CALLBACK_USB_GetDescriptor+0x36>
+ 8c0: ec ee ldi r30, 0xEC ; 236
+ 8c2: f0 e0 ldi r31, 0x00 ; 0
+ 8c4: 02 c0 rjmp .+4 ; 0x8ca <CALLBACK_USB_GetDescriptor+0x36>
break;
case 0x02:
Address = &ProductString;
Size = pgm_read_byte(&ProductString.Header.Size);
- 928: e6 e0 ldi r30, 0x06 ; 6
- 92a: f1 e0 ldi r31, 0x01 ; 1
- 92c: 24 91 lpm r18, Z+
- 92e: 30 e0 ldi r19, 0x00 ; 0
+ 8c6: e6 e0 ldi r30, 0x06 ; 6
+ 8c8: f1 e0 ldi r31, 0x01 ; 1
+ 8ca: 24 91 lpm r18, Z+
+ 8cc: 30 e0 ldi r19, 0x00 ; 0
break;
- 930: 09 c0 rjmp .+18 ; 0x944 <CALLBACK_USB_GetDescriptor+0x4e>
+ 8ce: 09 c0 rjmp .+18 ; 0x8e2 <CALLBACK_USB_GetDescriptor+0x4e>
switch (DescriptorType)
{
case DTYPE_Device:
Address = &DeviceDescriptor;
Size = sizeof(USB_Descriptor_Device_t);
- 932: 22 e1 ldi r18, 0x12 ; 18
- 934: 30 e0 ldi r19, 0x00 ; 0
+ 8d0: 22 e1 ldi r18, 0x12 ; 18
+ 8d2: 30 e0 ldi r19, 0x00 ; 0
uint16_t Size = NO_DESCRIPTOR;
switch (DescriptorType)
{
case DTYPE_Device:
Address = &DeviceDescriptor;
- 936: e8 e9 ldi r30, 0x98 ; 152
- 938: f0 e0 ldi r31, 0x00 ; 0
- 93a: 04 c0 rjmp .+8 ; 0x944 <CALLBACK_USB_GetDescriptor+0x4e>
+ 8d4: e8 e9 ldi r30, 0x98 ; 152
+ 8d6: f0 e0 ldi r31, 0x00 ; 0
+ 8d8: 04 c0 rjmp .+8 ; 0x8e2 <CALLBACK_USB_GetDescriptor+0x4e>
{
const uint8_t DescriptorType = (wValue >> 8);
const uint8_t DescriptorNumber = (wValue & 0xFF);
const void* Address = NULL;
uint16_t Size = NO_DESCRIPTOR;
- 93c: 20 e0 ldi r18, 0x00 ; 0
- 93e: 30 e0 ldi r19, 0x00 ; 0
+ 8da: 20 e0 ldi r18, 0x00 ; 0
+ 8dc: 30 e0 ldi r19, 0x00 ; 0
const void** const DescriptorAddress)
{
const uint8_t DescriptorType = (wValue >> 8);
const uint8_t DescriptorNumber = (wValue & 0xFF);
const void* Address = NULL;
- 940: e0 e0 ldi r30, 0x00 ; 0
- 942: f0 e0 ldi r31, 0x00 ; 0
+ 8de: e0 e0 ldi r30, 0x00 ; 0
+ 8e0: f0 e0 ldi r31, 0x00 ; 0
}
break;
}
*DescriptorAddress = Address;
- 944: da 01 movw r26, r20
- 946: 11 96 adiw r26, 0x01 ; 1
- 948: fc 93 st X, r31
- 94a: ee 93 st -X, r30
+ 8e2: da 01 movw r26, r20
+ 8e4: 11 96 adiw r26, 0x01 ; 1
+ 8e6: fc 93 st X, r31
+ 8e8: ee 93 st -X, r30
return Size;
}
- 94c: c9 01 movw r24, r18
- 94e: 08 95 ret
+ 8ea: c9 01 movw r24, r18
+ 8ec: 08 95 ret
-00000950 <Endpoint_Write_Control_Stream_LE>:
+000008ee <Endpoint_Write_Control_Stream_LE>:
#if defined(TEMPLATE_FUNC_NAME)
uint8_t TEMPLATE_FUNC_NAME (const void* const Buffer,
uint16_t Length)
{
uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length));
- 950: 28 2f mov r18, r24
- 952: 39 2f mov r19, r25
- 954: f9 01 movw r30, r18
+ 8ee: 28 2f mov r18, r24
+ 8f0: 39 2f mov r19, r25
+ 8f2: f9 01 movw r30, r18
bool LastPacketFull = false;
if (Length > USB_ControlRequest.wLength)
- 956: 80 91 74 02 lds r24, 0x0274
- 95a: 90 91 75 02 lds r25, 0x0275
- 95e: 86 17 cp r24, r22
- 960: 97 07 cpc r25, r23
- 962: 18 f4 brcc .+6 ; 0x96a <Endpoint_Write_Control_Stream_LE+0x1a>
- 964: bc 01 movw r22, r24
- 966: 20 e0 ldi r18, 0x00 ; 0
- 968: 34 c0 rjmp .+104 ; 0x9d2 <Endpoint_Write_Control_Stream_LE+0x82>
+ 8f4: 80 91 7a 02 lds r24, 0x027A
+ 8f8: 90 91 7b 02 lds r25, 0x027B
+ 8fc: 86 17 cp r24, r22
+ 8fe: 97 07 cpc r25, r23
+ 900: 18 f4 brcc .+6 ; 0x908 <Endpoint_Write_Control_Stream_LE+0x1a>
+ 902: bc 01 movw r22, r24
+ 904: 20 e0 ldi r18, 0x00 ; 0
+ 906: 34 c0 rjmp .+104 ; 0x970 <Endpoint_Write_Control_Stream_LE+0x82>
Length = USB_ControlRequest.wLength;
else if (!(Length))
- 96a: 61 15 cp r22, r1
- 96c: 71 05 cpc r23, r1
- 96e: d9 f7 brne .-10 ; 0x966 <Endpoint_Write_Control_Stream_LE+0x16>
+ 908: 61 15 cp r22, r1
+ 90a: 71 05 cpc r23, r1
+ 90c: d9 f7 brne .-10 ; 0x904 <Endpoint_Write_Control_Stream_LE+0x16>
*/
static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearIN(void)
{
#if !defined(CONTROL_ONLY_DEVICE)
UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
- 970: 80 91 e8 00 lds r24, 0x00E8
- 974: 8e 77 andi r24, 0x7E ; 126
- 976: 80 93 e8 00 sts 0x00E8, r24
- 97a: f5 cf rjmp .-22 ; 0x966 <Endpoint_Write_Control_Stream_LE+0x16>
+ 90e: 80 91 e8 00 lds r24, 0x00E8
+ 912: 8e 77 andi r24, 0x7E ; 126
+ 914: 80 93 e8 00 sts 0x00E8, r24
+ 918: f5 cf rjmp .-22 ; 0x904 <Endpoint_Write_Control_Stream_LE+0x16>
Endpoint_ClearIN();
while (Length || LastPacketFull)
{
uint8_t USB_DeviceState_LCL = USB_DeviceState;
- 97c: 8e b3 in r24, 0x1e ; 30
+ 91a: 8e b3 in r24, 0x1e ; 30
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
- 97e: 88 23 and r24, r24
- 980: e9 f1 breq .+122 ; 0x9fc <Endpoint_Write_Control_Stream_LE+0xac>
+ 91c: 88 23 and r24, r24
+ 91e: e9 f1 breq .+122 ; 0x99a <Endpoint_Write_Control_Stream_LE+0xac>
return ENDPOINT_RWCSTREAM_DeviceDisconnected;
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
- 982: 85 30 cpi r24, 0x05 ; 5
- 984: b9 f1 breq .+110 ; 0x9f4 <Endpoint_Write_Control_Stream_LE+0xa4>
+ 920: 85 30 cpi r24, 0x05 ; 5
+ 922: b9 f1 breq .+110 ; 0x992 <Endpoint_Write_Control_Stream_LE+0xa4>
* \return Boolean \c true if the selected endpoint has received a SETUP packet, \c false otherwise.
*/
static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsSETUPReceived(void)
{
return ((UEINTX & (1 << RXSTPI)) ? true : false);
- 986: 80 91 e8 00 lds r24, 0x00E8
+ 924: 80 91 e8 00 lds r24, 0x00E8
return ENDPOINT_RWCSTREAM_BusSuspended;
else if (Endpoint_IsSETUPReceived())
- 98a: 83 fd sbrc r24, 3
- 98c: 35 c0 rjmp .+106 ; 0x9f8 <Endpoint_Write_Control_Stream_LE+0xa8>
+ 928: 83 fd sbrc r24, 3
+ 92a: 35 c0 rjmp .+106 ; 0x996 <Endpoint_Write_Control_Stream_LE+0xa8>
* \return Boolean \c true if current endpoint is has received an OUT packet, \c false otherwise.
*/
static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsOUTReceived(void)
{
return ((UEINTX & (1 << RXOUTI)) ? true : false);
- 98e: 80 91 e8 00 lds r24, 0x00E8
+ 92c: 80 91 e8 00 lds r24, 0x00E8
return ENDPOINT_RWCSTREAM_HostAborted;
else if (Endpoint_IsOUTReceived())
- 992: 82 fd sbrc r24, 2
- 994: 29 c0 rjmp .+82 ; 0x9e8 <Endpoint_Write_Control_Stream_LE+0x98>
+ 930: 82 fd sbrc r24, 2
+ 932: 29 c0 rjmp .+82 ; 0x986 <Endpoint_Write_Control_Stream_LE+0x98>
* \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
*/
static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsINReady(void)
{
return ((UEINTX & (1 << TXINI)) ? true : false);
- 996: 80 91 e8 00 lds r24, 0x00E8
+ 934: 80 91 e8 00 lds r24, 0x00E8
break;
if (Endpoint_IsINReady())
- 99a: 80 ff sbrs r24, 0
- 99c: 1a c0 rjmp .+52 ; 0x9d2 <Endpoint_Write_Control_Stream_LE+0x82>
+ 938: 80 ff sbrs r24, 0
+ 93a: 1a c0 rjmp .+52 ; 0x970 <Endpoint_Write_Control_Stream_LE+0x82>
#if (defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
return UEBCX;
#elif defined(USB_SERIES_4_AVR)
return (((uint16_t)UEBCHX << 8) | UEBCLX);
#elif defined(USB_SERIES_2_AVR)
return UEBCLX;
- 99e: 80 91 f2 00 lds r24, 0x00F2
- 9a2: 90 e0 ldi r25, 0x00 ; 0
+ 93c: 80 91 f2 00 lds r24, 0x00F2
+ 940: 90 e0 ldi r25, 0x00 ; 0
{
uint16_t BytesInEndpoint = Endpoint_BytesInEndpoint();
while (Length && (BytesInEndpoint < USB_Device_ControlEndpointSize))
- 9a4: 06 c0 rjmp .+12 ; 0x9b2 <Endpoint_Write_Control_Stream_LE+0x62>
+ 942: 06 c0 rjmp .+12 ; 0x950 <Endpoint_Write_Control_Stream_LE+0x62>
{
TEMPLATE_TRANSFER_BYTE(DataStream);
- 9a6: 21 91 ld r18, Z+
+ 944: 21 91 ld r18, Z+
* \param[in] Data Data to write into the the currently selected endpoint's FIFO buffer.
*/
static inline void Endpoint_Write_8(const uint8_t Data) ATTR_ALWAYS_INLINE;
static inline void Endpoint_Write_8(const uint8_t Data)
{
UEDATX = Data;
- 9a8: 20 93 f1 00 sts 0x00F1, r18
+ 946: 20 93 f1 00 sts 0x00F1, r18
TEMPLATE_BUFFER_MOVE(DataStream, 1);
Length--;
- 9ac: 61 50 subi r22, 0x01 ; 1
- 9ae: 70 40 sbci r23, 0x00 ; 0
+ 94a: 61 50 subi r22, 0x01 ; 1
+ 94c: 70 40 sbci r23, 0x00 ; 0
BytesInEndpoint++;
- 9b0: 01 96 adiw r24, 0x01 ; 1
+ 94e: 01 96 adiw r24, 0x01 ; 1
if (Endpoint_IsINReady())
{
uint16_t BytesInEndpoint = Endpoint_BytesInEndpoint();
while (Length && (BytesInEndpoint < USB_Device_ControlEndpointSize))
- 9b2: 61 15 cp r22, r1
- 9b4: 71 05 cpc r23, r1
- 9b6: 19 f0 breq .+6 ; 0x9be <Endpoint_Write_Control_Stream_LE+0x6e>
- 9b8: 88 30 cpi r24, 0x08 ; 8
- 9ba: 91 05 cpc r25, r1
- 9bc: a0 f3 brcs .-24 ; 0x9a6 <Endpoint_Write_Control_Stream_LE+0x56>
+ 950: 61 15 cp r22, r1
+ 952: 71 05 cpc r23, r1
+ 954: 19 f0 breq .+6 ; 0x95c <Endpoint_Write_Control_Stream_LE+0x6e>
+ 956: 88 30 cpi r24, 0x08 ; 8
+ 958: 91 05 cpc r25, r1
+ 95a: a0 f3 brcs .-24 ; 0x944 <Endpoint_Write_Control_Stream_LE+0x56>
TEMPLATE_BUFFER_MOVE(DataStream, 1);
Length--;
BytesInEndpoint++;
}
LastPacketFull = (BytesInEndpoint == USB_Device_ControlEndpointSize);
- 9be: 21 e0 ldi r18, 0x01 ; 1
- 9c0: 88 30 cpi r24, 0x08 ; 8
- 9c2: 91 05 cpc r25, r1
- 9c4: 09 f0 breq .+2 ; 0x9c8 <Endpoint_Write_Control_Stream_LE+0x78>
- 9c6: 20 e0 ldi r18, 0x00 ; 0
+ 95c: 21 e0 ldi r18, 0x01 ; 1
+ 95e: 88 30 cpi r24, 0x08 ; 8
+ 960: 91 05 cpc r25, r1
+ 962: 09 f0 breq .+2 ; 0x966 <Endpoint_Write_Control_Stream_LE+0x78>
+ 964: 20 e0 ldi r18, 0x00 ; 0
*/
static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearIN(void)
{
#if !defined(CONTROL_ONLY_DEVICE)
UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
- 9c8: 80 91 e8 00 lds r24, 0x00E8
- 9cc: 8e 77 andi r24, 0x7E ; 126
- 9ce: 80 93 e8 00 sts 0x00E8, r24
+ 966: 80 91 e8 00 lds r24, 0x00E8
+ 96a: 8e 77 andi r24, 0x7E ; 126
+ 96c: 80 93 e8 00 sts 0x00E8, r24
if (Length > USB_ControlRequest.wLength)
Length = USB_ControlRequest.wLength;
else if (!(Length))
Endpoint_ClearIN();
while (Length || LastPacketFull)
- 9d2: 61 15 cp r22, r1
- 9d4: 71 05 cpc r23, r1
- 9d6: 91 f6 brne .-92 ; 0x97c <Endpoint_Write_Control_Stream_LE+0x2c>
- 9d8: 22 23 and r18, r18
- 9da: 81 f6 brne .-96 ; 0x97c <Endpoint_Write_Control_Stream_LE+0x2c>
- 9dc: 05 c0 rjmp .+10 ; 0x9e8 <Endpoint_Write_Control_Stream_LE+0x98>
+ 970: 61 15 cp r22, r1
+ 972: 71 05 cpc r23, r1
+ 974: 91 f6 brne .-92 ; 0x91a <Endpoint_Write_Control_Stream_LE+0x2c>
+ 976: 22 23 and r18, r18
+ 978: 81 f6 brne .-96 ; 0x91a <Endpoint_Write_Control_Stream_LE+0x2c>
+ 97a: 05 c0 rjmp .+10 ; 0x986 <Endpoint_Write_Control_Stream_LE+0x98>
}
}
while (!(Endpoint_IsOUTReceived()))
{
uint8_t USB_DeviceState_LCL = USB_DeviceState;
- 9de: 8e b3 in r24, 0x1e ; 30
+ 97c: 8e b3 in r24, 0x1e ; 30
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
- 9e0: 88 23 and r24, r24
- 9e2: 61 f0 breq .+24 ; 0x9fc <Endpoint_Write_Control_Stream_LE+0xac>
+ 97e: 88 23 and r24, r24
+ 980: 61 f0 breq .+24 ; 0x99a <Endpoint_Write_Control_Stream_LE+0xac>
return ENDPOINT_RWCSTREAM_DeviceDisconnected;
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
- 9e4: 85 30 cpi r24, 0x05 ; 5
- 9e6: 61 f0 breq .+24 ; 0xa00 <Endpoint_Write_Control_Stream_LE+0xb0>
+ 982: 85 30 cpi r24, 0x05 ; 5
+ 984: 61 f0 breq .+24 ; 0x99e <Endpoint_Write_Control_Stream_LE+0xb0>
* \return Boolean \c true if current endpoint is has received an OUT packet, \c false otherwise.
*/
static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsOUTReceived(void)
{
return ((UEINTX & (1 << RXOUTI)) ? true : false);
- 9e8: 80 91 e8 00 lds r24, 0x00E8
+ 986: 80 91 e8 00 lds r24, 0x00E8
LastPacketFull = (BytesInEndpoint == USB_Device_ControlEndpointSize);
Endpoint_ClearIN();
}
}
while (!(Endpoint_IsOUTReceived()))
- 9ec: 82 ff sbrs r24, 2
- 9ee: f7 cf rjmp .-18 ; 0x9de <Endpoint_Write_Control_Stream_LE+0x8e>
+ 98a: 82 ff sbrs r24, 2
+ 98c: f7 cf rjmp .-18 ; 0x97c <Endpoint_Write_Control_Stream_LE+0x8e>
return ENDPOINT_RWCSTREAM_DeviceDisconnected;
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
return ENDPOINT_RWCSTREAM_BusSuspended;
}
return ENDPOINT_RWCSTREAM_NoError;
- 9f0: 80 e0 ldi r24, 0x00 ; 0
- 9f2: 08 95 ret
+ 98e: 80 e0 ldi r24, 0x00 ; 0
+ 990: 08 95 ret
uint8_t USB_DeviceState_LCL = USB_DeviceState;
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
return ENDPOINT_RWCSTREAM_DeviceDisconnected;
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
return ENDPOINT_RWCSTREAM_BusSuspended;
- 9f4: 83 e0 ldi r24, 0x03 ; 3
- 9f6: 08 95 ret
+ 992: 83 e0 ldi r24, 0x03 ; 3
+ 994: 08 95 ret
else if (Endpoint_IsSETUPReceived())
return ENDPOINT_RWCSTREAM_HostAborted;
- 9f8: 81 e0 ldi r24, 0x01 ; 1
- 9fa: 08 95 ret
+ 996: 81 e0 ldi r24, 0x01 ; 1
+ 998: 08 95 ret
while (!(Endpoint_IsOUTReceived()))
{
uint8_t USB_DeviceState_LCL = USB_DeviceState;
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
return ENDPOINT_RWCSTREAM_DeviceDisconnected;
- 9fc: 82 e0 ldi r24, 0x02 ; 2
- 9fe: 08 95 ret
+ 99a: 82 e0 ldi r24, 0x02 ; 2
+ 99c: 08 95 ret
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
return ENDPOINT_RWCSTREAM_BusSuspended;
- a00: 83 e0 ldi r24, 0x03 ; 3
+ 99e: 83 e0 ldi r24, 0x03 ; 3
}
return ENDPOINT_RWCSTREAM_NoError;
}
- a02: 08 95 ret
+ 9a0: 08 95 ret
-00000a04 <Endpoint_Write_Control_PStream_LE>:
+000009a2 <Endpoint_Write_Control_PStream_LE>:
#if defined(TEMPLATE_FUNC_NAME)
uint8_t TEMPLATE_FUNC_NAME (const void* const Buffer,
uint16_t Length)
{
uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length));
- a04: e8 2f mov r30, r24
- a06: f9 2f mov r31, r25
+ 9a2: e8 2f mov r30, r24
+ 9a4: f9 2f mov r31, r25
bool LastPacketFull = false;
if (Length > USB_ControlRequest.wLength)
- a08: 80 91 74 02 lds r24, 0x0274
- a0c: 90 91 75 02 lds r25, 0x0275
- a10: 86 17 cp r24, r22
- a12: 97 07 cpc r25, r23
- a14: 18 f4 brcc .+6 ; 0xa1c <Endpoint_Write_Control_PStream_LE+0x18>
- a16: bc 01 movw r22, r24
- a18: 20 e0 ldi r18, 0x00 ; 0
- a1a: 36 c0 rjmp .+108 ; 0xa88 <Endpoint_Write_Control_PStream_LE+0x84>
+ 9a6: 80 91 7a 02 lds r24, 0x027A
+ 9aa: 90 91 7b 02 lds r25, 0x027B
+ 9ae: 86 17 cp r24, r22
+ 9b0: 97 07 cpc r25, r23
+ 9b2: 18 f4 brcc .+6 ; 0x9ba <Endpoint_Write_Control_PStream_LE+0x18>
+ 9b4: bc 01 movw r22, r24
+ 9b6: 20 e0 ldi r18, 0x00 ; 0
+ 9b8: 36 c0 rjmp .+108 ; 0xa26 <Endpoint_Write_Control_PStream_LE+0x84>
Length = USB_ControlRequest.wLength;
else if (!(Length))
- a1c: 61 15 cp r22, r1
- a1e: 71 05 cpc r23, r1
- a20: d9 f7 brne .-10 ; 0xa18 <Endpoint_Write_Control_PStream_LE+0x14>
+ 9ba: 61 15 cp r22, r1
+ 9bc: 71 05 cpc r23, r1
+ 9be: d9 f7 brne .-10 ; 0x9b6 <Endpoint_Write_Control_PStream_LE+0x14>
*/
static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearIN(void)
{
#if !defined(CONTROL_ONLY_DEVICE)
UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
- a22: 80 91 e8 00 lds r24, 0x00E8
- a26: 8e 77 andi r24, 0x7E ; 126
- a28: 80 93 e8 00 sts 0x00E8, r24
- a2c: f5 cf rjmp .-22 ; 0xa18 <Endpoint_Write_Control_PStream_LE+0x14>
+ 9c0: 80 91 e8 00 lds r24, 0x00E8
+ 9c4: 8e 77 andi r24, 0x7E ; 126
+ 9c6: 80 93 e8 00 sts 0x00E8, r24
+ 9ca: f5 cf rjmp .-22 ; 0x9b6 <Endpoint_Write_Control_PStream_LE+0x14>
Endpoint_ClearIN();
while (Length || LastPacketFull)
{
uint8_t USB_DeviceState_LCL = USB_DeviceState;
- a2e: 8e b3 in r24, 0x1e ; 30
+ 9cc: 8e b3 in r24, 0x1e ; 30
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
- a30: 88 23 and r24, r24
- a32: 09 f4 brne .+2 ; 0xa36 <Endpoint_Write_Control_PStream_LE+0x32>
- a34: 3e c0 rjmp .+124 ; 0xab2 <Endpoint_Write_Control_PStream_LE+0xae>
+ 9ce: 88 23 and r24, r24
+ 9d0: 09 f4 brne .+2 ; 0x9d4 <Endpoint_Write_Control_PStream_LE+0x32>
+ 9d2: 3e c0 rjmp .+124 ; 0xa50 <Endpoint_Write_Control_PStream_LE+0xae>
return ENDPOINT_RWCSTREAM_DeviceDisconnected;
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
- a36: 85 30 cpi r24, 0x05 ; 5
- a38: c1 f1 breq .+112 ; 0xaaa <Endpoint_Write_Control_PStream_LE+0xa6>
+ 9d4: 85 30 cpi r24, 0x05 ; 5
+ 9d6: c1 f1 breq .+112 ; 0xa48 <Endpoint_Write_Control_PStream_LE+0xa6>
* \return Boolean \c true if the selected endpoint has received a SETUP packet, \c false otherwise.
*/
static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsSETUPReceived(void)
{
return ((UEINTX & (1 << RXSTPI)) ? true : false);
- a3a: 80 91 e8 00 lds r24, 0x00E8
+ 9d8: 80 91 e8 00 lds r24, 0x00E8
return ENDPOINT_RWCSTREAM_BusSuspended;
else if (Endpoint_IsSETUPReceived())
- a3e: 83 fd sbrc r24, 3
- a40: 36 c0 rjmp .+108 ; 0xaae <Endpoint_Write_Control_PStream_LE+0xaa>
+ 9dc: 83 fd sbrc r24, 3
+ 9de: 36 c0 rjmp .+108 ; 0xa4c <Endpoint_Write_Control_PStream_LE+0xaa>
* \return Boolean \c true if current endpoint is has received an OUT packet, \c false otherwise.
*/
static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsOUTReceived(void)
{
return ((UEINTX & (1 << RXOUTI)) ? true : false);
- a42: 80 91 e8 00 lds r24, 0x00E8
+ 9e0: 80 91 e8 00 lds r24, 0x00E8
return ENDPOINT_RWCSTREAM_HostAborted;
else if (Endpoint_IsOUTReceived())
- a46: 82 fd sbrc r24, 2
- a48: 2a c0 rjmp .+84 ; 0xa9e <Endpoint_Write_Control_PStream_LE+0x9a>
+ 9e4: 82 fd sbrc r24, 2
+ 9e6: 2a c0 rjmp .+84 ; 0xa3c <Endpoint_Write_Control_PStream_LE+0x9a>
* \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
*/
static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsINReady(void)
{
return ((UEINTX & (1 << TXINI)) ? true : false);
- a4a: 80 91 e8 00 lds r24, 0x00E8
+ 9e8: 80 91 e8 00 lds r24, 0x00E8
break;
if (Endpoint_IsINReady())
- a4e: 80 ff sbrs r24, 0
- a50: 1b c0 rjmp .+54 ; 0xa88 <Endpoint_Write_Control_PStream_LE+0x84>
+ 9ec: 80 ff sbrs r24, 0
+ 9ee: 1b c0 rjmp .+54 ; 0xa26 <Endpoint_Write_Control_PStream_LE+0x84>
#if (defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
return UEBCX;
#elif defined(USB_SERIES_4_AVR)
return (((uint16_t)UEBCHX << 8) | UEBCLX);
#elif defined(USB_SERIES_2_AVR)
return UEBCLX;
- a52: 80 91 f2 00 lds r24, 0x00F2
- a56: 90 e0 ldi r25, 0x00 ; 0
+ 9f0: 80 91 f2 00 lds r24, 0x00F2
+ 9f4: 90 e0 ldi r25, 0x00 ; 0
{
uint16_t BytesInEndpoint = Endpoint_BytesInEndpoint();
while (Length && (BytesInEndpoint < USB_Device_ControlEndpointSize))
- a58: 07 c0 rjmp .+14 ; 0xa68 <Endpoint_Write_Control_PStream_LE+0x64>
+ 9f6: 07 c0 rjmp .+14 ; 0xa06 <Endpoint_Write_Control_PStream_LE+0x64>
{
TEMPLATE_TRANSFER_BYTE(DataStream);
- a5a: 24 91 lpm r18, Z+
+ 9f8: 24 91 lpm r18, Z+
* \param[in] Data Data to write into the the currently selected endpoint's FIFO buffer.
*/
static inline void Endpoint_Write_8(const uint8_t Data) ATTR_ALWAYS_INLINE;
static inline void Endpoint_Write_8(const uint8_t Data)
{
UEDATX = Data;
- a5c: 20 93 f1 00 sts 0x00F1, r18
+ 9fa: 20 93 f1 00 sts 0x00F1, r18
TEMPLATE_BUFFER_MOVE(DataStream, 1);
- a60: 31 96 adiw r30, 0x01 ; 1
+ 9fe: 31 96 adiw r30, 0x01 ; 1
Length--;
- a62: 61 50 subi r22, 0x01 ; 1
- a64: 70 40 sbci r23, 0x00 ; 0
+ a00: 61 50 subi r22, 0x01 ; 1
+ a02: 70 40 sbci r23, 0x00 ; 0
BytesInEndpoint++;
- a66: 01 96 adiw r24, 0x01 ; 1
+ a04: 01 96 adiw r24, 0x01 ; 1
if (Endpoint_IsINReady())
{
uint16_t BytesInEndpoint = Endpoint_BytesInEndpoint();
while (Length && (BytesInEndpoint < USB_Device_ControlEndpointSize))
- a68: 61 15 cp r22, r1
- a6a: 71 05 cpc r23, r1
- a6c: 19 f0 breq .+6 ; 0xa74 <Endpoint_Write_Control_PStream_LE+0x70>
- a6e: 88 30 cpi r24, 0x08 ; 8
- a70: 91 05 cpc r25, r1
- a72: 98 f3 brcs .-26 ; 0xa5a <Endpoint_Write_Control_PStream_LE+0x56>
+ a06: 61 15 cp r22, r1
+ a08: 71 05 cpc r23, r1
+ a0a: 19 f0 breq .+6 ; 0xa12 <Endpoint_Write_Control_PStream_LE+0x70>
+ a0c: 88 30 cpi r24, 0x08 ; 8
+ a0e: 91 05 cpc r25, r1
+ a10: 98 f3 brcs .-26 ; 0x9f8 <Endpoint_Write_Control_PStream_LE+0x56>
TEMPLATE_BUFFER_MOVE(DataStream, 1);
Length--;
BytesInEndpoint++;
}
LastPacketFull = (BytesInEndpoint == USB_Device_ControlEndpointSize);
- a74: 21 e0 ldi r18, 0x01 ; 1
- a76: 88 30 cpi r24, 0x08 ; 8
- a78: 91 05 cpc r25, r1
- a7a: 09 f0 breq .+2 ; 0xa7e <Endpoint_Write_Control_PStream_LE+0x7a>
- a7c: 20 e0 ldi r18, 0x00 ; 0
+ a12: 21 e0 ldi r18, 0x01 ; 1
+ a14: 88 30 cpi r24, 0x08 ; 8
+ a16: 91 05 cpc r25, r1
+ a18: 09 f0 breq .+2 ; 0xa1c <Endpoint_Write_Control_PStream_LE+0x7a>
+ a1a: 20 e0 ldi r18, 0x00 ; 0
*/
static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearIN(void)
{
#if !defined(CONTROL_ONLY_DEVICE)
UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
- a7e: 80 91 e8 00 lds r24, 0x00E8
- a82: 8e 77 andi r24, 0x7E ; 126
- a84: 80 93 e8 00 sts 0x00E8, r24
+ a1c: 80 91 e8 00 lds r24, 0x00E8
+ a20: 8e 77 andi r24, 0x7E ; 126
+ a22: 80 93 e8 00 sts 0x00E8, r24
if (Length > USB_ControlRequest.wLength)
Length = USB_ControlRequest.wLength;
else if (!(Length))
Endpoint_ClearIN();
while (Length || LastPacketFull)
- a88: 61 15 cp r22, r1
- a8a: 71 05 cpc r23, r1
- a8c: 81 f6 brne .-96 ; 0xa2e <Endpoint_Write_Control_PStream_LE+0x2a>
- a8e: 22 23 and r18, r18
- a90: 71 f6 brne .-100 ; 0xa2e <Endpoint_Write_Control_PStream_LE+0x2a>
- a92: 05 c0 rjmp .+10 ; 0xa9e <Endpoint_Write_Control_PStream_LE+0x9a>
+ a26: 61 15 cp r22, r1
+ a28: 71 05 cpc r23, r1
+ a2a: 81 f6 brne .-96 ; 0x9cc <Endpoint_Write_Control_PStream_LE+0x2a>
+ a2c: 22 23 and r18, r18
+ a2e: 71 f6 brne .-100 ; 0x9cc <Endpoint_Write_Control_PStream_LE+0x2a>
+ a30: 05 c0 rjmp .+10 ; 0xa3c <Endpoint_Write_Control_PStream_LE+0x9a>
}
}
while (!(Endpoint_IsOUTReceived()))
{
uint8_t USB_DeviceState_LCL = USB_DeviceState;
- a94: 8e b3 in r24, 0x1e ; 30
+ a32: 8e b3 in r24, 0x1e ; 30
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
- a96: 88 23 and r24, r24
- a98: 61 f0 breq .+24 ; 0xab2 <Endpoint_Write_Control_PStream_LE+0xae>
+ a34: 88 23 and r24, r24
+ a36: 61 f0 breq .+24 ; 0xa50 <Endpoint_Write_Control_PStream_LE+0xae>
return ENDPOINT_RWCSTREAM_DeviceDisconnected;
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
- a9a: 85 30 cpi r24, 0x05 ; 5
- a9c: 61 f0 breq .+24 ; 0xab6 <Endpoint_Write_Control_PStream_LE+0xb2>
+ a38: 85 30 cpi r24, 0x05 ; 5
+ a3a: 61 f0 breq .+24 ; 0xa54 <Endpoint_Write_Control_PStream_LE+0xb2>
* \return Boolean \c true if current endpoint is has received an OUT packet, \c false otherwise.
*/
static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsOUTReceived(void)
{
return ((UEINTX & (1 << RXOUTI)) ? true : false);
- a9e: 80 91 e8 00 lds r24, 0x00E8
+ a3c: 80 91 e8 00 lds r24, 0x00E8
LastPacketFull = (BytesInEndpoint == USB_Device_ControlEndpointSize);
Endpoint_ClearIN();
}
}
while (!(Endpoint_IsOUTReceived()))
- aa2: 82 ff sbrs r24, 2
- aa4: f7 cf rjmp .-18 ; 0xa94 <Endpoint_Write_Control_PStream_LE+0x90>
+ a40: 82 ff sbrs r24, 2
+ a42: f7 cf rjmp .-18 ; 0xa32 <Endpoint_Write_Control_PStream_LE+0x90>
return ENDPOINT_RWCSTREAM_DeviceDisconnected;
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
return ENDPOINT_RWCSTREAM_BusSuspended;
}
return ENDPOINT_RWCSTREAM_NoError;
- aa6: 80 e0 ldi r24, 0x00 ; 0
- aa8: 08 95 ret
+ a44: 80 e0 ldi r24, 0x00 ; 0
+ a46: 08 95 ret
uint8_t USB_DeviceState_LCL = USB_DeviceState;
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
return ENDPOINT_RWCSTREAM_DeviceDisconnected;
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
return ENDPOINT_RWCSTREAM_BusSuspended;
- aaa: 83 e0 ldi r24, 0x03 ; 3
- aac: 08 95 ret
+ a48: 83 e0 ldi r24, 0x03 ; 3
+ a4a: 08 95 ret
else if (Endpoint_IsSETUPReceived())
return ENDPOINT_RWCSTREAM_HostAborted;
- aae: 81 e0 ldi r24, 0x01 ; 1
- ab0: 08 95 ret
+ a4c: 81 e0 ldi r24, 0x01 ; 1
+ a4e: 08 95 ret
while (!(Endpoint_IsOUTReceived()))
{
uint8_t USB_DeviceState_LCL = USB_DeviceState;
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
return ENDPOINT_RWCSTREAM_DeviceDisconnected;
- ab2: 82 e0 ldi r24, 0x02 ; 2
- ab4: 08 95 ret
+ a50: 82 e0 ldi r24, 0x02 ; 2
+ a52: 08 95 ret
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
return ENDPOINT_RWCSTREAM_BusSuspended;
- ab6: 83 e0 ldi r24, 0x03 ; 3
+ a54: 83 e0 ldi r24, 0x03 ; 3
}
return ENDPOINT_RWCSTREAM_NoError;
}
- ab8: 08 95 ret
+ a56: 08 95 ret
-00000aba <Endpoint_ConfigureEndpoint_Prv>:
+00000a58 <Endpoint_ConfigureEndpoint_Prv>:
UECFG0X = UECFG0XData;
UECFG1X = UECFG1XData;
return Endpoint_IsConfigured();
#else
for (uint8_t EPNum = Number; EPNum < ENDPOINT_TOTAL_ENDPOINTS; EPNum++)
- aba: 98 2f mov r25, r24
- abc: 2c c0 rjmp .+88 ; 0xb16 <Endpoint_ConfigureEndpoint_Prv+0x5c>
+ a58: 98 2f mov r25, r24
+ a5a: 2c c0 rjmp .+88 ; 0xab4 <Endpoint_ConfigureEndpoint_Prv+0x5c>
*/
static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void Endpoint_SelectEndpoint(const uint8_t Address)
{
#if !defined(CONTROL_ONLY_DEVICE)
UENUM = (Address & ENDPOINT_EPNUM_MASK);
- abe: 29 2f mov r18, r25
- ac0: 2f 70 andi r18, 0x0F ; 15
- ac2: 20 93 e9 00 sts 0x00E9, r18
+ a5c: 29 2f mov r18, r25
+ a5e: 2f 70 andi r18, 0x0F ; 15
+ a60: 20 93 e9 00 sts 0x00E9, r18
uint8_t UECFG1XTemp;
uint8_t UEIENXTemp;
Endpoint_SelectEndpoint(EPNum);
if (EPNum == Number)
- ac6: 98 17 cp r25, r24
- ac8: 39 f0 breq .+14 ; 0xad8 <Endpoint_ConfigureEndpoint_Prv+0x1e>
+ a64: 98 17 cp r25, r24
+ a66: 39 f0 breq .+14 ; 0xa76 <Endpoint_ConfigureEndpoint_Prv+0x1e>
UECFG1XTemp = UECFG1XData;
UEIENXTemp = 0;
}
else
{
UECFG0XTemp = UECFG0X;
- aca: 70 91 ec 00 lds r23, 0x00EC
+ a68: 70 91 ec 00 lds r23, 0x00EC
UECFG1XTemp = UECFG1X;
- ace: 20 91 ed 00 lds r18, 0x00ED
+ a6c: 20 91 ed 00 lds r18, 0x00ED
UEIENXTemp = UEIENX;
- ad2: 50 91 f0 00 lds r21, 0x00F0
- ad6: 03 c0 rjmp .+6 ; 0xade <Endpoint_ConfigureEndpoint_Prv+0x24>
+ a70: 50 91 f0 00 lds r21, 0x00F0
+ a74: 03 c0 rjmp .+6 ; 0xa7c <Endpoint_ConfigureEndpoint_Prv+0x24>
Endpoint_SelectEndpoint(EPNum);
if (EPNum == Number)
{
UECFG0XTemp = UECFG0XData;
UECFG1XTemp = UECFG1XData;
- ad8: 24 2f mov r18, r20
+ a76: 24 2f mov r18, r20
Endpoint_SelectEndpoint(EPNum);
if (EPNum == Number)
{
UECFG0XTemp = UECFG0XData;
- ada: 76 2f mov r23, r22
+ a78: 76 2f mov r23, r22
UECFG1XTemp = UECFG1XData;
UEIENXTemp = 0;
- adc: 50 e0 ldi r21, 0x00 ; 0
+ a7a: 50 e0 ldi r21, 0x00 ; 0
UECFG0XTemp = UECFG0X;
UECFG1XTemp = UECFG1X;
UEIENXTemp = UEIENX;
}
if (!(UECFG1XTemp & (1 << ALLOC)))
- ade: 21 ff sbrs r18, 1
- ae0: 19 c0 rjmp .+50 ; 0xb14 <Endpoint_ConfigureEndpoint_Prv+0x5a>
+ a7c: 21 ff sbrs r18, 1
+ a7e: 19 c0 rjmp .+50 ; 0xab2 <Endpoint_ConfigureEndpoint_Prv+0x5a>
* to and from a host.
*/
static inline void Endpoint_DisableEndpoint(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_DisableEndpoint(void)
{
UECONX &= ~(1 << EPEN);
- ae2: 30 91 eb 00 lds r19, 0x00EB
- ae6: 3e 7f andi r19, 0xFE ; 254
- ae8: 30 93 eb 00 sts 0x00EB, r19
+ a80: 30 91 eb 00 lds r19, 0x00EB
+ a84: 3e 7f andi r19, 0xFE ; 254
+ a86: 30 93 eb 00 sts 0x00EB, r19
continue;
Endpoint_DisableEndpoint();
UECFG1X &= ~(1 << ALLOC);
- aec: 30 91 ed 00 lds r19, 0x00ED
- af0: 3d 7f andi r19, 0xFD ; 253
- af2: 30 93 ed 00 sts 0x00ED, r19
+ a8a: 30 91 ed 00 lds r19, 0x00ED
+ a8e: 3d 7f andi r19, 0xFD ; 253
+ a90: 30 93 ed 00 sts 0x00ED, r19
* \note Endpoints must first be configured properly via \ref Endpoint_ConfigureEndpoint().
*/
static inline void Endpoint_EnableEndpoint(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_EnableEndpoint(void)
{
UECONX |= (1 << EPEN);
- af6: 30 91 eb 00 lds r19, 0x00EB
- afa: 31 60 ori r19, 0x01 ; 1
- afc: 30 93 eb 00 sts 0x00EB, r19
+ a94: 30 91 eb 00 lds r19, 0x00EB
+ a98: 31 60 ori r19, 0x01 ; 1
+ a9a: 30 93 eb 00 sts 0x00EB, r19
Endpoint_EnableEndpoint();
UECFG0X = UECFG0XTemp;
- b00: 70 93 ec 00 sts 0x00EC, r23
+ a9e: 70 93 ec 00 sts 0x00EC, r23
UECFG1X = UECFG1XTemp;
- b04: 20 93 ed 00 sts 0x00ED, r18
+ aa2: 20 93 ed 00 sts 0x00ED, r18
UEIENX = UEIENXTemp;
- b08: 50 93 f0 00 sts 0x00F0, r21
+ aa6: 50 93 f0 00 sts 0x00F0, r21
* \return Boolean \c true if the currently selected endpoint has been configured, \c false otherwise.
*/
static inline bool Endpoint_IsConfigured(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsConfigured(void)
{
return ((UESTA0X & (1 << CFGOK)) ? true : false);
- b0c: 20 91 ee 00 lds r18, 0x00EE
+ aaa: 20 91 ee 00 lds r18, 0x00EE
if (!(Endpoint_IsConfigured()))
- b10: 27 ff sbrs r18, 7
- b12: 08 c0 rjmp .+16 ; 0xb24 <Endpoint_ConfigureEndpoint_Prv+0x6a>
+ aae: 27 ff sbrs r18, 7
+ ab0: 08 c0 rjmp .+16 ; 0xac2 <Endpoint_ConfigureEndpoint_Prv+0x6a>
UECFG0X = UECFG0XData;
UECFG1X = UECFG1XData;
return Endpoint_IsConfigured();
#else
for (uint8_t EPNum = Number; EPNum < ENDPOINT_TOTAL_ENDPOINTS; EPNum++)
- b14: 9f 5f subi r25, 0xFF ; 255
- b16: 95 30 cpi r25, 0x05 ; 5
- b18: 90 f2 brcs .-92 ; 0xabe <Endpoint_ConfigureEndpoint_Prv+0x4>
+ ab2: 9f 5f subi r25, 0xFF ; 255
+ ab4: 95 30 cpi r25, 0x05 ; 5
+ ab6: 90 f2 brcs .-92 ; 0xa5c <Endpoint_ConfigureEndpoint_Prv+0x4>
*/
static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void Endpoint_SelectEndpoint(const uint8_t Address)
{
#if !defined(CONTROL_ONLY_DEVICE)
UENUM = (Address & ENDPOINT_EPNUM_MASK);
- b1a: 8f 70 andi r24, 0x0F ; 15
- b1c: 80 93 e9 00 sts 0x00E9, r24
+ ab8: 8f 70 andi r24, 0x0F ; 15
+ aba: 80 93 e9 00 sts 0x00E9, r24
if (!(Endpoint_IsConfigured()))
return false;
}
Endpoint_SelectEndpoint(Number);
return true;
- b20: 81 e0 ldi r24, 0x01 ; 1
- b22: 08 95 ret
+ abe: 81 e0 ldi r24, 0x01 ; 1
+ ac0: 08 95 ret
UECFG0X = UECFG0XTemp;
UECFG1X = UECFG1XTemp;
UEIENX = UEIENXTemp;
if (!(Endpoint_IsConfigured()))
return false;
- b24: 80 e0 ldi r24, 0x00 ; 0
+ ac2: 80 e0 ldi r24, 0x00 ; 0
}
Endpoint_SelectEndpoint(Number);
return true;
#endif
}
- b26: 08 95 ret
+ ac4: 08 95 ret
-00000b28 <Endpoint_ConfigureEndpointTable>:
+00000ac6 <Endpoint_ConfigureEndpointTable>:
uint8_t USB_Device_ControlEndpointSize = ENDPOINT_CONTROLEP_DEFAULT_SIZE;
#endif
bool Endpoint_ConfigureEndpointTable(const USB_Endpoint_Table_t* const Table,
const uint8_t Entries)
{
- b28: ef 92 push r14
- b2a: ff 92 push r15
- b2c: 0f 93 push r16
- b2e: 1f 93 push r17
- b30: cf 93 push r28
- b32: df 93 push r29
- b34: 16 2f mov r17, r22
+ ac6: ef 92 push r14
+ ac8: ff 92 push r15
+ aca: 0f 93 push r16
+ acc: 1f 93 push r17
+ ace: cf 93 push r28
+ ad0: df 93 push r29
+ ad2: 16 2f mov r17, r22
{
if (!(Table[i].Address))
continue;
if (!(Endpoint_ConfigureEndpoint(Table[i].Address, Table[i].Type, Table[i].Size, Table[i].Banks)))
return false;
- b36: e8 2e mov r14, r24
- b38: e7 01 movw r28, r14
- b3a: 7e 01 movw r14, r28
- b3c: f9 2e mov r15, r25
- b3e: e7 01 movw r28, r14
+ ad4: e8 2e mov r14, r24
+ ad6: e7 01 movw r28, r14
+ ad8: 7e 01 movw r14, r28
+ ada: f9 2e mov r15, r25
+ adc: e7 01 movw r28, r14
#endif
bool Endpoint_ConfigureEndpointTable(const USB_Endpoint_Table_t* const Table,
const uint8_t Entries)
{
for (uint8_t i = 0; i < Entries; i++)
- b40: 00 e0 ldi r16, 0x00 ; 0
- b42: 2a c0 rjmp .+84 ; 0xb98 <Endpoint_ConfigureEndpointTable+0x70>
+ ade: 00 e0 ldi r16, 0x00 ; 0
+ ae0: 2a c0 rjmp .+84 ; 0xb36 <Endpoint_ConfigureEndpointTable+0x70>
{
if (!(Table[i].Address))
- b44: 98 81 ld r25, Y
- b46: 99 23 and r25, r25
- b48: 29 f1 breq .+74 ; 0xb94 <Endpoint_ConfigureEndpointTable+0x6c>
+ ae2: 98 81 ld r25, Y
+ ae4: 99 23 and r25, r25
+ ae6: 29 f1 breq .+74 ; 0xb32 <Endpoint_ConfigureEndpointTable+0x6c>
continue;
if (!(Endpoint_ConfigureEndpoint(Table[i].Address, Table[i].Type, Table[i].Size, Table[i].Banks)))
- b4a: 6b 81 ldd r22, Y+3 ; 0x03
- b4c: e9 81 ldd r30, Y+1 ; 0x01
- b4e: fa 81 ldd r31, Y+2 ; 0x02
- b50: 2c 81 ldd r18, Y+4 ; 0x04
+ ae8: 6b 81 ldd r22, Y+3 ; 0x03
+ aea: e9 81 ldd r30, Y+1 ; 0x01
+ aec: fa 81 ldd r31, Y+2 ; 0x02
+ aee: 2c 81 ldd r18, Y+4 ; 0x04
static inline bool Endpoint_ConfigureEndpoint(const uint8_t Address,
const uint8_t Type,
const uint16_t Size,
const uint8_t Banks)
{
uint8_t Number = (Address & ENDPOINT_EPNUM_MASK);
- b52: 89 2f mov r24, r25
- b54: 8f 70 andi r24, 0x0F ; 15
+ af0: 89 2f mov r24, r25
+ af2: 8f 70 andi r24, 0x0F ; 15
if (Number >= ENDPOINT_TOTAL_ENDPOINTS)
- b56: 85 30 cpi r24, 0x05 ; 5
- b58: 18 f5 brcc .+70 ; 0xba0 <Endpoint_ConfigureEndpointTable+0x78>
+ af4: 85 30 cpi r24, 0x05 ; 5
+ af6: 18 f5 brcc .+70 ; 0xb3e <Endpoint_ConfigureEndpointTable+0x78>
return false;
return Endpoint_ConfigureEndpoint_Prv(Number,
((Type << EPTYPE0) | ((Address & ENDPOINT_DIR_IN) ? (1 << EPDIR) : 0)),
- b5a: 62 95 swap r22
- b5c: 66 0f add r22, r22
- b5e: 66 0f add r22, r22
- b60: 60 7c andi r22, 0xC0 ; 192
- b62: 99 1f adc r25, r25
- b64: 99 27 eor r25, r25
- b66: 99 1f adc r25, r25
+ af8: 62 95 swap r22
+ afa: 66 0f add r22, r22
+ afc: 66 0f add r22, r22
+ afe: 60 7c andi r22, 0xC0 ; 192
+ b00: 99 1f adc r25, r25
+ b02: 99 27 eor r25, r25
+ b04: 99 1f adc r25, r25
uint8_t Number = (Address & ENDPOINT_EPNUM_MASK);
if (Number >= ENDPOINT_TOTAL_ENDPOINTS)
return false;
return Endpoint_ConfigureEndpoint_Prv(Number,
- b68: 69 2b or r22, r25
- b6a: 22 30 cpi r18, 0x02 ; 2
- b6c: 10 f0 brcs .+4 ; 0xb72 <Endpoint_ConfigureEndpointTable+0x4a>
- b6e: 96 e0 ldi r25, 0x06 ; 6
- b70: 01 c0 rjmp .+2 ; 0xb74 <Endpoint_ConfigureEndpointTable+0x4c>
- b72: 92 e0 ldi r25, 0x02 ; 2
+ b06: 69 2b or r22, r25
+ b08: 22 30 cpi r18, 0x02 ; 2
+ b0a: 10 f0 brcs .+4 ; 0xb10 <Endpoint_ConfigureEndpointTable+0x4a>
+ b0c: 96 e0 ldi r25, 0x06 ; 6
+ b0e: 01 c0 rjmp .+2 ; 0xb12 <Endpoint_ConfigureEndpointTable+0x4c>
+ b10: 92 e0 ldi r25, 0x02 ; 2
static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST
ATTR_ALWAYS_INLINE;
static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes)
{
uint8_t MaskVal = 0;
uint16_t CheckBytes = 8;
- b74: 28 e0 ldi r18, 0x08 ; 8
- b76: 30 e0 ldi r19, 0x00 ; 0
+ b12: 28 e0 ldi r18, 0x08 ; 8
+ b14: 30 e0 ldi r19, 0x00 ; 0
/* Inline Functions: */
static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST
ATTR_ALWAYS_INLINE;
static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes)
{
uint8_t MaskVal = 0;
- b78: 40 e0 ldi r20, 0x00 ; 0
- b7a: 03 c0 rjmp .+6 ; 0xb82 <Endpoint_ConfigureEndpointTable+0x5a>
+ b16: 40 e0 ldi r20, 0x00 ; 0
+ b18: 03 c0 rjmp .+6 ; 0xb20 <Endpoint_ConfigureEndpointTable+0x5a>
uint16_t CheckBytes = 8;
while (CheckBytes < Bytes)
{
MaskVal++;
- b7c: 4f 5f subi r20, 0xFF ; 255
+ b1a: 4f 5f subi r20, 0xFF ; 255
CheckBytes <<= 1;
- b7e: 22 0f add r18, r18
- b80: 33 1f adc r19, r19
+ b1c: 22 0f add r18, r18
+ b1e: 33 1f adc r19, r19
static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes)
{
uint8_t MaskVal = 0;
uint16_t CheckBytes = 8;
while (CheckBytes < Bytes)
- b82: 2e 17 cp r18, r30
- b84: 3f 07 cpc r19, r31
- b86: d0 f3 brcs .-12 ; 0xb7c <Endpoint_ConfigureEndpointTable+0x54>
+ b20: 2e 17 cp r18, r30
+ b22: 3f 07 cpc r19, r31
+ b24: d0 f3 brcs .-12 ; 0xb1a <Endpoint_ConfigureEndpointTable+0x54>
{
MaskVal++;
CheckBytes <<= 1;
}
return (MaskVal << EPSIZE0);
- b88: 42 95 swap r20
- b8a: 40 7f andi r20, 0xF0 ; 240
+ b26: 42 95 swap r20
+ b28: 40 7f andi r20, 0xF0 ; 240
uint8_t Number = (Address & ENDPOINT_EPNUM_MASK);
if (Number >= ENDPOINT_TOTAL_ENDPOINTS)
return false;
return Endpoint_ConfigureEndpoint_Prv(Number,
- b8c: 49 2b or r20, r25
- b8e: 95 df rcall .-214 ; 0xaba <Endpoint_ConfigureEndpoint_Prv>
- b90: 88 23 and r24, r24
- b92: 31 f0 breq .+12 ; 0xba0 <Endpoint_ConfigureEndpointTable+0x78>
+ b2a: 49 2b or r20, r25
+ b2c: 95 df rcall .-214 ; 0xa58 <Endpoint_ConfigureEndpoint_Prv>
+ b2e: 88 23 and r24, r24
+ b30: 31 f0 breq .+12 ; 0xb3e <Endpoint_ConfigureEndpointTable+0x78>
#endif
bool Endpoint_ConfigureEndpointTable(const USB_Endpoint_Table_t* const Table,
const uint8_t Entries)
{
for (uint8_t i = 0; i < Entries; i++)
- b94: 0f 5f subi r16, 0xFF ; 255
- b96: 25 96 adiw r28, 0x05 ; 5
- b98: 01 17 cp r16, r17
- b9a: a0 f2 brcs .-88 ; 0xb44 <Endpoint_ConfigureEndpointTable+0x1c>
+ b32: 0f 5f subi r16, 0xFF ; 255
+ b34: 25 96 adiw r28, 0x05 ; 5
+ b36: 01 17 cp r16, r17
+ b38: a0 f2 brcs .-88 ; 0xae2 <Endpoint_ConfigureEndpointTable+0x1c>
if (!(Endpoint_ConfigureEndpoint(Table[i].Address, Table[i].Type, Table[i].Size, Table[i].Banks)))
return false;
}
return true;
- b9c: 81 e0 ldi r24, 0x01 ; 1
- b9e: 01 c0 rjmp .+2 ; 0xba2 <Endpoint_ConfigureEndpointTable+0x7a>
+ b3a: 81 e0 ldi r24, 0x01 ; 1
+ b3c: 01 c0 rjmp .+2 ; 0xb40 <Endpoint_ConfigureEndpointTable+0x7a>
{
if (!(Table[i].Address))
continue;
if (!(Endpoint_ConfigureEndpoint(Table[i].Address, Table[i].Type, Table[i].Size, Table[i].Banks)))
return false;
- ba0: 80 e0 ldi r24, 0x00 ; 0
+ b3e: 80 e0 ldi r24, 0x00 ; 0
}
return true;
}
- ba2: df 91 pop r29
- ba4: cf 91 pop r28
- ba6: 1f 91 pop r17
- ba8: 0f 91 pop r16
- baa: ff 90 pop r15
- bac: ef 90 pop r14
- bae: 08 95 ret
-
-00000bb0 <Endpoint_ClearStatusStage>:
+ b40: df 91 pop r29
+ b42: cf 91 pop r28
+ b44: 1f 91 pop r17
+ b46: 0f 91 pop r16
+ b48: ff 90 pop r15
+ b4a: ef 90 pop r14
+ b4c: 08 95 ret
+
+00000b4e <Endpoint_ClearStatusStage>:
}
}
void Endpoint_ClearStatusStage(void)
{
if (USB_ControlRequest.bmRequestType & REQDIR_DEVICETOHOST)
- bb0: 80 91 6e 02 lds r24, 0x026E
- bb4: 87 ff sbrs r24, 7
- bb6: 11 c0 rjmp .+34 ; 0xbda <Endpoint_ClearStatusStage+0x2a>
- bb8: 03 c0 rjmp .+6 ; 0xbc0 <Endpoint_ClearStatusStage+0x10>
+ b4e: 80 91 74 02 lds r24, 0x0274
+ b52: 87 ff sbrs r24, 7
+ b54: 11 c0 rjmp .+34 ; 0xb78 <Endpoint_ClearStatusStage+0x2a>
+ b56: 03 c0 rjmp .+6 ; 0xb5e <Endpoint_ClearStatusStage+0x10>
{
while (!(Endpoint_IsOUTReceived()))
{
if (USB_DeviceState == DEVICE_STATE_Unattached)
- bba: 8e b3 in r24, 0x1e ; 30
- bbc: 88 23 and r24, r24
- bbe: b1 f0 breq .+44 ; 0xbec <Endpoint_ClearStatusStage+0x3c>
+ b58: 8e b3 in r24, 0x1e ; 30
+ b5a: 88 23 and r24, r24
+ b5c: b1 f0 breq .+44 ; 0xb8a <Endpoint_ClearStatusStage+0x3c>
* \return Boolean \c true if current endpoint is has received an OUT packet, \c false otherwise.
*/
static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsOUTReceived(void)
{
return ((UEINTX & (1 << RXOUTI)) ? true : false);
- bc0: 80 91 e8 00 lds r24, 0x00E8
+ b5e: 80 91 e8 00 lds r24, 0x00E8
void Endpoint_ClearStatusStage(void)
{
if (USB_ControlRequest.bmRequestType & REQDIR_DEVICETOHOST)
{
while (!(Endpoint_IsOUTReceived()))
- bc4: 82 ff sbrs r24, 2
- bc6: f9 cf rjmp .-14 ; 0xbba <Endpoint_ClearStatusStage+0xa>
+ b62: 82 ff sbrs r24, 2
+ b64: f9 cf rjmp .-14 ; 0xb58 <Endpoint_ClearStatusStage+0xa>
*/
static inline void Endpoint_ClearOUT(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearOUT(void)
{
#if !defined(CONTROL_ONLY_DEVICE)
UEINTX &= ~((1 << RXOUTI) | (1 << FIFOCON));
- bc8: 80 91 e8 00 lds r24, 0x00E8
- bcc: 8b 77 andi r24, 0x7B ; 123
- bce: 80 93 e8 00 sts 0x00E8, r24
- bd2: 08 95 ret
+ b66: 80 91 e8 00 lds r24, 0x00E8
+ b6a: 8b 77 andi r24, 0x7B ; 123
+ b6c: 80 93 e8 00 sts 0x00E8, r24
+ b70: 08 95 ret
}
else
{
while (!(Endpoint_IsINReady()))
{
if (USB_DeviceState == DEVICE_STATE_Unattached)
- bd4: 8e b3 in r24, 0x1e ; 30
- bd6: 88 23 and r24, r24
- bd8: 49 f0 breq .+18 ; 0xbec <Endpoint_ClearStatusStage+0x3c>
+ b72: 8e b3 in r24, 0x1e ; 30
+ b74: 88 23 and r24, r24
+ b76: 49 f0 breq .+18 ; 0xb8a <Endpoint_ClearStatusStage+0x3c>
* \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
*/
static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsINReady(void)
{
return ((UEINTX & (1 << TXINI)) ? true : false);
- bda: 80 91 e8 00 lds r24, 0x00E8
+ b78: 80 91 e8 00 lds r24, 0x00E8
Endpoint_ClearOUT();
}
else
{
while (!(Endpoint_IsINReady()))
- bde: 80 ff sbrs r24, 0
- be0: f9 cf rjmp .-14 ; 0xbd4 <Endpoint_ClearStatusStage+0x24>
+ b7c: 80 ff sbrs r24, 0
+ b7e: f9 cf rjmp .-14 ; 0xb72 <Endpoint_ClearStatusStage+0x24>
*/
static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearIN(void)
{
#if !defined(CONTROL_ONLY_DEVICE)
UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
- be2: 80 91 e8 00 lds r24, 0x00E8
- be6: 8e 77 andi r24, 0x7E ; 126
- be8: 80 93 e8 00 sts 0x00E8, r24
- bec: 08 95 ret
+ b80: 80 91 e8 00 lds r24, 0x00E8
+ b84: 8e 77 andi r24, 0x7E ; 126
+ b86: 80 93 e8 00 sts 0x00E8, r24
+ b8a: 08 95 ret
-00000bee <Endpoint_WaitUntilReady>:
+00000b8c <Endpoint_WaitUntilReady>:
* \return Current USB frame number from the USB controller.
*/
static inline uint16_t USB_Device_GetFrameNumber(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
static inline uint16_t USB_Device_GetFrameNumber(void)
{
return UDFNUM;
- bee: 80 91 e4 00 lds r24, 0x00E4
- bf2: 90 91 e5 00 lds r25, 0x00E5
+ b8c: 80 91 e4 00 lds r24, 0x00E4
+ b90: 90 91 e5 00 lds r25, 0x00E5
#if !defined(CONTROL_ONLY_DEVICE)
uint8_t Endpoint_WaitUntilReady(void)
{
#if (USB_STREAM_TIMEOUT_MS < 0xFF)
uint8_t TimeoutMSRem = USB_STREAM_TIMEOUT_MS;
- bf6: 44 e6 ldi r20, 0x64 ; 100
+ b94: 44 e6 ldi r20, 0x64 ; 100
* \return The currently selected endpoint's direction, as a \c ENDPOINT_DIR_* mask.
*/
static inline uint8_t Endpoint_GetEndpointDirection(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline uint8_t Endpoint_GetEndpointDirection(void)
{
return (UECFG0X & (1 << EPDIR)) ? ENDPOINT_DIR_IN : ENDPOINT_DIR_OUT;
- bf8: 20 91 ec 00 lds r18, 0x00EC
- bfc: 20 ff sbrs r18, 0
- bfe: 25 c0 rjmp .+74 ; 0xc4a <Endpoint_WaitUntilReady+0x5c>
+ b96: 20 91 ec 00 lds r18, 0x00EC
+ b9a: 20 ff sbrs r18, 0
+ b9c: 25 c0 rjmp .+74 ; 0xbe8 <Endpoint_WaitUntilReady+0x5c>
* \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
*/
static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsINReady(void)
{
return ((UEINTX & (1 << TXINI)) ? true : false);
- c00: 20 91 e8 00 lds r18, 0x00E8
+ b9e: 20 91 e8 00 lds r18, 0x00E8
for (;;)
{
if (Endpoint_GetEndpointDirection() == ENDPOINT_DIR_IN)
{
if (Endpoint_IsINReady())
- c04: 20 fd sbrc r18, 0
- c06: 15 c0 rjmp .+42 ; 0xc32 <Endpoint_WaitUntilReady+0x44>
+ ba2: 20 fd sbrc r18, 0
+ ba4: 15 c0 rjmp .+42 ; 0xbd0 <Endpoint_WaitUntilReady+0x44>
{
if (Endpoint_IsOUTReceived())
return ENDPOINT_READYWAIT_NoError;
}
uint8_t USB_DeviceState_LCL = USB_DeviceState;
- c08: 2e b3 in r18, 0x1e ; 30
+ ba6: 2e b3 in r18, 0x1e ; 30
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
- c0a: 22 23 and r18, r18
- c0c: a1 f0 breq .+40 ; 0xc36 <Endpoint_WaitUntilReady+0x48>
+ ba8: 22 23 and r18, r18
+ baa: a1 f0 breq .+40 ; 0xbd4 <Endpoint_WaitUntilReady+0x48>
return ENDPOINT_READYWAIT_DeviceDisconnected;
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
- c0e: 25 30 cpi r18, 0x05 ; 5
- c10: a1 f0 breq .+40 ; 0xc3a <Endpoint_WaitUntilReady+0x4c>
+ bac: 25 30 cpi r18, 0x05 ; 5
+ bae: a1 f0 breq .+40 ; 0xbd8 <Endpoint_WaitUntilReady+0x4c>
* \return Boolean \c true if the currently selected endpoint is stalled, \c false otherwise.
*/
static inline bool Endpoint_IsStalled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsStalled(void)
{
return ((UECONX & (1 << STALLRQ)) ? true : false);
- c12: 20 91 eb 00 lds r18, 0x00EB
+ bb0: 20 91 eb 00 lds r18, 0x00EB
return ENDPOINT_READYWAIT_BusSuspended;
else if (Endpoint_IsStalled())
- c16: 25 fd sbrc r18, 5
- c18: 12 c0 rjmp .+36 ; 0xc3e <Endpoint_WaitUntilReady+0x50>
- c1a: 20 91 e4 00 lds r18, 0x00E4
- c1e: 30 91 e5 00 lds r19, 0x00E5
+ bb4: 25 fd sbrc r18, 5
+ bb6: 12 c0 rjmp .+36 ; 0xbdc <Endpoint_WaitUntilReady+0x50>
+ bb8: 20 91 e4 00 lds r18, 0x00E4
+ bbc: 30 91 e5 00 lds r19, 0x00E5
return ENDPOINT_READYWAIT_EndpointStalled;
uint16_t CurrentFrameNumber = USB_Device_GetFrameNumber();
if (CurrentFrameNumber != PreviousFrameNumber)
- c22: 28 17 cp r18, r24
- c24: 39 07 cpc r19, r25
- c26: 41 f3 breq .-48 ; 0xbf8 <Endpoint_WaitUntilReady+0xa>
+ bc0: 28 17 cp r18, r24
+ bc2: 39 07 cpc r19, r25
+ bc4: 41 f3 breq .-48 ; 0xb96 <Endpoint_WaitUntilReady+0xa>
{
PreviousFrameNumber = CurrentFrameNumber;
if (!(TimeoutMSRem--))
- c28: 44 23 and r20, r20
- c2a: 59 f0 breq .+22 ; 0xc42 <Endpoint_WaitUntilReady+0x54>
- c2c: 41 50 subi r20, 0x01 ; 1
- c2e: c9 01 movw r24, r18
- c30: e3 cf rjmp .-58 ; 0xbf8 <Endpoint_WaitUntilReady+0xa>
+ bc6: 44 23 and r20, r20
+ bc8: 59 f0 breq .+22 ; 0xbe0 <Endpoint_WaitUntilReady+0x54>
+ bca: 41 50 subi r20, 0x01 ; 1
+ bcc: c9 01 movw r24, r18
+ bce: e3 cf rjmp .-58 ; 0xb96 <Endpoint_WaitUntilReady+0xa>
for (;;)
{
if (Endpoint_GetEndpointDirection() == ENDPOINT_DIR_IN)
{
if (Endpoint_IsINReady())
return ENDPOINT_READYWAIT_NoError;
- c32: 80 e0 ldi r24, 0x00 ; 0
- c34: 08 95 ret
+ bd0: 80 e0 ldi r24, 0x00 ; 0
+ bd2: 08 95 ret
}
uint8_t USB_DeviceState_LCL = USB_DeviceState;
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
return ENDPOINT_READYWAIT_DeviceDisconnected;
- c36: 82 e0 ldi r24, 0x02 ; 2
- c38: 08 95 ret
+ bd4: 82 e0 ldi r24, 0x02 ; 2
+ bd6: 08 95 ret
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
return ENDPOINT_READYWAIT_BusSuspended;
- c3a: 83 e0 ldi r24, 0x03 ; 3
- c3c: 08 95 ret
+ bd8: 83 e0 ldi r24, 0x03 ; 3
+ bda: 08 95 ret
else if (Endpoint_IsStalled())
return ENDPOINT_READYWAIT_EndpointStalled;
- c3e: 81 e0 ldi r24, 0x01 ; 1
- c40: 08 95 ret
+ bdc: 81 e0 ldi r24, 0x01 ; 1
+ bde: 08 95 ret
if (CurrentFrameNumber != PreviousFrameNumber)
{
PreviousFrameNumber = CurrentFrameNumber;
if (!(TimeoutMSRem--))
return ENDPOINT_READYWAIT_Timeout;
- c42: 84 e0 ldi r24, 0x04 ; 4
- c44: 08 95 ret
+ be0: 84 e0 ldi r24, 0x04 ; 4
+ be2: 08 95 ret
return ENDPOINT_READYWAIT_NoError;
}
else
{
if (Endpoint_IsOUTReceived())
return ENDPOINT_READYWAIT_NoError;
- c46: 80 e0 ldi r24, 0x00 ; 0
+ be4: 80 e0 ldi r24, 0x00 ; 0
if (!(TimeoutMSRem--))
return ENDPOINT_READYWAIT_Timeout;
}
}
}
- c48: 08 95 ret
+ be6: 08 95 ret
* \return Boolean \c true if current endpoint is has received an OUT packet, \c false otherwise.
*/
static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsOUTReceived(void)
{
return ((UEINTX & (1 << RXOUTI)) ? true : false);
- c4a: 20 91 e8 00 lds r18, 0x00E8
+ be8: 20 91 e8 00 lds r18, 0x00E8
if (Endpoint_IsINReady())
return ENDPOINT_READYWAIT_NoError;
}
else
{
if (Endpoint_IsOUTReceived())
- c4e: 22 ff sbrs r18, 2
- c50: db cf rjmp .-74 ; 0xc08 <Endpoint_WaitUntilReady+0x1a>
- c52: f9 cf rjmp .-14 ; 0xc46 <Endpoint_WaitUntilReady+0x58>
+ bec: 22 ff sbrs r18, 2
+ bee: db cf rjmp .-74 ; 0xba6 <Endpoint_WaitUntilReady+0x1a>
+ bf0: f9 cf rjmp .-14 ; 0xbe4 <Endpoint_WaitUntilReady+0x58>
-00000c54 <USB_ResetInterface>:
+00000bf2 <USB_ResetInterface>:
{
#if defined(USB_CAN_BE_BOTH)
bool UIDModeSelectEnabled = ((UHWCON & (1 << UIDE)) != 0);
#endif
USB_INT_DisableAllInterrupts();
- c54: 40 d0 rcall .+128 ; 0xcd6 <USB_INT_DisableAllInterrupts>
+ bf2: 40 d0 rcall .+128 ; 0xc74 <USB_INT_DisableAllInterrupts>
USB_INT_ClearAllInterrupts();
- c56: 42 d0 rcall .+132 ; 0xcdc <USB_INT_ClearAllInterrupts>
+ bf4: 42 d0 rcall .+132 ; 0xc7a <USB_INT_ClearAllInterrupts>
}
static inline void USB_Controller_Reset(void) ATTR_ALWAYS_INLINE;
static inline void USB_Controller_Reset(void)
{
USBCON &= ~(1 << USBE);
- c58: 80 91 d8 00 lds r24, 0x00D8
- c5c: 8f 77 andi r24, 0x7F ; 127
- c5e: 80 93 d8 00 sts 0x00D8, r24
+ bf6: 80 91 d8 00 lds r24, 0x00D8
+ bfa: 8f 77 andi r24, 0x7F ; 127
+ bfc: 80 93 d8 00 sts 0x00D8, r24
USBCON |= (1 << USBE);
- c62: 80 91 d8 00 lds r24, 0x00D8
- c66: 80 68 ori r24, 0x80 ; 128
- c68: 80 93 d8 00 sts 0x00D8, r24
+ c00: 80 91 d8 00 lds r24, 0x00D8
+ c04: 80 68 ori r24, 0x80 ; 128
+ c06: 80 93 d8 00 sts 0x00D8, r24
}
static inline void USB_CLK_Unfreeze(void) ATTR_ALWAYS_INLINE;
static inline void USB_CLK_Unfreeze(void)
{
USBCON &= ~(1 << FRZCLK);
- c6c: 80 91 d8 00 lds r24, 0x00D8
- c70: 8f 7d andi r24, 0xDF ; 223
- c72: 80 93 d8 00 sts 0x00D8, r24
+ c0a: 80 91 d8 00 lds r24, 0x00D8
+ c0e: 8f 7d andi r24, 0xDF ; 223
+ c10: 80 93 d8 00 sts 0x00D8, r24
/* Inline Functions: */
static inline void USB_PLL_On(void) ATTR_ALWAYS_INLINE;
static inline void USB_PLL_On(void)
{
PLLCSR = USB_PLL_PSC;
- c76: 84 e0 ldi r24, 0x04 ; 4
- c78: 89 bd out 0x29, r24 ; 41
+ c14: 84 e0 ldi r24, 0x04 ; 4
+ c16: 89 bd out 0x29, r24 ; 41
PLLCSR = (USB_PLL_PSC | (1 << PLLE));
- c7a: 86 e0 ldi r24, 0x06 ; 6
- c7c: 89 bd out 0x29, r24 ; 41
+ c18: 86 e0 ldi r24, 0x06 ; 6
+ c1a: 89 bd out 0x29, r24 ; 41
if (!(USB_Options & USB_OPT_MANUAL_PLL))
{
#if defined(USB_SERIES_2_AVR)
USB_PLL_On();
while (!(USB_PLL_IsReady()));
- c7e: 09 b4 in r0, 0x29 ; 41
- c80: 00 fe sbrs r0, 0
- c82: fd cf rjmp .-6 ; 0xc7e <USB_ResetInterface+0x2a>
+ c1c: 09 b4 in r0, 0x29 ; 41
+ c1e: 00 fe sbrs r0, 0
+ c20: fd cf rjmp .-6 ; 0xc1c <USB_ResetInterface+0x2a>
}
#if defined(USB_CAN_BE_DEVICE)
static void USB_Init_Device(void)
{
USB_DeviceState = DEVICE_STATE_Unattached;
- c84: 1e ba out 0x1e, r1 ; 30
+ c22: 1e ba out 0x1e, r1 ; 30
USB_Device_ConfigurationNumber = 0;
- c86: 10 92 6a 02 sts 0x026A, r1
+ c24: 10 92 70 02 sts 0x0270, r1
#if !defined(NO_DEVICE_REMOTE_WAKEUP)
USB_Device_RemoteWakeupEnabled = false;
- c8a: 10 92 6c 02 sts 0x026C, r1
+ c28: 10 92 72 02 sts 0x0272, r1
#endif
#if !defined(NO_DEVICE_SELF_POWER)
USB_Device_CurrentlySelfPowered = false;
- c8e: 10 92 6b 02 sts 0x026B, r1
+ c2c: 10 92 71 02 sts 0x0271, r1
uint8_t Number = (Address & ENDPOINT_EPNUM_MASK);
if (Number >= ENDPOINT_TOTAL_ENDPOINTS)
return false;
return Endpoint_ConfigureEndpoint_Prv(Number,
- c92: 80 e0 ldi r24, 0x00 ; 0
- c94: 60 e0 ldi r22, 0x00 ; 0
- c96: 42 e0 ldi r20, 0x02 ; 2
- c98: 10 df rcall .-480 ; 0xaba <Endpoint_ConfigureEndpoint_Prv>
+ c30: 80 e0 ldi r24, 0x00 ; 0
+ c32: 60 e0 ldi r22, 0x00 ; 0
+ c34: 42 e0 ldi r20, 0x02 ; 2
+ c36: 10 df rcall .-480 ; 0xa58 <Endpoint_ConfigureEndpoint_Prv>
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
UDINT &= ~(1 << WAKEUPI);
break;
case USB_INT_SUSPI:
UDINT &= ~(1 << SUSPI);
- c9a: 80 91 e1 00 lds r24, 0x00E1
- c9e: 8e 7f andi r24, 0xFE ; 254
- ca0: 80 93 e1 00 sts 0x00E1, r24
+ c38: 80 91 e1 00 lds r24, 0x00E1
+ c3c: 8e 7f andi r24, 0xFE ; 254
+ c3e: 80 93 e1 00 sts 0x00E1, r24
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
UDIEN |= (1 << WAKEUPE);
break;
case USB_INT_SUSPI:
UDIEN |= (1 << SUSPE);
- ca4: 80 91 e2 00 lds r24, 0x00E2
- ca8: 81 60 ori r24, 0x01 ; 1
- caa: 80 93 e2 00 sts 0x00E2, r24
+ c42: 80 91 e2 00 lds r24, 0x00E2
+ c46: 81 60 ori r24, 0x01 ; 1
+ c48: 80 93 e2 00 sts 0x00E2, r24
break;
case USB_INT_EORSTI:
UDIEN |= (1 << EORSTE);
- cae: 80 91 e2 00 lds r24, 0x00E2
- cb2: 88 60 ori r24, 0x08 ; 8
- cb4: 80 93 e2 00 sts 0x00E2, r24
+ c4c: 80 91 e2 00 lds r24, 0x00E2
+ c50: 88 60 ori r24, 0x08 ; 8
+ c52: 80 93 e2 00 sts 0x00E2, r24
* register and despite the datasheet making no mention of its requirement in host mode.
*/
static inline void USB_Attach(void) ATTR_ALWAYS_INLINE;
static inline void USB_Attach(void)
{
UDCON &= ~(1 << DETACH);
- cb8: 80 91 e0 00 lds r24, 0x00E0
- cbc: 8e 7f andi r24, 0xFE ; 254
- cbe: 80 93 e0 00 sts 0x00E0, r24
+ c56: 80 91 e0 00 lds r24, 0x00E0
+ c5a: 8e 7f andi r24, 0xFE ; 254
+ c5c: 80 93 e0 00 sts 0x00E0, r24
}
#if (defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
USB_OTGPAD_On();
#endif
}
- cc2: 08 95 ret
+ c60: 08 95 ret
-00000cc4 <USB_Init>:
+00000c62 <USB_Init>:
static inline void USB_REG_On(void)
{
#if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)
UHWCON |= (1 << UVREGE);
#else
REGCR &= ~(1 << REGDIS);
- cc4: e3 e6 ldi r30, 0x63 ; 99
- cc6: f0 e0 ldi r31, 0x00 ; 0
- cc8: 80 81 ld r24, Z
- cca: 8e 7f andi r24, 0xFE ; 254
- ccc: 80 83 st Z, r24
+ c62: e3 e6 ldi r30, 0x63 ; 99
+ c64: f0 e0 ldi r31, 0x00 ; 0
+ c66: 80 81 ld r24, Z
+ c68: 8e 7f andi r24, 0xFE ; 254
+ c6a: 80 83 st Z, r24
UHWCON &= ~(1 << UIDE);
USB_CurrentMode = Mode;
}
#endif
USB_IsInitialized = true;
- cce: 81 e0 ldi r24, 0x01 ; 1
- cd0: 80 93 6d 02 sts 0x026D, r24
+ c6c: 81 e0 ldi r24, 0x01 ; 1
+ c6e: 80 93 73 02 sts 0x0273, r24
USB_ResetInterface();
}
- cd4: bf cf rjmp .-130 ; 0xc54 <USB_ResetInterface>
+ c72: bf cf rjmp .-130 ; 0xbf2 <USB_ResetInterface>
-00000cd6 <USB_INT_DisableAllInterrupts>:
+00000c74 <USB_INT_DisableAllInterrupts>:
#if defined(USB_CAN_BE_HOST)
UHIEN = 0;
#endif
#if defined(USB_CAN_BE_DEVICE)
UDIEN = 0;
- cd6: 10 92 e2 00 sts 0x00E2, r1
+ c74: 10 92 e2 00 sts 0x00E2, r1
#endif
}
- cda: 08 95 ret
+ c78: 08 95 ret
-00000cdc <USB_INT_ClearAllInterrupts>:
+00000c7a <USB_INT_ClearAllInterrupts>:
#if defined(USB_CAN_BE_HOST)
UHINT = 0;
#endif
#if defined(USB_CAN_BE_DEVICE)
UDINT = 0;
- cdc: 10 92 e1 00 sts 0x00E1, r1
+ c7a: 10 92 e1 00 sts 0x00E1, r1
#endif
}
- ce0: 08 95 ret
+ c7e: 08 95 ret
-00000ce2 <__vector_11>:
+00000c80 <__vector_11>:
ISR(USB_GEN_vect, ISR_BLOCK)
{
- ce2: 1f 92 push r1
- ce4: 0f 92 push r0
- ce6: 0f b6 in r0, 0x3f ; 63
- ce8: 0f 92 push r0
- cea: 11 24 eor r1, r1
- cec: 2f 93 push r18
- cee: 3f 93 push r19
- cf0: 4f 93 push r20
- cf2: 5f 93 push r21
- cf4: 6f 93 push r22
- cf6: 7f 93 push r23
- cf8: 8f 93 push r24
- cfa: 9f 93 push r25
- cfc: af 93 push r26
- cfe: bf 93 push r27
- d00: ef 93 push r30
- d02: ff 93 push r31
+ c80: 1f 92 push r1
+ c82: 0f 92 push r0
+ c84: 0f b6 in r0, 0x3f ; 63
+ c86: 0f 92 push r0
+ c88: 11 24 eor r1, r1
+ c8a: 2f 93 push r18
+ c8c: 3f 93 push r19
+ c8e: 4f 93 push r20
+ c90: 5f 93 push r21
+ c92: 6f 93 push r22
+ c94: 7f 93 push r23
+ c96: 8f 93 push r24
+ c98: 9f 93 push r25
+ c9a: af 93 push r26
+ c9c: bf 93 push r27
+ c9e: ef 93 push r30
+ ca0: ff 93 push r31
case USB_INT_SUSPI:
return (UDINT & (1 << SUSPI));
case USB_INT_EORSTI:
return (UDINT & (1 << EORSTI));
case USB_INT_SOFI:
return (UDINT & (1 << SOFI));
- d04: 80 91 e1 00 lds r24, 0x00E1
+ ca2: 80 91 e1 00 lds r24, 0x00E1
#if defined(USB_CAN_BE_DEVICE)
#if !defined(NO_SOF_EVENTS)
if (USB_INT_HasOccurred(USB_INT_SOFI) && USB_INT_IsEnabled(USB_INT_SOFI))
- d08: 82 ff sbrs r24, 2
- d0a: 0a c0 rjmp .+20 ; 0xd20 <__vector_11+0x3e>
+ ca6: 82 ff sbrs r24, 2
+ ca8: 0a c0 rjmp .+20 ; 0xcbe <__vector_11+0x3e>
case USB_INT_SUSPI:
return (UDIEN & (1 << SUSPE));
case USB_INT_EORSTI:
return (UDIEN & (1 << EORSTE));
case USB_INT_SOFI:
return (UDIEN & (1 << SOFE));
- d0c: 80 91 e2 00 lds r24, 0x00E2
- d10: 82 ff sbrs r24, 2
- d12: 06 c0 rjmp .+12 ; 0xd20 <__vector_11+0x3e>
+ caa: 80 91 e2 00 lds r24, 0x00E2
+ cae: 82 ff sbrs r24, 2
+ cb0: 06 c0 rjmp .+12 ; 0xcbe <__vector_11+0x3e>
break;
case USB_INT_EORSTI:
UDINT &= ~(1 << EORSTI);
break;
case USB_INT_SOFI:
UDINT &= ~(1 << SOFI);
- d14: 80 91 e1 00 lds r24, 0x00E1
- d18: 8b 7f andi r24, 0xFB ; 251
- d1a: 80 93 e1 00 sts 0x00E1, r24
+ cb2: 80 91 e1 00 lds r24, 0x00E1
+ cb6: 8b 7f andi r24, 0xFB ; 251
+ cb8: 80 93 e1 00 sts 0x00E1, r24
{
USB_INT_Clear(USB_INT_SOFI);
EVENT_USB_Device_StartOfFrame();
- d1e: 21 d2 rcall .+1090 ; 0x1162 <USB_Event_Stub>
+ cbc: 21 d2 rcall .+1090 ; 0x1100 <USB_Event_Stub>
#endif
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
return (UDINT & (1 << WAKEUPI));
case USB_INT_SUSPI:
return (UDINT & (1 << SUSPI));
- d20: 80 91 e1 00 lds r24, 0x00E1
+ cbe: 80 91 e1 00 lds r24, 0x00E1
EVENT_USB_Device_Disconnect();
}
}
#endif
if (USB_INT_HasOccurred(USB_INT_SUSPI) && USB_INT_IsEnabled(USB_INT_SUSPI))
- d24: 80 ff sbrs r24, 0
- d26: 16 c0 rjmp .+44 ; 0xd54 <__vector_11+0x72>
+ cc2: 80 ff sbrs r24, 0
+ cc4: 16 c0 rjmp .+44 ; 0xcf2 <__vector_11+0x72>
#endif
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
return (UDIEN & (1 << WAKEUPE));
case USB_INT_SUSPI:
return (UDIEN & (1 << SUSPE));
- d28: 80 91 e2 00 lds r24, 0x00E2
- d2c: 80 ff sbrs r24, 0
- d2e: 12 c0 rjmp .+36 ; 0xd54 <__vector_11+0x72>
+ cc6: 80 91 e2 00 lds r24, 0x00E2
+ cca: 80 ff sbrs r24, 0
+ ccc: 12 c0 rjmp .+36 ; 0xcf2 <__vector_11+0x72>
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
UDIEN &= ~(1 << WAKEUPE);
break;
case USB_INT_SUSPI:
UDIEN &= ~(1 << SUSPE);
- d30: 80 91 e2 00 lds r24, 0x00E2
- d34: 8e 7f andi r24, 0xFE ; 254
- d36: 80 93 e2 00 sts 0x00E2, r24
+ cce: 80 91 e2 00 lds r24, 0x00E2
+ cd2: 8e 7f andi r24, 0xFE ; 254
+ cd4: 80 93 e2 00 sts 0x00E2, r24
USBCON |= (1 << IDTE);
break;
#endif
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
UDIEN |= (1 << WAKEUPE);
- d3a: 80 91 e2 00 lds r24, 0x00E2
- d3e: 80 61 ori r24, 0x10 ; 16
- d40: 80 93 e2 00 sts 0x00E2, r24
+ cd8: 80 91 e2 00 lds r24, 0x00E2
+ cdc: 80 61 ori r24, 0x10 ; 16
+ cde: 80 93 e2 00 sts 0x00E2, r24
#endif
static inline void USB_CLK_Freeze(void) ATTR_ALWAYS_INLINE;
static inline void USB_CLK_Freeze(void)
{
USBCON |= (1 << FRZCLK);
- d44: 80 91 d8 00 lds r24, 0x00D8
- d48: 80 62 ori r24, 0x20 ; 32
- d4a: 80 93 d8 00 sts 0x00D8, r24
+ ce2: 80 91 d8 00 lds r24, 0x00D8
+ ce6: 80 62 ori r24, 0x20 ; 32
+ ce8: 80 93 d8 00 sts 0x00D8, r24
}
static inline void USB_PLL_Off(void) ATTR_ALWAYS_INLINE;
static inline void USB_PLL_Off(void)
{
PLLCSR = 0;
- d4e: 19 bc out 0x29, r1 ; 41
+ cec: 19 bc out 0x29, r1 ; 41
if (!(USB_Options & USB_OPT_MANUAL_PLL))
USB_PLL_Off();
#if defined(USB_SERIES_2_AVR) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
USB_DeviceState = DEVICE_STATE_Unattached;
- d50: 1e ba out 0x1e, r1 ; 30
+ cee: 1e ba out 0x1e, r1 ; 30
EVENT_USB_Device_Disconnect();
- d52: 60 dc rcall .-1856 ; 0x614 <EVENT_USB_Device_Disconnect>
+ cf0: de dc rcall .-1604 ; 0x6ae <EVENT_USB_Device_Disconnect>
case USB_INT_IDTI:
return (USBINT & (1 << IDTI));
#endif
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
return (UDINT & (1 << WAKEUPI));
- d54: 80 91 e1 00 lds r24, 0x00E1
+ cf2: 80 91 e1 00 lds r24, 0x00E1
USB_DeviceState = DEVICE_STATE_Suspended;
EVENT_USB_Device_Suspend();
#endif
}
if (USB_INT_HasOccurred(USB_INT_WAKEUPI) && USB_INT_IsEnabled(USB_INT_WAKEUPI))
- d58: 84 ff sbrs r24, 4
- d5a: 2c c0 rjmp .+88 ; 0xdb4 <__vector_11+0xd2>
+ cf6: 84 ff sbrs r24, 4
+ cf8: 2c c0 rjmp .+88 ; 0xd52 <__vector_11+0xd2>
case USB_INT_IDTI:
return (USBCON & (1 << IDTE));
#endif
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
return (UDIEN & (1 << WAKEUPE));
- d5c: 80 91 e2 00 lds r24, 0x00E2
- d60: 84 ff sbrs r24, 4
- d62: 28 c0 rjmp .+80 ; 0xdb4 <__vector_11+0xd2>
+ cfa: 80 91 e2 00 lds r24, 0x00E2
+ cfe: 84 ff sbrs r24, 4
+ d00: 28 c0 rjmp .+80 ; 0xd52 <__vector_11+0xd2>
/* Inline Functions: */
static inline void USB_PLL_On(void) ATTR_ALWAYS_INLINE;
static inline void USB_PLL_On(void)
{
PLLCSR = USB_PLL_PSC;
- d64: 84 e0 ldi r24, 0x04 ; 4
- d66: 89 bd out 0x29, r24 ; 41
+ d02: 84 e0 ldi r24, 0x04 ; 4
+ d04: 89 bd out 0x29, r24 ; 41
PLLCSR = (USB_PLL_PSC | (1 << PLLE));
- d68: 86 e0 ldi r24, 0x06 ; 6
- d6a: 89 bd out 0x29, r24 ; 41
+ d06: 86 e0 ldi r24, 0x06 ; 6
+ d08: 89 bd out 0x29, r24 ; 41
{
if (!(USB_Options & USB_OPT_MANUAL_PLL))
{
USB_PLL_On();
while (!(USB_PLL_IsReady()));
- d6c: 09 b4 in r0, 0x29 ; 41
- d6e: 00 fe sbrs r0, 0
- d70: fd cf rjmp .-6 ; 0xd6c <__vector_11+0x8a>
+ d0a: 09 b4 in r0, 0x29 ; 41
+ d0c: 00 fe sbrs r0, 0
+ d0e: fd cf rjmp .-6 ; 0xd0a <__vector_11+0x8a>
}
static inline void USB_CLK_Unfreeze(void) ATTR_ALWAYS_INLINE;
static inline void USB_CLK_Unfreeze(void)
{
USBCON &= ~(1 << FRZCLK);
- d72: 80 91 d8 00 lds r24, 0x00D8
- d76: 8f 7d andi r24, 0xDF ; 223
- d78: 80 93 d8 00 sts 0x00D8, r24
+ d10: 80 91 d8 00 lds r24, 0x00D8
+ d14: 8f 7d andi r24, 0xDF ; 223
+ d16: 80 93 d8 00 sts 0x00D8, r24
USBINT &= ~(1 << IDTI);
break;
#endif
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
UDINT &= ~(1 << WAKEUPI);
- d7c: 80 91 e1 00 lds r24, 0x00E1
- d80: 8f 7e andi r24, 0xEF ; 239
- d82: 80 93 e1 00 sts 0x00E1, r24
+ d1a: 80 91 e1 00 lds r24, 0x00E1
+ d1e: 8f 7e andi r24, 0xEF ; 239
+ d20: 80 93 e1 00 sts 0x00E1, r24
USBCON &= ~(1 << IDTE);
break;
#endif
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
UDIEN &= ~(1 << WAKEUPE);
- d86: 80 91 e2 00 lds r24, 0x00E2
- d8a: 8f 7e andi r24, 0xEF ; 239
- d8c: 80 93 e2 00 sts 0x00E2, r24
+ d24: 80 91 e2 00 lds r24, 0x00E2
+ d28: 8f 7e andi r24, 0xEF ; 239
+ d2a: 80 93 e2 00 sts 0x00E2, r24
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
UDIEN |= (1 << WAKEUPE);
break;
case USB_INT_SUSPI:
UDIEN |= (1 << SUSPE);
- d90: 80 91 e2 00 lds r24, 0x00E2
- d94: 81 60 ori r24, 0x01 ; 1
- d96: 80 93 e2 00 sts 0x00E2, r24
+ d2e: 80 91 e2 00 lds r24, 0x00E2
+ d32: 81 60 ori r24, 0x01 ; 1
+ d34: 80 93 e2 00 sts 0x00E2, r24
USB_INT_Clear(USB_INT_WAKEUPI);
USB_INT_Disable(USB_INT_WAKEUPI);
USB_INT_Enable(USB_INT_SUSPI);
if (USB_Device_ConfigurationNumber)
- d9a: 80 91 6a 02 lds r24, 0x026A
- d9e: 88 23 and r24, r24
- da0: 21 f4 brne .+8 ; 0xdaa <__vector_11+0xc8>
+ d38: 80 91 70 02 lds r24, 0x0270
+ d3c: 88 23 and r24, r24
+ d3e: 21 f4 brne .+8 ; 0xd48 <__vector_11+0xc8>
}
static inline bool USB_Device_IsAddressSet(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
static inline bool USB_Device_IsAddressSet(void)
{
return (UDADDR & (1 << ADDEN));
- da2: 80 91 e3 00 lds r24, 0x00E3
+ d40: 80 91 e3 00 lds r24, 0x00E3
USB_DeviceState = DEVICE_STATE_Configured;
else
USB_DeviceState = (USB_Device_IsAddressSet()) ? DEVICE_STATE_Configured : DEVICE_STATE_Powered;
- da6: 87 ff sbrs r24, 7
- da8: 02 c0 rjmp .+4 ; 0xdae <__vector_11+0xcc>
- daa: 84 e0 ldi r24, 0x04 ; 4
- dac: 01 c0 rjmp .+2 ; 0xdb0 <__vector_11+0xce>
- dae: 81 e0 ldi r24, 0x01 ; 1
- db0: 8e bb out 0x1e, r24 ; 30
+ d44: 87 ff sbrs r24, 7
+ d46: 02 c0 rjmp .+4 ; 0xd4c <__vector_11+0xcc>
+ d48: 84 e0 ldi r24, 0x04 ; 4
+ d4a: 01 c0 rjmp .+2 ; 0xd4e <__vector_11+0xce>
+ d4c: 81 e0 ldi r24, 0x01 ; 1
+ d4e: 8e bb out 0x1e, r24 ; 30
#if defined(USB_SERIES_2_AVR) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
EVENT_USB_Device_Connect();
- db2: 2f dc rcall .-1954 ; 0x612 <EVENT_USB_Device_Connect>
+ d50: ad dc rcall .-1702 ; 0x6ac <EVENT_USB_Device_Connect>
case USB_INT_WAKEUPI:
return (UDINT & (1 << WAKEUPI));
case USB_INT_SUSPI:
return (UDINT & (1 << SUSPI));
case USB_INT_EORSTI:
return (UDINT & (1 << EORSTI));
- db4: 80 91 e1 00 lds r24, 0x00E1
+ d52: 80 91 e1 00 lds r24, 0x00E1
#else
EVENT_USB_Device_WakeUp();
#endif
}
if (USB_INT_HasOccurred(USB_INT_EORSTI) && USB_INT_IsEnabled(USB_INT_EORSTI))
- db8: 83 ff sbrs r24, 3
- dba: 26 c0 rjmp .+76 ; 0xe08 <__vector_11+0x126>
+ d56: 83 ff sbrs r24, 3
+ d58: 26 c0 rjmp .+76 ; 0xda6 <__vector_11+0x126>
case USB_INT_WAKEUPI:
return (UDIEN & (1 << WAKEUPE));
case USB_INT_SUSPI:
return (UDIEN & (1 << SUSPE));
case USB_INT_EORSTI:
return (UDIEN & (1 << EORSTE));
- dbc: 80 91 e2 00 lds r24, 0x00E2
- dc0: 83 ff sbrs r24, 3
- dc2: 22 c0 rjmp .+68 ; 0xe08 <__vector_11+0x126>
+ d5a: 80 91 e2 00 lds r24, 0x00E2
+ d5e: 83 ff sbrs r24, 3
+ d60: 22 c0 rjmp .+68 ; 0xda6 <__vector_11+0x126>
break;
case USB_INT_SUSPI:
UDINT &= ~(1 << SUSPI);
break;
case USB_INT_EORSTI:
UDINT &= ~(1 << EORSTI);
- dc4: 80 91 e1 00 lds r24, 0x00E1
- dc8: 87 7f andi r24, 0xF7 ; 247
- dca: 80 93 e1 00 sts 0x00E1, r24
+ d62: 80 91 e1 00 lds r24, 0x00E1
+ d66: 87 7f andi r24, 0xF7 ; 247
+ d68: 80 93 e1 00 sts 0x00E1, r24
{
USB_INT_Clear(USB_INT_EORSTI);
USB_DeviceState = DEVICE_STATE_Default;
- dce: 82 e0 ldi r24, 0x02 ; 2
- dd0: 8e bb out 0x1e, r24 ; 30
+ d6c: 82 e0 ldi r24, 0x02 ; 2
+ d6e: 8e bb out 0x1e, r24 ; 30
USB_Device_ConfigurationNumber = 0;
- dd2: 10 92 6a 02 sts 0x026A, r1
+ d70: 10 92 70 02 sts 0x0270, r1
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
UDINT &= ~(1 << WAKEUPI);
break;
case USB_INT_SUSPI:
UDINT &= ~(1 << SUSPI);
- dd6: 80 91 e1 00 lds r24, 0x00E1
- dda: 8e 7f andi r24, 0xFE ; 254
- ddc: 80 93 e1 00 sts 0x00E1, r24
+ d74: 80 91 e1 00 lds r24, 0x00E1
+ d78: 8e 7f andi r24, 0xFE ; 254
+ d7a: 80 93 e1 00 sts 0x00E1, r24
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
UDIEN &= ~(1 << WAKEUPE);
break;
case USB_INT_SUSPI:
UDIEN &= ~(1 << SUSPE);
- de0: 80 91 e2 00 lds r24, 0x00E2
- de4: 8e 7f andi r24, 0xFE ; 254
- de6: 80 93 e2 00 sts 0x00E2, r24
+ d7e: 80 91 e2 00 lds r24, 0x00E2
+ d82: 8e 7f andi r24, 0xFE ; 254
+ d84: 80 93 e2 00 sts 0x00E2, r24
USBCON |= (1 << IDTE);
break;
#endif
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
UDIEN |= (1 << WAKEUPE);
- dea: 80 91 e2 00 lds r24, 0x00E2
- dee: 80 61 ori r24, 0x10 ; 16
- df0: 80 93 e2 00 sts 0x00E2, r24
+ d88: 80 91 e2 00 lds r24, 0x00E2
+ d8c: 80 61 ori r24, 0x10 ; 16
+ d8e: 80 93 e2 00 sts 0x00E2, r24
uint8_t Number = (Address & ENDPOINT_EPNUM_MASK);
if (Number >= ENDPOINT_TOTAL_ENDPOINTS)
return false;
return Endpoint_ConfigureEndpoint_Prv(Number,
- df4: 80 e0 ldi r24, 0x00 ; 0
- df6: 60 e0 ldi r22, 0x00 ; 0
- df8: 42 e0 ldi r20, 0x02 ; 2
- dfa: 5f de rcall .-834 ; 0xaba <Endpoint_ConfigureEndpoint_Prv>
+ d92: 80 e0 ldi r24, 0x00 ; 0
+ d94: 60 e0 ldi r22, 0x00 ; 0
+ d96: 42 e0 ldi r20, 0x02 ; 2
+ d98: 5f de rcall .-834 ; 0xa58 <Endpoint_ConfigureEndpoint_Prv>
break;
case USB_INT_SOFI:
UDIEN |= (1 << SOFE);
break;
case USB_INT_RXSTPI:
UEIENX |= (1 << RXSTPE);
- dfc: 80 91 f0 00 lds r24, 0x00F0
- e00: 88 60 ori r24, 0x08 ; 8
- e02: 80 93 f0 00 sts 0x00F0, r24
+ d9a: 80 91 f0 00 lds r24, 0x00F0
+ d9e: 88 60 ori r24, 0x08 ; 8
+ da0: 80 93 f0 00 sts 0x00F0, r24
#if defined(INTERRUPT_CONTROL_ENDPOINT)
USB_INT_Enable(USB_INT_RXSTPI);
#endif
EVENT_USB_Device_Reset();
- e06: ad d1 rcall .+858 ; 0x1162 <USB_Event_Stub>
+ da4: ad d1 rcall .+858 ; 0x1100 <USB_Event_Stub>
USB_ResetInterface();
EVENT_USB_UIDChange();
}
#endif
}
- e08: ff 91 pop r31
- e0a: ef 91 pop r30
- e0c: bf 91 pop r27
- e0e: af 91 pop r26
- e10: 9f 91 pop r25
- e12: 8f 91 pop r24
- e14: 7f 91 pop r23
- e16: 6f 91 pop r22
- e18: 5f 91 pop r21
- e1a: 4f 91 pop r20
- e1c: 3f 91 pop r19
- e1e: 2f 91 pop r18
- e20: 0f 90 pop r0
- e22: 0f be out 0x3f, r0 ; 63
- e24: 0f 90 pop r0
- e26: 1f 90 pop r1
- e28: 18 95 reti
-
-00000e2a <__vector_12>:
+ da6: ff 91 pop r31
+ da8: ef 91 pop r30
+ daa: bf 91 pop r27
+ dac: af 91 pop r26
+ dae: 9f 91 pop r25
+ db0: 8f 91 pop r24
+ db2: 7f 91 pop r23
+ db4: 6f 91 pop r22
+ db6: 5f 91 pop r21
+ db8: 4f 91 pop r20
+ dba: 3f 91 pop r19
+ dbc: 2f 91 pop r18
+ dbe: 0f 90 pop r0
+ dc0: 0f be out 0x3f, r0 ; 63
+ dc2: 0f 90 pop r0
+ dc4: 1f 90 pop r1
+ dc6: 18 95 reti
+
+00000dc8 <__vector_12>:
#if defined(INTERRUPT_CONTROL_ENDPOINT) && defined(USB_CAN_BE_DEVICE)
ISR(USB_COM_vect, ISR_BLOCK)
{
- e2a: 1f 92 push r1
- e2c: 0f 92 push r0
- e2e: 0f b6 in r0, 0x3f ; 63
- e30: 0f 92 push r0
- e32: 11 24 eor r1, r1
- e34: 1f 93 push r17
- e36: 2f 93 push r18
- e38: 3f 93 push r19
- e3a: 4f 93 push r20
- e3c: 5f 93 push r21
- e3e: 6f 93 push r22
- e40: 7f 93 push r23
- e42: 8f 93 push r24
- e44: 9f 93 push r25
- e46: af 93 push r26
- e48: bf 93 push r27
- e4a: ef 93 push r30
- e4c: ff 93 push r31
+ dc8: 1f 92 push r1
+ dca: 0f 92 push r0
+ dcc: 0f b6 in r0, 0x3f ; 63
+ dce: 0f 92 push r0
+ dd0: 11 24 eor r1, r1
+ dd2: 1f 93 push r17
+ dd4: 2f 93 push r18
+ dd6: 3f 93 push r19
+ dd8: 4f 93 push r20
+ dda: 5f 93 push r21
+ ddc: 6f 93 push r22
+ dde: 7f 93 push r23
+ de0: 8f 93 push r24
+ de2: 9f 93 push r25
+ de4: af 93 push r26
+ de6: bf 93 push r27
+ de8: ef 93 push r30
+ dea: ff 93 push r31
*/
static inline uint8_t Endpoint_GetCurrentEndpoint(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline uint8_t Endpoint_GetCurrentEndpoint(void)
{
#if !defined(CONTROL_ONLY_DEVICE)
return ((UENUM & ENDPOINT_EPNUM_MASK) | Endpoint_GetEndpointDirection());
- e4e: 10 91 e9 00 lds r17, 0x00E9
- e52: 1f 70 andi r17, 0x0F ; 15
+ dec: 10 91 e9 00 lds r17, 0x00E9
+ df0: 1f 70 andi r17, 0x0F ; 15
* \return The currently selected endpoint's direction, as a \c ENDPOINT_DIR_* mask.
*/
static inline uint8_t Endpoint_GetEndpointDirection(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline uint8_t Endpoint_GetEndpointDirection(void)
{
return (UECFG0X & (1 << EPDIR)) ? ENDPOINT_DIR_IN : ENDPOINT_DIR_OUT;
- e54: 80 91 ec 00 lds r24, 0x00EC
+ df2: 80 91 ec 00 lds r24, 0x00EC
*/
static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void Endpoint_SelectEndpoint(const uint8_t Address)
{
#if !defined(CONTROL_ONLY_DEVICE)
UENUM = (Address & ENDPOINT_EPNUM_MASK);
- e58: 10 92 e9 00 sts 0x00E9, r1
+ df6: 10 92 e9 00 sts 0x00E9, r1
break;
case USB_INT_SOFI:
UDIEN &= ~(1 << SOFE);
break;
case USB_INT_RXSTPI:
UEIENX &= ~(1 << RXSTPE);
- e5c: 80 91 f0 00 lds r24, 0x00F0
- e60: 87 7f andi r24, 0xF7 ; 247
- e62: 80 93 f0 00 sts 0x00F0, r24
+ dfa: 80 91 f0 00 lds r24, 0x00F0
+ dfe: 87 7f andi r24, 0xF7 ; 247
+ e00: 80 93 f0 00 sts 0x00F0, r24
static inline void GlobalInterruptEnable(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
sei();
- e66: 78 94 sei
+ e04: 78 94 sei
Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
USB_INT_Disable(USB_INT_RXSTPI);
GlobalInterruptEnable();
USB_Device_ProcessControlRequest();
- e68: 1b d0 rcall .+54 ; 0xea0 <USB_Device_ProcessControlRequest>
- e6a: 10 92 e9 00 sts 0x00E9, r1
+ e06: 1b d0 rcall .+54 ; 0xe3e <USB_Device_ProcessControlRequest>
+ e08: 10 92 e9 00 sts 0x00E9, r1
break;
case USB_INT_SOFI:
UDIEN |= (1 << SOFE);
break;
case USB_INT_RXSTPI:
UEIENX |= (1 << RXSTPE);
- e6e: 80 91 f0 00 lds r24, 0x00F0
- e72: 88 60 ori r24, 0x08 ; 8
- e74: 80 93 f0 00 sts 0x00F0, r24
- e78: 10 93 e9 00 sts 0x00E9, r17
+ e0c: 80 91 f0 00 lds r24, 0x00F0
+ e10: 88 60 ori r24, 0x08 ; 8
+ e12: 80 93 f0 00 sts 0x00F0, r24
+ e16: 10 93 e9 00 sts 0x00E9, r17
Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
USB_INT_Enable(USB_INT_RXSTPI);
Endpoint_SelectEndpoint(PrevSelectedEndpoint);
}
- e7c: ff 91 pop r31
- e7e: ef 91 pop r30
- e80: bf 91 pop r27
- e82: af 91 pop r26
- e84: 9f 91 pop r25
- e86: 8f 91 pop r24
- e88: 7f 91 pop r23
- e8a: 6f 91 pop r22
- e8c: 5f 91 pop r21
- e8e: 4f 91 pop r20
- e90: 3f 91 pop r19
- e92: 2f 91 pop r18
- e94: 1f 91 pop r17
- e96: 0f 90 pop r0
- e98: 0f be out 0x3f, r0 ; 63
- e9a: 0f 90 pop r0
- e9c: 1f 90 pop r1
- e9e: 18 95 reti
-
-00000ea0 <USB_Device_ProcessControlRequest>:
+ e1a: ff 91 pop r31
+ e1c: ef 91 pop r30
+ e1e: bf 91 pop r27
+ e20: af 91 pop r26
+ e22: 9f 91 pop r25
+ e24: 8f 91 pop r24
+ e26: 7f 91 pop r23
+ e28: 6f 91 pop r22
+ e2a: 5f 91 pop r21
+ e2c: 4f 91 pop r20
+ e2e: 3f 91 pop r19
+ e30: 2f 91 pop r18
+ e32: 1f 91 pop r17
+ e34: 0f 90 pop r0
+ e36: 0f be out 0x3f, r0 ; 63
+ e38: 0f 90 pop r0
+ e3a: 1f 90 pop r1
+ e3c: 18 95 reti
+
+00000e3e <USB_Device_ProcessControlRequest>:
#if !defined(NO_DEVICE_REMOTE_WAKEUP)
bool USB_Device_RemoteWakeupEnabled;
#endif
void USB_Device_ProcessControlRequest(void)
{
- ea0: 1f 93 push r17
- ea2: df 93 push r29
- ea4: cf 93 push r28
- ea6: cd b7 in r28, 0x3d ; 61
- ea8: de b7 in r29, 0x3e ; 62
- eaa: ac 97 sbiw r28, 0x2c ; 44
- eac: 0f b6 in r0, 0x3f ; 63
- eae: f8 94 cli
- eb0: de bf out 0x3e, r29 ; 62
- eb2: 0f be out 0x3f, r0 ; 63
- eb4: cd bf out 0x3d, r28 ; 61
+ e3e: 1f 93 push r17
+ e40: df 93 push r29
+ e42: cf 93 push r28
+ e44: cd b7 in r28, 0x3d ; 61
+ e46: de b7 in r29, 0x3e ; 62
+ e48: ac 97 sbiw r28, 0x2c ; 44
+ e4a: 0f b6 in r0, 0x3f ; 63
+ e4c: f8 94 cli
+ e4e: de bf out 0x3e, r29 ; 62
+ e50: 0f be out 0x3f, r0 ; 63
+ e52: cd bf out 0x3d, r28 ; 61
USB_ControlRequest.bRequest = Endpoint_Read_8();
USB_ControlRequest.wValue = Endpoint_Read_16_LE();
USB_ControlRequest.wIndex = Endpoint_Read_16_LE();
USB_ControlRequest.wLength = Endpoint_Read_16_LE();
#else
uint8_t* RequestHeader = (uint8_t*)&USB_ControlRequest;
- eb6: ee e6 ldi r30, 0x6E ; 110
- eb8: f2 e0 ldi r31, 0x02 ; 2
+ e54: e4 e7 ldi r30, 0x74 ; 116
+ e56: f2 e0 ldi r31, 0x02 ; 2
* \return Next byte in the currently selected endpoint's FIFO buffer.
*/
static inline uint8_t Endpoint_Read_8(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline uint8_t Endpoint_Read_8(void)
{
return UEDATX;
- eba: 80 91 f1 00 lds r24, 0x00F1
+ e58: 80 91 f1 00 lds r24, 0x00F1
for (uint8_t RequestHeaderByte = 0; RequestHeaderByte < sizeof(USB_Request_Header_t); RequestHeaderByte++)
*(RequestHeader++) = Endpoint_Read_8();
- ebe: 81 93 st Z+, r24
+ e5c: 81 93 st Z+, r24
USB_ControlRequest.wIndex = Endpoint_Read_16_LE();
USB_ControlRequest.wLength = Endpoint_Read_16_LE();
#else
uint8_t* RequestHeader = (uint8_t*)&USB_ControlRequest;
for (uint8_t RequestHeaderByte = 0; RequestHeaderByte < sizeof(USB_Request_Header_t); RequestHeaderByte++)
- ec0: 22 e0 ldi r18, 0x02 ; 2
- ec2: e6 37 cpi r30, 0x76 ; 118
- ec4: f2 07 cpc r31, r18
- ec6: c9 f7 brne .-14 ; 0xeba <USB_Device_ProcessControlRequest+0x1a>
+ e5e: 22 e0 ldi r18, 0x02 ; 2
+ e60: ec 37 cpi r30, 0x7C ; 124
+ e62: f2 07 cpc r31, r18
+ e64: c9 f7 brne .-14 ; 0xe58 <USB_Device_ProcessControlRequest+0x1a>
*(RequestHeader++) = Endpoint_Read_8();
#endif
EVENT_USB_Device_ControlRequest();
- ec8: a9 db rcall .-2222 ; 0x61c <EVENT_USB_Device_ControlRequest>
+ e66: 27 dc rcall .-1970 ; 0x6b6 <EVENT_USB_Device_ControlRequest>
* \return Boolean \c true if the selected endpoint has received a SETUP packet, \c false otherwise.
*/
static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsSETUPReceived(void)
{
return ((UEINTX & (1 << RXSTPI)) ? true : false);
- eca: 80 91 e8 00 lds r24, 0x00E8
+ e68: 80 91 e8 00 lds r24, 0x00E8
if (Endpoint_IsSETUPReceived())
- ece: 83 ff sbrs r24, 3
- ed0: 30 c1 rjmp .+608 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
+ e6c: 83 ff sbrs r24, 3
+ e6e: 30 c1 rjmp .+608 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
{
uint8_t bmRequestType = USB_ControlRequest.bmRequestType;
- ed2: 80 91 6e 02 lds r24, 0x026E
+ e70: 80 91 74 02 lds r24, 0x0274
switch (USB_ControlRequest.bRequest)
- ed6: 20 91 6f 02 lds r18, 0x026F
- eda: 25 30 cpi r18, 0x05 ; 5
- edc: 09 f4 brne .+2 ; 0xee0 <USB_Device_ProcessControlRequest+0x40>
- ede: 84 c0 rjmp .+264 ; 0xfe8 <USB_Device_ProcessControlRequest+0x148>
- ee0: 26 30 cpi r18, 0x06 ; 6
- ee2: 40 f4 brcc .+16 ; 0xef4 <USB_Device_ProcessControlRequest+0x54>
- ee4: 21 30 cpi r18, 0x01 ; 1
- ee6: a1 f1 breq .+104 ; 0xf50 <USB_Device_ProcessControlRequest+0xb0>
- ee8: 21 30 cpi r18, 0x01 ; 1
- eea: 70 f0 brcs .+28 ; 0xf08 <USB_Device_ProcessControlRequest+0x68>
- eec: 23 30 cpi r18, 0x03 ; 3
- eee: 09 f0 breq .+2 ; 0xef2 <USB_Device_ProcessControlRequest+0x52>
- ef0: 20 c1 rjmp .+576 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
- ef2: 2e c0 rjmp .+92 ; 0xf50 <USB_Device_ProcessControlRequest+0xb0>
- ef4: 28 30 cpi r18, 0x08 ; 8
- ef6: 09 f4 brne .+2 ; 0xefa <USB_Device_ProcessControlRequest+0x5a>
- ef8: ef c0 rjmp .+478 ; 0x10d8 <USB_Device_ProcessControlRequest+0x238>
- efa: 29 30 cpi r18, 0x09 ; 9
- efc: 09 f4 brne .+2 ; 0xf00 <USB_Device_ProcessControlRequest+0x60>
- efe: fe c0 rjmp .+508 ; 0x10fc <USB_Device_ProcessControlRequest+0x25c>
- f00: 26 30 cpi r18, 0x06 ; 6
- f02: 09 f0 breq .+2 ; 0xf06 <USB_Device_ProcessControlRequest+0x66>
- f04: 16 c1 rjmp .+556 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
- f06: 92 c0 rjmp .+292 ; 0x102c <USB_Device_ProcessControlRequest+0x18c>
+ e74: 20 91 75 02 lds r18, 0x0275
+ e78: 25 30 cpi r18, 0x05 ; 5
+ e7a: 09 f4 brne .+2 ; 0xe7e <USB_Device_ProcessControlRequest+0x40>
+ e7c: 84 c0 rjmp .+264 ; 0xf86 <USB_Device_ProcessControlRequest+0x148>
+ e7e: 26 30 cpi r18, 0x06 ; 6
+ e80: 40 f4 brcc .+16 ; 0xe92 <USB_Device_ProcessControlRequest+0x54>
+ e82: 21 30 cpi r18, 0x01 ; 1
+ e84: a1 f1 breq .+104 ; 0xeee <USB_Device_ProcessControlRequest+0xb0>
+ e86: 21 30 cpi r18, 0x01 ; 1
+ e88: 70 f0 brcs .+28 ; 0xea6 <USB_Device_ProcessControlRequest+0x68>
+ e8a: 23 30 cpi r18, 0x03 ; 3
+ e8c: 09 f0 breq .+2 ; 0xe90 <USB_Device_ProcessControlRequest+0x52>
+ e8e: 20 c1 rjmp .+576 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
+ e90: 2e c0 rjmp .+92 ; 0xeee <USB_Device_ProcessControlRequest+0xb0>
+ e92: 28 30 cpi r18, 0x08 ; 8
+ e94: 09 f4 brne .+2 ; 0xe98 <USB_Device_ProcessControlRequest+0x5a>
+ e96: ef c0 rjmp .+478 ; 0x1076 <USB_Device_ProcessControlRequest+0x238>
+ e98: 29 30 cpi r18, 0x09 ; 9
+ e9a: 09 f4 brne .+2 ; 0xe9e <USB_Device_ProcessControlRequest+0x60>
+ e9c: fe c0 rjmp .+508 ; 0x109a <USB_Device_ProcessControlRequest+0x25c>
+ e9e: 26 30 cpi r18, 0x06 ; 6
+ ea0: 09 f0 breq .+2 ; 0xea4 <USB_Device_ProcessControlRequest+0x66>
+ ea2: 16 c1 rjmp .+556 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
+ ea4: 92 c0 rjmp .+292 ; 0xfca <USB_Device_ProcessControlRequest+0x18c>
{
case REQ_GetStatus:
if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
- f08: 80 38 cpi r24, 0x80 ; 128
- f0a: 21 f0 breq .+8 ; 0xf14 <USB_Device_ProcessControlRequest+0x74>
- f0c: 82 38 cpi r24, 0x82 ; 130
- f0e: 09 f0 breq .+2 ; 0xf12 <USB_Device_ProcessControlRequest+0x72>
- f10: 10 c1 rjmp .+544 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
- f12: 08 c0 rjmp .+16 ; 0xf24 <USB_Device_ProcessControlRequest+0x84>
+ ea6: 80 38 cpi r24, 0x80 ; 128
+ ea8: 21 f0 breq .+8 ; 0xeb2 <USB_Device_ProcessControlRequest+0x74>
+ eaa: 82 38 cpi r24, 0x82 ; 130
+ eac: 09 f0 breq .+2 ; 0xeb0 <USB_Device_ProcessControlRequest+0x72>
+ eae: 10 c1 rjmp .+544 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
+ eb0: 08 c0 rjmp .+16 ; 0xec2 <USB_Device_ProcessControlRequest+0x84>
Endpoint_ClearOUT();
}
static void USB_Device_GetStatus(void)
{
uint8_t CurrentStatus = 0;
- f14: 80 91 6b 02 lds r24, 0x026B
+ eb2: 80 91 71 02 lds r24, 0x0271
if (USB_Device_CurrentlySelfPowered)
CurrentStatus |= FEATURE_SELFPOWERED_ENABLED;
#endif
#if !defined(NO_DEVICE_REMOTE_WAKEUP)
if (USB_Device_RemoteWakeupEnabled)
- f18: 90 91 6c 02 lds r25, 0x026C
- f1c: 99 23 and r25, r25
- f1e: 71 f0 breq .+28 ; 0xf3c <USB_Device_ProcessControlRequest+0x9c>
+ eb6: 90 91 72 02 lds r25, 0x0272
+ eba: 99 23 and r25, r25
+ ebc: 71 f0 breq .+28 ; 0xeda <USB_Device_ProcessControlRequest+0x9c>
CurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
- f20: 82 60 ori r24, 0x02 ; 2
- f22: 0c c0 rjmp .+24 ; 0xf3c <USB_Device_ProcessControlRequest+0x9c>
+ ebe: 82 60 ori r24, 0x02 ; 2
+ ec0: 0c c0 rjmp .+24 ; 0xeda <USB_Device_ProcessControlRequest+0x9c>
*/
static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void Endpoint_SelectEndpoint(const uint8_t Address)
{
#if !defined(CONTROL_ONLY_DEVICE)
UENUM = (Address & ENDPOINT_EPNUM_MASK);
- f24: 80 91 72 02 lds r24, 0x0272
- f28: 8f 70 andi r24, 0x0F ; 15
- f2a: 80 93 e9 00 sts 0x00E9, r24
+ ec2: 80 91 78 02 lds r24, 0x0278
+ ec6: 8f 70 andi r24, 0x0F ; 15
+ ec8: 80 93 e9 00 sts 0x00E9, r24
* \return Boolean \c true if the currently selected endpoint is stalled, \c false otherwise.
*/
static inline bool Endpoint_IsStalled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsStalled(void)
{
return ((UECONX & (1 << STALLRQ)) ? true : false);
- f2e: 90 91 eb 00 lds r25, 0x00EB
+ ecc: 90 91 eb 00 lds r25, 0x00EB
break;
case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT):
#if !defined(CONTROL_ONLY_DEVICE)
Endpoint_SelectEndpoint((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
CurrentStatus = Endpoint_IsStalled();
- f32: 81 e0 ldi r24, 0x01 ; 1
- f34: 95 ff sbrs r25, 5
- f36: 80 e0 ldi r24, 0x00 ; 0
+ ed0: 81 e0 ldi r24, 0x01 ; 1
+ ed2: 95 ff sbrs r25, 5
+ ed4: 80 e0 ldi r24, 0x00 ; 0
*/
static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void Endpoint_SelectEndpoint(const uint8_t Address)
{
#if !defined(CONTROL_ONLY_DEVICE)
UENUM = (Address & ENDPOINT_EPNUM_MASK);
- f38: 10 92 e9 00 sts 0x00E9, r1
+ ed6: 10 92 e9 00 sts 0x00E9, r1
* \note This is not applicable for non CONTROL type endpoints.
*/
static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearSETUP(void)
{
UEINTX &= ~(1 << RXSTPI);
- f3c: 90 91 e8 00 lds r25, 0x00E8
- f40: 97 7f andi r25, 0xF7 ; 247
- f42: 90 93 e8 00 sts 0x00E8, r25
+ eda: 90 91 e8 00 lds r25, 0x00E8
+ ede: 97 7f andi r25, 0xF7 ; 247
+ ee0: 90 93 e8 00 sts 0x00E8, r25
* \param[in] Data Data to write to the currently selected endpoint's FIFO buffer.
*/
static inline void Endpoint_Write_16_LE(const uint16_t Data) ATTR_ALWAYS_INLINE;
static inline void Endpoint_Write_16_LE(const uint16_t Data)
{
UEDATX = (Data & 0xFF);
- f46: 80 93 f1 00 sts 0x00F1, r24
+ ee4: 80 93 f1 00 sts 0x00F1, r24
UEDATX = (Data >> 8);
- f4a: 10 92 f1 00 sts 0x00F1, r1
- f4e: cf c0 rjmp .+414 ; 0x10ee <USB_Device_ProcessControlRequest+0x24e>
+ ee8: 10 92 f1 00 sts 0x00F1, r1
+ eec: cf c0 rjmp .+414 ; 0x108c <USB_Device_ProcessControlRequest+0x24e>
}
break;
case REQ_ClearFeature:
case REQ_SetFeature:
if ((bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE)) ||
- f50: 88 23 and r24, r24
- f52: 19 f0 breq .+6 ; 0xf5a <USB_Device_ProcessControlRequest+0xba>
- f54: 82 30 cpi r24, 0x02 ; 2
- f56: 09 f0 breq .+2 ; 0xf5a <USB_Device_ProcessControlRequest+0xba>
- f58: ec c0 rjmp .+472 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
+ eee: 88 23 and r24, r24
+ ef0: 19 f0 breq .+6 ; 0xef8 <USB_Device_ProcessControlRequest+0xba>
+ ef2: 82 30 cpi r24, 0x02 ; 2
+ ef4: 09 f0 breq .+2 ; 0xef8 <USB_Device_ProcessControlRequest+0xba>
+ ef6: ec c0 rjmp .+472 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
Endpoint_ClearStatusStage();
}
static void USB_Device_ClearSetFeature(void)
{
switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT)
- f5a: 90 e0 ldi r25, 0x00 ; 0
- f5c: 8f 71 andi r24, 0x1F ; 31
- f5e: 90 70 andi r25, 0x00 ; 0
- f60: 00 97 sbiw r24, 0x00 ; 0
- f62: 29 f0 breq .+10 ; 0xf6e <USB_Device_ProcessControlRequest+0xce>
- f64: 82 30 cpi r24, 0x02 ; 2
- f66: 91 05 cpc r25, r1
- f68: 09 f0 breq .+2 ; 0xf6c <USB_Device_ProcessControlRequest+0xcc>
- f6a: e3 c0 rjmp .+454 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
- f6c: 0b c0 rjmp .+22 ; 0xf84 <USB_Device_ProcessControlRequest+0xe4>
+ ef8: 90 e0 ldi r25, 0x00 ; 0
+ efa: 8f 71 andi r24, 0x1F ; 31
+ efc: 90 70 andi r25, 0x00 ; 0
+ efe: 00 97 sbiw r24, 0x00 ; 0
+ f00: 29 f0 breq .+10 ; 0xf0c <USB_Device_ProcessControlRequest+0xce>
+ f02: 82 30 cpi r24, 0x02 ; 2
+ f04: 91 05 cpc r25, r1
+ f06: 09 f0 breq .+2 ; 0xf0a <USB_Device_ProcessControlRequest+0xcc>
+ f08: e3 c0 rjmp .+454 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
+ f0a: 0b c0 rjmp .+22 ; 0xf22 <USB_Device_ProcessControlRequest+0xe4>
{
#if !defined(NO_DEVICE_REMOTE_WAKEUP)
case REQREC_DEVICE:
if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_DeviceRemoteWakeup)
- f6e: 80 91 70 02 lds r24, 0x0270
- f72: 81 30 cpi r24, 0x01 ; 1
- f74: 09 f0 breq .+2 ; 0xf78 <USB_Device_ProcessControlRequest+0xd8>
- f76: dd c0 rjmp .+442 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
+ f0c: 80 91 76 02 lds r24, 0x0276
+ f10: 81 30 cpi r24, 0x01 ; 1
+ f12: 09 f0 breq .+2 ; 0xf16 <USB_Device_ProcessControlRequest+0xd8>
+ f14: dd c0 rjmp .+442 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
USB_Device_RemoteWakeupEnabled = (USB_ControlRequest.bRequest == REQ_SetFeature);
- f78: 23 30 cpi r18, 0x03 ; 3
- f7a: 09 f0 breq .+2 ; 0xf7e <USB_Device_ProcessControlRequest+0xde>
- f7c: 80 e0 ldi r24, 0x00 ; 0
- f7e: 80 93 6c 02 sts 0x026C, r24
- f82: 2c c0 rjmp .+88 ; 0xfdc <USB_Device_ProcessControlRequest+0x13c>
+ f16: 23 30 cpi r18, 0x03 ; 3
+ f18: 09 f0 breq .+2 ; 0xf1c <USB_Device_ProcessControlRequest+0xde>
+ f1a: 80 e0 ldi r24, 0x00 ; 0
+ f1c: 80 93 72 02 sts 0x0272, r24
+ f20: 2c c0 rjmp .+88 ; 0xf7a <USB_Device_ProcessControlRequest+0x13c>
break;
#endif
#if !defined(CONTROL_ONLY_DEVICE)
case REQREC_ENDPOINT:
if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_EndpointHalt)
- f84: 80 91 70 02 lds r24, 0x0270
- f88: 88 23 and r24, r24
- f8a: 41 f5 brne .+80 ; 0xfdc <USB_Device_ProcessControlRequest+0x13c>
+ f22: 80 91 76 02 lds r24, 0x0276
+ f26: 88 23 and r24, r24
+ f28: 41 f5 brne .+80 ; 0xf7a <USB_Device_ProcessControlRequest+0x13c>
{
uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
- f8c: 20 91 72 02 lds r18, 0x0272
- f90: 2f 70 andi r18, 0x0F ; 15
+ f2a: 20 91 78 02 lds r18, 0x0278
+ f2e: 2f 70 andi r18, 0x0F ; 15
if (EndpointIndex == ENDPOINT_CONTROLEP)
- f92: 09 f4 brne .+2 ; 0xf96 <USB_Device_ProcessControlRequest+0xf6>
- f94: ce c0 rjmp .+412 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
+ f30: 09 f4 brne .+2 ; 0xf34 <USB_Device_ProcessControlRequest+0xf6>
+ f32: ce c0 rjmp .+412 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
*/
static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void Endpoint_SelectEndpoint(const uint8_t Address)
{
#if !defined(CONTROL_ONLY_DEVICE)
UENUM = (Address & ENDPOINT_EPNUM_MASK);
- f96: 20 93 e9 00 sts 0x00E9, r18
+ f34: 20 93 e9 00 sts 0x00E9, r18
* \return Boolean \c true if the currently selected endpoint is enabled, \c false otherwise.
*/
static inline bool Endpoint_IsEnabled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsEnabled(void)
{
return ((UECONX & (1 << EPEN)) ? true : false);
- f9a: 80 91 eb 00 lds r24, 0x00EB
+ f38: 80 91 eb 00 lds r24, 0x00EB
return;
Endpoint_SelectEndpoint(EndpointIndex);
if (Endpoint_IsEnabled())
- f9e: 80 ff sbrs r24, 0
- fa0: 1d c0 rjmp .+58 ; 0xfdc <USB_Device_ProcessControlRequest+0x13c>
+ f3c: 80 ff sbrs r24, 0
+ f3e: 1d c0 rjmp .+58 ; 0xf7a <USB_Device_ProcessControlRequest+0x13c>
{
if (USB_ControlRequest.bRequest == REQ_SetFeature)
- fa2: 80 91 6f 02 lds r24, 0x026F
- fa6: 83 30 cpi r24, 0x03 ; 3
- fa8: 21 f4 brne .+8 ; 0xfb2 <USB_Device_ProcessControlRequest+0x112>
+ f40: 80 91 75 02 lds r24, 0x0275
+ f44: 83 30 cpi r24, 0x03 ; 3
+ f46: 21 f4 brne .+8 ; 0xf50 <USB_Device_ProcessControlRequest+0x112>
* \ingroup Group_EndpointPacketManagement_AVR8
*/
static inline void Endpoint_StallTransaction(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_StallTransaction(void)
{
UECONX |= (1 << STALLRQ);
- faa: 80 91 eb 00 lds r24, 0x00EB
- fae: 80 62 ori r24, 0x20 ; 32
- fb0: 13 c0 rjmp .+38 ; 0xfd8 <USB_Device_ProcessControlRequest+0x138>
+ f48: 80 91 eb 00 lds r24, 0x00EB
+ f4c: 80 62 ori r24, 0x20 ; 32
+ f4e: 13 c0 rjmp .+38 ; 0xf76 <USB_Device_ProcessControlRequest+0x138>
* \ingroup Group_EndpointPacketManagement_AVR8
*/
static inline void Endpoint_ClearStall(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearStall(void)
{
UECONX |= (1 << STALLRQC);
- fb2: 80 91 eb 00 lds r24, 0x00EB
- fb6: 80 61 ori r24, 0x10 ; 16
- fb8: 80 93 eb 00 sts 0x00EB, r24
+ f50: 80 91 eb 00 lds r24, 0x00EB
+ f54: 80 61 ori r24, 0x10 ; 16
+ f56: 80 93 eb 00 sts 0x00EB, r24
* \param[in] Address Endpoint address whose FIFO buffers are to be reset.
*/
static inline void Endpoint_ResetEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ResetEndpoint(const uint8_t Address)
{
UERST = (1 << (Address & ENDPOINT_EPNUM_MASK));
- fbc: 81 e0 ldi r24, 0x01 ; 1
- fbe: 90 e0 ldi r25, 0x00 ; 0
- fc0: 02 c0 rjmp .+4 ; 0xfc6 <USB_Device_ProcessControlRequest+0x126>
- fc2: 88 0f add r24, r24
- fc4: 99 1f adc r25, r25
- fc6: 2a 95 dec r18
- fc8: e2 f7 brpl .-8 ; 0xfc2 <USB_Device_ProcessControlRequest+0x122>
- fca: 80 93 ea 00 sts 0x00EA, r24
+ f5a: 81 e0 ldi r24, 0x01 ; 1
+ f5c: 90 e0 ldi r25, 0x00 ; 0
+ f5e: 02 c0 rjmp .+4 ; 0xf64 <USB_Device_ProcessControlRequest+0x126>
+ f60: 88 0f add r24, r24
+ f62: 99 1f adc r25, r25
+ f64: 2a 95 dec r18
+ f66: e2 f7 brpl .-8 ; 0xf60 <USB_Device_ProcessControlRequest+0x122>
+ f68: 80 93 ea 00 sts 0x00EA, r24
UERST = 0;
- fce: 10 92 ea 00 sts 0x00EA, r1
+ f6c: 10 92 ea 00 sts 0x00EA, r1
/** Resets the data toggle of the currently selected endpoint. */
static inline void Endpoint_ResetDataToggle(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ResetDataToggle(void)
{
UECONX |= (1 << RSTDT);
- fd2: 80 91 eb 00 lds r24, 0x00EB
- fd6: 88 60 ori r24, 0x08 ; 8
- fd8: 80 93 eb 00 sts 0x00EB, r24
+ f70: 80 91 eb 00 lds r24, 0x00EB
+ f74: 88 60 ori r24, 0x08 ; 8
+ f76: 80 93 eb 00 sts 0x00EB, r24
*/
static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void Endpoint_SelectEndpoint(const uint8_t Address)
{
#if !defined(CONTROL_ONLY_DEVICE)
UENUM = (Address & ENDPOINT_EPNUM_MASK);
- fdc: 10 92 e9 00 sts 0x00E9, r1
+ f7a: 10 92 e9 00 sts 0x00E9, r1
* \note This is not applicable for non CONTROL type endpoints.
*/
static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearSETUP(void)
{
UEINTX &= ~(1 << RXSTPI);
- fe0: 80 91 e8 00 lds r24, 0x00E8
- fe4: 87 7f andi r24, 0xF7 ; 247
- fe6: 86 c0 rjmp .+268 ; 0x10f4 <USB_Device_ProcessControlRequest+0x254>
+ f7e: 80 91 e8 00 lds r24, 0x00E8
+ f82: 87 7f andi r24, 0xF7 ; 247
+ f84: 86 c0 rjmp .+268 ; 0x1092 <USB_Device_ProcessControlRequest+0x254>
USB_Device_ClearSetFeature();
}
break;
case REQ_SetAddress:
if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
- fe8: 88 23 and r24, r24
- fea: 09 f0 breq .+2 ; 0xfee <USB_Device_ProcessControlRequest+0x14e>
- fec: a2 c0 rjmp .+324 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
+ f86: 88 23 and r24, r24
+ f88: 09 f0 breq .+2 ; 0xf8c <USB_Device_ProcessControlRequest+0x14e>
+ f8a: a2 c0 rjmp .+324 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
}
}
static void USB_Device_SetAddress(void)
{
uint8_t DeviceAddress = (USB_ControlRequest.wValue & 0x7F);
- fee: 10 91 70 02 lds r17, 0x0270
- ff2: 1f 77 andi r17, 0x7F ; 127
+ f8c: 10 91 76 02 lds r17, 0x0276
+ f90: 1f 77 andi r17, 0x7F ; 127
#endif
static inline void USB_Device_SetDeviceAddress(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void USB_Device_SetDeviceAddress(const uint8_t Address)
{
UDADDR = (UDADDR & (1 << ADDEN)) | (Address & 0x7F);
- ff4: 80 91 e3 00 lds r24, 0x00E3
- ff8: 80 78 andi r24, 0x80 ; 128
- ffa: 81 2b or r24, r17
- ffc: 80 93 e3 00 sts 0x00E3, r24
- 1000: 80 91 e8 00 lds r24, 0x00E8
- 1004: 87 7f andi r24, 0xF7 ; 247
- 1006: 80 93 e8 00 sts 0x00E8, r24
+ f92: 80 91 e3 00 lds r24, 0x00E3
+ f96: 80 78 andi r24, 0x80 ; 128
+ f98: 81 2b or r24, r17
+ f9a: 80 93 e3 00 sts 0x00E3, r24
+ f9e: 80 91 e8 00 lds r24, 0x00E8
+ fa2: 87 7f andi r24, 0xF7 ; 247
+ fa4: 80 93 e8 00 sts 0x00E8, r24
USB_Device_SetDeviceAddress(DeviceAddress);
Endpoint_ClearSETUP();
Endpoint_ClearStatusStage();
- 100a: d2 dd rcall .-1116 ; 0xbb0 <Endpoint_ClearStatusStage>
+ fa8: d2 dd rcall .-1116 ; 0xb4e <Endpoint_ClearStatusStage>
* \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
*/
static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsINReady(void)
{
return ((UEINTX & (1 << TXINI)) ? true : false);
- 100c: 80 91 e8 00 lds r24, 0x00E8
+ faa: 80 91 e8 00 lds r24, 0x00E8
while (!(Endpoint_IsINReady()));
- 1010: 80 ff sbrs r24, 0
- 1012: fc cf rjmp .-8 ; 0x100c <USB_Device_ProcessControlRequest+0x16c>
+ fae: 80 ff sbrs r24, 0
+ fb0: fc cf rjmp .-8 ; 0xfaa <USB_Device_ProcessControlRequest+0x16c>
static inline void USB_Device_EnableDeviceAddress(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void USB_Device_EnableDeviceAddress(const uint8_t Address)
{
(void)Address;
UDADDR |= (1 << ADDEN);
- 1014: 80 91 e3 00 lds r24, 0x00E3
- 1018: 80 68 ori r24, 0x80 ; 128
- 101a: 80 93 e3 00 sts 0x00E3, r24
+ fb2: 80 91 e3 00 lds r24, 0x00E3
+ fb6: 80 68 ori r24, 0x80 ; 128
+ fb8: 80 93 e3 00 sts 0x00E3, r24
USB_Device_EnableDeviceAddress(DeviceAddress);
USB_DeviceState = (DeviceAddress) ? DEVICE_STATE_Addressed : DEVICE_STATE_Default;
- 101e: 11 23 and r17, r17
- 1020: 11 f0 breq .+4 ; 0x1026 <USB_Device_ProcessControlRequest+0x186>
- 1022: 83 e0 ldi r24, 0x03 ; 3
- 1024: 01 c0 rjmp .+2 ; 0x1028 <USB_Device_ProcessControlRequest+0x188>
- 1026: 82 e0 ldi r24, 0x02 ; 2
- 1028: 8e bb out 0x1e, r24 ; 30
- 102a: 83 c0 rjmp .+262 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
+ fbc: 11 23 and r17, r17
+ fbe: 11 f0 breq .+4 ; 0xfc4 <USB_Device_ProcessControlRequest+0x186>
+ fc0: 83 e0 ldi r24, 0x03 ; 3
+ fc2: 01 c0 rjmp .+2 ; 0xfc6 <USB_Device_ProcessControlRequest+0x188>
+ fc4: 82 e0 ldi r24, 0x02 ; 2
+ fc6: 8e bb out 0x1e, r24 ; 30
+ fc8: 83 c0 rjmp .+262 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
USB_Device_SetAddress();
break;
case REQ_GetDescriptor:
if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
- 102c: 80 58 subi r24, 0x80 ; 128
- 102e: 82 30 cpi r24, 0x02 ; 2
- 1030: 08 f0 brcs .+2 ; 0x1034 <USB_Device_ProcessControlRequest+0x194>
- 1032: 7f c0 rjmp .+254 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
+ fca: 80 58 subi r24, 0x80 ; 128
+ fcc: 82 30 cpi r24, 0x02 ; 2
+ fce: 08 f0 brcs .+2 ; 0xfd2 <USB_Device_ProcessControlRequest+0x194>
+ fd0: 7f c0 rjmp .+254 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
!(defined(USE_FLASH_DESCRIPTORS) || defined(USE_EEPROM_DESCRIPTORS) || defined(USE_RAM_DESCRIPTORS))
uint8_t DescriptorAddressSpace;
#endif
#if !defined(NO_INTERNAL_SERIAL) && (USE_INTERNAL_SERIAL != NO_DESCRIPTOR)
if (USB_ControlRequest.wValue == ((DTYPE_String << 8) | USE_INTERNAL_SERIAL))
- 1034: 80 91 70 02 lds r24, 0x0270
- 1038: 90 91 71 02 lds r25, 0x0271
- 103c: 23 e0 ldi r18, 0x03 ; 3
- 103e: 8c 3d cpi r24, 0xDC ; 220
- 1040: 92 07 cpc r25, r18
- 1042: 91 f5 brne .+100 ; 0x10a8 <USB_Device_ProcessControlRequest+0x208>
+ fd2: 80 91 76 02 lds r24, 0x0276
+ fd6: 90 91 77 02 lds r25, 0x0277
+ fda: 23 e0 ldi r18, 0x03 ; 3
+ fdc: 8c 3d cpi r24, 0xDC ; 220
+ fde: 92 07 cpc r25, r18
+ fe0: 91 f5 brne .+100 ; 0x1046 <USB_Device_ProcessControlRequest+0x208>
{
USB_Descriptor_Header_t Header;
uint16_t UnicodeString[INTERNAL_SERIAL_LENGTH_BITS / 4];
} SignatureDescriptor;
SignatureDescriptor.Header.Type = DTYPE_String;
- 1044: 83 e0 ldi r24, 0x03 ; 3
- 1046: 8c 83 std Y+4, r24 ; 0x04
+ fe2: 83 e0 ldi r24, 0x03 ; 3
+ fe4: 8c 83 std Y+4, r24 ; 0x04
SignatureDescriptor.Header.Size = USB_STRING_LEN(INTERNAL_SERIAL_LENGTH_BITS / 4);
- 1048: 8a e2 ldi r24, 0x2A ; 42
- 104a: 8b 83 std Y+3, r24 ; 0x03
+ fe6: 8a e2 ldi r24, 0x2A ; 42
+ fe8: 8b 83 std Y+3, r24 ; 0x03
static inline uint_reg_t GetGlobalInterruptMask(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
return SREG;
- 104c: 5f b7 in r21, 0x3f ; 63
+ fea: 5f b7 in r21, 0x3f ; 63
static inline void GlobalInterruptDisable(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
cli();
- 104e: f8 94 cli
+ fec: f8 94 cli
__builtin_ssrf(AVR32_SR_GM_OFFSET);
#elif (ARCH == ARCH_XMEGA)
cli();
#endif
GCC_MEMORY_BARRIER();
- 1050: de 01 movw r26, r28
- 1052: 15 96 adiw r26, 0x05 ; 5
- 1054: 80 e0 ldi r24, 0x00 ; 0
- 1056: 90 e0 ldi r25, 0x00 ; 0
+ fee: de 01 movw r26, r28
+ ff0: 15 96 adiw r26, 0x05 ; 5
+ ff2: 80 e0 ldi r24, 0x00 ; 0
+ ff4: 90 e0 ldi r25, 0x00 ; 0
static inline void USB_Device_GetSerialString(uint16_t* const UnicodeString)
{
uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
GlobalInterruptDisable();
uint8_t SigReadAddress = INTERNAL_SERIAL_START_ADDRESS;
- 1058: 4e e0 ldi r20, 0x0E ; 14
+ ff6: 4e e0 ldi r20, 0x0E ; 14
for (uint8_t SerialCharNum = 0; SerialCharNum < (INTERNAL_SERIAL_LENGTH_BITS / 4); SerialCharNum++)
{
uint8_t SerialByte = boot_signature_byte_get(SigReadAddress);
- 105a: 61 e2 ldi r22, 0x21 ; 33
- 105c: e4 2f mov r30, r20
- 105e: f0 e0 ldi r31, 0x00 ; 0
- 1060: 60 93 57 00 sts 0x0057, r22
- 1064: e4 91 lpm r30, Z+
+ ff8: 61 e2 ldi r22, 0x21 ; 33
+ ffa: e4 2f mov r30, r20
+ ffc: f0 e0 ldi r31, 0x00 ; 0
+ ffe: 60 93 57 00 sts 0x0057, r22
+ 1002: e4 91 lpm r30, Z+
if (SerialCharNum & 0x01)
- 1066: 80 ff sbrs r24, 0
- 1068: 03 c0 rjmp .+6 ; 0x1070 <USB_Device_ProcessControlRequest+0x1d0>
+ 1004: 80 ff sbrs r24, 0
+ 1006: 03 c0 rjmp .+6 ; 0x100e <USB_Device_ProcessControlRequest+0x1d0>
{
SerialByte >>= 4;
- 106a: e2 95 swap r30
- 106c: ef 70 andi r30, 0x0F ; 15
+ 1008: e2 95 swap r30
+ 100a: ef 70 andi r30, 0x0F ; 15
SigReadAddress++;
- 106e: 4f 5f subi r20, 0xFF ; 255
+ 100c: 4f 5f subi r20, 0xFF ; 255
}
SerialByte &= 0x0F;
- 1070: ef 70 andi r30, 0x0F ; 15
- 1072: 2e 2f mov r18, r30
- 1074: 30 e0 ldi r19, 0x00 ; 0
+ 100e: ef 70 andi r30, 0x0F ; 15
+ 1010: 2e 2f mov r18, r30
+ 1012: 30 e0 ldi r19, 0x00 ; 0
UnicodeString[SerialCharNum] = cpu_to_le16((SerialByte >= 10) ?
- 1076: ea 30 cpi r30, 0x0A ; 10
- 1078: 18 f0 brcs .+6 ; 0x1080 <USB_Device_ProcessControlRequest+0x1e0>
- 107a: 29 5c subi r18, 0xC9 ; 201
- 107c: 3f 4f sbci r19, 0xFF ; 255
- 107e: 02 c0 rjmp .+4 ; 0x1084 <USB_Device_ProcessControlRequest+0x1e4>
- 1080: 20 5d subi r18, 0xD0 ; 208
- 1082: 3f 4f sbci r19, 0xFF ; 255
- 1084: 2d 93 st X+, r18
- 1086: 3d 93 st X+, r19
- 1088: 01 96 adiw r24, 0x01 ; 1
+ 1014: ea 30 cpi r30, 0x0A ; 10
+ 1016: 18 f0 brcs .+6 ; 0x101e <USB_Device_ProcessControlRequest+0x1e0>
+ 1018: 29 5c subi r18, 0xC9 ; 201
+ 101a: 3f 4f sbci r19, 0xFF ; 255
+ 101c: 02 c0 rjmp .+4 ; 0x1022 <USB_Device_ProcessControlRequest+0x1e4>
+ 101e: 20 5d subi r18, 0xD0 ; 208
+ 1020: 3f 4f sbci r19, 0xFF ; 255
+ 1022: 2d 93 st X+, r18
+ 1024: 3d 93 st X+, r19
+ 1026: 01 96 adiw r24, 0x01 ; 1
uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
GlobalInterruptDisable();
uint8_t SigReadAddress = INTERNAL_SERIAL_START_ADDRESS;
for (uint8_t SerialCharNum = 0; SerialCharNum < (INTERNAL_SERIAL_LENGTH_BITS / 4); SerialCharNum++)
- 108a: 84 31 cpi r24, 0x14 ; 20
- 108c: 91 05 cpc r25, r1
- 108e: 31 f7 brne .-52 ; 0x105c <USB_Device_ProcessControlRequest+0x1bc>
+ 1028: 84 31 cpi r24, 0x14 ; 20
+ 102a: 91 05 cpc r25, r1
+ 102c: 31 f7 brne .-52 ; 0xffa <USB_Device_ProcessControlRequest+0x1bc>
static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
SREG = GlobalIntState;
- 1090: 5f bf out 0x3f, r21 ; 63
+ 102e: 5f bf out 0x3f, r21 ; 63
* \note This is not applicable for non CONTROL type endpoints.
*/
static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearSETUP(void)
{
UEINTX &= ~(1 << RXSTPI);
- 1092: 80 91 e8 00 lds r24, 0x00E8
- 1096: 87 7f andi r24, 0xF7 ; 247
- 1098: 80 93 e8 00 sts 0x00E8, r24
+ 1030: 80 91 e8 00 lds r24, 0x00E8
+ 1034: 87 7f andi r24, 0xF7 ; 247
+ 1036: 80 93 e8 00 sts 0x00E8, r24
USB_Device_GetSerialString(SignatureDescriptor.UnicodeString);
Endpoint_ClearSETUP();
Endpoint_Write_Control_Stream_LE(&SignatureDescriptor, sizeof(SignatureDescriptor));
- 109c: ce 01 movw r24, r28
- 109e: 03 96 adiw r24, 0x03 ; 3
- 10a0: 6a e2 ldi r22, 0x2A ; 42
- 10a2: 70 e0 ldi r23, 0x00 ; 0
- 10a4: 55 dc rcall .-1878 ; 0x950 <Endpoint_Write_Control_Stream_LE>
- 10a6: 12 c0 rjmp .+36 ; 0x10cc <USB_Device_ProcessControlRequest+0x22c>
+ 103a: ce 01 movw r24, r28
+ 103c: 03 96 adiw r24, 0x03 ; 3
+ 103e: 6a e2 ldi r22, 0x2A ; 42
+ 1040: 70 e0 ldi r23, 0x00 ; 0
+ 1042: 55 dc rcall .-1878 ; 0x8ee <Endpoint_Write_Control_Stream_LE>
+ 1044: 12 c0 rjmp .+36 ; 0x106a <USB_Device_ProcessControlRequest+0x22c>
USB_Device_GetInternalSerialDescriptor();
return;
}
#endif
if ((DescriptorSize = CALLBACK_USB_GetDescriptor(USB_ControlRequest.wValue, USB_ControlRequest.wIndex,
- 10a8: 60 91 72 02 lds r22, 0x0272
- 10ac: ae 01 movw r20, r28
- 10ae: 4f 5f subi r20, 0xFF ; 255
- 10b0: 5f 4f sbci r21, 0xFF ; 255
- 10b2: 21 dc rcall .-1982 ; 0x8f6 <CALLBACK_USB_GetDescriptor>
- 10b4: bc 01 movw r22, r24
- 10b6: 00 97 sbiw r24, 0x00 ; 0
- 10b8: 09 f4 brne .+2 ; 0x10bc <USB_Device_ProcessControlRequest+0x21c>
- 10ba: 3b c0 rjmp .+118 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
- 10bc: 80 91 e8 00 lds r24, 0x00E8
- 10c0: 87 7f andi r24, 0xF7 ; 247
- 10c2: 80 93 e8 00 sts 0x00E8, r24
+ 1046: 60 91 78 02 lds r22, 0x0278
+ 104a: ae 01 movw r20, r28
+ 104c: 4f 5f subi r20, 0xFF ; 255
+ 104e: 5f 4f sbci r21, 0xFF ; 255
+ 1050: 21 dc rcall .-1982 ; 0x894 <CALLBACK_USB_GetDescriptor>
+ 1052: bc 01 movw r22, r24
+ 1054: 00 97 sbiw r24, 0x00 ; 0
+ 1056: 09 f4 brne .+2 ; 0x105a <USB_Device_ProcessControlRequest+0x21c>
+ 1058: 3b c0 rjmp .+118 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
+ 105a: 80 91 e8 00 lds r24, 0x00E8
+ 105e: 87 7f andi r24, 0xF7 ; 247
+ 1060: 80 93 e8 00 sts 0x00E8, r24
#if defined(USE_RAM_DESCRIPTORS) || !defined(ARCH_HAS_MULTI_ADDRESS_SPACE)
Endpoint_Write_Control_Stream_LE(DescriptorPointer, DescriptorSize);
#elif defined(USE_EEPROM_DESCRIPTORS)
Endpoint_Write_Control_EStream_LE(DescriptorPointer, DescriptorSize);
#elif defined(USE_FLASH_DESCRIPTORS)
Endpoint_Write_Control_PStream_LE(DescriptorPointer, DescriptorSize);
- 10c6: 89 81 ldd r24, Y+1 ; 0x01
- 10c8: 9a 81 ldd r25, Y+2 ; 0x02
- 10ca: 9c dc rcall .-1736 ; 0xa04 <Endpoint_Write_Control_PStream_LE>
+ 1064: 89 81 ldd r24, Y+1 ; 0x01
+ 1066: 9a 81 ldd r25, Y+2 ; 0x02
+ 1068: 9c dc rcall .-1736 ; 0x9a2 <Endpoint_Write_Control_PStream_LE>
*/
static inline void Endpoint_ClearOUT(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearOUT(void)
{
#if !defined(CONTROL_ONLY_DEVICE)
UEINTX &= ~((1 << RXOUTI) | (1 << FIFOCON));
- 10cc: 80 91 e8 00 lds r24, 0x00E8
- 10d0: 8b 77 andi r24, 0x7B ; 123
- 10d2: 80 93 e8 00 sts 0x00E8, r24
- 10d6: 2d c0 rjmp .+90 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
+ 106a: 80 91 e8 00 lds r24, 0x00E8
+ 106e: 8b 77 andi r24, 0x7B ; 123
+ 1070: 80 93 e8 00 sts 0x00E8, r24
+ 1074: 2d c0 rjmp .+90 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
USB_Device_GetDescriptor();
}
break;
case REQ_GetConfiguration:
if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE))
- 10d8: 80 38 cpi r24, 0x80 ; 128
- 10da: 59 f5 brne .+86 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
+ 1076: 80 38 cpi r24, 0x80 ; 128
+ 1078: 59 f5 brne .+86 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
* \note This is not applicable for non CONTROL type endpoints.
*/
static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearSETUP(void)
{
UEINTX &= ~(1 << RXSTPI);
- 10dc: 80 91 e8 00 lds r24, 0x00E8
- 10e0: 87 7f andi r24, 0xF7 ; 247
- 10e2: 80 93 e8 00 sts 0x00E8, r24
+ 107a: 80 91 e8 00 lds r24, 0x00E8
+ 107e: 87 7f andi r24, 0xF7 ; 247
+ 1080: 80 93 e8 00 sts 0x00E8, r24
static void USB_Device_GetConfiguration(void)
{
Endpoint_ClearSETUP();
Endpoint_Write_8(USB_Device_ConfigurationNumber);
- 10e6: 80 91 6a 02 lds r24, 0x026A
+ 1084: 80 91 70 02 lds r24, 0x0270
* \param[in] Data Data to write into the the currently selected endpoint's FIFO buffer.
*/
static inline void Endpoint_Write_8(const uint8_t Data) ATTR_ALWAYS_INLINE;
static inline void Endpoint_Write_8(const uint8_t Data)
{
UEDATX = Data;
- 10ea: 80 93 f1 00 sts 0x00F1, r24
+ 1088: 80 93 f1 00 sts 0x00F1, r24
*/
static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearIN(void)
{
#if !defined(CONTROL_ONLY_DEVICE)
UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
- 10ee: 80 91 e8 00 lds r24, 0x00E8
- 10f2: 8e 77 andi r24, 0x7E ; 126
- 10f4: 80 93 e8 00 sts 0x00E8, r24
+ 108c: 80 91 e8 00 lds r24, 0x00E8
+ 1090: 8e 77 andi r24, 0x7E ; 126
+ 1092: 80 93 e8 00 sts 0x00E8, r24
Endpoint_ClearIN();
Endpoint_ClearStatusStage();
- 10f8: 5b dd rcall .-1354 ; 0xbb0 <Endpoint_ClearStatusStage>
- 10fa: 1b c0 rjmp .+54 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
+ 1096: 5b dd rcall .-1354 ; 0xb4e <Endpoint_ClearStatusStage>
+ 1098: 1b c0 rjmp .+54 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE))
USB_Device_GetConfiguration();
break;
case REQ_SetConfiguration:
if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
- 10fc: 88 23 and r24, r24
- 10fe: c9 f4 brne .+50 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
+ 109a: 88 23 and r24, r24
+ 109c: c9 f4 brne .+50 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
}
static void USB_Device_SetConfiguration(void)
{
#if defined(FIXED_NUM_CONFIGURATIONS)
if ((uint8_t)USB_ControlRequest.wValue > FIXED_NUM_CONFIGURATIONS)
- 1100: 90 91 70 02 lds r25, 0x0270
- 1104: 92 30 cpi r25, 0x02 ; 2
- 1106: a8 f4 brcc .+42 ; 0x1132 <USB_Device_ProcessControlRequest+0x292>
+ 109e: 90 91 76 02 lds r25, 0x0276
+ 10a2: 92 30 cpi r25, 0x02 ; 2
+ 10a4: a8 f4 brcc .+42 ; 0x10d0 <USB_Device_ProcessControlRequest+0x292>
* \note This is not applicable for non CONTROL type endpoints.
*/
static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearSETUP(void)
{
UEINTX &= ~(1 << RXSTPI);
- 1108: 80 91 e8 00 lds r24, 0x00E8
- 110c: 87 7f andi r24, 0xF7 ; 247
- 110e: 80 93 e8 00 sts 0x00E8, r24
+ 10a6: 80 91 e8 00 lds r24, 0x00E8
+ 10aa: 87 7f andi r24, 0xF7 ; 247
+ 10ac: 80 93 e8 00 sts 0x00E8, r24
#endif
#endif
Endpoint_ClearSETUP();
USB_Device_ConfigurationNumber = (uint8_t)USB_ControlRequest.wValue;
- 1112: 90 93 6a 02 sts 0x026A, r25
+ 10b0: 90 93 70 02 sts 0x0270, r25
Endpoint_ClearStatusStage();
- 1116: 4c dd rcall .-1384 ; 0xbb0 <Endpoint_ClearStatusStage>
+ 10b4: 4c dd rcall .-1384 ; 0xb4e <Endpoint_ClearStatusStage>
if (USB_Device_ConfigurationNumber)
- 1118: 80 91 6a 02 lds r24, 0x026A
- 111c: 88 23 and r24, r24
- 111e: 21 f4 brne .+8 ; 0x1128 <USB_Device_ProcessControlRequest+0x288>
+ 10b6: 80 91 70 02 lds r24, 0x0270
+ 10ba: 88 23 and r24, r24
+ 10bc: 21 f4 brne .+8 ; 0x10c6 <USB_Device_ProcessControlRequest+0x288>
}
static inline bool USB_Device_IsAddressSet(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
static inline bool USB_Device_IsAddressSet(void)
{
return (UDADDR & (1 << ADDEN));
- 1120: 80 91 e3 00 lds r24, 0x00E3
+ 10be: 80 91 e3 00 lds r24, 0x00E3
USB_DeviceState = DEVICE_STATE_Configured;
else
USB_DeviceState = (USB_Device_IsAddressSet()) ? DEVICE_STATE_Configured : DEVICE_STATE_Powered;
- 1124: 87 ff sbrs r24, 7
- 1126: 02 c0 rjmp .+4 ; 0x112c <USB_Device_ProcessControlRequest+0x28c>
- 1128: 84 e0 ldi r24, 0x04 ; 4
- 112a: 01 c0 rjmp .+2 ; 0x112e <USB_Device_ProcessControlRequest+0x28e>
- 112c: 81 e0 ldi r24, 0x01 ; 1
- 112e: 8e bb out 0x1e, r24 ; 30
+ 10c2: 87 ff sbrs r24, 7
+ 10c4: 02 c0 rjmp .+4 ; 0x10ca <USB_Device_ProcessControlRequest+0x28c>
+ 10c6: 84 e0 ldi r24, 0x04 ; 4
+ 10c8: 01 c0 rjmp .+2 ; 0x10cc <USB_Device_ProcessControlRequest+0x28e>
+ 10ca: 81 e0 ldi r24, 0x01 ; 1
+ 10cc: 8e bb out 0x1e, r24 ; 30
EVENT_USB_Device_ConfigurationChanged();
- 1130: 72 da rcall .-2844 ; 0x616 <EVENT_USB_Device_ConfigurationChanged>
+ 10ce: f0 da rcall .-2592 ; 0x6b0 <EVENT_USB_Device_ConfigurationChanged>
* \return Boolean \c true if the selected endpoint has received a SETUP packet, \c false otherwise.
*/
static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsSETUPReceived(void)
{
return ((UEINTX & (1 << RXSTPI)) ? true : false);
- 1132: 80 91 e8 00 lds r24, 0x00E8
+ 10d0: 80 91 e8 00 lds r24, 0x00E8
default:
break;
}
}
if (Endpoint_IsSETUPReceived())
- 1136: 83 ff sbrs r24, 3
- 1138: 0a c0 rjmp .+20 ; 0x114e <USB_Device_ProcessControlRequest+0x2ae>
+ 10d4: 83 ff sbrs r24, 3
+ 10d6: 0a c0 rjmp .+20 ; 0x10ec <USB_Device_ProcessControlRequest+0x2ae>
* \note This is not applicable for non CONTROL type endpoints.
*/
static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearSETUP(void)
{
UEINTX &= ~(1 << RXSTPI);
- 113a: 80 91 e8 00 lds r24, 0x00E8
- 113e: 87 7f andi r24, 0xF7 ; 247
- 1140: 80 93 e8 00 sts 0x00E8, r24
+ 10d8: 80 91 e8 00 lds r24, 0x00E8
+ 10dc: 87 7f andi r24, 0xF7 ; 247
+ 10de: 80 93 e8 00 sts 0x00E8, r24
* \ingroup Group_EndpointPacketManagement_AVR8
*/
static inline void Endpoint_StallTransaction(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_StallTransaction(void)
{
UECONX |= (1 << STALLRQ);
- 1144: 80 91 eb 00 lds r24, 0x00EB
- 1148: 80 62 ori r24, 0x20 ; 32
- 114a: 80 93 eb 00 sts 0x00EB, r24
+ 10e2: 80 91 eb 00 lds r24, 0x00EB
+ 10e6: 80 62 ori r24, 0x20 ; 32
+ 10e8: 80 93 eb 00 sts 0x00EB, r24
{
Endpoint_ClearSETUP();
Endpoint_StallTransaction();
}
}
- 114e: ac 96 adiw r28, 0x2c ; 44
- 1150: 0f b6 in r0, 0x3f ; 63
- 1152: f8 94 cli
- 1154: de bf out 0x3e, r29 ; 62
- 1156: 0f be out 0x3f, r0 ; 63
- 1158: cd bf out 0x3d, r28 ; 61
- 115a: cf 91 pop r28
- 115c: df 91 pop r29
- 115e: 1f 91 pop r17
- 1160: 08 95 ret
-
-00001162 <USB_Event_Stub>:
+ 10ec: ac 96 adiw r28, 0x2c ; 44
+ 10ee: 0f b6 in r0, 0x3f ; 63
+ 10f0: f8 94 cli
+ 10f2: de bf out 0x3e, r29 ; 62
+ 10f4: 0f be out 0x3f, r0 ; 63
+ 10f6: cd bf out 0x3d, r28 ; 61
+ 10f8: cf 91 pop r28
+ 10fa: df 91 pop r29
+ 10fc: 1f 91 pop r17
+ 10fe: 08 95 ret
+
+00001100 <USB_Event_Stub>:
#include "Events.h"
void USB_Event_Stub(void)
{
}
- 1162: 08 95 ret
+ 1100: 08 95 ret
-00001164 <USB_USBTask>:
+00001102 <USB_USBTask>:
#if defined(USB_CAN_BE_DEVICE) && !defined(DEVICE_STATE_AS_GPIOR)
volatile uint8_t USB_DeviceState;
#endif
void USB_USBTask(void)
{
- 1164: 1f 93 push r17
+ 1102: 1f 93 push r17
}
#if defined(USB_CAN_BE_DEVICE)
static void USB_DeviceTask(void)
{
if (USB_DeviceState == DEVICE_STATE_Unattached)
- 1166: 8e b3 in r24, 0x1e ; 30
- 1168: 88 23 and r24, r24
- 116a: a9 f0 breq .+42 ; 0x1196 <USB_USBTask+0x32>
+ 1104: 8e b3 in r24, 0x1e ; 30
+ 1106: 88 23 and r24, r24
+ 1108: a9 f0 breq .+42 ; 0x1134 <USB_USBTask+0x32>
*/
static inline uint8_t Endpoint_GetCurrentEndpoint(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline uint8_t Endpoint_GetCurrentEndpoint(void)
{
#if !defined(CONTROL_ONLY_DEVICE)
return ((UENUM & ENDPOINT_EPNUM_MASK) | Endpoint_GetEndpointDirection());
- 116c: 80 91 e9 00 lds r24, 0x00E9
- 1170: 8f 70 andi r24, 0x0F ; 15
+ 110a: 80 91 e9 00 lds r24, 0x00E9
+ 110e: 8f 70 andi r24, 0x0F ; 15
* \return The currently selected endpoint's direction, as a \c ENDPOINT_DIR_* mask.
*/
static inline uint8_t Endpoint_GetEndpointDirection(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline uint8_t Endpoint_GetEndpointDirection(void)
{
return (UECFG0X & (1 << EPDIR)) ? ENDPOINT_DIR_IN : ENDPOINT_DIR_OUT;
- 1172: 90 91 ec 00 lds r25, 0x00EC
- 1176: 90 ff sbrs r25, 0
- 1178: 02 c0 rjmp .+4 ; 0x117e <USB_USBTask+0x1a>
- 117a: 10 e8 ldi r17, 0x80 ; 128
- 117c: 01 c0 rjmp .+2 ; 0x1180 <USB_USBTask+0x1c>
- 117e: 10 e0 ldi r17, 0x00 ; 0
+ 1110: 90 91 ec 00 lds r25, 0x00EC
+ 1114: 90 ff sbrs r25, 0
+ 1116: 02 c0 rjmp .+4 ; 0x111c <USB_USBTask+0x1a>
+ 1118: 10 e8 ldi r17, 0x80 ; 128
+ 111a: 01 c0 rjmp .+2 ; 0x111e <USB_USBTask+0x1c>
+ 111c: 10 e0 ldi r17, 0x00 ; 0
*/
static inline uint8_t Endpoint_GetCurrentEndpoint(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline uint8_t Endpoint_GetCurrentEndpoint(void)
{
#if !defined(CONTROL_ONLY_DEVICE)
return ((UENUM & ENDPOINT_EPNUM_MASK) | Endpoint_GetEndpointDirection());
- 1180: 18 2b or r17, r24
+ 111e: 18 2b or r17, r24
*/
static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void Endpoint_SelectEndpoint(const uint8_t Address)
{
#if !defined(CONTROL_ONLY_DEVICE)
UENUM = (Address & ENDPOINT_EPNUM_MASK);
- 1182: 10 92 e9 00 sts 0x00E9, r1
+ 1120: 10 92 e9 00 sts 0x00E9, r1
* \return Boolean \c true if the selected endpoint has received a SETUP packet, \c false otherwise.
*/
static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsSETUPReceived(void)
{
return ((UEINTX & (1 << RXSTPI)) ? true : false);
- 1186: 80 91 e8 00 lds r24, 0x00E8
+ 1124: 80 91 e8 00 lds r24, 0x00E8
uint8_t PrevEndpoint = Endpoint_GetCurrentEndpoint();
Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
if (Endpoint_IsSETUPReceived())
- 118a: 83 ff sbrs r24, 3
- 118c: 01 c0 rjmp .+2 ; 0x1190 <USB_USBTask+0x2c>
+ 1128: 83 ff sbrs r24, 3
+ 112a: 01 c0 rjmp .+2 ; 0x112e <USB_USBTask+0x2c>
USB_Device_ProcessControlRequest();
- 118e: 88 de rcall .-752 ; 0xea0 <USB_Device_ProcessControlRequest>
+ 112c: 88 de rcall .-752 ; 0xe3e <USB_Device_ProcessControlRequest>
*/
static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void Endpoint_SelectEndpoint(const uint8_t Address)
{
#if !defined(CONTROL_ONLY_DEVICE)
UENUM = (Address & ENDPOINT_EPNUM_MASK);
- 1190: 1f 70 andi r17, 0x0F ; 15
- 1192: 10 93 e9 00 sts 0x00E9, r17
+ 112e: 1f 70 andi r17, 0x0F ; 15
+ 1130: 10 93 e9 00 sts 0x00E9, r17
#elif defined(USB_CAN_BE_HOST)
USB_HostTask();
#elif defined(USB_CAN_BE_DEVICE)
USB_DeviceTask();
#endif
}
- 1196: 1f 91 pop r17
- 1198: 08 95 ret
+ 1134: 1f 91 pop r17
+ 1136: 08 95 ret
-0000119a <CDC_Device_ProcessControlRequest>:
+00001138 <CDC_Device_ProcessControlRequest>:
#define __INCLUDE_FROM_CDC_DRIVER
#define __INCLUDE_FROM_CDC_DEVICE_C
#include "CDCClassDevice.h"
void CDC_Device_ProcessControlRequest(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{
- 119a: cf 93 push r28
- 119c: df 93 push r29
- 119e: ec 01 movw r28, r24
+ 1138: cf 93 push r28
+ 113a: df 93 push r29
+ 113c: ec 01 movw r28, r24
* \return Boolean \c true if the selected endpoint has received a SETUP packet, \c false otherwise.
*/
static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsSETUPReceived(void)
{
return ((UEINTX & (1 << RXSTPI)) ? true : false);
- 11a0: 80 91 e8 00 lds r24, 0x00E8
+ 113e: 80 91 e8 00 lds r24, 0x00E8
if (!(Endpoint_IsSETUPReceived()))
- 11a4: 83 ff sbrs r24, 3
- 11a6: a2 c0 rjmp .+324 ; 0x12ec <CDC_Device_ProcessControlRequest+0x152>
+ 1142: 83 ff sbrs r24, 3
+ 1144: a2 c0 rjmp .+324 ; 0x128a <CDC_Device_ProcessControlRequest+0x152>
return;
if (USB_ControlRequest.wIndex != CDCInterfaceInfo->Config.ControlInterfaceNumber)
- 11a8: 88 81 ld r24, Y
- 11aa: 90 e0 ldi r25, 0x00 ; 0
- 11ac: 20 91 72 02 lds r18, 0x0272
- 11b0: 30 91 73 02 lds r19, 0x0273
- 11b4: 28 17 cp r18, r24
- 11b6: 39 07 cpc r19, r25
- 11b8: 09 f0 breq .+2 ; 0x11bc <CDC_Device_ProcessControlRequest+0x22>
- 11ba: 98 c0 rjmp .+304 ; 0x12ec <CDC_Device_ProcessControlRequest+0x152>
+ 1146: 88 81 ld r24, Y
+ 1148: 90 e0 ldi r25, 0x00 ; 0
+ 114a: 20 91 78 02 lds r18, 0x0278
+ 114e: 30 91 79 02 lds r19, 0x0279
+ 1152: 28 17 cp r18, r24
+ 1154: 39 07 cpc r19, r25
+ 1156: 09 f0 breq .+2 ; 0x115a <CDC_Device_ProcessControlRequest+0x22>
+ 1158: 98 c0 rjmp .+304 ; 0x128a <CDC_Device_ProcessControlRequest+0x152>
return;
switch (USB_ControlRequest.bRequest)
- 11bc: 80 91 6f 02 lds r24, 0x026F
- 11c0: 81 32 cpi r24, 0x21 ; 33
- 11c2: 69 f0 breq .+26 ; 0x11de <CDC_Device_ProcessControlRequest+0x44>
- 11c4: 82 32 cpi r24, 0x22 ; 34
- 11c6: 20 f4 brcc .+8 ; 0x11d0 <CDC_Device_ProcessControlRequest+0x36>
- 11c8: 80 32 cpi r24, 0x20 ; 32
- 11ca: 09 f0 breq .+2 ; 0x11ce <CDC_Device_ProcessControlRequest+0x34>
- 11cc: 8f c0 rjmp .+286 ; 0x12ec <CDC_Device_ProcessControlRequest+0x152>
- 11ce: 3c c0 rjmp .+120 ; 0x1248 <CDC_Device_ProcessControlRequest+0xae>
- 11d0: 82 32 cpi r24, 0x22 ; 34
- 11d2: 09 f4 brne .+2 ; 0x11d6 <CDC_Device_ProcessControlRequest+0x3c>
- 11d4: 6a c0 rjmp .+212 ; 0x12aa <CDC_Device_ProcessControlRequest+0x110>
- 11d6: 83 32 cpi r24, 0x23 ; 35
- 11d8: 09 f0 breq .+2 ; 0x11dc <CDC_Device_ProcessControlRequest+0x42>
- 11da: 88 c0 rjmp .+272 ; 0x12ec <CDC_Device_ProcessControlRequest+0x152>
- 11dc: 79 c0 rjmp .+242 ; 0x12d0 <CDC_Device_ProcessControlRequest+0x136>
+ 115a: 80 91 75 02 lds r24, 0x0275
+ 115e: 81 32 cpi r24, 0x21 ; 33
+ 1160: 69 f0 breq .+26 ; 0x117c <CDC_Device_ProcessControlRequest+0x44>
+ 1162: 82 32 cpi r24, 0x22 ; 34
+ 1164: 20 f4 brcc .+8 ; 0x116e <CDC_Device_ProcessControlRequest+0x36>
+ 1166: 80 32 cpi r24, 0x20 ; 32
+ 1168: 09 f0 breq .+2 ; 0x116c <CDC_Device_ProcessControlRequest+0x34>
+ 116a: 8f c0 rjmp .+286 ; 0x128a <CDC_Device_ProcessControlRequest+0x152>
+ 116c: 3c c0 rjmp .+120 ; 0x11e6 <CDC_Device_ProcessControlRequest+0xae>
+ 116e: 82 32 cpi r24, 0x22 ; 34
+ 1170: 09 f4 brne .+2 ; 0x1174 <CDC_Device_ProcessControlRequest+0x3c>
+ 1172: 6a c0 rjmp .+212 ; 0x1248 <CDC_Device_ProcessControlRequest+0x110>
+ 1174: 83 32 cpi r24, 0x23 ; 35
+ 1176: 09 f0 breq .+2 ; 0x117a <CDC_Device_ProcessControlRequest+0x42>
+ 1178: 88 c0 rjmp .+272 ; 0x128a <CDC_Device_ProcessControlRequest+0x152>
+ 117a: 79 c0 rjmp .+242 ; 0x126e <CDC_Device_ProcessControlRequest+0x136>
{
case CDC_REQ_GetLineEncoding:
if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
- 11de: 80 91 6e 02 lds r24, 0x026E
- 11e2: 81 3a cpi r24, 0xA1 ; 161
- 11e4: 09 f0 breq .+2 ; 0x11e8 <CDC_Device_ProcessControlRequest+0x4e>
- 11e6: 82 c0 rjmp .+260 ; 0x12ec <CDC_Device_ProcessControlRequest+0x152>
+ 117c: 80 91 74 02 lds r24, 0x0274
+ 1180: 81 3a cpi r24, 0xA1 ; 161
+ 1182: 09 f0 breq .+2 ; 0x1186 <CDC_Device_ProcessControlRequest+0x4e>
+ 1184: 82 c0 rjmp .+260 ; 0x128a <CDC_Device_ProcessControlRequest+0x152>
* \note This is not applicable for non CONTROL type endpoints.
*/
static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearSETUP(void)
{
UEINTX &= ~(1 << RXSTPI);
- 11e8: 80 91 e8 00 lds r24, 0x00E8
- 11ec: 87 7f andi r24, 0xF7 ; 247
- 11ee: 80 93 e8 00 sts 0x00E8, r24
+ 1186: 80 91 e8 00 lds r24, 0x00E8
+ 118a: 87 7f andi r24, 0xF7 ; 247
+ 118c: 80 93 e8 00 sts 0x00E8, r24
* \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
*/
static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsINReady(void)
{
return ((UEINTX & (1 << TXINI)) ? true : false);
- 11f2: 80 91 e8 00 lds r24, 0x00E8
+ 1190: 80 91 e8 00 lds r24, 0x00E8
{
Endpoint_ClearSETUP();
while (!(Endpoint_IsINReady()));
- 11f6: 80 ff sbrs r24, 0
- 11f8: fc cf rjmp .-8 ; 0x11f2 <CDC_Device_ProcessControlRequest+0x58>
+ 1194: 80 ff sbrs r24, 0
+ 1196: fc cf rjmp .-8 ; 0x1190 <CDC_Device_ProcessControlRequest+0x58>
Endpoint_Write_32_LE(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
- 11fa: 8c 89 ldd r24, Y+20 ; 0x14
- 11fc: 9d 89 ldd r25, Y+21 ; 0x15
- 11fe: ae 89 ldd r26, Y+22 ; 0x16
- 1200: bf 89 ldd r27, Y+23 ; 0x17
+ 1198: 8c 89 ldd r24, Y+20 ; 0x14
+ 119a: 9d 89 ldd r25, Y+21 ; 0x15
+ 119c: ae 89 ldd r26, Y+22 ; 0x16
+ 119e: bf 89 ldd r27, Y+23 ; 0x17
* \param[in] Data Data to write to the currently selected endpoint's FIFO buffer.
*/
static inline void Endpoint_Write_32_LE(const uint32_t Data) ATTR_ALWAYS_INLINE;
static inline void Endpoint_Write_32_LE(const uint32_t Data)
{
UEDATX = (Data & 0xFF);
- 1202: 80 93 f1 00 sts 0x00F1, r24
+ 11a0: 80 93 f1 00 sts 0x00F1, r24
UEDATX = (Data >> 8);
- 1206: 29 2f mov r18, r25
- 1208: 3a 2f mov r19, r26
- 120a: 4b 2f mov r20, r27
- 120c: 55 27 eor r21, r21
- 120e: 20 93 f1 00 sts 0x00F1, r18
+ 11a4: 29 2f mov r18, r25
+ 11a6: 3a 2f mov r19, r26
+ 11a8: 4b 2f mov r20, r27
+ 11aa: 55 27 eor r21, r21
+ 11ac: 20 93 f1 00 sts 0x00F1, r18
UEDATX = (Data >> 16);
- 1212: 9d 01 movw r18, r26
- 1214: 44 27 eor r20, r20
- 1216: 55 27 eor r21, r21
- 1218: 20 93 f1 00 sts 0x00F1, r18
+ 11b0: 9d 01 movw r18, r26
+ 11b2: 44 27 eor r20, r20
+ 11b4: 55 27 eor r21, r21
+ 11b6: 20 93 f1 00 sts 0x00F1, r18
UEDATX = (Data >> 24);
- 121c: 8b 2f mov r24, r27
- 121e: 99 27 eor r25, r25
- 1220: aa 27 eor r26, r26
- 1222: bb 27 eor r27, r27
- 1224: 80 93 f1 00 sts 0x00F1, r24
+ 11ba: 8b 2f mov r24, r27
+ 11bc: 99 27 eor r25, r25
+ 11be: aa 27 eor r26, r26
+ 11c0: bb 27 eor r27, r27
+ 11c2: 80 93 f1 00 sts 0x00F1, r24
Endpoint_Write_8(CDCInterfaceInfo->State.LineEncoding.CharFormat);
- 1228: 88 8d ldd r24, Y+24 ; 0x18
+ 11c6: 88 8d ldd r24, Y+24 ; 0x18
* \param[in] Data Data to write into the the currently selected endpoint's FIFO buffer.
*/
static inline void Endpoint_Write_8(const uint8_t Data) ATTR_ALWAYS_INLINE;
static inline void Endpoint_Write_8(const uint8_t Data)
{
UEDATX = Data;
- 122a: 80 93 f1 00 sts 0x00F1, r24
+ 11c8: 80 93 f1 00 sts 0x00F1, r24
Endpoint_Write_8(CDCInterfaceInfo->State.LineEncoding.ParityType);
- 122e: 89 8d ldd r24, Y+25 ; 0x19
- 1230: 80 93 f1 00 sts 0x00F1, r24
+ 11cc: 89 8d ldd r24, Y+25 ; 0x19
+ 11ce: 80 93 f1 00 sts 0x00F1, r24
Endpoint_Write_8(CDCInterfaceInfo->State.LineEncoding.DataBits);
- 1234: 8a 8d ldd r24, Y+26 ; 0x1a
- 1236: 80 93 f1 00 sts 0x00F1, r24
+ 11d2: 8a 8d ldd r24, Y+26 ; 0x1a
+ 11d4: 80 93 f1 00 sts 0x00F1, r24
*/
static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearIN(void)
{
#if !defined(CONTROL_ONLY_DEVICE)
UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
- 123a: 80 91 e8 00 lds r24, 0x00E8
- 123e: 8e 77 andi r24, 0x7E ; 126
- 1240: 80 93 e8 00 sts 0x00E8, r24
+ 11d8: 80 91 e8 00 lds r24, 0x00E8
+ 11dc: 8e 77 andi r24, 0x7E ; 126
+ 11de: 80 93 e8 00 sts 0x00E8, r24
Endpoint_ClearIN();
Endpoint_ClearStatusStage();
- 1244: b5 dc rcall .-1686 ; 0xbb0 <Endpoint_ClearStatusStage>
- 1246: 52 c0 rjmp .+164 ; 0x12ec <CDC_Device_ProcessControlRequest+0x152>
+ 11e2: b5 dc rcall .-1686 ; 0xb4e <Endpoint_ClearStatusStage>
+ 11e4: 52 c0 rjmp .+164 ; 0x128a <CDC_Device_ProcessControlRequest+0x152>
}
break;
case CDC_REQ_SetLineEncoding:
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
- 1248: 80 91 6e 02 lds r24, 0x026E
- 124c: 81 32 cpi r24, 0x21 ; 33
- 124e: 09 f0 breq .+2 ; 0x1252 <CDC_Device_ProcessControlRequest+0xb8>
- 1250: 4d c0 rjmp .+154 ; 0x12ec <CDC_Device_ProcessControlRequest+0x152>
+ 11e6: 80 91 74 02 lds r24, 0x0274
+ 11ea: 81 32 cpi r24, 0x21 ; 33
+ 11ec: 09 f0 breq .+2 ; 0x11f0 <CDC_Device_ProcessControlRequest+0xb8>
+ 11ee: 4d c0 rjmp .+154 ; 0x128a <CDC_Device_ProcessControlRequest+0x152>
* \note This is not applicable for non CONTROL type endpoints.
*/
static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearSETUP(void)
{
UEINTX &= ~(1 << RXSTPI);
- 1252: 80 91 e8 00 lds r24, 0x00E8
- 1256: 87 7f andi r24, 0xF7 ; 247
- 1258: 80 93 e8 00 sts 0x00E8, r24
+ 11f0: 80 91 e8 00 lds r24, 0x00E8
+ 11f4: 87 7f andi r24, 0xF7 ; 247
+ 11f6: 80 93 e8 00 sts 0x00E8, r24
{
Endpoint_ClearSETUP();
while (!(Endpoint_IsOUTReceived()))
- 125c: 04 c0 rjmp .+8 ; 0x1266 <CDC_Device_ProcessControlRequest+0xcc>
+ 11fa: 04 c0 rjmp .+8 ; 0x1204 <CDC_Device_ProcessControlRequest+0xcc>
{
if (USB_DeviceState == DEVICE_STATE_Unattached)
- 125e: 8e b3 in r24, 0x1e ; 30
- 1260: 88 23 and r24, r24
- 1262: 09 f4 brne .+2 ; 0x1266 <CDC_Device_ProcessControlRequest+0xcc>
- 1264: 43 c0 rjmp .+134 ; 0x12ec <CDC_Device_ProcessControlRequest+0x152>
+ 11fc: 8e b3 in r24, 0x1e ; 30
+ 11fe: 88 23 and r24, r24
+ 1200: 09 f4 brne .+2 ; 0x1204 <CDC_Device_ProcessControlRequest+0xcc>
+ 1202: 43 c0 rjmp .+134 ; 0x128a <CDC_Device_ProcessControlRequest+0x152>
* \return Boolean \c true if current endpoint is has received an OUT packet, \c false otherwise.
*/
static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsOUTReceived(void)
{
return ((UEINTX & (1 << RXOUTI)) ? true : false);
- 1266: 80 91 e8 00 lds r24, 0x00E8
+ 1204: 80 91 e8 00 lds r24, 0x00E8
case CDC_REQ_SetLineEncoding:
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
{
Endpoint_ClearSETUP();
while (!(Endpoint_IsOUTReceived()))
- 126a: 82 ff sbrs r24, 2
- 126c: f8 cf rjmp .-16 ; 0x125e <CDC_Device_ProcessControlRequest+0xc4>
+ 1208: 82 ff sbrs r24, 2
+ 120a: f8 cf rjmp .-16 ; 0x11fc <CDC_Device_ProcessControlRequest+0xc4>
{
uint32_t Value;
uint8_t Bytes[4];
} Data;
Data.Bytes[0] = UEDATX;
- 126e: 30 91 f1 00 lds r19, 0x00F1
+ 120c: 30 91 f1 00 lds r19, 0x00F1
Data.Bytes[1] = UEDATX;
- 1272: 20 91 f1 00 lds r18, 0x00F1
+ 1210: 20 91 f1 00 lds r18, 0x00F1
Data.Bytes[2] = UEDATX;
- 1276: 90 91 f1 00 lds r25, 0x00F1
+ 1214: 90 91 f1 00 lds r25, 0x00F1
Data.Bytes[3] = UEDATX;
- 127a: 80 91 f1 00 lds r24, 0x00F1
+ 1218: 80 91 f1 00 lds r24, 0x00F1
{
if (USB_DeviceState == DEVICE_STATE_Unattached)
return;
}
CDCInterfaceInfo->State.LineEncoding.BaudRateBPS = Endpoint_Read_32_LE();
- 127e: 3c 8b std Y+20, r19 ; 0x14
- 1280: 2d 8b std Y+21, r18 ; 0x15
- 1282: 9e 8b std Y+22, r25 ; 0x16
- 1284: 8f 8b std Y+23, r24 ; 0x17
+ 121c: 3c 8b std Y+20, r19 ; 0x14
+ 121e: 2d 8b std Y+21, r18 ; 0x15
+ 1220: 9e 8b std Y+22, r25 ; 0x16
+ 1222: 8f 8b std Y+23, r24 ; 0x17
* \return Next byte in the currently selected endpoint's FIFO buffer.
*/
static inline uint8_t Endpoint_Read_8(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline uint8_t Endpoint_Read_8(void)
{
return UEDATX;
- 1286: 80 91 f1 00 lds r24, 0x00F1
+ 1224: 80 91 f1 00 lds r24, 0x00F1
CDCInterfaceInfo->State.LineEncoding.CharFormat = Endpoint_Read_8();
- 128a: 88 8f std Y+24, r24 ; 0x18
- 128c: 80 91 f1 00 lds r24, 0x00F1
+ 1228: 88 8f std Y+24, r24 ; 0x18
+ 122a: 80 91 f1 00 lds r24, 0x00F1
CDCInterfaceInfo->State.LineEncoding.ParityType = Endpoint_Read_8();
- 1290: 89 8f std Y+25, r24 ; 0x19
- 1292: 80 91 f1 00 lds r24, 0x00F1
+ 122e: 89 8f std Y+25, r24 ; 0x19
+ 1230: 80 91 f1 00 lds r24, 0x00F1
CDCInterfaceInfo->State.LineEncoding.DataBits = Endpoint_Read_8();
- 1296: 8a 8f std Y+26, r24 ; 0x1a
+ 1234: 8a 8f std Y+26, r24 ; 0x1a
*/
static inline void Endpoint_ClearOUT(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearOUT(void)
{
#if !defined(CONTROL_ONLY_DEVICE)
UEINTX &= ~((1 << RXOUTI) | (1 << FIFOCON));
- 1298: 80 91 e8 00 lds r24, 0x00E8
- 129c: 8b 77 andi r24, 0x7B ; 123
- 129e: 80 93 e8 00 sts 0x00E8, r24
+ 1236: 80 91 e8 00 lds r24, 0x00E8
+ 123a: 8b 77 andi r24, 0x7B ; 123
+ 123c: 80 93 e8 00 sts 0x00E8, r24
Endpoint_ClearOUT();
Endpoint_ClearStatusStage();
- 12a2: 86 dc rcall .-1780 ; 0xbb0 <Endpoint_ClearStatusStage>
+ 1240: 86 dc rcall .-1780 ; 0xb4e <Endpoint_ClearStatusStage>
EVENT_CDC_Device_LineEncodingChanged(CDCInterfaceInfo);
- 12a4: ce 01 movw r24, r28
- 12a6: e7 d9 rcall .-3122 ; 0x676 <EVENT_CDC_Device_LineEncodingChanged>
- 12a8: 21 c0 rjmp .+66 ; 0x12ec <CDC_Device_ProcessControlRequest+0x152>
+ 1242: ce 01 movw r24, r28
+ 1244: 65 da rcall .-2870 ; 0x710 <EVENT_CDC_Device_LineEncodingChanged>
+ 1246: 21 c0 rjmp .+66 ; 0x128a <CDC_Device_ProcessControlRequest+0x152>
}
break;
case CDC_REQ_SetControlLineState:
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
- 12aa: 80 91 6e 02 lds r24, 0x026E
- 12ae: 81 32 cpi r24, 0x21 ; 33
- 12b0: e9 f4 brne .+58 ; 0x12ec <CDC_Device_ProcessControlRequest+0x152>
+ 1248: 80 91 74 02 lds r24, 0x0274
+ 124c: 81 32 cpi r24, 0x21 ; 33
+ 124e: e9 f4 brne .+58 ; 0x128a <CDC_Device_ProcessControlRequest+0x152>
* \note This is not applicable for non CONTROL type endpoints.
*/
static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearSETUP(void)
{
UEINTX &= ~(1 << RXSTPI);
- 12b2: 80 91 e8 00 lds r24, 0x00E8
- 12b6: 87 7f andi r24, 0xF7 ; 247
- 12b8: 80 93 e8 00 sts 0x00E8, r24
+ 1250: 80 91 e8 00 lds r24, 0x00E8
+ 1254: 87 7f andi r24, 0xF7 ; 247
+ 1256: 80 93 e8 00 sts 0x00E8, r24
{
Endpoint_ClearSETUP();
Endpoint_ClearStatusStage();
- 12bc: 79 dc rcall .-1806 ; 0xbb0 <Endpoint_ClearStatusStage>
+ 125a: 79 dc rcall .-1806 ; 0xb4e <Endpoint_ClearStatusStage>
CDCInterfaceInfo->State.ControlLineStates.HostToDevice = USB_ControlRequest.wValue;
- 12be: 80 91 70 02 lds r24, 0x0270
- 12c2: 90 91 71 02 lds r25, 0x0271
- 12c6: 99 8b std Y+17, r25 ; 0x11
- 12c8: 88 8b std Y+16, r24 ; 0x10
+ 125c: 80 91 76 02 lds r24, 0x0276
+ 1260: 90 91 77 02 lds r25, 0x0277
+ 1264: 99 8b std Y+17, r25 ; 0x11
+ 1266: 88 8b std Y+16, r24 ; 0x10
EVENT_CDC_Device_ControLineStateChanged(CDCInterfaceInfo);
- 12ca: ce 01 movw r24, r28
- 12cc: d4 d0 rcall .+424 ; 0x1476 <CDC_Device_Event_Stub>
- 12ce: 0e c0 rjmp .+28 ; 0x12ec <CDC_Device_ProcessControlRequest+0x152>
+ 1268: ce 01 movw r24, r28
+ 126a: d4 d0 rcall .+424 ; 0x1414 <CDC_Device_Event_Stub>
+ 126c: 0e c0 rjmp .+28 ; 0x128a <CDC_Device_ProcessControlRequest+0x152>
}
break;
case CDC_REQ_SendBreak:
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
- 12d0: 80 91 6e 02 lds r24, 0x026E
- 12d4: 81 32 cpi r24, 0x21 ; 33
- 12d6: 51 f4 brne .+20 ; 0x12ec <CDC_Device_ProcessControlRequest+0x152>
- 12d8: 80 91 e8 00 lds r24, 0x00E8
- 12dc: 87 7f andi r24, 0xF7 ; 247
- 12de: 80 93 e8 00 sts 0x00E8, r24
+ 126e: 80 91 74 02 lds r24, 0x0274
+ 1272: 81 32 cpi r24, 0x21 ; 33
+ 1274: 51 f4 brne .+20 ; 0x128a <CDC_Device_ProcessControlRequest+0x152>
+ 1276: 80 91 e8 00 lds r24, 0x00E8
+ 127a: 87 7f andi r24, 0xF7 ; 247
+ 127c: 80 93 e8 00 sts 0x00E8, r24
{
Endpoint_ClearSETUP();
Endpoint_ClearStatusStage();
- 12e2: 66 dc rcall .-1844 ; 0xbb0 <Endpoint_ClearStatusStage>
+ 1280: 66 dc rcall .-1844 ; 0xb4e <Endpoint_ClearStatusStage>
EVENT_CDC_Device_BreakSent(CDCInterfaceInfo, (uint8_t)USB_ControlRequest.wValue);
- 12e4: ce 01 movw r24, r28
- 12e6: 60 91 70 02 lds r22, 0x0270
- 12ea: c5 d0 rcall .+394 ; 0x1476 <CDC_Device_Event_Stub>
+ 1282: ce 01 movw r24, r28
+ 1284: 60 91 76 02 lds r22, 0x0276
+ 1288: c5 d0 rcall .+394 ; 0x1414 <CDC_Device_Event_Stub>
}
break;
}
}
- 12ec: df 91 pop r29
- 12ee: cf 91 pop r28
- 12f0: 08 95 ret
+ 128a: df 91 pop r29
+ 128c: cf 91 pop r28
+ 128e: 08 95 ret
-000012f2 <CDC_Device_ConfigureEndpoints>:
+00001290 <CDC_Device_ConfigureEndpoints>:
bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{
- 12f2: cf 93 push r28
- 12f4: df 93 push r29
- 12f6: ec 01 movw r28, r24
+ 1290: cf 93 push r28
+ 1292: df 93 push r29
+ 1294: ec 01 movw r28, r24
memset(&CDCInterfaceInfo->State, 0x00, sizeof(CDCInterfaceInfo->State));
- 12f8: 40 96 adiw r24, 0x10 ; 16
- 12fa: fc 01 movw r30, r24
- 12fc: 8b e0 ldi r24, 0x0B ; 11
- 12fe: df 01 movw r26, r30
- 1300: 1d 92 st X+, r1
- 1302: 8a 95 dec r24
- 1304: e9 f7 brne .-6 ; 0x1300 <CDC_Device_ConfigureEndpoints+0xe>
+ 1296: 40 96 adiw r24, 0x10 ; 16
+ 1298: fc 01 movw r30, r24
+ 129a: 8b e0 ldi r24, 0x0B ; 11
+ 129c: df 01 movw r26, r30
+ 129e: 1d 92 st X+, r1
+ 12a0: 8a 95 dec r24
+ 12a2: e9 f7 brne .-6 ; 0x129e <CDC_Device_ConfigureEndpoints+0xe>
CDCInterfaceInfo->Config.DataINEndpoint.Type = EP_TYPE_BULK;
- 1306: 82 e0 ldi r24, 0x02 ; 2
- 1308: 8c 83 std Y+4, r24 ; 0x04
+ 12a4: 82 e0 ldi r24, 0x02 ; 2
+ 12a6: 8c 83 std Y+4, r24 ; 0x04
CDCInterfaceInfo->Config.DataOUTEndpoint.Type = EP_TYPE_BULK;
- 130a: 89 87 std Y+9, r24 ; 0x09
+ 12a8: 89 87 std Y+9, r24 ; 0x09
CDCInterfaceInfo->Config.NotificationEndpoint.Type = EP_TYPE_INTERRUPT;
- 130c: 83 e0 ldi r24, 0x03 ; 3
- 130e: 8e 87 std Y+14, r24 ; 0x0e
+ 12aa: 83 e0 ldi r24, 0x03 ; 3
+ 12ac: 8e 87 std Y+14, r24 ; 0x0e
if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.DataINEndpoint, 1)))
- 1310: ce 01 movw r24, r28
- 1312: 01 96 adiw r24, 0x01 ; 1
- 1314: 61 e0 ldi r22, 0x01 ; 1
- 1316: 08 dc rcall .-2032 ; 0xb28 <Endpoint_ConfigureEndpointTable>
- 1318: 88 23 and r24, r24
- 131a: 59 f0 breq .+22 ; 0x1332 <CDC_Device_ConfigureEndpoints+0x40>
+ 12ae: ce 01 movw r24, r28
+ 12b0: 01 96 adiw r24, 0x01 ; 1
+ 12b2: 61 e0 ldi r22, 0x01 ; 1
+ 12b4: 08 dc rcall .-2032 ; 0xac6 <Endpoint_ConfigureEndpointTable>
+ 12b6: 88 23 and r24, r24
+ 12b8: 59 f0 breq .+22 ; 0x12d0 <CDC_Device_ConfigureEndpoints+0x40>
return false;
if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.DataOUTEndpoint, 1)))
- 131c: ce 01 movw r24, r28
- 131e: 06 96 adiw r24, 0x06 ; 6
- 1320: 61 e0 ldi r22, 0x01 ; 1
- 1322: 02 dc rcall .-2044 ; 0xb28 <Endpoint_ConfigureEndpointTable>
- 1324: 88 23 and r24, r24
- 1326: 29 f0 breq .+10 ; 0x1332 <CDC_Device_ConfigureEndpoints+0x40>
+ 12ba: ce 01 movw r24, r28
+ 12bc: 06 96 adiw r24, 0x06 ; 6
+ 12be: 61 e0 ldi r22, 0x01 ; 1
+ 12c0: 02 dc rcall .-2044 ; 0xac6 <Endpoint_ConfigureEndpointTable>
+ 12c2: 88 23 and r24, r24
+ 12c4: 29 f0 breq .+10 ; 0x12d0 <CDC_Device_ConfigureEndpoints+0x40>
return false;
if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.NotificationEndpoint, 1)))
- 1328: ce 01 movw r24, r28
- 132a: 0b 96 adiw r24, 0x0b ; 11
- 132c: 61 e0 ldi r22, 0x01 ; 1
- 132e: fc db rcall .-2056 ; 0xb28 <Endpoint_ConfigureEndpointTable>
- 1330: 01 c0 rjmp .+2 ; 0x1334 <CDC_Device_ConfigureEndpoints+0x42>
+ 12c6: ce 01 movw r24, r28
+ 12c8: 0b 96 adiw r24, 0x0b ; 11
+ 12ca: 61 e0 ldi r22, 0x01 ; 1
+ 12cc: fc db rcall .-2056 ; 0xac6 <Endpoint_ConfigureEndpointTable>
+ 12ce: 01 c0 rjmp .+2 ; 0x12d2 <CDC_Device_ConfigureEndpoints+0x42>
if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.DataINEndpoint, 1)))
return false;
if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.DataOUTEndpoint, 1)))
return false;
- 1332: 80 e0 ldi r24, 0x00 ; 0
+ 12d0: 80 e0 ldi r24, 0x00 ; 0
if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.NotificationEndpoint, 1)))
return false;
return true;
}
- 1334: df 91 pop r29
- 1336: cf 91 pop r28
- 1338: 08 95 ret
+ 12d2: df 91 pop r29
+ 12d4: cf 91 pop r28
+ 12d6: 08 95 ret
-0000133a <CDC_Device_SendByte>:
+000012d8 <CDC_Device_SendByte>:
return Endpoint_Write_Stream_LE(Buffer, Length, NULL);
}
uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
const uint8_t Data)
{
- 133a: df 93 push r29
- 133c: cf 93 push r28
- 133e: 0f 92 push r0
- 1340: cd b7 in r28, 0x3d ; 61
- 1342: de b7 in r29, 0x3e ; 62
- 1344: fc 01 movw r30, r24
+ 12d8: df 93 push r29
+ 12da: cf 93 push r28
+ 12dc: 0f 92 push r0
+ 12de: cd b7 in r28, 0x3d ; 61
+ 12e0: de b7 in r29, 0x3e ; 62
+ 12e2: fc 01 movw r30, r24
if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
- 1346: 8e b3 in r24, 0x1e ; 30
- 1348: 84 30 cpi r24, 0x04 ; 4
- 134a: f9 f4 brne .+62 ; 0x138a <CDC_Device_SendByte+0x50>
- 134c: 24 89 ldd r18, Z+20 ; 0x14
- 134e: 35 89 ldd r19, Z+21 ; 0x15
- 1350: 46 89 ldd r20, Z+22 ; 0x16
- 1352: 57 89 ldd r21, Z+23 ; 0x17
- 1354: 21 15 cp r18, r1
- 1356: 31 05 cpc r19, r1
- 1358: 41 05 cpc r20, r1
- 135a: 51 05 cpc r21, r1
- 135c: b1 f0 breq .+44 ; 0x138a <CDC_Device_SendByte+0x50>
+ 12e4: 8e b3 in r24, 0x1e ; 30
+ 12e6: 84 30 cpi r24, 0x04 ; 4
+ 12e8: f9 f4 brne .+62 ; 0x1328 <CDC_Device_SendByte+0x50>
+ 12ea: 24 89 ldd r18, Z+20 ; 0x14
+ 12ec: 35 89 ldd r19, Z+21 ; 0x15
+ 12ee: 46 89 ldd r20, Z+22 ; 0x16
+ 12f0: 57 89 ldd r21, Z+23 ; 0x17
+ 12f2: 21 15 cp r18, r1
+ 12f4: 31 05 cpc r19, r1
+ 12f6: 41 05 cpc r20, r1
+ 12f8: 51 05 cpc r21, r1
+ 12fa: b1 f0 breq .+44 ; 0x1328 <CDC_Device_SendByte+0x50>
*/
static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void Endpoint_SelectEndpoint(const uint8_t Address)
{
#if !defined(CONTROL_ONLY_DEVICE)
UENUM = (Address & ENDPOINT_EPNUM_MASK);
- 135e: 81 81 ldd r24, Z+1 ; 0x01
- 1360: 8f 70 andi r24, 0x0F ; 15
- 1362: 80 93 e9 00 sts 0x00E9, r24
+ 12fc: 81 81 ldd r24, Z+1 ; 0x01
+ 12fe: 8f 70 andi r24, 0x0F ; 15
+ 1300: 80 93 e9 00 sts 0x00E9, r24
* on its direction.
*/
static inline bool Endpoint_IsReadWriteAllowed(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsReadWriteAllowed(void)
{
return ((UEINTX & (1 << RWAL)) ? true : false);
- 1366: 80 91 e8 00 lds r24, 0x00E8
+ 1304: 80 91 e8 00 lds r24, 0x00E8
return ENDPOINT_RWSTREAM_DeviceDisconnected;
Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
if (!(Endpoint_IsReadWriteAllowed()))
- 136a: 85 fd sbrc r24, 5
- 136c: 0a c0 rjmp .+20 ; 0x1382 <CDC_Device_SendByte+0x48>
+ 1308: 85 fd sbrc r24, 5
+ 130a: 0a c0 rjmp .+20 ; 0x1320 <CDC_Device_SendByte+0x48>
*/
static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearIN(void)
{
#if !defined(CONTROL_ONLY_DEVICE)
UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
- 136e: 80 91 e8 00 lds r24, 0x00E8
- 1372: 8e 77 andi r24, 0x7E ; 126
- 1374: 80 93 e8 00 sts 0x00E8, r24
+ 130c: 80 91 e8 00 lds r24, 0x00E8
+ 1310: 8e 77 andi r24, 0x7E ; 126
+ 1312: 80 93 e8 00 sts 0x00E8, r24
{
Endpoint_ClearIN();
uint8_t ErrorCode;
if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
- 1378: 69 83 std Y+1, r22 ; 0x01
- 137a: 39 dc rcall .-1934 ; 0xbee <Endpoint_WaitUntilReady>
- 137c: 69 81 ldd r22, Y+1 ; 0x01
- 137e: 88 23 and r24, r24
- 1380: 29 f4 brne .+10 ; 0x138c <CDC_Device_SendByte+0x52>
+ 1316: 69 83 std Y+1, r22 ; 0x01
+ 1318: 39 dc rcall .-1934 ; 0xb8c <Endpoint_WaitUntilReady>
+ 131a: 69 81 ldd r22, Y+1 ; 0x01
+ 131c: 88 23 and r24, r24
+ 131e: 29 f4 brne .+10 ; 0x132a <CDC_Device_SendByte+0x52>
* \param[in] Data Data to write into the the currently selected endpoint's FIFO buffer.
*/
static inline void Endpoint_Write_8(const uint8_t Data) ATTR_ALWAYS_INLINE;
static inline void Endpoint_Write_8(const uint8_t Data)
{
UEDATX = Data;
- 1382: 60 93 f1 00 sts 0x00F1, r22
+ 1320: 60 93 f1 00 sts 0x00F1, r22
return ErrorCode;
}
Endpoint_Write_8(Data);
return ENDPOINT_READYWAIT_NoError;
- 1386: 80 e0 ldi r24, 0x00 ; 0
- 1388: 01 c0 rjmp .+2 ; 0x138c <CDC_Device_SendByte+0x52>
+ 1324: 80 e0 ldi r24, 0x00 ; 0
+ 1326: 01 c0 rjmp .+2 ; 0x132a <CDC_Device_SendByte+0x52>
uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
const uint8_t Data)
{
if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
return ENDPOINT_RWSTREAM_DeviceDisconnected;
- 138a: 82 e0 ldi r24, 0x02 ; 2
+ 1328: 82 e0 ldi r24, 0x02 ; 2
return ErrorCode;
}
Endpoint_Write_8(Data);
return ENDPOINT_READYWAIT_NoError;
}
- 138c: 0f 90 pop r0
- 138e: cf 91 pop r28
- 1390: df 91 pop r29
- 1392: 08 95 ret
+ 132a: 0f 90 pop r0
+ 132c: cf 91 pop r28
+ 132e: df 91 pop r29
+ 1330: 08 95 ret
-00001394 <CDC_Device_Flush>:
+00001332 <CDC_Device_Flush>:
uint8_t CDC_Device_Flush(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{
- 1394: fc 01 movw r30, r24
+ 1332: fc 01 movw r30, r24
if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
- 1396: 8e b3 in r24, 0x1e ; 30
- 1398: 84 30 cpi r24, 0x04 ; 4
- 139a: 19 f5 brne .+70 ; 0x13e2 <CDC_Device_Flush+0x4e>
- 139c: 24 89 ldd r18, Z+20 ; 0x14
- 139e: 35 89 ldd r19, Z+21 ; 0x15
- 13a0: 46 89 ldd r20, Z+22 ; 0x16
- 13a2: 57 89 ldd r21, Z+23 ; 0x17
- 13a4: 21 15 cp r18, r1
- 13a6: 31 05 cpc r19, r1
- 13a8: 41 05 cpc r20, r1
- 13aa: 51 05 cpc r21, r1
- 13ac: d1 f0 breq .+52 ; 0x13e2 <CDC_Device_Flush+0x4e>
+ 1334: 8e b3 in r24, 0x1e ; 30
+ 1336: 84 30 cpi r24, 0x04 ; 4
+ 1338: 19 f5 brne .+70 ; 0x1380 <CDC_Device_Flush+0x4e>
+ 133a: 24 89 ldd r18, Z+20 ; 0x14
+ 133c: 35 89 ldd r19, Z+21 ; 0x15
+ 133e: 46 89 ldd r20, Z+22 ; 0x16
+ 1340: 57 89 ldd r21, Z+23 ; 0x17
+ 1342: 21 15 cp r18, r1
+ 1344: 31 05 cpc r19, r1
+ 1346: 41 05 cpc r20, r1
+ 1348: 51 05 cpc r21, r1
+ 134a: d1 f0 breq .+52 ; 0x1380 <CDC_Device_Flush+0x4e>
*/
static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void Endpoint_SelectEndpoint(const uint8_t Address)
{
#if !defined(CONTROL_ONLY_DEVICE)
UENUM = (Address & ENDPOINT_EPNUM_MASK);
- 13ae: 81 81 ldd r24, Z+1 ; 0x01
- 13b0: 8f 70 andi r24, 0x0F ; 15
- 13b2: 80 93 e9 00 sts 0x00E9, r24
+ 134c: 81 81 ldd r24, Z+1 ; 0x01
+ 134e: 8f 70 andi r24, 0x0F ; 15
+ 1350: 80 93 e9 00 sts 0x00E9, r24
#if (defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
return UEBCX;
#elif defined(USB_SERIES_4_AVR)
return (((uint16_t)UEBCHX << 8) | UEBCLX);
#elif defined(USB_SERIES_2_AVR)
return UEBCLX;
- 13b6: 80 91 f2 00 lds r24, 0x00F2
+ 1354: 80 91 f2 00 lds r24, 0x00F2
uint8_t ErrorCode;
Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
if (!(Endpoint_BytesInEndpoint()))
- 13ba: 88 23 and r24, r24
- 13bc: a1 f0 breq .+40 ; 0x13e6 <CDC_Device_Flush+0x52>
+ 1358: 88 23 and r24, r24
+ 135a: a1 f0 breq .+40 ; 0x1384 <CDC_Device_Flush+0x52>
* on its direction.
*/
static inline bool Endpoint_IsReadWriteAllowed(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsReadWriteAllowed(void)
{
return ((UEINTX & (1 << RWAL)) ? true : false);
- 13be: 90 91 e8 00 lds r25, 0x00E8
+ 135c: 90 91 e8 00 lds r25, 0x00E8
*/
static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearIN(void)
{
#if !defined(CONTROL_ONLY_DEVICE)
UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
- 13c2: 80 91 e8 00 lds r24, 0x00E8
- 13c6: 8e 77 andi r24, 0x7E ; 126
- 13c8: 80 93 e8 00 sts 0x00E8, r24
+ 1360: 80 91 e8 00 lds r24, 0x00E8
+ 1364: 8e 77 andi r24, 0x7E ; 126
+ 1366: 80 93 e8 00 sts 0x00E8, r24
bool BankFull = !(Endpoint_IsReadWriteAllowed());
Endpoint_ClearIN();
if (BankFull)
- 13cc: 95 fd sbrc r25, 5
- 13ce: 0d c0 rjmp .+26 ; 0x13ea <CDC_Device_Flush+0x56>
+ 136a: 95 fd sbrc r25, 5
+ 136c: 0d c0 rjmp .+26 ; 0x1388 <CDC_Device_Flush+0x56>
{
if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
- 13d0: 0e dc rcall .-2020 ; 0xbee <Endpoint_WaitUntilReady>
- 13d2: 88 23 and r24, r24
- 13d4: 59 f4 brne .+22 ; 0x13ec <CDC_Device_Flush+0x58>
- 13d6: 90 91 e8 00 lds r25, 0x00E8
- 13da: 9e 77 andi r25, 0x7E ; 126
- 13dc: 90 93 e8 00 sts 0x00E8, r25
- 13e0: 08 95 ret
+ 136e: 0e dc rcall .-2020 ; 0xb8c <Endpoint_WaitUntilReady>
+ 1370: 88 23 and r24, r24
+ 1372: 59 f4 brne .+22 ; 0x138a <CDC_Device_Flush+0x58>
+ 1374: 90 91 e8 00 lds r25, 0x00E8
+ 1378: 9e 77 andi r25, 0x7E ; 126
+ 137a: 90 93 e8 00 sts 0x00E8, r25
+ 137e: 08 95 ret
}
uint8_t CDC_Device_Flush(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{
if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
return ENDPOINT_RWSTREAM_DeviceDisconnected;
- 13e2: 82 e0 ldi r24, 0x02 ; 2
- 13e4: 08 95 ret
+ 1380: 82 e0 ldi r24, 0x02 ; 2
+ 1382: 08 95 ret
uint8_t ErrorCode;
Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
if (!(Endpoint_BytesInEndpoint()))
return ENDPOINT_READYWAIT_NoError;
- 13e6: 80 e0 ldi r24, 0x00 ; 0
- 13e8: 08 95 ret
+ 1384: 80 e0 ldi r24, 0x00 ; 0
+ 1386: 08 95 ret
return ErrorCode;
Endpoint_ClearIN();
}
return ENDPOINT_READYWAIT_NoError;
- 13ea: 80 e0 ldi r24, 0x00 ; 0
+ 1388: 80 e0 ldi r24, 0x00 ; 0
}
- 13ec: 08 95 ret
+ 138a: 08 95 ret
-000013ee <CDC_Device_USBTask>:
+0000138c <CDC_Device_USBTask>:
return true;
}
void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{
if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
- 13ee: 2e b3 in r18, 0x1e ; 30
- 13f0: 24 30 cpi r18, 0x04 ; 4
- 13f2: 99 f4 brne .+38 ; 0x141a <CDC_Device_USBTask+0x2c>
- 13f4: fc 01 movw r30, r24
- 13f6: 24 89 ldd r18, Z+20 ; 0x14
- 13f8: 35 89 ldd r19, Z+21 ; 0x15
- 13fa: 46 89 ldd r20, Z+22 ; 0x16
- 13fc: 57 89 ldd r21, Z+23 ; 0x17
- 13fe: 21 15 cp r18, r1
- 1400: 31 05 cpc r19, r1
- 1402: 41 05 cpc r20, r1
- 1404: 51 05 cpc r21, r1
- 1406: 49 f0 breq .+18 ; 0x141a <CDC_Device_USBTask+0x2c>
+ 138c: 2e b3 in r18, 0x1e ; 30
+ 138e: 24 30 cpi r18, 0x04 ; 4
+ 1390: 99 f4 brne .+38 ; 0x13b8 <CDC_Device_USBTask+0x2c>
+ 1392: fc 01 movw r30, r24
+ 1394: 24 89 ldd r18, Z+20 ; 0x14
+ 1396: 35 89 ldd r19, Z+21 ; 0x15
+ 1398: 46 89 ldd r20, Z+22 ; 0x16
+ 139a: 57 89 ldd r21, Z+23 ; 0x17
+ 139c: 21 15 cp r18, r1
+ 139e: 31 05 cpc r19, r1
+ 13a0: 41 05 cpc r20, r1
+ 13a2: 51 05 cpc r21, r1
+ 13a4: 49 f0 breq .+18 ; 0x13b8 <CDC_Device_USBTask+0x2c>
*/
static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void Endpoint_SelectEndpoint(const uint8_t Address)
{
#if !defined(CONTROL_ONLY_DEVICE)
UENUM = (Address & ENDPOINT_EPNUM_MASK);
- 1408: 21 81 ldd r18, Z+1 ; 0x01
- 140a: 2f 70 andi r18, 0x0F ; 15
- 140c: 20 93 e9 00 sts 0x00E9, r18
+ 13a6: 21 81 ldd r18, Z+1 ; 0x01
+ 13a8: 2f 70 andi r18, 0x0F ; 15
+ 13aa: 20 93 e9 00 sts 0x00E9, r18
* \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
*/
static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsINReady(void)
{
return ((UEINTX & (1 << TXINI)) ? true : false);
- 1410: 20 91 e8 00 lds r18, 0x00E8
+ 13ae: 20 91 e8 00 lds r18, 0x00E8
return;
#if !defined(NO_CLASS_DRIVER_AUTOFLUSH)
Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
if (Endpoint_IsINReady())
- 1414: 20 ff sbrs r18, 0
- 1416: 01 c0 rjmp .+2 ; 0x141a <CDC_Device_USBTask+0x2c>
+ 13b2: 20 ff sbrs r18, 0
+ 13b4: 01 c0 rjmp .+2 ; 0x13b8 <CDC_Device_USBTask+0x2c>
CDC_Device_Flush(CDCInterfaceInfo);
- 1418: bd cf rjmp .-134 ; 0x1394 <CDC_Device_Flush>
- 141a: 08 95 ret
+ 13b6: bd cf rjmp .-134 ; 0x1332 <CDC_Device_Flush>
+ 13b8: 08 95 ret
-0000141c <CDC_Device_ReceiveByte>:
+000013ba <CDC_Device_ReceiveByte>:
return 0;
}
}
int16_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{
- 141c: fc 01 movw r30, r24
+ 13ba: fc 01 movw r30, r24
if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
- 141e: 8e b3 in r24, 0x1e ; 30
- 1420: 84 30 cpi r24, 0x04 ; 4
- 1422: 29 f5 brne .+74 ; 0x146e <CDC_Device_ReceiveByte+0x52>
- 1424: 24 89 ldd r18, Z+20 ; 0x14
- 1426: 35 89 ldd r19, Z+21 ; 0x15
- 1428: 46 89 ldd r20, Z+22 ; 0x16
- 142a: 57 89 ldd r21, Z+23 ; 0x17
- 142c: 21 15 cp r18, r1
- 142e: 31 05 cpc r19, r1
- 1430: 41 05 cpc r20, r1
- 1432: 51 05 cpc r21, r1
- 1434: e1 f0 breq .+56 ; 0x146e <CDC_Device_ReceiveByte+0x52>
+ 13bc: 8e b3 in r24, 0x1e ; 30
+ 13be: 84 30 cpi r24, 0x04 ; 4
+ 13c0: 29 f5 brne .+74 ; 0x140c <CDC_Device_ReceiveByte+0x52>
+ 13c2: 24 89 ldd r18, Z+20 ; 0x14
+ 13c4: 35 89 ldd r19, Z+21 ; 0x15
+ 13c6: 46 89 ldd r20, Z+22 ; 0x16
+ 13c8: 57 89 ldd r21, Z+23 ; 0x17
+ 13ca: 21 15 cp r18, r1
+ 13cc: 31 05 cpc r19, r1
+ 13ce: 41 05 cpc r20, r1
+ 13d0: 51 05 cpc r21, r1
+ 13d2: e1 f0 breq .+56 ; 0x140c <CDC_Device_ReceiveByte+0x52>
*/
static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
static inline void Endpoint_SelectEndpoint(const uint8_t Address)
{
#if !defined(CONTROL_ONLY_DEVICE)
UENUM = (Address & ENDPOINT_EPNUM_MASK);
- 1436: 86 81 ldd r24, Z+6 ; 0x06
- 1438: 8f 70 andi r24, 0x0F ; 15
- 143a: 80 93 e9 00 sts 0x00E9, r24
+ 13d4: 86 81 ldd r24, Z+6 ; 0x06
+ 13d6: 8f 70 andi r24, 0x0F ; 15
+ 13d8: 80 93 e9 00 sts 0x00E9, r24
* \return Boolean \c true if current endpoint is has received an OUT packet, \c false otherwise.
*/
static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsOUTReceived(void)
{
return ((UEINTX & (1 << RXOUTI)) ? true : false);
- 143e: 80 91 e8 00 lds r24, 0x00E8
+ 13dc: 80 91 e8 00 lds r24, 0x00E8
int16_t ReceivedByte = -1;
Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpoint.Address);
if (Endpoint_IsOUTReceived())
- 1442: 82 ff sbrs r24, 2
- 1444: 14 c0 rjmp .+40 ; 0x146e <CDC_Device_ReceiveByte+0x52>
+ 13e0: 82 ff sbrs r24, 2
+ 13e2: 14 c0 rjmp .+40 ; 0x140c <CDC_Device_ReceiveByte+0x52>
#if (defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
return UEBCX;
#elif defined(USB_SERIES_4_AVR)
return (((uint16_t)UEBCHX << 8) | UEBCLX);
#elif defined(USB_SERIES_2_AVR)
return UEBCLX;
- 1446: 80 91 f2 00 lds r24, 0x00F2
+ 13e4: 80 91 f2 00 lds r24, 0x00F2
{
if (Endpoint_BytesInEndpoint())
- 144a: 88 23 and r24, r24
- 144c: 21 f0 breq .+8 ; 0x1456 <CDC_Device_ReceiveByte+0x3a>
+ 13e8: 88 23 and r24, r24
+ 13ea: 21 f0 breq .+8 ; 0x13f4 <CDC_Device_ReceiveByte+0x3a>
* \return Next byte in the currently selected endpoint's FIFO buffer.
*/
static inline uint8_t Endpoint_Read_8(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline uint8_t Endpoint_Read_8(void)
{
return UEDATX;
- 144e: 20 91 f1 00 lds r18, 0x00F1
+ 13ec: 20 91 f1 00 lds r18, 0x00F1
ReceivedByte = Endpoint_Read_8();
- 1452: 30 e0 ldi r19, 0x00 ; 0
- 1454: 02 c0 rjmp .+4 ; 0x145a <CDC_Device_ReceiveByte+0x3e>
+ 13f0: 30 e0 ldi r19, 0x00 ; 0
+ 13f2: 02 c0 rjmp .+4 ; 0x13f8 <CDC_Device_ReceiveByte+0x3e>
int16_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{
if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
return -1;
int16_t ReceivedByte = -1;
- 1456: 2f ef ldi r18, 0xFF ; 255
- 1458: 3f ef ldi r19, 0xFF ; 255
+ 13f4: 2f ef ldi r18, 0xFF ; 255
+ 13f6: 3f ef ldi r19, 0xFF ; 255
#if (defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
return UEBCX;
#elif defined(USB_SERIES_4_AVR)
return (((uint16_t)UEBCHX << 8) | UEBCLX);
#elif defined(USB_SERIES_2_AVR)
return UEBCLX;
- 145a: 80 91 f2 00 lds r24, 0x00F2
+ 13f8: 80 91 f2 00 lds r24, 0x00F2
if (Endpoint_IsOUTReceived())
{
if (Endpoint_BytesInEndpoint())
ReceivedByte = Endpoint_Read_8();
if (!(Endpoint_BytesInEndpoint()))
- 145e: 88 23 and r24, r24
- 1460: 41 f4 brne .+16 ; 0x1472 <CDC_Device_ReceiveByte+0x56>
+ 13fc: 88 23 and r24, r24
+ 13fe: 41 f4 brne .+16 ; 0x1410 <CDC_Device_ReceiveByte+0x56>
*/
static inline void Endpoint_ClearOUT(void) ATTR_ALWAYS_INLINE;
static inline void Endpoint_ClearOUT(void)
{
#if !defined(CONTROL_ONLY_DEVICE)
UEINTX &= ~((1 << RXOUTI) | (1 << FIFOCON));
- 1462: 80 91 e8 00 lds r24, 0x00E8
- 1466: 8b 77 andi r24, 0x7B ; 123
- 1468: 80 93 e8 00 sts 0x00E8, r24
- 146c: 02 c0 rjmp .+4 ; 0x1472 <CDC_Device_ReceiveByte+0x56>
+ 1400: 80 91 e8 00 lds r24, 0x00E8
+ 1404: 8b 77 andi r24, 0x7B ; 123
+ 1406: 80 93 e8 00 sts 0x00E8, r24
+ 140a: 02 c0 rjmp .+4 ; 0x1410 <CDC_Device_ReceiveByte+0x56>
int16_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{
if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
return -1;
int16_t ReceivedByte = -1;
- 146e: 2f ef ldi r18, 0xFF ; 255
- 1470: 3f ef ldi r19, 0xFF ; 255
+ 140c: 2f ef ldi r18, 0xFF ; 255
+ 140e: 3f ef ldi r19, 0xFF ; 255
if (!(Endpoint_BytesInEndpoint()))
Endpoint_ClearOUT();
}
return ReceivedByte;
}
- 1472: c9 01 movw r24, r18
- 1474: 08 95 ret
+ 1410: c9 01 movw r24, r18
+ 1412: 08 95 ret
-00001476 <CDC_Device_Event_Stub>:
+00001414 <CDC_Device_Event_Stub>:
#endif
void CDC_Device_Event_Stub(void)
{
}
- 1476: 08 95 ret
-
-00001478 <__subsf3>:
- 1478: 50 58 subi r21, 0x80 ; 128
-
-0000147a <__addsf3>:
- 147a: bb 27 eor r27, r27
- 147c: aa 27 eor r26, r26
- 147e: 0e d0 rcall .+28 ; 0x149c <__addsf3x>
- 1480: 70 c1 rjmp .+736 ; 0x1762 <__fp_round>
- 1482: 61 d1 rcall .+706 ; 0x1746 <__fp_pscA>
- 1484: 30 f0 brcs .+12 ; 0x1492 <__addsf3+0x18>
- 1486: 66 d1 rcall .+716 ; 0x1754 <__fp_pscB>
- 1488: 20 f0 brcs .+8 ; 0x1492 <__addsf3+0x18>
- 148a: 31 f4 brne .+12 ; 0x1498 <__addsf3+0x1e>
- 148c: 9f 3f cpi r25, 0xFF ; 255
- 148e: 11 f4 brne .+4 ; 0x1494 <__addsf3+0x1a>
- 1490: 1e f4 brtc .+6 ; 0x1498 <__addsf3+0x1e>
- 1492: 56 c1 rjmp .+684 ; 0x1740 <__fp_nan>
- 1494: 0e f4 brtc .+2 ; 0x1498 <__addsf3+0x1e>
- 1496: e0 95 com r30
- 1498: e7 fb bst r30, 7
- 149a: 4c c1 rjmp .+664 ; 0x1734 <__fp_inf>
-
-0000149c <__addsf3x>:
- 149c: e9 2f mov r30, r25
- 149e: 72 d1 rcall .+740 ; 0x1784 <__fp_split3>
- 14a0: 80 f3 brcs .-32 ; 0x1482 <__addsf3+0x8>
- 14a2: ba 17 cp r27, r26
- 14a4: 62 07 cpc r22, r18
- 14a6: 73 07 cpc r23, r19
- 14a8: 84 07 cpc r24, r20
- 14aa: 95 07 cpc r25, r21
- 14ac: 18 f0 brcs .+6 ; 0x14b4 <__addsf3x+0x18>
- 14ae: 71 f4 brne .+28 ; 0x14cc <__addsf3x+0x30>
- 14b0: 9e f5 brtc .+102 ; 0x1518 <__addsf3x+0x7c>
- 14b2: 8a c1 rjmp .+788 ; 0x17c8 <__fp_zero>
- 14b4: 0e f4 brtc .+2 ; 0x14b8 <__addsf3x+0x1c>
- 14b6: e0 95 com r30
- 14b8: 0b 2e mov r0, r27
- 14ba: ba 2f mov r27, r26
- 14bc: a0 2d mov r26, r0
- 14be: 0b 01 movw r0, r22
- 14c0: b9 01 movw r22, r18
- 14c2: 90 01 movw r18, r0
- 14c4: 0c 01 movw r0, r24
- 14c6: ca 01 movw r24, r20
- 14c8: a0 01 movw r20, r0
- 14ca: 11 24 eor r1, r1
- 14cc: ff 27 eor r31, r31
- 14ce: 59 1b sub r21, r25
- 14d0: 99 f0 breq .+38 ; 0x14f8 <__addsf3x+0x5c>
- 14d2: 59 3f cpi r21, 0xF9 ; 249
- 14d4: 50 f4 brcc .+20 ; 0x14ea <__addsf3x+0x4e>
- 14d6: 50 3e cpi r21, 0xE0 ; 224
- 14d8: 68 f1 brcs .+90 ; 0x1534 <__addsf3x+0x98>
- 14da: 1a 16 cp r1, r26
- 14dc: f0 40 sbci r31, 0x00 ; 0
- 14de: a2 2f mov r26, r18
- 14e0: 23 2f mov r18, r19
- 14e2: 34 2f mov r19, r20
- 14e4: 44 27 eor r20, r20
- 14e6: 58 5f subi r21, 0xF8 ; 248
- 14e8: f3 cf rjmp .-26 ; 0x14d0 <__addsf3x+0x34>
- 14ea: 46 95 lsr r20
- 14ec: 37 95 ror r19
- 14ee: 27 95 ror r18
- 14f0: a7 95 ror r26
- 14f2: f0 40 sbci r31, 0x00 ; 0
- 14f4: 53 95 inc r21
- 14f6: c9 f7 brne .-14 ; 0x14ea <__addsf3x+0x4e>
- 14f8: 7e f4 brtc .+30 ; 0x1518 <__addsf3x+0x7c>
- 14fa: 1f 16 cp r1, r31
- 14fc: ba 0b sbc r27, r26
- 14fe: 62 0b sbc r22, r18
- 1500: 73 0b sbc r23, r19
- 1502: 84 0b sbc r24, r20
- 1504: ba f0 brmi .+46 ; 0x1534 <__addsf3x+0x98>
- 1506: 91 50 subi r25, 0x01 ; 1
- 1508: a1 f0 breq .+40 ; 0x1532 <__addsf3x+0x96>
- 150a: ff 0f add r31, r31
- 150c: bb 1f adc r27, r27
- 150e: 66 1f adc r22, r22
- 1510: 77 1f adc r23, r23
- 1512: 88 1f adc r24, r24
- 1514: c2 f7 brpl .-16 ; 0x1506 <__addsf3x+0x6a>
- 1516: 0e c0 rjmp .+28 ; 0x1534 <__addsf3x+0x98>
- 1518: ba 0f add r27, r26
- 151a: 62 1f adc r22, r18
- 151c: 73 1f adc r23, r19
- 151e: 84 1f adc r24, r20
- 1520: 48 f4 brcc .+18 ; 0x1534 <__addsf3x+0x98>
- 1522: 87 95 ror r24
- 1524: 77 95 ror r23
- 1526: 67 95 ror r22
- 1528: b7 95 ror r27
- 152a: f7 95 ror r31
- 152c: 9e 3f cpi r25, 0xFE ; 254
- 152e: 08 f0 brcs .+2 ; 0x1532 <__addsf3x+0x96>
- 1530: b3 cf rjmp .-154 ; 0x1498 <__addsf3+0x1e>
- 1532: 93 95 inc r25
- 1534: 88 0f add r24, r24
- 1536: 08 f0 brcs .+2 ; 0x153a <__addsf3x+0x9e>
- 1538: 99 27 eor r25, r25
- 153a: ee 0f add r30, r30
- 153c: 97 95 ror r25
- 153e: 87 95 ror r24
- 1540: 08 95 ret
-
-00001542 <__cmpsf2>:
- 1542: d4 d0 rcall .+424 ; 0x16ec <__fp_cmp>
- 1544: 08 f4 brcc .+2 ; 0x1548 <__cmpsf2+0x6>
- 1546: 81 e0 ldi r24, 0x01 ; 1
- 1548: 08 95 ret
-
-0000154a <__divsf3>:
- 154a: 0c d0 rcall .+24 ; 0x1564 <__divsf3x>
- 154c: 0a c1 rjmp .+532 ; 0x1762 <__fp_round>
- 154e: 02 d1 rcall .+516 ; 0x1754 <__fp_pscB>
- 1550: 40 f0 brcs .+16 ; 0x1562 <__divsf3+0x18>
- 1552: f9 d0 rcall .+498 ; 0x1746 <__fp_pscA>
- 1554: 30 f0 brcs .+12 ; 0x1562 <__divsf3+0x18>
- 1556: 21 f4 brne .+8 ; 0x1560 <__divsf3+0x16>
- 1558: 5f 3f cpi r21, 0xFF ; 255
- 155a: 19 f0 breq .+6 ; 0x1562 <__divsf3+0x18>
- 155c: eb c0 rjmp .+470 ; 0x1734 <__fp_inf>
- 155e: 51 11 cpse r21, r1
- 1560: 34 c1 rjmp .+616 ; 0x17ca <__fp_szero>
- 1562: ee c0 rjmp .+476 ; 0x1740 <__fp_nan>
-
-00001564 <__divsf3x>:
- 1564: 0f d1 rcall .+542 ; 0x1784 <__fp_split3>
- 1566: 98 f3 brcs .-26 ; 0x154e <__divsf3+0x4>
-
-00001568 <__divsf3_pse>:
- 1568: 99 23 and r25, r25
- 156a: c9 f3 breq .-14 ; 0x155e <__divsf3+0x14>
- 156c: 55 23 and r21, r21
- 156e: b1 f3 breq .-20 ; 0x155c <__divsf3+0x12>
- 1570: 95 1b sub r25, r21
- 1572: 55 0b sbc r21, r21
- 1574: bb 27 eor r27, r27
- 1576: aa 27 eor r26, r26
- 1578: 62 17 cp r22, r18
- 157a: 73 07 cpc r23, r19
- 157c: 84 07 cpc r24, r20
- 157e: 38 f0 brcs .+14 ; 0x158e <__divsf3_pse+0x26>
- 1580: 9f 5f subi r25, 0xFF ; 255
- 1582: 5f 4f sbci r21, 0xFF ; 255
- 1584: 22 0f add r18, r18
- 1586: 33 1f adc r19, r19
- 1588: 44 1f adc r20, r20
- 158a: aa 1f adc r26, r26
- 158c: a9 f3 breq .-22 ; 0x1578 <__divsf3_pse+0x10>
- 158e: 33 d0 rcall .+102 ; 0x15f6 <__divsf3_pse+0x8e>
- 1590: 0e 2e mov r0, r30
- 1592: 3a f0 brmi .+14 ; 0x15a2 <__divsf3_pse+0x3a>
- 1594: e0 e8 ldi r30, 0x80 ; 128
- 1596: 30 d0 rcall .+96 ; 0x15f8 <__divsf3_pse+0x90>
- 1598: 91 50 subi r25, 0x01 ; 1
- 159a: 50 40 sbci r21, 0x00 ; 0
- 159c: e6 95 lsr r30
- 159e: 00 1c adc r0, r0
- 15a0: ca f7 brpl .-14 ; 0x1594 <__divsf3_pse+0x2c>
- 15a2: 29 d0 rcall .+82 ; 0x15f6 <__divsf3_pse+0x8e>
- 15a4: fe 2f mov r31, r30
- 15a6: 27 d0 rcall .+78 ; 0x15f6 <__divsf3_pse+0x8e>
- 15a8: 66 0f add r22, r22
- 15aa: 77 1f adc r23, r23
- 15ac: 88 1f adc r24, r24
- 15ae: bb 1f adc r27, r27
- 15b0: 26 17 cp r18, r22
- 15b2: 37 07 cpc r19, r23
- 15b4: 48 07 cpc r20, r24
- 15b6: ab 07 cpc r26, r27
- 15b8: b0 e8 ldi r27, 0x80 ; 128
- 15ba: 09 f0 breq .+2 ; 0x15be <__divsf3_pse+0x56>
- 15bc: bb 0b sbc r27, r27
- 15be: 80 2d mov r24, r0
- 15c0: bf 01 movw r22, r30
- 15c2: ff 27 eor r31, r31
- 15c4: 93 58 subi r25, 0x83 ; 131
- 15c6: 5f 4f sbci r21, 0xFF ; 255
- 15c8: 2a f0 brmi .+10 ; 0x15d4 <__divsf3_pse+0x6c>
- 15ca: 9e 3f cpi r25, 0xFE ; 254
- 15cc: 51 05 cpc r21, r1
- 15ce: 68 f0 brcs .+26 ; 0x15ea <__divsf3_pse+0x82>
- 15d0: b1 c0 rjmp .+354 ; 0x1734 <__fp_inf>
- 15d2: fb c0 rjmp .+502 ; 0x17ca <__fp_szero>
- 15d4: 5f 3f cpi r21, 0xFF ; 255
- 15d6: ec f3 brlt .-6 ; 0x15d2 <__divsf3_pse+0x6a>
- 15d8: 98 3e cpi r25, 0xE8 ; 232
- 15da: dc f3 brlt .-10 ; 0x15d2 <__divsf3_pse+0x6a>
- 15dc: 86 95 lsr r24
- 15de: 77 95 ror r23
- 15e0: 67 95 ror r22
- 15e2: b7 95 ror r27
- 15e4: f7 95 ror r31
- 15e6: 9f 5f subi r25, 0xFF ; 255
- 15e8: c9 f7 brne .-14 ; 0x15dc <__divsf3_pse+0x74>
- 15ea: 88 0f add r24, r24
- 15ec: 91 1d adc r25, r1
- 15ee: 96 95 lsr r25
- 15f0: 87 95 ror r24
- 15f2: 97 f9 bld r25, 7
- 15f4: 08 95 ret
- 15f6: e1 e0 ldi r30, 0x01 ; 1
- 15f8: 66 0f add r22, r22
- 15fa: 77 1f adc r23, r23
- 15fc: 88 1f adc r24, r24
- 15fe: bb 1f adc r27, r27
- 1600: 62 17 cp r22, r18
- 1602: 73 07 cpc r23, r19
- 1604: 84 07 cpc r24, r20
- 1606: ba 07 cpc r27, r26
- 1608: 20 f0 brcs .+8 ; 0x1612 <__divsf3_pse+0xaa>
- 160a: 62 1b sub r22, r18
- 160c: 73 0b sbc r23, r19
- 160e: 84 0b sbc r24, r20
- 1610: ba 0b sbc r27, r26
- 1612: ee 1f adc r30, r30
- 1614: 88 f7 brcc .-30 ; 0x15f8 <__divsf3_pse+0x90>
- 1616: e0 95 com r30
- 1618: 08 95 ret
-
-0000161a <__fixunssfsi>:
- 161a: bc d0 rcall .+376 ; 0x1794 <__fp_splitA>
- 161c: 88 f0 brcs .+34 ; 0x1640 <__fixunssfsi+0x26>
- 161e: 9f 57 subi r25, 0x7F ; 127
- 1620: 90 f0 brcs .+36 ; 0x1646 <__fixunssfsi+0x2c>
- 1622: b9 2f mov r27, r25
- 1624: 99 27 eor r25, r25
- 1626: b7 51 subi r27, 0x17 ; 23
- 1628: a0 f0 brcs .+40 ; 0x1652 <__fixunssfsi+0x38>
- 162a: d1 f0 breq .+52 ; 0x1660 <__fixunssfsi+0x46>
- 162c: 66 0f add r22, r22
- 162e: 77 1f adc r23, r23
- 1630: 88 1f adc r24, r24
- 1632: 99 1f adc r25, r25
- 1634: 1a f0 brmi .+6 ; 0x163c <__fixunssfsi+0x22>
- 1636: ba 95 dec r27
- 1638: c9 f7 brne .-14 ; 0x162c <__fixunssfsi+0x12>
- 163a: 12 c0 rjmp .+36 ; 0x1660 <__fixunssfsi+0x46>
- 163c: b1 30 cpi r27, 0x01 ; 1
- 163e: 81 f0 breq .+32 ; 0x1660 <__fixunssfsi+0x46>
- 1640: c3 d0 rcall .+390 ; 0x17c8 <__fp_zero>
- 1642: b1 e0 ldi r27, 0x01 ; 1
- 1644: 08 95 ret
- 1646: c0 c0 rjmp .+384 ; 0x17c8 <__fp_zero>
- 1648: 67 2f mov r22, r23
- 164a: 78 2f mov r23, r24
- 164c: 88 27 eor r24, r24
- 164e: b8 5f subi r27, 0xF8 ; 248
- 1650: 39 f0 breq .+14 ; 0x1660 <__fixunssfsi+0x46>
- 1652: b9 3f cpi r27, 0xF9 ; 249
- 1654: cc f3 brlt .-14 ; 0x1648 <__fixunssfsi+0x2e>
- 1656: 86 95 lsr r24
- 1658: 77 95 ror r23
- 165a: 67 95 ror r22
- 165c: b3 95 inc r27
- 165e: d9 f7 brne .-10 ; 0x1656 <__fixunssfsi+0x3c>
- 1660: 3e f4 brtc .+14 ; 0x1670 <__fixunssfsi+0x56>
- 1662: 90 95 com r25
- 1664: 80 95 com r24
- 1666: 70 95 com r23
- 1668: 61 95 neg r22
- 166a: 7f 4f sbci r23, 0xFF ; 255
- 166c: 8f 4f sbci r24, 0xFF ; 255
- 166e: 9f 4f sbci r25, 0xFF ; 255
- 1670: 08 95 ret
-
-00001672 <__floatunsisf>:
- 1672: e8 94 clt
- 1674: 09 c0 rjmp .+18 ; 0x1688 <__floatsisf+0x12>
-
-00001676 <__floatsisf>:
- 1676: 97 fb bst r25, 7
- 1678: 3e f4 brtc .+14 ; 0x1688 <__floatsisf+0x12>
- 167a: 90 95 com r25
- 167c: 80 95 com r24
- 167e: 70 95 com r23
- 1680: 61 95 neg r22
- 1682: 7f 4f sbci r23, 0xFF ; 255
- 1684: 8f 4f sbci r24, 0xFF ; 255
- 1686: 9f 4f sbci r25, 0xFF ; 255
- 1688: 99 23 and r25, r25
- 168a: a9 f0 breq .+42 ; 0x16b6 <__floatsisf+0x40>
- 168c: f9 2f mov r31, r25
- 168e: 96 e9 ldi r25, 0x96 ; 150
- 1690: bb 27 eor r27, r27
- 1692: 93 95 inc r25
- 1694: f6 95 lsr r31
- 1696: 87 95 ror r24
- 1698: 77 95 ror r23
- 169a: 67 95 ror r22
- 169c: b7 95 ror r27
- 169e: f1 11 cpse r31, r1
- 16a0: f8 cf rjmp .-16 ; 0x1692 <__floatsisf+0x1c>
- 16a2: fa f4 brpl .+62 ; 0x16e2 <__floatsisf+0x6c>
- 16a4: bb 0f add r27, r27
- 16a6: 11 f4 brne .+4 ; 0x16ac <__floatsisf+0x36>
- 16a8: 60 ff sbrs r22, 0
- 16aa: 1b c0 rjmp .+54 ; 0x16e2 <__floatsisf+0x6c>
- 16ac: 6f 5f subi r22, 0xFF ; 255
- 16ae: 7f 4f sbci r23, 0xFF ; 255
- 16b0: 8f 4f sbci r24, 0xFF ; 255
- 16b2: 9f 4f sbci r25, 0xFF ; 255
- 16b4: 16 c0 rjmp .+44 ; 0x16e2 <__floatsisf+0x6c>
- 16b6: 88 23 and r24, r24
- 16b8: 11 f0 breq .+4 ; 0x16be <__floatsisf+0x48>
- 16ba: 96 e9 ldi r25, 0x96 ; 150
- 16bc: 11 c0 rjmp .+34 ; 0x16e0 <__floatsisf+0x6a>
- 16be: 77 23 and r23, r23
- 16c0: 21 f0 breq .+8 ; 0x16ca <__floatsisf+0x54>
- 16c2: 9e e8 ldi r25, 0x8E ; 142
- 16c4: 87 2f mov r24, r23
- 16c6: 76 2f mov r23, r22
- 16c8: 05 c0 rjmp .+10 ; 0x16d4 <__floatsisf+0x5e>
- 16ca: 66 23 and r22, r22
- 16cc: 71 f0 breq .+28 ; 0x16ea <__floatsisf+0x74>
- 16ce: 96 e8 ldi r25, 0x86 ; 134
- 16d0: 86 2f mov r24, r22
- 16d2: 70 e0 ldi r23, 0x00 ; 0
- 16d4: 60 e0 ldi r22, 0x00 ; 0
- 16d6: 2a f0 brmi .+10 ; 0x16e2 <__floatsisf+0x6c>
- 16d8: 9a 95 dec r25
- 16da: 66 0f add r22, r22
- 16dc: 77 1f adc r23, r23
- 16de: 88 1f adc r24, r24
- 16e0: da f7 brpl .-10 ; 0x16d8 <__floatsisf+0x62>
- 16e2: 88 0f add r24, r24
- 16e4: 96 95 lsr r25
- 16e6: 87 95 ror r24
- 16e8: 97 f9 bld r25, 7
- 16ea: 08 95 ret
-
-000016ec <__fp_cmp>:
- 16ec: 99 0f add r25, r25
- 16ee: 00 08 sbc r0, r0
- 16f0: 55 0f add r21, r21
- 16f2: aa 0b sbc r26, r26
- 16f4: e0 e8 ldi r30, 0x80 ; 128
- 16f6: fe ef ldi r31, 0xFE ; 254
- 16f8: 16 16 cp r1, r22
- 16fa: 17 06 cpc r1, r23
- 16fc: e8 07 cpc r30, r24
- 16fe: f9 07 cpc r31, r25
- 1700: c0 f0 brcs .+48 ; 0x1732 <__fp_cmp+0x46>
- 1702: 12 16 cp r1, r18
- 1704: 13 06 cpc r1, r19
- 1706: e4 07 cpc r30, r20
- 1708: f5 07 cpc r31, r21
- 170a: 98 f0 brcs .+38 ; 0x1732 <__fp_cmp+0x46>
- 170c: 62 1b sub r22, r18
- 170e: 73 0b sbc r23, r19
- 1710: 84 0b sbc r24, r20
- 1712: 95 0b sbc r25, r21
- 1714: 39 f4 brne .+14 ; 0x1724 <__fp_cmp+0x38>
- 1716: 0a 26 eor r0, r26
- 1718: 61 f0 breq .+24 ; 0x1732 <__fp_cmp+0x46>
- 171a: 23 2b or r18, r19
- 171c: 24 2b or r18, r20
- 171e: 25 2b or r18, r21
- 1720: 21 f4 brne .+8 ; 0x172a <__fp_cmp+0x3e>
- 1722: 08 95 ret
- 1724: 0a 26 eor r0, r26
- 1726: 09 f4 brne .+2 ; 0x172a <__fp_cmp+0x3e>
- 1728: a1 40 sbci r26, 0x01 ; 1
- 172a: a6 95 lsr r26
- 172c: 8f ef ldi r24, 0xFF ; 255
- 172e: 81 1d adc r24, r1
- 1730: 81 1d adc r24, r1
- 1732: 08 95 ret
-
-00001734 <__fp_inf>:
- 1734: 97 f9 bld r25, 7
- 1736: 9f 67 ori r25, 0x7F ; 127
- 1738: 80 e8 ldi r24, 0x80 ; 128
- 173a: 70 e0 ldi r23, 0x00 ; 0
- 173c: 60 e0 ldi r22, 0x00 ; 0
- 173e: 08 95 ret
-
-00001740 <__fp_nan>:
- 1740: 9f ef ldi r25, 0xFF ; 255
- 1742: 80 ec ldi r24, 0xC0 ; 192
- 1744: 08 95 ret
-
-00001746 <__fp_pscA>:
- 1746: 00 24 eor r0, r0
- 1748: 0a 94 dec r0
- 174a: 16 16 cp r1, r22
- 174c: 17 06 cpc r1, r23
- 174e: 18 06 cpc r1, r24
- 1750: 09 06 cpc r0, r25
- 1752: 08 95 ret
-
-00001754 <__fp_pscB>:
- 1754: 00 24 eor r0, r0
- 1756: 0a 94 dec r0
- 1758: 12 16 cp r1, r18
- 175a: 13 06 cpc r1, r19
- 175c: 14 06 cpc r1, r20
- 175e: 05 06 cpc r0, r21
- 1760: 08 95 ret
-
-00001762 <__fp_round>:
- 1762: 09 2e mov r0, r25
- 1764: 03 94 inc r0
- 1766: 00 0c add r0, r0
- 1768: 11 f4 brne .+4 ; 0x176e <__fp_round+0xc>
- 176a: 88 23 and r24, r24
- 176c: 52 f0 brmi .+20 ; 0x1782 <__fp_round+0x20>
- 176e: bb 0f add r27, r27
- 1770: 40 f4 brcc .+16 ; 0x1782 <__fp_round+0x20>
- 1772: bf 2b or r27, r31
- 1774: 11 f4 brne .+4 ; 0x177a <__fp_round+0x18>
- 1776: 60 ff sbrs r22, 0
- 1778: 04 c0 rjmp .+8 ; 0x1782 <__fp_round+0x20>
- 177a: 6f 5f subi r22, 0xFF ; 255
- 177c: 7f 4f sbci r23, 0xFF ; 255
- 177e: 8f 4f sbci r24, 0xFF ; 255
- 1780: 9f 4f sbci r25, 0xFF ; 255
- 1782: 08 95 ret
-
-00001784 <__fp_split3>:
- 1784: 57 fd sbrc r21, 7
- 1786: 90 58 subi r25, 0x80 ; 128
- 1788: 44 0f add r20, r20
- 178a: 55 1f adc r21, r21
- 178c: 59 f0 breq .+22 ; 0x17a4 <__fp_splitA+0x10>
- 178e: 5f 3f cpi r21, 0xFF ; 255
- 1790: 71 f0 breq .+28 ; 0x17ae <__fp_splitA+0x1a>
- 1792: 47 95 ror r20
-
-00001794 <__fp_splitA>:
- 1794: 88 0f add r24, r24
- 1796: 97 fb bst r25, 7
- 1798: 99 1f adc r25, r25
- 179a: 61 f0 breq .+24 ; 0x17b4 <__fp_splitA+0x20>
- 179c: 9f 3f cpi r25, 0xFF ; 255
- 179e: 79 f0 breq .+30 ; 0x17be <__fp_splitA+0x2a>
- 17a0: 87 95 ror r24
+ 1414: 08 95 ret
+
+00001416 <__subsf3>:
+ 1416: 50 58 subi r21, 0x80 ; 128
+
+00001418 <__addsf3>:
+ 1418: bb 27 eor r27, r27
+ 141a: aa 27 eor r26, r26
+ 141c: 0e d0 rcall .+28 ; 0x143a <__addsf3x>
+ 141e: 70 c1 rjmp .+736 ; 0x1700 <__fp_round>
+ 1420: 61 d1 rcall .+706 ; 0x16e4 <__fp_pscA>
+ 1422: 30 f0 brcs .+12 ; 0x1430 <__addsf3+0x18>
+ 1424: 66 d1 rcall .+716 ; 0x16f2 <__fp_pscB>
+ 1426: 20 f0 brcs .+8 ; 0x1430 <__addsf3+0x18>
+ 1428: 31 f4 brne .+12 ; 0x1436 <__addsf3+0x1e>
+ 142a: 9f 3f cpi r25, 0xFF ; 255
+ 142c: 11 f4 brne .+4 ; 0x1432 <__addsf3+0x1a>
+ 142e: 1e f4 brtc .+6 ; 0x1436 <__addsf3+0x1e>
+ 1430: 56 c1 rjmp .+684 ; 0x16de <__fp_nan>
+ 1432: 0e f4 brtc .+2 ; 0x1436 <__addsf3+0x1e>
+ 1434: e0 95 com r30
+ 1436: e7 fb bst r30, 7
+ 1438: 4c c1 rjmp .+664 ; 0x16d2 <__fp_inf>
+
+0000143a <__addsf3x>:
+ 143a: e9 2f mov r30, r25
+ 143c: 72 d1 rcall .+740 ; 0x1722 <__fp_split3>
+ 143e: 80 f3 brcs .-32 ; 0x1420 <__addsf3+0x8>
+ 1440: ba 17 cp r27, r26
+ 1442: 62 07 cpc r22, r18
+ 1444: 73 07 cpc r23, r19
+ 1446: 84 07 cpc r24, r20
+ 1448: 95 07 cpc r25, r21
+ 144a: 18 f0 brcs .+6 ; 0x1452 <__addsf3x+0x18>
+ 144c: 71 f4 brne .+28 ; 0x146a <__addsf3x+0x30>
+ 144e: 9e f5 brtc .+102 ; 0x14b6 <__addsf3x+0x7c>
+ 1450: 8a c1 rjmp .+788 ; 0x1766 <__fp_zero>
+ 1452: 0e f4 brtc .+2 ; 0x1456 <__addsf3x+0x1c>
+ 1454: e0 95 com r30
+ 1456: 0b 2e mov r0, r27
+ 1458: ba 2f mov r27, r26
+ 145a: a0 2d mov r26, r0
+ 145c: 0b 01 movw r0, r22
+ 145e: b9 01 movw r22, r18
+ 1460: 90 01 movw r18, r0
+ 1462: 0c 01 movw r0, r24
+ 1464: ca 01 movw r24, r20
+ 1466: a0 01 movw r20, r0
+ 1468: 11 24 eor r1, r1
+ 146a: ff 27 eor r31, r31
+ 146c: 59 1b sub r21, r25
+ 146e: 99 f0 breq .+38 ; 0x1496 <__addsf3x+0x5c>
+ 1470: 59 3f cpi r21, 0xF9 ; 249
+ 1472: 50 f4 brcc .+20 ; 0x1488 <__addsf3x+0x4e>
+ 1474: 50 3e cpi r21, 0xE0 ; 224
+ 1476: 68 f1 brcs .+90 ; 0x14d2 <__addsf3x+0x98>
+ 1478: 1a 16 cp r1, r26
+ 147a: f0 40 sbci r31, 0x00 ; 0
+ 147c: a2 2f mov r26, r18
+ 147e: 23 2f mov r18, r19
+ 1480: 34 2f mov r19, r20
+ 1482: 44 27 eor r20, r20
+ 1484: 58 5f subi r21, 0xF8 ; 248
+ 1486: f3 cf rjmp .-26 ; 0x146e <__addsf3x+0x34>
+ 1488: 46 95 lsr r20
+ 148a: 37 95 ror r19
+ 148c: 27 95 ror r18
+ 148e: a7 95 ror r26
+ 1490: f0 40 sbci r31, 0x00 ; 0
+ 1492: 53 95 inc r21
+ 1494: c9 f7 brne .-14 ; 0x1488 <__addsf3x+0x4e>
+ 1496: 7e f4 brtc .+30 ; 0x14b6 <__addsf3x+0x7c>
+ 1498: 1f 16 cp r1, r31
+ 149a: ba 0b sbc r27, r26
+ 149c: 62 0b sbc r22, r18
+ 149e: 73 0b sbc r23, r19
+ 14a0: 84 0b sbc r24, r20
+ 14a2: ba f0 brmi .+46 ; 0x14d2 <__addsf3x+0x98>
+ 14a4: 91 50 subi r25, 0x01 ; 1
+ 14a6: a1 f0 breq .+40 ; 0x14d0 <__addsf3x+0x96>
+ 14a8: ff 0f add r31, r31
+ 14aa: bb 1f adc r27, r27
+ 14ac: 66 1f adc r22, r22
+ 14ae: 77 1f adc r23, r23
+ 14b0: 88 1f adc r24, r24
+ 14b2: c2 f7 brpl .-16 ; 0x14a4 <__addsf3x+0x6a>
+ 14b4: 0e c0 rjmp .+28 ; 0x14d2 <__addsf3x+0x98>
+ 14b6: ba 0f add r27, r26
+ 14b8: 62 1f adc r22, r18
+ 14ba: 73 1f adc r23, r19
+ 14bc: 84 1f adc r24, r20
+ 14be: 48 f4 brcc .+18 ; 0x14d2 <__addsf3x+0x98>
+ 14c0: 87 95 ror r24
+ 14c2: 77 95 ror r23
+ 14c4: 67 95 ror r22
+ 14c6: b7 95 ror r27
+ 14c8: f7 95 ror r31
+ 14ca: 9e 3f cpi r25, 0xFE ; 254
+ 14cc: 08 f0 brcs .+2 ; 0x14d0 <__addsf3x+0x96>
+ 14ce: b3 cf rjmp .-154 ; 0x1436 <__addsf3+0x1e>
+ 14d0: 93 95 inc r25
+ 14d2: 88 0f add r24, r24
+ 14d4: 08 f0 brcs .+2 ; 0x14d8 <__addsf3x+0x9e>
+ 14d6: 99 27 eor r25, r25
+ 14d8: ee 0f add r30, r30
+ 14da: 97 95 ror r25
+ 14dc: 87 95 ror r24
+ 14de: 08 95 ret
+
+000014e0 <__cmpsf2>:
+ 14e0: d4 d0 rcall .+424 ; 0x168a <__fp_cmp>
+ 14e2: 08 f4 brcc .+2 ; 0x14e6 <__cmpsf2+0x6>
+ 14e4: 81 e0 ldi r24, 0x01 ; 1
+ 14e6: 08 95 ret
+
+000014e8 <__divsf3>:
+ 14e8: 0c d0 rcall .+24 ; 0x1502 <__divsf3x>
+ 14ea: 0a c1 rjmp .+532 ; 0x1700 <__fp_round>
+ 14ec: 02 d1 rcall .+516 ; 0x16f2 <__fp_pscB>
+ 14ee: 40 f0 brcs .+16 ; 0x1500 <__divsf3+0x18>
+ 14f0: f9 d0 rcall .+498 ; 0x16e4 <__fp_pscA>
+ 14f2: 30 f0 brcs .+12 ; 0x1500 <__divsf3+0x18>
+ 14f4: 21 f4 brne .+8 ; 0x14fe <__divsf3+0x16>
+ 14f6: 5f 3f cpi r21, 0xFF ; 255
+ 14f8: 19 f0 breq .+6 ; 0x1500 <__divsf3+0x18>
+ 14fa: eb c0 rjmp .+470 ; 0x16d2 <__fp_inf>
+ 14fc: 51 11 cpse r21, r1
+ 14fe: 34 c1 rjmp .+616 ; 0x1768 <__fp_szero>
+ 1500: ee c0 rjmp .+476 ; 0x16de <__fp_nan>
+
+00001502 <__divsf3x>:
+ 1502: 0f d1 rcall .+542 ; 0x1722 <__fp_split3>
+ 1504: 98 f3 brcs .-26 ; 0x14ec <__divsf3+0x4>
+
+00001506 <__divsf3_pse>:
+ 1506: 99 23 and r25, r25
+ 1508: c9 f3 breq .-14 ; 0x14fc <__divsf3+0x14>
+ 150a: 55 23 and r21, r21
+ 150c: b1 f3 breq .-20 ; 0x14fa <__divsf3+0x12>
+ 150e: 95 1b sub r25, r21
+ 1510: 55 0b sbc r21, r21
+ 1512: bb 27 eor r27, r27
+ 1514: aa 27 eor r26, r26
+ 1516: 62 17 cp r22, r18
+ 1518: 73 07 cpc r23, r19
+ 151a: 84 07 cpc r24, r20
+ 151c: 38 f0 brcs .+14 ; 0x152c <__divsf3_pse+0x26>
+ 151e: 9f 5f subi r25, 0xFF ; 255
+ 1520: 5f 4f sbci r21, 0xFF ; 255
+ 1522: 22 0f add r18, r18
+ 1524: 33 1f adc r19, r19
+ 1526: 44 1f adc r20, r20
+ 1528: aa 1f adc r26, r26
+ 152a: a9 f3 breq .-22 ; 0x1516 <__divsf3_pse+0x10>
+ 152c: 33 d0 rcall .+102 ; 0x1594 <__divsf3_pse+0x8e>
+ 152e: 0e 2e mov r0, r30
+ 1530: 3a f0 brmi .+14 ; 0x1540 <__divsf3_pse+0x3a>
+ 1532: e0 e8 ldi r30, 0x80 ; 128
+ 1534: 30 d0 rcall .+96 ; 0x1596 <__divsf3_pse+0x90>
+ 1536: 91 50 subi r25, 0x01 ; 1
+ 1538: 50 40 sbci r21, 0x00 ; 0
+ 153a: e6 95 lsr r30
+ 153c: 00 1c adc r0, r0
+ 153e: ca f7 brpl .-14 ; 0x1532 <__divsf3_pse+0x2c>
+ 1540: 29 d0 rcall .+82 ; 0x1594 <__divsf3_pse+0x8e>
+ 1542: fe 2f mov r31, r30
+ 1544: 27 d0 rcall .+78 ; 0x1594 <__divsf3_pse+0x8e>
+ 1546: 66 0f add r22, r22
+ 1548: 77 1f adc r23, r23
+ 154a: 88 1f adc r24, r24
+ 154c: bb 1f adc r27, r27
+ 154e: 26 17 cp r18, r22
+ 1550: 37 07 cpc r19, r23
+ 1552: 48 07 cpc r20, r24
+ 1554: ab 07 cpc r26, r27
+ 1556: b0 e8 ldi r27, 0x80 ; 128
+ 1558: 09 f0 breq .+2 ; 0x155c <__divsf3_pse+0x56>
+ 155a: bb 0b sbc r27, r27
+ 155c: 80 2d mov r24, r0
+ 155e: bf 01 movw r22, r30
+ 1560: ff 27 eor r31, r31
+ 1562: 93 58 subi r25, 0x83 ; 131
+ 1564: 5f 4f sbci r21, 0xFF ; 255
+ 1566: 2a f0 brmi .+10 ; 0x1572 <__divsf3_pse+0x6c>
+ 1568: 9e 3f cpi r25, 0xFE ; 254
+ 156a: 51 05 cpc r21, r1
+ 156c: 68 f0 brcs .+26 ; 0x1588 <__divsf3_pse+0x82>
+ 156e: b1 c0 rjmp .+354 ; 0x16d2 <__fp_inf>
+ 1570: fb c0 rjmp .+502 ; 0x1768 <__fp_szero>
+ 1572: 5f 3f cpi r21, 0xFF ; 255
+ 1574: ec f3 brlt .-6 ; 0x1570 <__divsf3_pse+0x6a>
+ 1576: 98 3e cpi r25, 0xE8 ; 232
+ 1578: dc f3 brlt .-10 ; 0x1570 <__divsf3_pse+0x6a>
+ 157a: 86 95 lsr r24
+ 157c: 77 95 ror r23
+ 157e: 67 95 ror r22
+ 1580: b7 95 ror r27
+ 1582: f7 95 ror r31
+ 1584: 9f 5f subi r25, 0xFF ; 255
+ 1586: c9 f7 brne .-14 ; 0x157a <__divsf3_pse+0x74>
+ 1588: 88 0f add r24, r24
+ 158a: 91 1d adc r25, r1
+ 158c: 96 95 lsr r25
+ 158e: 87 95 ror r24
+ 1590: 97 f9 bld r25, 7
+ 1592: 08 95 ret
+ 1594: e1 e0 ldi r30, 0x01 ; 1
+ 1596: 66 0f add r22, r22
+ 1598: 77 1f adc r23, r23
+ 159a: 88 1f adc r24, r24
+ 159c: bb 1f adc r27, r27
+ 159e: 62 17 cp r22, r18
+ 15a0: 73 07 cpc r23, r19
+ 15a2: 84 07 cpc r24, r20
+ 15a4: ba 07 cpc r27, r26
+ 15a6: 20 f0 brcs .+8 ; 0x15b0 <__divsf3_pse+0xaa>
+ 15a8: 62 1b sub r22, r18
+ 15aa: 73 0b sbc r23, r19
+ 15ac: 84 0b sbc r24, r20
+ 15ae: ba 0b sbc r27, r26
+ 15b0: ee 1f adc r30, r30
+ 15b2: 88 f7 brcc .-30 ; 0x1596 <__divsf3_pse+0x90>
+ 15b4: e0 95 com r30
+ 15b6: 08 95 ret
+
+000015b8 <__fixunssfsi>:
+ 15b8: bc d0 rcall .+376 ; 0x1732 <__fp_splitA>
+ 15ba: 88 f0 brcs .+34 ; 0x15de <__fixunssfsi+0x26>
+ 15bc: 9f 57 subi r25, 0x7F ; 127
+ 15be: 90 f0 brcs .+36 ; 0x15e4 <__fixunssfsi+0x2c>
+ 15c0: b9 2f mov r27, r25
+ 15c2: 99 27 eor r25, r25
+ 15c4: b7 51 subi r27, 0x17 ; 23
+ 15c6: a0 f0 brcs .+40 ; 0x15f0 <__fixunssfsi+0x38>
+ 15c8: d1 f0 breq .+52 ; 0x15fe <__fixunssfsi+0x46>
+ 15ca: 66 0f add r22, r22
+ 15cc: 77 1f adc r23, r23
+ 15ce: 88 1f adc r24, r24
+ 15d0: 99 1f adc r25, r25
+ 15d2: 1a f0 brmi .+6 ; 0x15da <__fixunssfsi+0x22>
+ 15d4: ba 95 dec r27
+ 15d6: c9 f7 brne .-14 ; 0x15ca <__fixunssfsi+0x12>
+ 15d8: 12 c0 rjmp .+36 ; 0x15fe <__fixunssfsi+0x46>
+ 15da: b1 30 cpi r27, 0x01 ; 1
+ 15dc: 81 f0 breq .+32 ; 0x15fe <__fixunssfsi+0x46>
+ 15de: c3 d0 rcall .+390 ; 0x1766 <__fp_zero>
+ 15e0: b1 e0 ldi r27, 0x01 ; 1
+ 15e2: 08 95 ret
+ 15e4: c0 c0 rjmp .+384 ; 0x1766 <__fp_zero>
+ 15e6: 67 2f mov r22, r23
+ 15e8: 78 2f mov r23, r24
+ 15ea: 88 27 eor r24, r24
+ 15ec: b8 5f subi r27, 0xF8 ; 248
+ 15ee: 39 f0 breq .+14 ; 0x15fe <__fixunssfsi+0x46>
+ 15f0: b9 3f cpi r27, 0xF9 ; 249
+ 15f2: cc f3 brlt .-14 ; 0x15e6 <__fixunssfsi+0x2e>
+ 15f4: 86 95 lsr r24
+ 15f6: 77 95 ror r23
+ 15f8: 67 95 ror r22
+ 15fa: b3 95 inc r27
+ 15fc: d9 f7 brne .-10 ; 0x15f4 <__fixunssfsi+0x3c>
+ 15fe: 3e f4 brtc .+14 ; 0x160e <__fixunssfsi+0x56>
+ 1600: 90 95 com r25
+ 1602: 80 95 com r24
+ 1604: 70 95 com r23
+ 1606: 61 95 neg r22
+ 1608: 7f 4f sbci r23, 0xFF ; 255
+ 160a: 8f 4f sbci r24, 0xFF ; 255
+ 160c: 9f 4f sbci r25, 0xFF ; 255
+ 160e: 08 95 ret
+
+00001610 <__floatunsisf>:
+ 1610: e8 94 clt
+ 1612: 09 c0 rjmp .+18 ; 0x1626 <__floatsisf+0x12>
+
+00001614 <__floatsisf>:
+ 1614: 97 fb bst r25, 7
+ 1616: 3e f4 brtc .+14 ; 0x1626 <__floatsisf+0x12>
+ 1618: 90 95 com r25
+ 161a: 80 95 com r24
+ 161c: 70 95 com r23
+ 161e: 61 95 neg r22
+ 1620: 7f 4f sbci r23, 0xFF ; 255
+ 1622: 8f 4f sbci r24, 0xFF ; 255
+ 1624: 9f 4f sbci r25, 0xFF ; 255
+ 1626: 99 23 and r25, r25
+ 1628: a9 f0 breq .+42 ; 0x1654 <__floatsisf+0x40>
+ 162a: f9 2f mov r31, r25
+ 162c: 96 e9 ldi r25, 0x96 ; 150
+ 162e: bb 27 eor r27, r27
+ 1630: 93 95 inc r25
+ 1632: f6 95 lsr r31
+ 1634: 87 95 ror r24
+ 1636: 77 95 ror r23
+ 1638: 67 95 ror r22
+ 163a: b7 95 ror r27
+ 163c: f1 11 cpse r31, r1
+ 163e: f8 cf rjmp .-16 ; 0x1630 <__floatsisf+0x1c>
+ 1640: fa f4 brpl .+62 ; 0x1680 <__floatsisf+0x6c>
+ 1642: bb 0f add r27, r27
+ 1644: 11 f4 brne .+4 ; 0x164a <__floatsisf+0x36>
+ 1646: 60 ff sbrs r22, 0
+ 1648: 1b c0 rjmp .+54 ; 0x1680 <__floatsisf+0x6c>
+ 164a: 6f 5f subi r22, 0xFF ; 255
+ 164c: 7f 4f sbci r23, 0xFF ; 255
+ 164e: 8f 4f sbci r24, 0xFF ; 255
+ 1650: 9f 4f sbci r25, 0xFF ; 255
+ 1652: 16 c0 rjmp .+44 ; 0x1680 <__floatsisf+0x6c>
+ 1654: 88 23 and r24, r24
+ 1656: 11 f0 breq .+4 ; 0x165c <__floatsisf+0x48>
+ 1658: 96 e9 ldi r25, 0x96 ; 150
+ 165a: 11 c0 rjmp .+34 ; 0x167e <__floatsisf+0x6a>
+ 165c: 77 23 and r23, r23
+ 165e: 21 f0 breq .+8 ; 0x1668 <__floatsisf+0x54>
+ 1660: 9e e8 ldi r25, 0x8E ; 142
+ 1662: 87 2f mov r24, r23
+ 1664: 76 2f mov r23, r22
+ 1666: 05 c0 rjmp .+10 ; 0x1672 <__floatsisf+0x5e>
+ 1668: 66 23 and r22, r22
+ 166a: 71 f0 breq .+28 ; 0x1688 <__floatsisf+0x74>
+ 166c: 96 e8 ldi r25, 0x86 ; 134
+ 166e: 86 2f mov r24, r22
+ 1670: 70 e0 ldi r23, 0x00 ; 0
+ 1672: 60 e0 ldi r22, 0x00 ; 0
+ 1674: 2a f0 brmi .+10 ; 0x1680 <__floatsisf+0x6c>
+ 1676: 9a 95 dec r25
+ 1678: 66 0f add r22, r22
+ 167a: 77 1f adc r23, r23
+ 167c: 88 1f adc r24, r24
+ 167e: da f7 brpl .-10 ; 0x1676 <__floatsisf+0x62>
+ 1680: 88 0f add r24, r24
+ 1682: 96 95 lsr r25
+ 1684: 87 95 ror r24
+ 1686: 97 f9 bld r25, 7
+ 1688: 08 95 ret
+
+0000168a <__fp_cmp>:
+ 168a: 99 0f add r25, r25
+ 168c: 00 08 sbc r0, r0
+ 168e: 55 0f add r21, r21
+ 1690: aa 0b sbc r26, r26
+ 1692: e0 e8 ldi r30, 0x80 ; 128
+ 1694: fe ef ldi r31, 0xFE ; 254
+ 1696: 16 16 cp r1, r22
+ 1698: 17 06 cpc r1, r23
+ 169a: e8 07 cpc r30, r24
+ 169c: f9 07 cpc r31, r25
+ 169e: c0 f0 brcs .+48 ; 0x16d0 <__fp_cmp+0x46>
+ 16a0: 12 16 cp r1, r18
+ 16a2: 13 06 cpc r1, r19
+ 16a4: e4 07 cpc r30, r20
+ 16a6: f5 07 cpc r31, r21
+ 16a8: 98 f0 brcs .+38 ; 0x16d0 <__fp_cmp+0x46>
+ 16aa: 62 1b sub r22, r18
+ 16ac: 73 0b sbc r23, r19
+ 16ae: 84 0b sbc r24, r20
+ 16b0: 95 0b sbc r25, r21
+ 16b2: 39 f4 brne .+14 ; 0x16c2 <__fp_cmp+0x38>
+ 16b4: 0a 26 eor r0, r26
+ 16b6: 61 f0 breq .+24 ; 0x16d0 <__fp_cmp+0x46>
+ 16b8: 23 2b or r18, r19
+ 16ba: 24 2b or r18, r20
+ 16bc: 25 2b or r18, r21
+ 16be: 21 f4 brne .+8 ; 0x16c8 <__fp_cmp+0x3e>
+ 16c0: 08 95 ret
+ 16c2: 0a 26 eor r0, r26
+ 16c4: 09 f4 brne .+2 ; 0x16c8 <__fp_cmp+0x3e>
+ 16c6: a1 40 sbci r26, 0x01 ; 1
+ 16c8: a6 95 lsr r26
+ 16ca: 8f ef ldi r24, 0xFF ; 255
+ 16cc: 81 1d adc r24, r1
+ 16ce: 81 1d adc r24, r1
+ 16d0: 08 95 ret
+
+000016d2 <__fp_inf>:
+ 16d2: 97 f9 bld r25, 7
+ 16d4: 9f 67 ori r25, 0x7F ; 127
+ 16d6: 80 e8 ldi r24, 0x80 ; 128
+ 16d8: 70 e0 ldi r23, 0x00 ; 0
+ 16da: 60 e0 ldi r22, 0x00 ; 0
+ 16dc: 08 95 ret
+
+000016de <__fp_nan>:
+ 16de: 9f ef ldi r25, 0xFF ; 255
+ 16e0: 80 ec ldi r24, 0xC0 ; 192
+ 16e2: 08 95 ret
+
+000016e4 <__fp_pscA>:
+ 16e4: 00 24 eor r0, r0
+ 16e6: 0a 94 dec r0
+ 16e8: 16 16 cp r1, r22
+ 16ea: 17 06 cpc r1, r23
+ 16ec: 18 06 cpc r1, r24
+ 16ee: 09 06 cpc r0, r25
+ 16f0: 08 95 ret
+
+000016f2 <__fp_pscB>:
+ 16f2: 00 24 eor r0, r0
+ 16f4: 0a 94 dec r0
+ 16f6: 12 16 cp r1, r18
+ 16f8: 13 06 cpc r1, r19
+ 16fa: 14 06 cpc r1, r20
+ 16fc: 05 06 cpc r0, r21
+ 16fe: 08 95 ret
+
+00001700 <__fp_round>:
+ 1700: 09 2e mov r0, r25
+ 1702: 03 94 inc r0
+ 1704: 00 0c add r0, r0
+ 1706: 11 f4 brne .+4 ; 0x170c <__fp_round+0xc>
+ 1708: 88 23 and r24, r24
+ 170a: 52 f0 brmi .+20 ; 0x1720 <__fp_round+0x20>
+ 170c: bb 0f add r27, r27
+ 170e: 40 f4 brcc .+16 ; 0x1720 <__fp_round+0x20>
+ 1710: bf 2b or r27, r31
+ 1712: 11 f4 brne .+4 ; 0x1718 <__fp_round+0x18>
+ 1714: 60 ff sbrs r22, 0
+ 1716: 04 c0 rjmp .+8 ; 0x1720 <__fp_round+0x20>
+ 1718: 6f 5f subi r22, 0xFF ; 255
+ 171a: 7f 4f sbci r23, 0xFF ; 255
+ 171c: 8f 4f sbci r24, 0xFF ; 255
+ 171e: 9f 4f sbci r25, 0xFF ; 255
+ 1720: 08 95 ret
+
+00001722 <__fp_split3>:
+ 1722: 57 fd sbrc r21, 7
+ 1724: 90 58 subi r25, 0x80 ; 128
+ 1726: 44 0f add r20, r20
+ 1728: 55 1f adc r21, r21
+ 172a: 59 f0 breq .+22 ; 0x1742 <__fp_splitA+0x10>
+ 172c: 5f 3f cpi r21, 0xFF ; 255
+ 172e: 71 f0 breq .+28 ; 0x174c <__fp_splitA+0x1a>
+ 1730: 47 95 ror r20
+
+00001732 <__fp_splitA>:
+ 1732: 88 0f add r24, r24
+ 1734: 97 fb bst r25, 7
+ 1736: 99 1f adc r25, r25
+ 1738: 61 f0 breq .+24 ; 0x1752 <__fp_splitA+0x20>
+ 173a: 9f 3f cpi r25, 0xFF ; 255
+ 173c: 79 f0 breq .+30 ; 0x175c <__fp_splitA+0x2a>
+ 173e: 87 95 ror r24
+ 1740: 08 95 ret
+ 1742: 12 16 cp r1, r18
+ 1744: 13 06 cpc r1, r19
+ 1746: 14 06 cpc r1, r20
+ 1748: 55 1f adc r21, r21
+ 174a: f2 cf rjmp .-28 ; 0x1730 <__fp_split3+0xe>
+ 174c: 46 95 lsr r20
+ 174e: f1 df rcall .-30 ; 0x1732 <__fp_splitA>
+ 1750: 08 c0 rjmp .+16 ; 0x1762 <__fp_splitA+0x30>
+ 1752: 16 16 cp r1, r22
+ 1754: 17 06 cpc r1, r23
+ 1756: 18 06 cpc r1, r24
+ 1758: 99 1f adc r25, r25
+ 175a: f1 cf rjmp .-30 ; 0x173e <__fp_splitA+0xc>
+ 175c: 86 95 lsr r24
+ 175e: 71 05 cpc r23, r1
+ 1760: 61 05 cpc r22, r1
+ 1762: 08 94 sec
+ 1764: 08 95 ret
+
+00001766 <__fp_zero>:
+ 1766: e8 94 clt
+
+00001768 <__fp_szero>:
+ 1768: bb 27 eor r27, r27
+ 176a: 66 27 eor r22, r22
+ 176c: 77 27 eor r23, r23
+ 176e: cb 01 movw r24, r22
+ 1770: 97 f9 bld r25, 7
+ 1772: 08 95 ret
+
+00001774 <__gesf2>:
+ 1774: 8a df rcall .-236 ; 0x168a <__fp_cmp>
+ 1776: 08 f4 brcc .+2 ; 0x177a <__gesf2+0x6>
+ 1778: 8f ef ldi r24, 0xFF ; 255
+ 177a: 08 95 ret
+
+0000177c <__udivmodhi4>:
+ 177c: aa 1b sub r26, r26
+ 177e: bb 1b sub r27, r27
+ 1780: 51 e1 ldi r21, 0x11 ; 17
+ 1782: 07 c0 rjmp .+14 ; 0x1792 <__udivmodhi4_ep>
+
+00001784 <__udivmodhi4_loop>:
+ 1784: aa 1f adc r26, r26
+ 1786: bb 1f adc r27, r27
+ 1788: a6 17 cp r26, r22
+ 178a: b7 07 cpc r27, r23
+ 178c: 10 f0 brcs .+4 ; 0x1792 <__udivmodhi4_ep>
+ 178e: a6 1b sub r26, r22
+ 1790: b7 0b sbc r27, r23
+
+00001792 <__udivmodhi4_ep>:
+ 1792: 88 1f adc r24, r24
+ 1794: 99 1f adc r25, r25
+ 1796: 5a 95 dec r21
+ 1798: a9 f7 brne .-22 ; 0x1784 <__udivmodhi4_loop>
+ 179a: 80 95 com r24
+ 179c: 90 95 com r25
+ 179e: bc 01 movw r22, r24
+ 17a0: cd 01 movw r24, r26
17a2: 08 95 ret
- 17a4: 12 16 cp r1, r18
- 17a6: 13 06 cpc r1, r19
- 17a8: 14 06 cpc r1, r20
- 17aa: 55 1f adc r21, r21
- 17ac: f2 cf rjmp .-28 ; 0x1792 <__fp_split3+0xe>
- 17ae: 46 95 lsr r20
- 17b0: f1 df rcall .-30 ; 0x1794 <__fp_splitA>
- 17b2: 08 c0 rjmp .+16 ; 0x17c4 <__fp_splitA+0x30>
- 17b4: 16 16 cp r1, r22
- 17b6: 17 06 cpc r1, r23
- 17b8: 18 06 cpc r1, r24
- 17ba: 99 1f adc r25, r25
- 17bc: f1 cf rjmp .-30 ; 0x17a0 <__fp_splitA+0xc>
- 17be: 86 95 lsr r24
- 17c0: 71 05 cpc r23, r1
- 17c2: 61 05 cpc r22, r1
- 17c4: 08 94 sec
- 17c6: 08 95 ret
-
-000017c8 <__fp_zero>:
- 17c8: e8 94 clt
-
-000017ca <__fp_szero>:
- 17ca: bb 27 eor r27, r27
- 17cc: 66 27 eor r22, r22
- 17ce: 77 27 eor r23, r23
- 17d0: cb 01 movw r24, r22
- 17d2: 97 f9 bld r25, 7
- 17d4: 08 95 ret
-
-000017d6 <__gesf2>:
- 17d6: 8a df rcall .-236 ; 0x16ec <__fp_cmp>
- 17d8: 08 f4 brcc .+2 ; 0x17dc <__gesf2+0x6>
- 17da: 8f ef ldi r24, 0xFF ; 255
- 17dc: 08 95 ret
-
-000017de <__udivmodsi4>:
- 17de: a1 e2 ldi r26, 0x21 ; 33
- 17e0: 1a 2e mov r1, r26
- 17e2: aa 1b sub r26, r26
- 17e4: bb 1b sub r27, r27
- 17e6: fd 01 movw r30, r26
- 17e8: 0d c0 rjmp .+26 ; 0x1804 <__udivmodsi4_ep>
-
-000017ea <__udivmodsi4_loop>:
- 17ea: aa 1f adc r26, r26
- 17ec: bb 1f adc r27, r27
- 17ee: ee 1f adc r30, r30
- 17f0: ff 1f adc r31, r31
- 17f2: a2 17 cp r26, r18
- 17f4: b3 07 cpc r27, r19
- 17f6: e4 07 cpc r30, r20
- 17f8: f5 07 cpc r31, r21
- 17fa: 20 f0 brcs .+8 ; 0x1804 <__udivmodsi4_ep>
- 17fc: a2 1b sub r26, r18
- 17fe: b3 0b sbc r27, r19
- 1800: e4 0b sbc r30, r20
- 1802: f5 0b sbc r31, r21
-
-00001804 <__udivmodsi4_ep>:
- 1804: 66 1f adc r22, r22
- 1806: 77 1f adc r23, r23
- 1808: 88 1f adc r24, r24
- 180a: 99 1f adc r25, r25
- 180c: 1a 94 dec r1
- 180e: 69 f7 brne .-38 ; 0x17ea <__udivmodsi4_loop>
- 1810: 60 95 com r22
- 1812: 70 95 com r23
- 1814: 80 95 com r24
- 1816: 90 95 com r25
- 1818: 9b 01 movw r18, r22
- 181a: ac 01 movw r20, r24
- 181c: bd 01 movw r22, r26
- 181e: cf 01 movw r24, r30
- 1820: 08 95 ret
-
-00001822 <_exit>:
- 1822: f8 94 cli
-
-00001824 <__stop_program>:
- 1824: ff cf rjmp .-2 ; 0x1824 <__stop_program>
+
+000017a4 <_exit>:
+ 17a4: f8 94 cli
+
+000017a6 <__stop_program>:
+ 17a6: ff cf rjmp .-2 ; 0x17a6 <__stop_program>
jspc29 / coral.git / commitdiff