Sections:
Idx Name Size VMA LMA File off Algn
- 0 .data 00000062 00800100 000017fa 0000188e 2**0
+ 0 .data 0000006a 00800100 00001ab8 00001b4c 2**0
CONTENTS, ALLOC, LOAD, DATA
- 1 .text 000017fa 00000000 00000000 00000094 2**1
+ 1 .text 00001ab8 00000000 00000000 00000094 2**1
CONTENTS, ALLOC, LOAD, READONLY, CODE
- 2 .bss 00000135 00800162 00800162 000018f0 2**0
+ 2 .bss 0000013a 0080016a 0080016a 00001bb6 2**0
ALLOC
- 3 .stab 0000228c 00000000 00000000 000018f0 2**2
+ 3 .stab 0000228c 00000000 00000000 00001bb8 2**2
CONTENTS, READONLY, DEBUGGING
- 4 .stabstr 0000044f 00000000 00000000 00003b7c 2**0
+ 4 .stabstr 0000044f 00000000 00000000 00003e44 2**0
CONTENTS, READONLY, DEBUGGING
- 5 .debug_aranges 00000530 00000000 00000000 00003fcb 2**0
+ 5 .debug_aranges 00000568 00000000 00000000 00004293 2**0
CONTENTS, READONLY, DEBUGGING
- 6 .debug_pubnames 00000e15 00000000 00000000 000044fb 2**0
+ 6 .debug_pubnames 00000e6e 00000000 00000000 000047fb 2**0
CONTENTS, READONLY, DEBUGGING
- 7 .debug_info 00008daf 00000000 00000000 00005310 2**0
+ 7 .debug_info 00008f87 00000000 00000000 00005669 2**0
CONTENTS, READONLY, DEBUGGING
- 8 .debug_abbrev 0000219a 00000000 00000000 0000e0bf 2**0
+ 8 .debug_abbrev 000021f5 00000000 00000000 0000e5f0 2**0
CONTENTS, READONLY, DEBUGGING
- 9 .debug_line 000077dd 00000000 00000000 00010259 2**0
+ 9 .debug_line 0000781c 00000000 00000000 000107e5 2**0
CONTENTS, READONLY, DEBUGGING
- 10 .debug_frame 00000820 00000000 00000000 00017a38 2**2
+ 10 .debug_frame 00000890 00000000 00000000 00018004 2**2
CONTENTS, READONLY, DEBUGGING
- 11 .debug_str 00003ce7 00000000 00000000 00018258 2**0
+ 11 .debug_str 00003c87 00000000 00000000 00018894 2**0
CONTENTS, READONLY, DEBUGGING
- 12 .debug_loc 00004631 00000000 00000000 0001bf3f 2**0
+ 12 .debug_loc 00004764 00000000 00000000 0001c51b 2**0
CONTENTS, READONLY, DEBUGGING
- 13 .debug_pubtypes 00001111 00000000 00000000 00020570 2**0
+ 13 .debug_pubtypes 00001111 00000000 00000000 00020c7f 2**0
CONTENTS, READONLY, DEBUGGING
- 14 .debug_ranges 00000788 00000000 00000000 00021681 2**0
+ 14 .debug_ranges 000007c0 00000000 00000000 00021d90 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: 79 c6 rjmp .+3314 ; 0xd20 <__vector_11>
+ 2c: 7c c7 rjmp .+3832 ; 0xf26 <__vector_11>
2e: 00 00 nop
- 30: 9e c0 rjmp .+316 ; 0x16e <__bad_interrupt>
- 32: 00 00 nop
+ 30: 0c 94 37 08 jmp 0x106e ; 0x106e <__vector_12>
34: 9c c0 rjmp .+312 ; 0x16e <__bad_interrupt>
36: 00 00 nop
38: 9a c0 rjmp .+308 ; 0x16e <__bad_interrupt>
4e: 00 00 nop
50: 8e c0 rjmp .+284 ; 0x16e <__bad_interrupt>
52: 00 00 nop
- 54: d6 c0 rjmp .+428 ; 0x202 <__vector_21>
+ 54: 4b c1 rjmp .+662 ; 0x2ec <__vector_21>
56: 00 00 nop
58: 8a c0 rjmp .+276 ; 0x16e <__bad_interrupt>
5a: 00 00 nop
- 5c: d8 c2 rjmp .+1456 ; 0x60e <__vector_23>
+ 5c: 4e c3 rjmp .+1692 ; 0x6fa <__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: ea ef ldi r30, 0xFA ; 250
- 14a: f7 e1 ldi r31, 0x17 ; 23
+ 148: e8 eb ldi r30, 0xB8 ; 184
+ 14a: fa e1 ldi r31, 0x1A ; 26
14c: 02 c0 rjmp .+4 ; 0x152 <__do_copy_data+0x10>
14e: 05 90 lpm r0, Z+
150: 0d 92 st X+, r0
- 152: a2 36 cpi r26, 0x62 ; 98
+ 152: aa 36 cpi r26, 0x6A ; 106
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 e6 ldi r26, 0x62 ; 98
+ 15a: aa e6 ldi r26, 0x6A ; 106
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: a7 39 cpi r26, 0x97 ; 151
+ 162: a4 3a cpi r26, 0xA4 ; 164
164: b1 07 cpc r27, r17
166: e1 f7 brne .-8 ; 0x160 <.do_clear_bss_loop>
- 168: 5d d3 rcall .+1722 ; 0x824 <main>
- 16a: 0c 94 fb 0b jmp 0x17f6 ; 0x17f6 <_exit>
+ 168: 65 d4 rcall .+2250 ; 0xa34 <main>
+ 16a: 0c 94 5a 0d jmp 0x1ab4 ; 0x1ab4 <_exit>
0000016e <__bad_interrupt>:
16e: 48 cf rjmp .-368 ; 0x0 <__vectors>
}
1d6: 08 95 ret
-000001d8 <RingBuffer_InitBuffer.clone.0>:
+000001d8 <set_x>:
+
+uint8_t phase_pattern[4] = { 0b00001010, 0b00001001, 0b00000101, 0b00000110};
+
+
+void set_x(uint8_t byte) {
+ PORTX0 &= ~(1<<X0);
+ 1d8: 2a 98 cbi 0x05, 2 ; 5
+ PORTX1 &= ~(1<<X1);
+ 1da: 2b 98 cbi 0x05, 3 ; 5
+ PORTX2 &= ~(1<<X2);
+ 1dc: 2c 98 cbi 0x05, 4 ; 5
+ PORTX3 &= ~(1<<X3);
+ 1de: 2d 98 cbi 0x05, 5 ; 5
+
+ PORTX0 |= ((byte & (1<<0))>>0)<<X0;
+ 1e0: 45 b1 in r20, 0x05 ; 5
+ 1e2: 90 e0 ldi r25, 0x00 ; 0
+ 1e4: 9c 01 movw r18, r24
+ 1e6: 21 70 andi r18, 0x01 ; 1
+ 1e8: 30 70 andi r19, 0x00 ; 0
+ 1ea: 22 0f add r18, r18
+ 1ec: 33 1f adc r19, r19
+ 1ee: 22 0f add r18, r18
+ 1f0: 33 1f adc r19, r19
+ 1f2: 42 2b or r20, r18
+ 1f4: 45 b9 out 0x05, r20 ; 5
+ PORTX1 |= ((byte & (1<<1))>>1)<<X1;
+ 1f6: 45 b1 in r20, 0x05 ; 5
+ 1f8: 9c 01 movw r18, r24
+ 1fa: 22 70 andi r18, 0x02 ; 2
+ 1fc: 30 70 andi r19, 0x00 ; 0
+ 1fe: 35 95 asr r19
+ 200: 27 95 ror r18
+ 202: 73 e0 ldi r23, 0x03 ; 3
+ 204: 22 0f add r18, r18
+ 206: 33 1f adc r19, r19
+ 208: 7a 95 dec r23
+ 20a: e1 f7 brne .-8 ; 0x204 <set_x+0x2c>
+ 20c: 42 2b or r20, r18
+ 20e: 45 b9 out 0x05, r20 ; 5
+ PORTX2 |= ((byte & (1<<2))>>2)<<X2;
+ 210: 45 b1 in r20, 0x05 ; 5
+ 212: 9c 01 movw r18, r24
+ 214: 24 70 andi r18, 0x04 ; 4
+ 216: 30 70 andi r19, 0x00 ; 0
+ 218: 35 95 asr r19
+ 21a: 27 95 ror r18
+ 21c: 35 95 asr r19
+ 21e: 27 95 ror r18
+ 220: 54 e0 ldi r21, 0x04 ; 4
+ 222: 22 0f add r18, r18
+ 224: 33 1f adc r19, r19
+ 226: 5a 95 dec r21
+ 228: e1 f7 brne .-8 ; 0x222 <set_x+0x4a>
+ 22a: 42 2b or r20, r18
+ 22c: 45 b9 out 0x05, r20 ; 5
+ PORTX3 |= ((byte & (1<<3))>>3)<<X3;
+ 22e: 25 b1 in r18, 0x05 ; 5
+ 230: 88 70 andi r24, 0x08 ; 8
+ 232: 90 70 andi r25, 0x00 ; 0
+ 234: 43 e0 ldi r20, 0x03 ; 3
+ 236: 95 95 asr r25
+ 238: 87 95 ror r24
+ 23a: 4a 95 dec r20
+ 23c: e1 f7 brne .-8 ; 0x236 <set_x+0x5e>
+ 23e: 35 e0 ldi r19, 0x05 ; 5
+ 240: 88 0f add r24, r24
+ 242: 99 1f adc r25, r25
+ 244: 3a 95 dec r19
+ 246: e1 f7 brne .-8 ; 0x240 <set_x+0x68>
+ 248: 28 2b or r18, r24
+ 24a: 25 b9 out 0x05, r18 ; 5
+}
+ 24c: 08 95 ret
+
+0000024e <set_y>:
+
+void set_y(uint8_t byte) {
+ PORTY0 &= ~(1<<Y0);
+ 24e: 2f 98 cbi 0x05, 7 ; 5
+ PORTY1 &= ~(1<<Y1);
+ 250: 2e 98 cbi 0x05, 6 ; 5
+ PORTY2 &= ~(1<<Y2);
+ 252: 47 98 cbi 0x08, 7 ; 8
+ PORTY3 &= ~(1<<Y3);
+ 254: 46 98 cbi 0x08, 6 ; 8
+
+ PORTY0 |= ((byte & (1<<0))>>0)<<Y0;
+ 256: 45 b1 in r20, 0x05 ; 5
+ 258: 90 e0 ldi r25, 0x00 ; 0
+ 25a: 9c 01 movw r18, r24
+ 25c: 36 95 lsr r19
+ 25e: 32 2f mov r19, r18
+ 260: 22 27 eor r18, r18
+ 262: 37 95 ror r19
+ 264: 27 95 ror r18
+ 266: 42 2b or r20, r18
+ 268: 45 b9 out 0x05, r20 ; 5
+ PORTY1 |= ((byte & (1<<1))>>1)<<Y1;
+ 26a: 45 b1 in r20, 0x05 ; 5
+ 26c: 9c 01 movw r18, r24
+ 26e: 22 70 andi r18, 0x02 ; 2
+ 270: 30 70 andi r19, 0x00 ; 0
+ 272: 35 95 asr r19
+ 274: 27 95 ror r18
+ 276: 76 e0 ldi r23, 0x06 ; 6
+ 278: 22 0f add r18, r18
+ 27a: 33 1f adc r19, r19
+ 27c: 7a 95 dec r23
+ 27e: e1 f7 brne .-8 ; 0x278 <set_y+0x2a>
+ 280: 42 2b or r20, r18
+ 282: 45 b9 out 0x05, r20 ; 5
+ PORTY2 |= ((byte & (1<<2))>>2)<<Y2;
+ 284: 48 b1 in r20, 0x08 ; 8
+ 286: 9c 01 movw r18, r24
+ 288: 24 70 andi r18, 0x04 ; 4
+ 28a: 30 70 andi r19, 0x00 ; 0
+ 28c: 35 95 asr r19
+ 28e: 27 95 ror r18
+ 290: 35 95 asr r19
+ 292: 27 95 ror r18
+ 294: 36 95 lsr r19
+ 296: 32 2f mov r19, r18
+ 298: 22 27 eor r18, r18
+ 29a: 37 95 ror r19
+ 29c: 27 95 ror r18
+ 29e: 42 2b or r20, r18
+ 2a0: 48 b9 out 0x08, r20 ; 8
+ PORTY3 |= ((byte & (1<<3))>>3)<<Y3;
+ 2a2: 28 b1 in r18, 0x08 ; 8
+ 2a4: 88 70 andi r24, 0x08 ; 8
+ 2a6: 90 70 andi r25, 0x00 ; 0
+ 2a8: b3 e0 ldi r27, 0x03 ; 3
+ 2aa: 95 95 asr r25
+ 2ac: 87 95 ror r24
+ 2ae: ba 95 dec r27
+ 2b0: e1 f7 brne .-8 ; 0x2aa <set_y+0x5c>
+ 2b2: a6 e0 ldi r26, 0x06 ; 6
+ 2b4: 88 0f add r24, r24
+ 2b6: 99 1f adc r25, r25
+ 2b8: aa 95 dec r26
+ 2ba: e1 f7 brne .-8 ; 0x2b4 <set_y+0x66>
+ 2bc: 28 2b or r18, r24
+ 2be: 28 b9 out 0x08, r18 ; 8
+}
+ 2c0: 08 95 ret
+
+000002c2 <RingBuffer_InitBuffer.clone.0>:
const uint16_t Size) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
static inline void RingBuffer_InitBuffer(RingBuffer_t* Buffer,
uint8_t* const DataPtr,
const uint16_t Size)
{
GCC_FORCE_POINTER_ACCESS(Buffer);
- 1d8: fc 01 movw r30, r24
+ 2c2: fc 01 movw r30, r24
static inline uint_reg_t GetGlobalInterruptMask(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
return SREG;
- 1da: 2f b7 in r18, 0x3f ; 63
+ 2c4: 2f b7 in r18, 0x3f ; 63
static inline void GlobalInterruptDisable(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
cli();
- 1dc: f8 94 cli
+ 2c6: f8 94 cli
uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
GlobalInterruptDisable();
Buffer->In = DataPtr;
- 1de: 71 83 std Z+1, r23 ; 0x01
- 1e0: 60 83 st Z, r22
+ 2c8: 71 83 std Z+1, r23 ; 0x01
+ 2ca: 60 83 st Z, r22
Buffer->Out = DataPtr;
- 1e2: 73 83 std Z+3, r23 ; 0x03
- 1e4: 62 83 std Z+2, r22 ; 0x02
+ 2cc: 73 83 std Z+3, r23 ; 0x03
+ 2ce: 62 83 std Z+2, r22 ; 0x02
Buffer->Start = &DataPtr[0];
- 1e6: 75 83 std Z+5, r23 ; 0x05
- 1e8: 64 83 std Z+4, r22 ; 0x04
+ 2d0: 75 83 std Z+5, r23 ; 0x05
+ 2d2: 64 83 std Z+4, r22 ; 0x04
Buffer->End = &DataPtr[Size];
- 1ea: 60 58 subi r22, 0x80 ; 128
- 1ec: 7f 4f sbci r23, 0xFF ; 255
- 1ee: 77 83 std Z+7, r23 ; 0x07
- 1f0: 66 83 std Z+6, r22 ; 0x06
+ 2d4: 60 58 subi r22, 0x80 ; 128
+ 2d6: 7f 4f sbci r23, 0xFF ; 255
+ 2d8: 77 83 std Z+7, r23 ; 0x07
+ 2da: 66 83 std Z+6, r22 ; 0x06
Buffer->Size = Size;
- 1f2: 80 e8 ldi r24, 0x80 ; 128
- 1f4: 90 e0 ldi r25, 0x00 ; 0
- 1f6: 91 87 std Z+9, r25 ; 0x09
- 1f8: 80 87 std Z+8, r24 ; 0x08
+ 2dc: 80 e8 ldi r24, 0x80 ; 128
+ 2de: 90 e0 ldi r25, 0x00 ; 0
+ 2e0: 91 87 std Z+9, r25 ; 0x09
+ 2e2: 80 87 std Z+8, r24 ; 0x08
Buffer->Count = 0;
- 1fa: 13 86 std Z+11, r1 ; 0x0b
- 1fc: 12 86 std Z+10, r1 ; 0x0a
+ 2e4: 13 86 std Z+11, r1 ; 0x0b
+ 2e6: 12 86 std Z+10, r1 ; 0x0a
static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
SREG = GlobalIntState;
- 1fe: 2f bf out 0x3f, r18 ; 63
+ 2e8: 2f bf out 0x3f, r18 ; 63
SetGlobalInterruptMask(CurrentGlobalInt);
}
- 200: 08 95 ret
+ 2ea: 08 95 ret
-00000202 <__vector_21>:
+000002ec <__vector_21>:
u08 adb_werte[MAX_ADB];
u08 t0ovfcount;
volatile u08 adb_data_length;
ISR( TIMER0_OVF_vect) {
- 202: 1f 92 push r1
- 204: 0f 92 push r0
- 206: 0f b6 in r0, 0x3f ; 63
- 208: 0f 92 push r0
- 20a: 11 24 eor r1, r1
- 20c: 8f 93 push r24
+ 2ec: 1f 92 push r1
+ 2ee: 0f 92 push r0
+ 2f0: 0f b6 in r0, 0x3f ; 63
+ 2f2: 0f 92 push r0
+ 2f4: 11 24 eor r1, r1
+ 2f6: 8f 93 push r24
t0ovfcount++;
- 20e: 80 91 88 02 lds r24, 0x0288
- 212: 8f 5f subi r24, 0xFF ; 255
- 214: 80 93 88 02 sts 0x0288, r24
+ 2f8: 80 91 96 02 lds r24, 0x0296
+ 2fc: 8f 5f subi r24, 0xFF ; 255
+ 2fe: 80 93 96 02 sts 0x0296, r24
}
- 218: 8f 91 pop r24
- 21a: 0f 90 pop r0
- 21c: 0f be out 0x3f, r0 ; 63
- 21e: 0f 90 pop r0
- 220: 1f 90 pop r1
- 222: 18 95 reti
+ 302: 8f 91 pop r24
+ 304: 0f 90 pop r0
+ 306: 0f be out 0x3f, r0 ; 63
+ 308: 0f 90 pop r0
+ 30a: 1f 90 pop r1
+ 30c: 18 95 reti
-00000224 <t0ext>:
+0000030e <t0ext>:
uint16_t t0ext(void) {
return (t0ovfcount * 256 + (u16) TCNT0); // return current counter value
- 224: 86 b5 in r24, 0x26 ; 38
- 226: 30 91 88 02 lds r19, 0x0288
- 22a: 20 e0 ldi r18, 0x00 ; 0
- 22c: 28 0f add r18, r24
- 22e: 31 1d adc r19, r1
+ 30e: 86 b5 in r24, 0x26 ; 38
+ 310: 30 91 96 02 lds r19, 0x0296
+ 314: 20 e0 ldi r18, 0x00 ; 0
+ 316: 28 0f add r18, r24
+ 318: 31 1d adc r19, r1
// plus number of already passed counter cycles times 256
}
- 230: c9 01 movw r24, r18
- 232: 08 95 ret
+ 31a: c9 01 movw r24, r18
+ 31c: 08 95 ret
-00000234 <t0rst>:
+0000031e <t0rst>:
void t0rst(void) {
TCNT0 = 0; // set counter to zero
- 234: 16 bc out 0x26, r1 ; 38
+ 31e: 16 bc out 0x26, r1 ; 38
t0ovfcount = 0; // set overflow counter to zero
- 236: 10 92 88 02 sts 0x0288, r1
+ 320: 10 92 96 02 sts 0x0296, r1
}
- 23a: 08 95 ret
+ 324: 08 95 ret
// Befehl in adb_werte[0]. Empfangene bzw. zu sendende Daten in adb_werte[1 bis 8]
u08 adb(void) {
- 23c: df 92 push r13
- 23e: ef 92 push r14
- 240: ff 92 push r15
- 242: 0f 93 push r16
- 244: 1f 93 push r17
- 246: cf 93 push r28
- 248: df 93 push r29
+ 326: df 92 push r13
+ 328: ef 92 push r14
+ 32a: ff 92 push r15
+ 32c: 0f 93 push r16
+ 32e: 1f 93 push r17
+ 330: cf 93 push r28
+ 332: df 93 push r29
#define ADB_IMPULS_TLT TAKT/ADB_VORTEILER_B*250/1000000 // !!! 375 mach das mit anderem prescaler
// #define ADB_IMPULS_TLT TAKT/ADB_VORTEILER_A*31/1000000 // modified
//#define ADB_IMPULS_PAUSE TAKT/ADB_VORTEILER_B*200/1000000
//Attention Signal
TCCR0B = ADB_VORTEILER_A_BIT;
- 24a: 83 e0 ldi r24, 0x03 ; 3
- 24c: 85 bd out 0x25, r24 ; 37
+ 334: 83 e0 ldi r24, 0x03 ; 3
+ 336: 85 bd out 0x25, r24 ; 37
t0rst(); // TCNT0 = 0; // Zähler auf null setzen
- 24e: f2 df rcall .-28 ; 0x234 <t0rst>
+ 338: f2 df rcall .-28 ; 0x31e <t0rst>
ADB_PDIR |= ADB_BIT; // Ausgang 0
- 250: 50 9a sbi 0x0a, 0 ; 10
+ 33a: 50 9a sbi 0x0a, 0 ; 10
ADB_POUT &= ~ADB_BIT;
- 252: 58 98 cbi 0x0b, 0 ; 11
+ 33c: 58 98 cbi 0x0b, 0 ; 11
while (t0ext() < ADB_IMPULS_ATT)
- 254: e7 df rcall .-50 ; 0x224 <t0ext>
- 256: bc 01 movw r22, r24
- 258: 80 e0 ldi r24, 0x00 ; 0
- 25a: 90 e0 ldi r25, 0x00 ; 0
- 25c: 0e 94 23 0b call 0x1646 ; 0x1646 <__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 8b 0a call 0x1516 ; 0x1516 <__cmpsf2>
- 26c: 87 fd sbrc r24, 7
-
26e: f2 cf rjmp .-28 ; 0x254 <adb+0x18>
+ 33e: e7 df rcall .-50 ; 0x30e <t0ext>
+ 340: bc 01 movw r22, r24
+ 342: 80 e0 ldi r24, 0x00 ; 0
+ 344: 90 e0 ldi r25, 0x00 ; 0
+ 346: 0e 94 5b 0c call 0x18b6 ; 0x18b6 <__floatunsisf>
+ 34a: 20 e0 ldi r18, 0x00 ; 0
+ 34c: 30 e8 ldi r19, 0x80 ; 128
+ 34e: 4e e0 ldi r20, 0x0E ; 14
+ 350: 53 e4 ldi r21, 0x43 ; 67
+ 352: 0e 94 c3 0b call 0x1786 ; 0x1786 <__cmpsf2>
+ 356: 87 fd sbrc r24, 7
+
358: f2 cf rjmp .-28 ; 0x33e <adb+0x18>
; // Warteschleife
TCCR0B = ADB_VORTEILER_B_BIT; // ab hier alles im schnellen modus
- 270: 82 e0 ldi r24, 0x02 ; 2
- 272: 85 bd out 0x25, r24 ; 37
+ 35a: 82 e0 ldi r24, 0x02 ; 2
+ 35c: 85 bd out 0x25, r24 ; 37
anzahl_out = 1; // Mindestens Befehl übertragen
- 274: dd 24 eor r13, r13
- 276: d3 94 inc r13
+ 35e: dd 24 eor r13, r13
+ 360: d3 94 inc r13
z_byte = 0;
- 278: 10 e0 ldi r17, 0x00 ; 0
+ 362: 10 e0 ldi r17, 0x00 ; 0
do {
// START BIT (1)
t0rst(); // TCNT0 = 0;
- 27a: dc df rcall .-72 ; 0x234 <t0rst>
+ 364: dc df rcall .-72 ; 0x31e <t0rst>
ADB_PDIR |= ADB_BIT; // Ausgang 0
- 27c: 50 9a sbi 0x0a, 0 ; 10
+ 366: 50 9a sbi 0x0a, 0 ; 10
ADB_POUT &= ~ADB_BIT;
- 27e: 58 98 cbi 0x0b, 0 ; 11
+ 368: 58 98 cbi 0x0b, 0 ; 11
while (t0ext() < ADB_IMPULS_KURZ)
- 280: d1 df rcall .-94 ; 0x224 <t0ext>
- 282: bc 01 movw r22, r24
- 284: 80 e0 ldi r24, 0x00 ; 0
- 286: 90 e0 ldi r25, 0x00 ; 0
- 288: 0e 94 23 0b call 0x1646 ; 0x1646 <__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 8b 0a call 0x1516 ; 0x1516 <__cmpsf2>
- 298: 87 fd sbrc r24, 7
-
29a: f2 cf rjmp .-28 ; 0x280 <adb+0x44>
+ 36a: d1 df rcall .-94 ; 0x30e <t0ext>
+ 36c: bc 01 movw r22, r24
+ 36e: 80 e0 ldi r24, 0x00 ; 0
+ 370: 90 e0 ldi r25, 0x00 ; 0
+ 372: 0e 94 5b 0c call 0x18b6 ; 0x18b6 <__floatunsisf>
+ 376: 20 e0 ldi r18, 0x00 ; 0
+ 378: 30 e0 ldi r19, 0x00 ; 0
+ 37a: 4c e8 ldi r20, 0x8C ; 140
+ 37c: 52 e4 ldi r21, 0x42 ; 66
+ 37e: 0e 94 c3 0b call 0x1786 ; 0x1786 <__cmpsf2>
+ 382: 87 fd sbrc r24, 7
+
384: f2 cf rjmp .-28 ; 0x36a <adb+0x44>
;
ADB_PDIR &= ~ADB_BIT; // Eingang über Pullup
- 29c: 50 98 cbi 0x0a, 0 ; 10
+ 386: 50 98 cbi 0x0a, 0 ; 10
ADB_POUT |= ADB_BIT;
- 29e: 58 9a sbi 0x0b, 0 ; 11
+ 388: 58 9a sbi 0x0b, 0 ; 11
while (t0ext() < ADB_IMPULS_KURZ + ADB_IMPULS_LANG)
- 2a0: c1 df rcall .-126 ; 0x224 <t0ext>
- 2a2: bc 01 movw r22, r24
- 2a4: 80 e0 ldi r24, 0x00 ; 0
- 2a6: 90 e0 ldi r25, 0x00 ; 0
- 2a8: 0e 94 23 0b call 0x1646 ; 0x1646 <__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 8b 0a call 0x1516 ; 0x1516 <__cmpsf2>
- 2b8: 87 fd sbrc r24, 7
-
2ba: f2 cf rjmp .-28 ; 0x2a0 <adb+0x64>
-
2bc: 41 c0 rjmp .+130 ; 0x340 <adb+0x104>
+ 38a: c1 df rcall .-126 ; 0x30e <t0ext>
+ 38c: bc 01 movw r22, r24
+ 38e: 80 e0 ldi r24, 0x00 ; 0
+ 390: 90 e0 ldi r25, 0x00 ; 0
+ 392: 0e 94 5b 0c call 0x18b6 ; 0x18b6 <__floatunsisf>
+ 396: 20 e0 ldi r18, 0x00 ; 0
+ 398: 30 e0 ldi r19, 0x00 ; 0
+ 39a: 48 e4 ldi r20, 0x48 ; 72
+ 39c: 53 e4 ldi r21, 0x43 ; 67
+ 39e: 0e 94 c3 0b call 0x1786 ; 0x1786 <__cmpsf2>
+ 3a2: 87 fd sbrc r24, 7
+
3a4: f2 cf rjmp .-28 ; 0x38a <adb+0x64>
+
3a6: 41 c0 rjmp .+130 ; 0x42a <adb+0x104>
;
for (; z_byte < anzahl_out; z_byte++) {
- 2be: c8 e0 ldi r28, 0x08 ; 8
- 2c0: d0 e0 ldi r29, 0x00 ; 0
- 2c2: 00 e8 ldi r16, 0x80 ; 128
+ 3a8: c8 e0 ldi r28, 0x08 ; 8
+ 3aa: d0 e0 ldi r29, 0x00 ; 0
+ 3ac: 00 e8 ldi r16, 0x80 ; 128
for (bitpos = 128; bitpos; bitpos >>= 1) { //Daten ausgeben
t0rst(); // TCNT0 = 0;
ADB_PDIR |= ADB_BIT; // Ausgang 0
ADB_POUT &= ~ADB_BIT;
if (adb_werte[z_byte] & bitpos)
- 2c4: e1 2e mov r14, r17
- 2c6: ff 24 eor r15, r15
- 2c8: 8f e7 ldi r24, 0x7F ; 127
- 2ca: 92 e0 ldi r25, 0x02 ; 2
- 2cc: e8 0e add r14, r24
- 2ce: f9 1e adc r15, r25
+ 3ae: e1 2e mov r14, r17
+ 3b0: ff 24 eor r15, r15
+ 3b2: 8d e8 ldi r24, 0x8D ; 141
+ 3b4: 92 e0 ldi r25, 0x02 ; 2
+ 3b6: e8 0e add r14, r24
+ 3b8: f9 1e adc r15, r25
while (t0ext() < ADB_IMPULS_KURZ + ADB_IMPULS_LANG)
;
for (; z_byte < anzahl_out; z_byte++) {
for (bitpos = 128; bitpos; bitpos >>= 1) { //Daten ausgeben
t0rst(); // TCNT0 = 0;
- 2d0: b1 df rcall .-158 ; 0x234 <t0rst>
+ 3ba: b1 df rcall .-158 ; 0x31e <t0rst>
ADB_PDIR |= ADB_BIT; // Ausgang 0
- 2d2: 50 9a sbi 0x0a, 0 ; 10
+ 3bc: 50 9a sbi 0x0a, 0 ; 10
ADB_POUT &= ~ADB_BIT;
- 2d4: 58 98 cbi 0x0b, 0 ; 11
+ 3be: 58 98 cbi 0x0b, 0 ; 11
if (adb_werte[z_byte] & bitpos)
- 2d6: f7 01 movw r30, r14
- 2d8: 80 81 ld r24, Z
- 2da: 80 23 and r24, r16
-
2dc: 79 f0 breq .+30 ; 0x2fc <adb+0xc0>
+ 3c0: f7 01 movw r30, r14
+ 3c2: 80 81 ld r24, Z
+ 3c4: 80 23 and r24, r16
+
3c6: 79 f0 breq .+30 ; 0x3e6 <adb+0xc0>
while (t0ext() < ADB_IMPULS_KURZ)
- 2de: a2 df rcall .-188 ; 0x224 <t0ext>
- 2e0: bc 01 movw r22, r24
- 2e2: 80 e0 ldi r24, 0x00 ; 0
- 2e4: 90 e0 ldi r25, 0x00 ; 0
- 2e6: 0e 94 23 0b call 0x1646 ; 0x1646 <__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 8b 0a call 0x1516 ; 0x1516 <__cmpsf2>
- 2f6: 87 fd sbrc r24, 7
-
2f8: f2 cf rjmp .-28 ; 0x2de <adb+0xa2>
-
2fa: 0e c0 rjmp .+28 ; 0x318 <adb+0xdc>
+ 3c8: a2 df rcall .-188 ; 0x30e <t0ext>
+ 3ca: bc 01 movw r22, r24
+ 3cc: 80 e0 ldi r24, 0x00 ; 0
+ 3ce: 90 e0 ldi r25, 0x00 ; 0
+ 3d0: 0e 94 5b 0c call 0x18b6 ; 0x18b6 <__floatunsisf>
+ 3d4: 20 e0 ldi r18, 0x00 ; 0
+ 3d6: 30 e0 ldi r19, 0x00 ; 0
+ 3d8: 4c e8 ldi r20, 0x8C ; 140
+ 3da: 52 e4 ldi r21, 0x42 ; 66
+ 3dc: 0e 94 c3 0b call 0x1786 ; 0x1786 <__cmpsf2>
+ 3e0: 87 fd sbrc r24, 7
+
3e2: f2 cf rjmp .-28 ; 0x3c8 <adb+0xa2>
+
3e4: 0e c0 rjmp .+28 ; 0x402 <adb+0xdc>
;
else
while (t0ext() < ADB_IMPULS_LANG)
- 2fc: 93 df rcall .-218 ; 0x224 <t0ext>
- 2fe: bc 01 movw r22, r24
- 300: 80 e0 ldi r24, 0x00 ; 0
- 302: 90 e0 ldi r25, 0x00 ; 0
- 304: 0e 94 23 0b call 0x1646 ; 0x1646 <__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 8b 0a call 0x1516 ; 0x1516 <__cmpsf2>
- 314: 87 fd sbrc r24, 7
-
316: f2 cf rjmp .-28 ; 0x2fc <adb+0xc0>
+ 3e6: 93 df rcall .-218 ; 0x30e <t0ext>
+ 3e8: bc 01 movw r22, r24
+ 3ea: 80 e0 ldi r24, 0x00 ; 0
+ 3ec: 90 e0 ldi r25, 0x00 ; 0
+ 3ee: 0e 94 5b 0c call 0x18b6 ; 0x18b6 <__floatunsisf>
+ 3f2: 20 e0 ldi r18, 0x00 ; 0
+ 3f4: 30 e0 ldi r19, 0x00 ; 0
+ 3f6: 42 e0 ldi r20, 0x02 ; 2
+ 3f8: 53 e4 ldi r21, 0x43 ; 67
+ 3fa: 0e 94 c3 0b call 0x1786 ; 0x1786 <__cmpsf2>
+ 3fe: 87 fd sbrc r24, 7
+
400: f2 cf rjmp .-28 ; 0x3e6 <adb+0xc0>
;
ADB_PDIR &= ~ADB_BIT; // Eingang über Pullup
- 318: 50 98 cbi 0x0a, 0 ; 10
+ 402: 50 98 cbi 0x0a, 0 ; 10
ADB_POUT |= ADB_BIT;
- 31a: 58 9a sbi 0x0b, 0 ; 11
+ 404: 58 9a sbi 0x0b, 0 ; 11
while (t0ext() < ADB_IMPULS_KURZ + ADB_IMPULS_LANG)
- 31c: 83 df rcall .-250 ; 0x224 <t0ext>
- 31e: bc 01 movw r22, r24
- 320: 80 e0 ldi r24, 0x00 ; 0
- 322: 90 e0 ldi r25, 0x00 ; 0
- 324: 0e 94 23 0b call 0x1646 ; 0x1646 <__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 8b 0a call 0x1516 ; 0x1516 <__cmpsf2>
- 334: 87 fd sbrc r24, 7
-
336: f2 cf rjmp .-28 ; 0x31c <adb+0xe0>
+ 406: 83 df rcall .-250 ; 0x30e <t0ext>
+ 408: bc 01 movw r22, r24
+ 40a: 80 e0 ldi r24, 0x00 ; 0
+ 40c: 90 e0 ldi r25, 0x00 ; 0
+ 40e: 0e 94 5b 0c call 0x18b6 ; 0x18b6 <__floatunsisf>
+ 412: 20 e0 ldi r18, 0x00 ; 0
+ 414: 30 e0 ldi r19, 0x00 ; 0
+ 416: 48 e4 ldi r20, 0x48 ; 72
+ 418: 53 e4 ldi r21, 0x43 ; 67
+ 41a: 0e 94 c3 0b call 0x1786 ; 0x1786 <__cmpsf2>
+ 41e: 87 fd sbrc r24, 7
+
420: f2 cf rjmp .-28 ; 0x406 <adb+0xe0>
ADB_POUT |= ADB_BIT;
while (t0ext() < ADB_IMPULS_KURZ + ADB_IMPULS_LANG)
;
for (; z_byte < anzahl_out; z_byte++) {
for (bitpos = 128; bitpos; bitpos >>= 1) { //Daten ausgeben
- 338: 06 95 lsr r16
- 33a: 21 97 sbiw r28, 0x01 ; 1
-
33c: 49 f6 brne .-110 ; 0x2d0 <adb+0x94>
+ 422: 06 95 lsr r16
+ 424: 21 97 sbiw r28, 0x01 ; 1
+
426: 49 f6 brne .-110 ; 0x3ba <adb+0x94>
ADB_PDIR &= ~ADB_BIT; // Eingang über Pullup
ADB_POUT |= ADB_BIT;
while (t0ext() < ADB_IMPULS_KURZ + ADB_IMPULS_LANG)
;
for (; z_byte < anzahl_out; z_byte++) {
- 33e: 1f 5f subi r17, 0xFF ; 255
- 340: 1d 15 cp r17, r13
-
342: 08 f4 brcc .+2 ; 0x346 <adb+0x10a>
-
344: bc cf rjmp .-136 ; 0x2be <adb+0x82>
+ 428: 1f 5f subi r17, 0xFF ; 255
+ 42a: 1d 15 cp r17, r13
+
42c: 08 f4 brcc .+2 ; 0x430 <adb+0x10a>
+
42e: bc cf rjmp .-136 ; 0x3a8 <adb+0x82>
while (t0ext() < ADB_IMPULS_KURZ + ADB_IMPULS_LANG)
;
}
}
// STOP BIT (0)
t0rst(); // TCNT0 = 0;
- 346: 76 df rcall .-276 ; 0x234 <t0rst>
+ 430: 76 df rcall .-276 ; 0x31e <t0rst>
ADB_PDIR |= ADB_BIT; // Ausgang 0
- 348: 50 9a sbi 0x0a, 0 ; 10
+ 432: 50 9a sbi 0x0a, 0 ; 10
ADB_POUT &= ~ADB_BIT;
- 34a: 58 98 cbi 0x0b, 0 ; 11
+ 434: 58 98 cbi 0x0b, 0 ; 11
while (t0ext() < ADB_IMPULS_LANG)
- 34c: 6b df rcall .-298 ; 0x224 <t0ext>
- 34e: bc 01 movw r22, r24
- 350: 80 e0 ldi r24, 0x00 ; 0
- 352: 90 e0 ldi r25, 0x00 ; 0
- 354: 0e 94 23 0b call 0x1646 ; 0x1646 <__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 8b 0a call 0x1516 ; 0x1516 <__cmpsf2>
- 364: 87 fd sbrc r24, 7
-
366: f2 cf rjmp .-28 ; 0x34c <adb+0x110>
+ 436: 6b df rcall .-298 ; 0x30e <t0ext>
+ 438: bc 01 movw r22, r24
+ 43a: 80 e0 ldi r24, 0x00 ; 0
+ 43c: 90 e0 ldi r25, 0x00 ; 0
+ 43e: 0e 94 5b 0c call 0x18b6 ; 0x18b6 <__floatunsisf>
+ 442: 20 e0 ldi r18, 0x00 ; 0
+ 444: 30 e0 ldi r19, 0x00 ; 0
+ 446: 42 e0 ldi r20, 0x02 ; 2
+ 448: 53 e4 ldi r21, 0x43 ; 67
+ 44a: 0e 94 c3 0b call 0x1786 ; 0x1786 <__cmpsf2>
+ 44e: 87 fd sbrc r24, 7
+
450: f2 cf rjmp .-28 ; 0x436 <adb+0x110>
;
ADB_PDIR &= ~ADB_BIT; // Eingang über Pullup
- 368: 50 98 cbi 0x0a, 0 ; 10
+ 452: 50 98 cbi 0x0a, 0 ; 10
ADB_POUT |= ADB_BIT;
- 36a: 58 9a sbi 0x0b, 0 ; 11
+ 454: 58 9a sbi 0x0b, 0 ; 11
while (t0ext() < ADB_IMPULS_KURZ + ADB_IMPULS_LANG)
- 36c: 5b df rcall .-330 ; 0x224 <t0ext>
- 36e: bc 01 movw r22, r24
- 370: 80 e0 ldi r24, 0x00 ; 0
- 372: 90 e0 ldi r25, 0x00 ; 0
- 374: 0e 94 23 0b call 0x1646 ; 0x1646 <__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 8b 0a call 0x1516 ; 0x1516 <__cmpsf2>
- 384: 87 fd sbrc r24, 7
-
386: f2 cf rjmp .-28 ; 0x36c <adb+0x130>
+ 456: 5b df rcall .-330 ; 0x30e <t0ext>
+ 458: bc 01 movw r22, r24
+ 45a: 80 e0 ldi r24, 0x00 ; 0
+ 45c: 90 e0 ldi r25, 0x00 ; 0
+ 45e: 0e 94 5b 0c call 0x18b6 ; 0x18b6 <__floatunsisf>
+ 462: 20 e0 ldi r18, 0x00 ; 0
+ 464: 30 e0 ldi r19, 0x00 ; 0
+ 466: 48 e4 ldi r20, 0x48 ; 72
+ 468: 53 e4 ldi r21, 0x43 ; 67
+ 46a: 0e 94 c3 0b call 0x1786 ; 0x1786 <__cmpsf2>
+ 46e: 87 fd sbrc r24, 7
+
470: f2 cf rjmp .-28 ; 0x456 <adb+0x130>
;
// Entscheidung, ob noch weitere Daten übertragen werden
if (adb_werte[0] == COM_LISTEN3)
- 388: 80 91 7f 02 lds r24, 0x027F
- 38c: 8b 33 cpi r24, 0x3B ; 59
-
38e: 29 f0 breq .+10 ; 0x39a <adb+0x15e>
+ 472: 80 91 8d 02 lds r24, 0x028D
+ 476: 8b 33 cpi r24, 0x3B ; 59
+
478: 29 f0 breq .+10 ; 0x484 <adb+0x15e>
anzahl_out = 2 + 1;
else if (adb_werte[0] == COM_LISTEN1)
- 390: 89 33 cpi r24, 0x39 ; 57
-
392: 41 f4 brne .+16 ; 0x3a4 <adb+0x168>
+ 47a: 89 33 cpi r24, 0x39 ; 57
+
47c: 41 f4 brne .+16 ; 0x48e <adb+0x168>
anzahl_out = 8 + 1;
- 394: 29 e0 ldi r18, 0x09 ; 9
- 396: d2 2e mov r13, r18
-
398: 02 c0 rjmp .+4 ; 0x39e <adb+0x162>
+ 47e: 09 e0 ldi r16, 0x09 ; 9
+ 480: d0 2e mov r13, r16
+
482: 02 c0 rjmp .+4 ; 0x488 <adb+0x162>
while (t0ext() < ADB_IMPULS_KURZ + ADB_IMPULS_LANG)
;
// Entscheidung, ob noch weitere Daten übertragen werden
if (adb_werte[0] == COM_LISTEN3)
anzahl_out = 2 + 1;
- 39a: 93 e0 ldi r25, 0x03 ; 3
- 39c: d9 2e mov r13, r25
+ 484: b3 e0 ldi r27, 0x03 ; 3
+ 486: db 2e mov r13, r27
else if (adb_werte[0] == COM_LISTEN1)
anzahl_out = 8 + 1;
else
z_byte = 8;
} while (z_byte < 2);
- 39e: 11 30 cpi r17, 0x01 ; 1
-
3a0: 09 f4 brne .+2 ; 0x3a4 <adb+0x168>
-
3a2: 6b cf rjmp .-298 ; 0x27a <adb+0x3e>
+ 488: 11 30 cpi r17, 0x01 ; 1
+
48a: 09 f4 brne .+2 ; 0x48e <adb+0x168>
+
48c: 6b cf rjmp .-298 ; 0x364 <adb+0x3e>
// Warten auf Rückgabewerte sonst Abbruch
// TCCR0 = ADB_VORTEILER_A_BIT; // micha modifikation
t0rst(); // TCNT0 = 0;
- 3a4: 47 df rcall .-370 ; 0x234 <t0rst>
+ 48e: 47 df rcall .-370 ; 0x31e <t0rst>
do {
if (t0ext() > ADB_IMPULS_TLT) {
- 3a6: 3e df rcall .-388 ; 0x224 <t0ext>
- 3a8: bc 01 movw r22, r24
- 3aa: 80 e0 ldi r24, 0x00 ; 0
- 3ac: 90 e0 ldi r25, 0x00 ; 0
- 3ae: 0e 94 23 0b call 0x1646 ; 0x1646 <__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 d5 0b call 0x17aa ; 0x17aa <__gesf2>
- 3be: 18 16 cp r1, r24
-
3c0: 0c f4 brge .+2 ; 0x3c4 <adb+0x188>
- 3c2: 42 c0 rjmp .+132 ; 0x448 <adb+0x20c>
+ 490: 3e df rcall .-388 ; 0x30e <t0ext>
+ 492: bc 01 movw r22, r24
+ 494: 80 e0 ldi r24, 0x00 ; 0
+ 496: 90 e0 ldi r25, 0x00 ; 0
+ 498: 0e 94 5b 0c call 0x18b6 ; 0x18b6 <__floatunsisf>
+ 49c: 20 e0 ldi r18, 0x00 ; 0
+ 49e: 30 e0 ldi r19, 0x00 ; 0
+ 4a0: 4a ef ldi r20, 0xFA ; 250
+ 4a2: 53 e4 ldi r21, 0x43 ; 67
+ 4a4: 0e 94 0d 0d call 0x1a1a ; 0x1a1a <__gesf2>
+ 4a8: 18 16 cp r1, r24
+
4aa: 0c f4 brge .+2 ; 0x4ae <adb+0x188>
+ 4ac: 42 c0 rjmp .+132 ; 0x532 <__stack+0x33>
return (0);
}
} while (ADB_PIN & ADB_BIT);
- 3c4: 48 99 sbic 0x09, 0 ; 9
-
3c6: ef cf rjmp .-34 ; 0x3a6 <adb+0x16a>
+ 4ae: 48 99 sbic 0x09, 0 ; 9
+
4b0: ef cf rjmp .-34 ; 0x490 <adb+0x16a>
while (!(ADB_PIN & ADB_BIT))
- 3c8: 48 9b sbis 0x09, 0 ; 9
-
3ca: fe cf rjmp .-4 ; 0x3c8 <adb+0x18c>
- 3cc: c0 e8 ldi r28, 0x80 ; 128
- 3ce: d2 e0 ldi r29, 0x02 ; 2
- 3d0: 11 e0 ldi r17, 0x01 ; 1
-
3d2: 01 c0 rjmp .+2 ; 0x3d6 <adb+0x19a>
+ 4b2: 48 9b sbis 0x09, 0 ; 9
+
4b4: fe cf rjmp .-4 ; 0x4b2 <adb+0x18c>
+ 4b6: ce e8 ldi r28, 0x8E ; 142
+ 4b8: d2 e0 ldi r29, 0x02 ; 2
+ 4ba: 11 e0 ldi r17, 0x01 ; 1
+
4bc: 01 c0 rjmp .+2 ; 0x4c0 <adb+0x19a>
while (!(ADB_PIN & ADB_BIT))
;
if (t0ext() < (ADB_IMPULS_KURZ + ADB_IMPULS_LANG) / 2)
adb_werte[z_byte] += bitpos;
}
z_byte++;
- 3d4: 18 2f mov r17, r24
+ 4be: 18 2f mov r17, r24
while (!(ADB_PIN & ADB_BIT))
; // Start Bit
z_byte = 1;
while (z_byte < MAX_ADB) {
adb_werte[z_byte] = 0;
- 3d6: 18 82 st Y, r1
- 3d8: 88 e0 ldi r24, 0x08 ; 8
- 3da: e8 2e mov r14, r24
- 3dc: f1 2c mov r15, r1
+ 4c0: 18 82 st Y, r1
+ 4c2: a8 e0 ldi r26, 0x08 ; 8
+ 4c4: ea 2e mov r14, r26
+ 4c6: f1 2c mov r15, r1
for (bitpos = 128; bitpos; bitpos >>= 1) { //Bits einlesen
- 3de: 00 e8 ldi r16, 0x80 ; 128
+ 4c8: 00 e8 ldi r16, 0x80 ; 128
//TCCR0 = ADB_VORTEILER_B_BIT; //micha modifikation
t0rst(); // TCNT0 = 0;
- 3e0: 29 df rcall .-430 ; 0x234 <t0rst>
+ 4ca: 29 df rcall .-430 ; 0x31e <t0rst>
// Abbruch wenn keine weiteren Bytes übertragen werden.
do {
if (t0ext() > ADB_IMPULS_KURZ + ADB_IMPULS_LANG) {
- 3e2: 20 df rcall .-448 ; 0x224 <t0ext>
- 3e4: bc 01 movw r22, r24
- 3e6: 80 e0 ldi r24, 0x00 ; 0
- 3e8: 90 e0 ldi r25, 0x00 ; 0
- 3ea: 0e 94 23 0b call 0x1646 ; 0x1646 <__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 d5 0b call 0x17aa ; 0x17aa <__gesf2>
- 3fa: 18 16 cp r1, r24
-
3fc: 14 f4 brge .+4 ; 0x402 <adb+0x1c6>
+ 4cc: 20 df rcall .-448 ; 0x30e <t0ext>
+ 4ce: bc 01 movw r22, r24
+ 4d0: 80 e0 ldi r24, 0x00 ; 0
+ 4d2: 90 e0 ldi r25, 0x00 ; 0
+ 4d4: 0e 94 5b 0c call 0x18b6 ; 0x18b6 <__floatunsisf>
+ 4d8: 20 e0 ldi r18, 0x00 ; 0
+ 4da: 30 e0 ldi r19, 0x00 ; 0
+ 4dc: 48 e4 ldi r20, 0x48 ; 72
+ 4de: 53 e4 ldi r21, 0x43 ; 67
+ 4e0: 0e 94 0d 0d call 0x1a1a ; 0x1a1a <__gesf2>
+ 4e4: 18 16 cp r1, r24
+
4e6: 14 f4 brge .+4 ; 0x4ec <adb+0x1c6>
return (z_byte - 1);
- 3fe: 11 50 subi r17, 0x01 ; 1
- 400: 24 c0 rjmp .+72 ; 0x44a <adb+0x20e>
+ 4e8: 11 50 subi r17, 0x01 ; 1
+ 4ea: 24 c0 rjmp .+72 ; 0x534 <__stack+0x35>
}
} while (ADB_PIN & ADB_BIT);
- 402: 48 99 sbic 0x09, 0 ; 9
- 4
04: ee cf rjmp .-36 ; 0x3e2 <adb+0x1a6>
+ 4ec: 48 99 sbic 0x09, 0 ; 9
+ 4
ee: ee cf rjmp .-36 ; 0x4cc <adb+0x1a6>
t0rst(); // TCNT0 = 0;
- 406: 16 df rcall .-468 ; 0x234 <t0rst>
+ 4f0: 16 df rcall .-468 ; 0x31e <t0rst>
while (!(ADB_PIN & ADB_BIT))
- 408: 48 9b sbis 0x09, 0 ; 9
- 4
0a: fe cf rjmp .-4 ; 0x408 <adb+0x1cc>
+ 4f2: 48 9b sbis 0x09, 0 ; 9
+ 4
f4: fe cf rjmp .-4 ; 0x4f2 <adb+0x1cc>
;
if (t0ext() < (ADB_IMPULS_KURZ + ADB_IMPULS_LANG) / 2)
- 40c: 0b df rcall .-490 ; 0x224 <t0ext>
- 40e: bc 01 movw r22, r24
- 410: 80 e0 ldi r24, 0x00 ; 0
- 412: 90 e0 ldi r25, 0x00 ; 0
- 414: 0e 94 23 0b call 0x1646 ; 0x1646 <__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 8b 0a call 0x1516 ; 0x1516 <__cmpsf2>
- 424: 87 ff sbrs r24, 7
- 426: 03 c0 rjmp .+6 ; 0x42e <adb+0x1f2>
+ 4f6: 0b df rcall .-490 ; 0x30e <t0ext>
+ 4f8: bc 01 movw r22, r24
+ 4fa: 80 e0 ldi r24, 0x00 ; 0
+ 4fc: 90 e0 ldi r25, 0x00 ; 0
+ 4fe: 0e 94 5b 0c call 0x18b6 ; 0x18b6 <__floatunsisf>
+ 502: 20 e0 ldi r18, 0x00 ; 0
+ 504: 30 e0 ldi r19, 0x00 ; 0
+ 506: 48 ec ldi r20, 0xC8 ; 200
+ 508: 52 e4 ldi r21, 0x42 ; 66
+ 50a: 0e 94 c3 0b call 0x1786 ; 0x1786 <__cmpsf2>
+ 50e: 87 ff sbrs r24, 7
+ 510: 03 c0 rjmp .+6 ; 0x518 <__stack+0x19>
adb_werte[z_byte] += bitpos;
- 428: 88 81 ld r24, Y
- 42a: 80 0f add r24, r16
- 42c: 88 83 st Y, r24
+ 512: 88 81 ld r24, Y
+ 514: 80 0f add r24, r16
+ 516: 88 83 st Y, r24
; // Start Bit
z_byte = 1;
while (z_byte < MAX_ADB) {
adb_werte[z_byte] = 0;
for (bitpos = 128; bitpos; bitpos >>= 1) { //Bits einlesen
- 42e: 06 95 lsr r16
- 430: 08 94 sec
- 432: e1 08 sbc r14, r1
- 434: f1 08 sbc r15, r1
- 436: e1 14 cp r14, r1
- 438: f1 04 cpc r15, r1
-
43a: 91 f6 brne .-92 ; 0x3e0 <adb+0x1a4>
+ 518: 06 95 lsr r16
+ 51a: 08 94 sec
+ 51c: e1 08 sbc r14, r1
+ 51e: f1 08 sbc r15, r1
+ 520: e1 14 cp r14, r1
+ 522: f1 04 cpc r15, r1
+
524: 91 f6 brne .-92 ; 0x4ca <adb+0x1a4>
while (!(ADB_PIN & ADB_BIT))
;
if (t0ext() < (ADB_IMPULS_KURZ + ADB_IMPULS_LANG) / 2)
adb_werte[z_byte] += bitpos;
}
z_byte++;
- 43c: 81 2f mov r24, r17
- 43e: 8f 5f subi r24, 0xFF ; 255
- 440: 21 96 adiw r28, 0x01 ; 1
+ 526: 81 2f mov r24, r17
+ 528: 8f 5f subi r24, 0xFF ; 255
+ 52a: 21 96 adiw r28, 0x01 ; 1
} while (ADB_PIN & ADB_BIT);
while (!(ADB_PIN & ADB_BIT))
; // Start Bit
z_byte = 1;
while (z_byte < MAX_ADB) {
- 442: 89 30 cpi r24, 0x09 ; 9
-
444: 39 f6 brne .-114 ; 0x3d4 <adb+0x198>
- 446: 01 c0 rjmp .+2 ; 0x44a <adb+0x20e>
+ 52c: 89 30 cpi r24, 0x09 ; 9
+
52e: 39 f6 brne .-114 ; 0x4be <adb+0x198>
+ 530: 01 c0 rjmp .+2 ; 0x534 <__stack+0x35>
// TCCR0 = ADB_VORTEILER_A_BIT; // micha modifikation
t0rst(); // TCNT0 = 0;
do {
if (t0ext() > ADB_IMPULS_TLT) {
return (0);
- 448: 10 e0 ldi r17, 0x00 ; 0
+ 532: 10 e0 ldi r17, 0x00 ; 0
adb_werte[z_byte] += bitpos;
}
z_byte++;
}
return (z_byte - 1);
}
- 44a: 81 2f mov r24, r17
- 44c: df 91 pop r29
- 44e: cf 91 pop r28
- 450: 1f 91 pop r17
- 452: 0f 91 pop r16
- 454: ff 90 pop r15
- 456: ef 90 pop r14
- 458: df 90 pop r13
- 45a: 08 95 ret
-
-0000045c <touchpad_init>:
+ 534: 81 2f mov r24, r17
+ 536: df 91 pop r29
+ 538: cf 91 pop r28
+ 53a: 1f 91 pop r17
+ 53c: 0f 91 pop r16
+ 53e: ff 90 pop r15
+ 540: ef 90 pop r14
+ 542: df 90 pop r13
+ 544: 08 95 ret
+
+00000546 <touchpad_init>:
void touchpad_init(void) {
// Eingänge
ADB_PDIR &= ~ADB_BIT;
- 45c: 50 98 cbi 0x0a, 0 ; 10
+ 546: 50 98 cbi 0x0a, 0 ; 10
// Pull Up einschalten
ADB_POUT |= ADB_BIT;
- 45e: 58 9a sbi 0x0b, 0 ; 11
+ 548: 58 9a sbi 0x0b, 0 ; 11
//enable timer0 interrupt
TIMSK0 |= (1 << TOIE0);
- 460: ee e6 ldi r30, 0x6E ; 110
- 462: f0 e0 ldi r31, 0x00 ; 0
- 464: 80 81 ld r24, Z
- 466: 81 60 ori r24, 0x01 ; 1
- 468: 80 83 st Z, r24
+ 54a: ee e6 ldi r30, 0x6E ; 110
+ 54c: f0 e0 ldi r31, 0x00 ; 0
+ 54e: 80 81 ld r24, Z
+ 550: 81 60 ori r24, 0x01 ; 1
+ 552: 80 83 st Z, r24
}
- 46a: 08 95 ret
+ 554: 08 95 ret
-0000046c <touchpad_read>:
+00000556 <touchpad_read>:
uint8_t touchpad_read(void) {
adb_werte[0] = COM_TALK0;
- 46c: 8c e3 ldi r24, 0x3C ; 60
- 46e: 80 93 7f 02 sts 0x027F, r24
+ 556: 8c e3 ldi r24, 0x3C ; 60
+ 558: 80 93 8d 02 sts 0x028D, r24
adb_data_length = adb();
-
472: e4 de rcall .-568 ; 0x23c <adb>
- 474: 80 93 89 02 sts 0x0289, r24
+
55c: e4 de rcall .-568 ; 0x326 <adb>
+ 55e: 80 93 97 02 sts 0x0297, r24
return adb_data_length;
- 478: 80 91 89 02 lds r24, 0x0289
+ 562: 80 91 97 02 lds r24, 0x0297
}
- 47c: 08 95 ret
+ 566: 08 95 ret
-0000047e <touchpad_set_abs_mode>:
+00000568 <touchpad_set_abs_mode>:
void touchpad_set_abs_mode(void) {
// Auf Absolutmodus umschalten
adb_werte[0] = COM_LISTEN3;
- 47e: 8b e3 ldi r24, 0x3B ; 59
- 480: 80 93 7f 02 sts 0x027F, r24
+ 568: 8b e3 ldi r24, 0x3B ; 59
+ 56a: 80 93 8d 02 sts 0x028D, r24
adb_werte[1] = BITS(0110,0011);
- 484: 83 e6 ldi r24, 0x63 ; 99
- 486: 80 93 80 02 sts 0x0280, r24
+ 56e: 83 e6 ldi r24, 0x63 ; 99
+ 570: 80 93 8e 02 sts 0x028E, r24
adb_werte[2] = 4; //CDM Modus
- 48a: 84 e0 ldi r24, 0x04 ; 4
- 48c: 80 93 81 02 sts 0x0281, r24
+ 574: 84 e0 ldi r24, 0x04 ; 4
+ 576: 80 93 8f 02 sts 0x028F, r24
adb();
-
490: d5 de rcall .-598 ; 0x23c <adb>
+
57a: d5 de rcall .-598 ; 0x326 <adb>
adb_werte[0] = COM_TALK1;
- 492: 8d e3 ldi r24, 0x3D ; 61
- 494: 80 93 7f 02 sts 0x027F, r24
+ 57c: 8d e3 ldi r24, 0x3D ; 61
+ 57e: 80 93 8d 02 sts 0x028D, r24
adb(); // Werte holen
-
498: d1 de rcall .-606 ; 0x23c <adb>
+
582: d1 de rcall .-606 ; 0x326 <adb>
adb_werte[0] = COM_LISTEN1;
- 49a: 89 e3 ldi r24, 0x39 ; 57
- 49c: 80 93 7f 02 sts 0x027F, r24
+ 584: 89 e3 ldi r24, 0x39 ; 57
+ 586: 80 93 8d 02 sts 0x028D, r24
adb_werte[7] = 0x00; //Absolutmodus
- 4a0: 10 92 86 02 sts 0x0286, r1
+ 58a: 10 92 94 02 sts 0x0294, r1
adb();
-
4a4: cb de rcall .-618 ; 0x23c <adb>
+
58e: cb de rcall .-618 ; 0x326 <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
+ 590: 8f ef ldi r24, 0xFF ; 255
+ 592: 91 ee ldi r25, 0xE1 ; 225
+ 594: a4 e0 ldi r26, 0x04 ; 4
+ 596: 81 50 subi r24, 0x01 ; 1
+ 598: 90 40 sbci r25, 0x00 ; 0
+ 59a: a0 40 sbci r26, 0x00 ; 0
+ 59c: e1 f7 brne .-8 ; 0x596 <touchpad_set_abs_mode+0x2e>
+ 59e: 00 c0 rjmp .+0 ; 0x5a0 <touchpad_set_abs_mode+0x38>
+ 5a0: 00 00 nop
_delay_ms(100);
}
- 4b8: 08 95 ret
+ 5a2: 08 95 ret
-000004ba <touchpad_set_rel_mode_100dpi>:
+000005a4 <touchpad_set_rel_mode_100dpi>:
void touchpad_set_rel_mode_100dpi(void) {
// Auf Relativmodus umschalten
adb_werte[0] = COM_LISTEN3;
- 4ba: 8b e3 ldi r24, 0x3B ; 59
- 4bc: 80 93 7f 02 sts 0x027F, r24
+ 5a4: 8b e3 ldi r24, 0x3B ; 59
+ 5a6: 80 93 8d 02 sts 0x028D, r24
adb_werte[1] = BITS(0110,0011);
- 4c0: 83 e6 ldi r24, 0x63 ; 99
- 4c2: 80 93 80 02 sts 0x0280, r24
+ 5aa: 83 e6 ldi r24, 0x63 ; 99
+ 5ac: 80 93 8e 02 sts 0x028E, r24
adb_werte[2] = 1; //default modus: 100 dpi mouse
- 4c6: 81 e0 ldi r24, 0x01 ; 1
- 4c8: 80 93 81 02 sts 0x0281, r24
+ 5b0: 81 e0 ldi r24, 0x01 ; 1
+ 5b2: 80 93 8f 02 sts 0x028F, r24
adb();
-
4cc: b7 de rcall .-658 ; 0x23c <adb>
- 4ce: 8f ef ldi r24, 0xFF ; 255
- 4d0: 91 ee ldi r25, 0xE1 ; 225
- 4d2: a4 e0 ldi r26, 0x04 ; 4
- 4d4: 81 50 subi r24, 0x01 ; 1
- 4d6: 90 40 sbci r25, 0x00 ; 0
- 4d8: a0 40 sbci r26, 0x00 ; 0
- 4da: e1 f7 brne .-8 ; 0x4d4 <touchpad_set_rel_mode_100dpi+0x1a>
- 4dc: 00 c0 rjmp .+0 ; 0x4de <touchpad_set_rel_mode_100dpi+0x24>
- 4de: 00 00 nop
+
5b6: b7 de rcall .-658 ; 0x326 <adb>
+ 5b8: 8f ef ldi r24, 0xFF ; 255
+ 5ba: 91 ee ldi r25, 0xE1 ; 225
+ 5bc: a4 e0 ldi r26, 0x04 ; 4
+ 5be: 81 50 subi r24, 0x01 ; 1
+ 5c0: 90 40 sbci r25, 0x00 ; 0
+ 5c2: a0 40 sbci r26, 0x00 ; 0
+ 5c4: e1 f7 brne .-8 ; 0x5be <touchpad_set_rel_mode_100dpi+0x1a>
+ 5c6: 00 c0 rjmp .+0 ; 0x5c8 <touchpad_set_rel_mode_100dpi+0x24>
+ 5c8: 00 00 nop
_delay_ms(100);
}
- 4e0: 08 95 ret
+ 5ca: 08 95 ret
-000004e2 <delta_y>:
+000005cc <delta_y>:
return ((adb_werte[4] & 0b01110000) << 6)
| ((adb_werte[3] & 0b01110000) << 3) | (adb_werte[1] & 0b01111111);
}
int8_t delta_y(void) {
if(adb_data_length ==0) {
- 4e2: 80 91 89 02 lds r24, 0x0289
- 4e6: 88 23 and r24, r24
- 4e8: 51 f0 breq .+20 ; 0x4fe <delta_y+0x1c>
+ 5cc: 80 91 97 02 lds r24, 0x0297
+ 5d0: 88 23 and r24, r24
+ 5d2: 51 f0 breq .+20 ; 0x5e8 <delta_y+0x1c>
return 0;
}
if (adb_werte[1] & 0b01000000) {
- 4ea: 80 91 80 02 lds r24, 0x0280
- 4ee: 86 ff sbrs r24, 6
- 4f0: 04 c0 rjmp .+8 ; 0x4fa <delta_y+0x18>
+ 5d4: 80 91 8e 02 lds r24, 0x028E
+ 5d8: 86 ff sbrs r24, 6
+ 5da: 04 c0 rjmp .+8 ; 0x5e4 <delta_y+0x18>
return -((128 - adb_werte[1]) & 0b00111111);
- 4f2: 81 95 neg r24
- 4f4: 8f 73 andi r24, 0x3F ; 63
- 4f6: 81 95 neg r24
- 4f8: 08 95 ret
+ 5dc: 81 95 neg r24
+ 5de: 8f 73 andi r24, 0x3F ; 63
+ 5e0: 81 95 neg r24
+ 5e2: 08 95 ret
} else {
return adb_werte[1] & 0b00111111;
- 4fa: 8f 73 andi r24, 0x3F ; 63
- 4fc: 08 95 ret
+ 5e4: 8f 73 andi r24, 0x3F ; 63
+ 5e6: 08 95 ret
| ((adb_werte[3] & 0b01110000) << 3) | (adb_werte[1] & 0b01111111);
}
int8_t delta_y(void) {
if(adb_data_length ==0) {
return 0;
- 4fe: 80 e0 ldi r24, 0x00 ; 0
+ 5e8: 80 e0 ldi r24, 0x00 ; 0
if (adb_werte[1] & 0b01000000) {
return -((128 - adb_werte[1]) & 0b00111111);
} else {
return adb_werte[1] & 0b00111111;
}
}
- 500: 08 95 ret
+ 5ea: 08 95 ret
-00000502 <delta_x>:
+000005ec <delta_x>:
int8_t delta_x(void) {
if(adb_data_length ==0) {
- 502: 80 91 89 02 lds r24, 0x0289
- 506: 88 23 and r24, r24
- 508: 51 f0 breq .+20 ; 0x51e <delta_x+0x1c>
+ 5ec: 80 91 97 02 lds r24, 0x0297
+ 5f0: 88 23 and r24, r24
+ 5f2: 51 f0 breq .+20 ; 0x608 <delta_x+0x1c>
return 0;
}
if (adb_werte[2] & 0b01000000) {
- 50a: 80 91 81 02 lds r24, 0x0281
- 50e: 86 ff sbrs r24, 6
- 510: 04 c0 rjmp .+8 ; 0x51a <delta_x+0x18>
+ 5f4: 80 91 8f 02 lds r24, 0x028F
+ 5f8: 86 ff sbrs r24, 6
+ 5fa: 04 c0 rjmp .+8 ; 0x604 <delta_x+0x18>
return -((128 - adb_werte[2]) & 0b00111111);
- 512: 81 95 neg r24
- 514: 8f 73 andi r24, 0x3F ; 63
- 516: 81 95 neg r24
- 518: 08 95 ret
+ 5fc: 81 95 neg r24
+ 5fe: 8f 73 andi r24, 0x3F ; 63
+ 600: 81 95 neg r24
+ 602: 08 95 ret
} else {
return adb_werte[2] & 0b00111111;
- 51a: 8f 73 andi r24, 0x3F ; 63
- 51c: 08 95 ret
+ 604: 8f 73 andi r24, 0x3F ; 63
+ 606: 08 95 ret
}
}
int8_t delta_x(void) {
if(adb_data_length ==0) {
return 0;
- 51e: 80 e0 ldi r24, 0x00 ; 0
+ 608: 80 e0 ldi r24, 0x00 ; 0
if (adb_werte[2] & 0b01000000) {
return -((128 - adb_werte[2]) & 0b00111111);
} else {
return adb_werte[2] & 0b00111111;
}
}
- 520: 08 95 ret
+ 60a: 08 95 ret
-00000522 <Usb2SerialTask>:
+0000060c <Usb2SerialTask>:
void Usb2SerialTask(void) {
- 522: 1f 93 push r17
+ 60c: 1f 93 push r17
static inline uint_reg_t GetGlobalInterruptMask(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
return SREG;
- 524: 8f b7 in r24, 0x3f ; 63
+ 60e: 8f b7 in r24, 0x3f ; 63
static inline void GlobalInterruptDisable(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
cli();
- 526: f8 94 cli
+ 610: f8 94 cli
uint16_t Count;
uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
GlobalInterruptDisable();
Count = Buffer->Count;
- 528: 20 91 6c 01 lds r18, 0x016C
- 52c: 30 91 6d 01 lds r19, 0x016D
+ 612: 20 91 74 01 lds r18, 0x0174
+ 616: 30 91 75 01 lds r19, 0x0175
static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
SREG = GlobalIntState;
- 530: 8f bf out 0x3f, r24 ; 63
+ 61a: 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)))
- 532: 80 91 6a 01 lds r24, 0x016A
- 536: 90 91 6b 01 lds r25, 0x016B
- 53a: 28 17 cp r18, r24
- 53c: 39 07 cpc r19, r25
- 53e: 49 f0 breq .+18 ; 0x552 <Usb2SerialTask+0x30>
+ 61c: 80 91 72 01 lds r24, 0x0172
+ 620: 90 91 73 01 lds r25, 0x0173
+ 624: 28 17 cp r18, r24
+ 626: 39 07 cpc r19, r25
+ 628: 51 f0 breq .+20 ; 0x63e <Usb2SerialTask+0x32>
{
int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
- 540: 85 e4 ldi r24, 0x45 ; 69
- 542: 91 e0 ldi r25, 0x01 ; 1
- 544: 54 d7 rcall .+3752 ; 0x13ee <CDC_Device_ReceiveByte>
- 546: bc 01 movw r22, r24
+ 62a: 85 e4 ldi r24, 0x45 ; 69
+ 62c: 91 e0 ldi r25, 0x01 ; 1
+ 62e: 0e 94 30 0b call 0x1660 ; 0x1660 <CDC_Device_ReceiveByte>
+ 632: bc 01 movw r22, r24
/* Read bytes from the USB OUT endpoint into the USART transmit buffer */
if (!(ReceivedByte < 0))
- 548: 97 fd sbrc r25, 7
- 54a: 03 c0 rjmp .+6 ; 0x552 <Usb2SerialTask+0x30>
+ 634: 97 fd sbrc r25, 7
+ 636: 03 c0 rjmp .+6 ; 0x63e <Usb2SerialTask+0x32>
RingBuffer_Insert(&USBtoUSART_Buffer, ReceivedByte);
- 54c: 82 e6 ldi r24, 0x62 ; 98
- 54e: 91 e0 ldi r25, 0x01 ; 1
- 550: 0f de rcall .-994 ; 0x170 <RingBuffer_Insert>
+ 638: 8a e6 ldi r24, 0x6A ; 106
+ 63a: 91 e0 ldi r25, 0x01 ; 1
+ 63c: 99 dd rcall .-1230 ; 0x170 <RingBuffer_Insert>
static inline uint_reg_t GetGlobalInterruptMask(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
return SREG;
- 552: 2f b7 in r18, 0x3f ; 63
+ 63e: 2f b7 in r18, 0x3f ; 63
static inline void GlobalInterruptDisable(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
cli();
- 554: f8 94 cli
- 556: 80 91 f8 01 lds r24, 0x01F8
- 55a: 90 91 f9 01 lds r25, 0x01F9
+ 640: f8 94 cli
+ 642: 80 91 00 02 lds r24, 0x0200
+ 646: 90 91 01 02 lds r25, 0x0201
static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
SREG = GlobalIntState;
- 55e: 2f bf out 0x3f, r18 ; 63
+ 64a: 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)
- 560: 00 97 sbiw r24, 0x00 ; 0
- 562: 01 f1 breq .+64 ; 0x5a4 <Usb2SerialTask+0x82>
+ 64c: 00 97 sbiw r24, 0x00 ; 0
+ 64e: 01 f1 breq .+64 ; 0x690 <Usb2SerialTask+0x84>
*/
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);
- 564: 20 91 46 01 lds r18, 0x0146
- 568: 2f 70 andi r18, 0x0F ; 15
- 56a: 20 93 e9 00 sts 0x00E9, r18
+ 650: 20 91 46 01 lds r18, 0x0146
+ 654: 2f 70 andi r18, 0x0F ; 15
+ 656: 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);
- 56e: 20 91 e8 00 lds r18, 0x00E8
+ 65a: 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())
- 572: 20 ff sbrs r18, 0
- 574: 17 c0 rjmp .+46 ; 0x5a4 <Usb2SerialTask+0x82>
+ 65e: 20 ff sbrs r18, 0
+ 660: 17 c0 rjmp .+46 ; 0x690 <Usb2SerialTask+0x84>
{
/* 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));
- 576: 80 31 cpi r24, 0x10 ; 16
- 578: 91 05 cpc r25, r1
- 57a: 10 f0 brcs .+4 ; 0x580 <Usb2SerialTask+0x5e>
- 57c: 8f e0 ldi r24, 0x0F ; 15
- 57e: 90 e0 ldi r25, 0x00 ; 0
- 580: 18 2f mov r17, r24
+ 662: 80 31 cpi r24, 0x10 ; 16
+ 664: 91 05 cpc r25, r1
+ 666: 10 f0 brcs .+4 ; 0x66c <Usb2SerialTask+0x60>
+ 668: 8f e0 ldi r24, 0x0F ; 15
+ 66a: 90 e0 ldi r25, 0x00 ; 0
+ 66c: 18 2f mov r17, r24
/* Read bytes from the USART receive buffer into the USB IN endpoint */
while (BytesToSend--)
- 582: 0e c0 rjmp .+28 ; 0x5a0 <Usb2SerialTask+0x7e>
+ 66e: 0e c0 rjmp .+28 ; 0x68c <Usb2SerialTask+0x80>
* \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;
- 584: e0 91 f0 01 lds r30, 0x01F0
- 588: f0 91 f1 01 lds r31, 0x01F1
+ 670: e0 91 f8 01 lds r30, 0x01F8
+ 674: f0 91 f9 01 lds r31, 0x01F9
{
/* 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,
- 58c: 85 e4 ldi r24, 0x45 ; 69
- 58e: 91 e0 ldi r25, 0x01 ; 1
- 590: 60 81 ld r22, Z
- 592: b9 d6 rcall .+3442 ; 0x1306 <CDC_Device_SendByte>
- 594: 11 50 subi r17, 0x01 ; 1
- 596: 88 23 and r24, r24
- 598: 29 f4 brne .+10 ; 0x5a4 <Usb2SerialTask+0x82>
+ 678: 85 e4 ldi r24, 0x45 ; 69
+ 67a: 91 e0 ldi r25, 0x01 ; 1
+ 67c: 60 81 ld r22, Z
+ 67e: 7f d7 rcall .+3838 ; 0x157e <CDC_Device_SendByte>
+ 680: 11 50 subi r17, 0x01 ; 1
+ 682: 88 23 and r24, r24
+ 684: 29 f4 brne .+10 ; 0x690 <Usb2SerialTask+0x84>
{
break;
}
/* Dequeue the already sent byte from the buffer now we have confirmed that no transmission error occurred */
RingBuffer_Remove(&USARTtoUSB_Buffer);
- 59a: 8e ee ldi r24, 0xEE ; 238
- 59c: 91 e0 ldi r25, 0x01 ; 1
- 59e: 03 de rcall .-1018 ; 0x1a6 <RingBuffer_Remove>
+ 686: 86 ef ldi r24, 0xF6 ; 246
+ 688: 91 e0 ldi r25, 0x01 ; 1
+ 68a: 8d dd rcall .-1254 ; 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--)
- 5a0: 11 23 and r17, r17
- 5a2: 81 f7 brne .-32 ; 0x584 <Usb2SerialTask+0x62>
+ 68c: 11 23 and r17, r17
+ 68e: 81 f7 brne .-32 ; 0x670 <Usb2SerialTask+0x64>
static inline uint_reg_t GetGlobalInterruptMask(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
return SREG;
- 5a4: 2f b7 in r18, 0x3f ; 63
+ 690: 2f b7 in r18, 0x3f ; 63
static inline void GlobalInterruptDisable(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
cli();
- 5a6: f8 94 cli
+ 692: f8 94 cli
uint16_t Count;
uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
GlobalInterruptDisable();
Count = Buffer->Count;
- 5a8: 80 91 6c 01 lds r24, 0x016C
- 5ac: 90 91 6d 01 lds r25, 0x016D
+ 694: 80 91 74 01 lds r24, 0x0174
+ 698: 90 91 75 01 lds r25, 0x0175
static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
SREG = GlobalIntState;
- 5b0: 2f bf out 0x3f, r18 ; 63
+ 69c: 2f bf out 0x3f, r18 ; 63
}
}
}
/* Load the next byte from the USART transmit buffer into the USART */
if (!(RingBuffer_IsEmpty(&USBtoUSART_Buffer))) {
- 5b2: 00 97 sbiw r24, 0x00 ; 0
- 5b4: 49 f0 breq .+18 ; 0x5c8 <Usb2SerialTask+0xa6>
+ 69e: 00 97 sbiw r24, 0x00 ; 0
+ 6a0: 49 f0 breq .+18 ; 0x6b4 <Usb2SerialTask+0xa8>
Serial_SendByte(RingBuffer_Remove(&USBtoUSART_Buffer));
- 5b6: 82 e6 ldi r24, 0x62 ; 98
- 5b8: 91 e0 ldi r25, 0x01 ; 1
- 5ba: f5 dd rcall .-1046 ; 0x1a6 <RingBuffer_Remove>
+ 6a2: 8a e6 ldi r24, 0x6A ; 106
+ 6a4: 91 e0 ldi r25, 0x01 ; 1
+ 6a6: 7f dd rcall .-1282 ; 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)));
- 5bc: 90 91 c8 00 lds r25, 0x00C8
- 5c0: 95 ff sbrs r25, 5
- 5c2: fc cf rjmp .-8 ; 0x5bc <Usb2SerialTask+0x9a>
+ 6a8: 90 91 c8 00 lds r25, 0x00C8
+ 6ac: 95 ff sbrs r25, 5
+ 6ae: fc cf rjmp .-8 ; 0x6a8 <Usb2SerialTask+0x9c>
UDR1 = DataByte;
- 5c4: 80 93 ce 00 sts 0x00CE, r24
+ 6b0: 80 93 ce 00 sts 0x00CE, r24
// dummy = RingBuffer_Remove(&USBtoUSART_Buffer);
// sendPayload(&dummy,1,0);
}
CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
- 5c8: 85 e4 ldi r24, 0x45 ; 69
- 5ca: 91 e0 ldi r25, 0x01 ; 1
- 5cc: f8 d6 rcall .+3568 ; 0x13be <CDC_Device_USBTask>
+ 6b4: 85 e4 ldi r24, 0x45 ; 69
+ 6b6: 91 e0 ldi r25, 0x01 ; 1
+ 6b8: bc d7 rcall .+3960 ; 0x1632 <CDC_Device_USBTask>
USB_USBTask();
- 5ce: ae d5 rcall .+2908 ; 0x112c <USB_USBTask>
+ 6ba: 76 d6 rcall .+3308 ; 0x13a8 <USB_USBTask>
}
- 5d0: 1f 91 pop r17
- 5d2: 08 95 ret
+ 6bc: 1f 91 pop r17
+ 6be: 08 95 ret
-000005d4 <SetupHardware>:
+000006c0 <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);
- 5d4: 84 b7 in r24, 0x34 ; 52
- 5d6: 87 7f andi r24, 0xF7 ; 247
- 5d8: 84 bf out 0x34, r24 ; 52
+ 6c0: 84 b7 in r24, 0x34 ; 52
+ 6c2: 87 7f andi r24, 0xF7 ; 247
+ 6c4: 84 bf out 0x34, r24 ; 52
wdt_disable();
- 5da: 88 e1 ldi r24, 0x18 ; 24
- 5dc: 0f b6 in r0, 0x3f ; 63
- 5de: f8 94 cli
- 5e0: 80 93 60 00 sts 0x0060, r24
- 5e4: 10 92 60 00 sts 0x0060, r1
- 5e8: 0f be out 0x3f, r0 ; 63
+ 6c6: 88 e1 ldi r24, 0x18 ; 24
+ 6c8: 0f b6 in r0, 0x3f ; 63
+ 6ca: f8 94 cli
+ 6cc: 80 93 60 00 sts 0x0060, r24
+ 6d0: 10 92 60 00 sts 0x0060, r1
+ 6d4: 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__ (
- 5ea: 90 e0 ldi r25, 0x00 ; 0
- 5ec: 80 e8 ldi r24, 0x80 ; 128
- 5ee: 0f b6 in r0, 0x3f ; 63
- 5f0: f8 94 cli
- 5f2: 80 93 61 00 sts 0x0061, r24
- 5f6: 90 93 61 00 sts 0x0061, r25
- 5fa: 0f be out 0x3f, r0 ; 63
+ 6d6: 90 e0 ldi r25, 0x00 ; 0
+ 6d8: 80 e8 ldi r24, 0x80 ; 128
+ 6da: 0f b6 in r0, 0x3f ; 63
+ 6dc: f8 94 cli
+ 6de: 80 93 61 00 sts 0x0061, r24
+ 6e2: 90 93 61 00 sts 0x0061, r25
+ 6e6: 0f be out 0x3f, r0 ; 63
clock_prescale_set(clock_div_1);
/* Hardware Initialization */
// LEDs_Init();
USB_Init();
}
- 5fc: 82 c3 rjmp .+1796 ; 0xd02 <USB_Init>
+ 6e8: 0f c4 rjmp .+2078 ; 0xf08 <USB_Init>
-000005fe <EVENT_USB_Device_Connect>:
+000006ea <EVENT_USB_Device_Connect>:
/** Event handler for the library USB Connection event. */
void EVENT_USB_Device_Connect(void)
{
// LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
}
- 5fe: 08 95 ret
+ 6ea: 08 95 ret
-00000600 <EVENT_USB_Device_Disconnect>:
+000006ec <EVENT_USB_Device_Disconnect>:
/** Event handler for the library USB Disconnection event. */
void EVENT_USB_Device_Disconnect(void)
{
// LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
}
- 600: 08 95 ret
+ 6ec: 08 95 ret
-00000602 <EVENT_USB_Device_ConfigurationChanged>:
+000006ee <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);
- 602: 85 e4 ldi r24, 0x45 ; 69
- 604: 91 e0 ldi r25, 0x01 ; 1
+ 6ee: 85 e4 ldi r24, 0x45 ; 69
+ 6f0: 91 e0 ldi r25, 0x01 ; 1
// LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
}
- 606: 5b c6 rjmp .+3254 ; 0x12be <CDC_Device_ConfigureEndpoints>
+ 6f2: 21 c7 rjmp .+3650 ; 0x1536 <CDC_Device_ConfigureEndpoints>
-00000608 <EVENT_USB_Device_ControlRequest>:
+000006f4 <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);
- 608: 85 e4 ldi r24, 0x45 ; 69
- 60a: 91 e0 ldi r25, 0x01 ; 1
+ 6f4: 85 e4 ldi r24, 0x45 ; 69
+ 6f6: 91 e0 ldi r25, 0x01 ; 1
}
- 60c: ab c5 rjmp .+2902 ; 0x1164 <CDC_Device_ProcessControlRequest>
+ 6f8: 72 c6 rjmp .+3300 ; 0x13de <CDC_Device_ProcessControlRequest>
-0000060e <__vector_23>:
+000006fa <__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)
{
- 60e: 1f 92 push r1
- 610: 0f 92 push r0
- 612: 0f b6 in r0, 0x3f ; 63
- 614: 0f 92 push r0
- 616: 11 24 eor r1, r1
- 618: 2f 93 push r18
- 61a: 3f 93 push r19
- 61c: 4f 93 push r20
- 61e: 5f 93 push r21
- 620: 6f 93 push r22
- 622: 7f 93 push r23
- 624: 8f 93 push r24
- 626: 9f 93 push r25
- 628: af 93 push r26
- 62a: bf 93 push r27
- 62c: ef 93 push r30
- 62e: ff 93 push r31
+ 6fa: 1f 92 push r1
+ 6fc: 0f 92 push r0
+ 6fe: 0f b6 in r0, 0x3f ; 63
+ 700: 0f 92 push r0
+ 702: 11 24 eor r1, r1
+ 704: 2f 93 push r18
+ 706: 3f 93 push r19
+ 708: 4f 93 push r20
+ 70a: 5f 93 push r21
+ 70c: 6f 93 push r22
+ 70e: 7f 93 push r23
+ 710: 8f 93 push r24
+ 712: 9f 93 push r25
+ 714: af 93 push r26
+ 716: bf 93 push r27
+ 718: ef 93 push r30
+ 71a: ff 93 push r31
uint8_t ReceivedByte = UDR1;
- 630: 60 91 ce 00 lds r22, 0x00CE
+ 71c: 60 91 ce 00 lds r22, 0x00CE
if (USB_DeviceState == DEVICE_STATE_Configured)
- 634: 8e b3 in r24, 0x1e ; 30
- 636: 84 30 cpi r24, 0x04 ; 4
- 638: 19 f4 brne .+6 ; 0x640 <__vector_23+0x32>
+ 720: 8e b3 in r24, 0x1e ; 30
+ 722: 84 30 cpi r24, 0x04 ; 4
+ 724: 19 f4 brne .+6 ; 0x72c <__vector_23+0x32>
RingBuffer_Insert(&USARTtoUSB_Buffer, ReceivedByte);
- 63a: 8e ee ldi r24, 0xEE ; 238
- 63c: 91 e0 ldi r25, 0x01 ; 1
- 63e: 98 dd rcall .-1232 ; 0x170 <RingBuffer_Insert>
+ 726: 86 ef ldi r24, 0xF6 ; 246
+ 728: 91 e0 ldi r25, 0x01 ; 1
+ 72a: 22 dd rcall .-1468 ; 0x170 <RingBuffer_Insert>
}
- 640: ff 91 pop r31
- 642: ef 91 pop r30
- 644: bf 91 pop r27
- 646: af 91 pop r26
- 648: 9f 91 pop r25
- 64a: 8f 91 pop r24
- 64c: 7f 91 pop r23
- 64e: 6f 91 pop r22
- 650: 5f 91 pop r21
- 652: 4f 91 pop r20
- 654: 3f 91 pop r19
- 656: 2f 91 pop r18
- 658: 0f 90 pop r0
- 65a: 0f be out 0x3f, r0 ; 63
- 65c: 0f 90 pop r0
- 65e: 1f 90 pop r1
- 660: 18 95 reti
-
-00000662 <EVENT_CDC_Device_LineEncodingChanged>:
+ 72c: ff 91 pop r31
+ 72e: ef 91 pop r30
+ 730: bf 91 pop r27
+ 732: af 91 pop r26
+ 734: 9f 91 pop r25
+ 736: 8f 91 pop r24
+ 738: 7f 91 pop r23
+ 73a: 6f 91 pop r22
+ 73c: 5f 91 pop r21
+ 73e: 4f 91 pop r20
+ 740: 3f 91 pop r19
+ 742: 2f 91 pop r18
+ 744: 0f 90 pop r0
+ 746: 0f be out 0x3f, r0 ; 63
+ 748: 0f 90 pop r0
+ 74a: 1f 90 pop r1
+ 74c: 18 95 reti
+
+0000074e <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)
{
- 662: 8f 92 push r8
- 664: 9f 92 push r9
- 666: af 92 push r10
- 668: bf 92 push r11
- 66a: cf 92 push r12
- 66c: df 92 push r13
- 66e: ef 92 push r14
- 670: ff 92 push r15
- 672: 1f 93 push r17
- 674: fc 01 movw r30, r24
+ 74e: 8f 92 push r8
+ 750: 9f 92 push r9
+ 752: af 92 push r10
+ 754: bf 92 push r11
+ 756: cf 92 push r12
+ 758: df 92 push r13
+ 75a: ef 92 push r14
+ 75c: ff 92 push r15
+ 75e: 1f 93 push r17
+ 760: fc 01 movw r30, r24
uint8_t ConfigMask = 0;
switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
- 676: a1 8d ldd r26, Z+25 ; 0x19
- 678: a1 50 subi r26, 0x01 ; 1
- 67a: a2 30 cpi r26, 0x02 ; 2
- 67c: 28 f4 brcc .+10 ; 0x688 <EVENT_CDC_Device_LineEncodingChanged+0x26>
- 67e: b0 e0 ldi r27, 0x00 ; 0
- 680: a0 5a subi r26, 0xA0 ; 160
- 682: be 4f sbci r27, 0xFE ; 254
- 684: 1c 91 ld r17, X
- 686: 01 c0 rjmp .+2 ; 0x68a <EVENT_CDC_Device_LineEncodingChanged+0x28>
- 688: 10 e0 ldi r17, 0x00 ; 0
+ 762: a1 8d ldd r26, Z+25 ; 0x19
+ 764: a1 50 subi r26, 0x01 ; 1
+ 766: a2 30 cpi r26, 0x02 ; 2
+ 768: 28 f4 brcc .+10 ; 0x774 <EVENT_CDC_Device_LineEncodingChanged+0x26>
+ 76a: b0 e0 ldi r27, 0x00 ; 0
+ 76c: ac 59 subi r26, 0x9C ; 156
+ 76e: be 4f sbci r27, 0xFE ; 254
+ 770: 1c 91 ld r17, X
+ 772: 01 c0 rjmp .+2 ; 0x776 <EVENT_CDC_Device_LineEncodingChanged+0x28>
+ 774: 10 e0 ldi r17, 0x00 ; 0
case CDC_PARITY_Even:
ConfigMask = (1 << UPM11);
break;
}
if (CDCInterfaceInfo->State.LineEncoding.CharFormat == CDC_LINEENCODING_TwoStopBits)
- 68a: 80 8d ldd r24, Z+24 ; 0x18
- 68c: 82 30 cpi r24, 0x02 ; 2
- 68e: 09 f4 brne .+2 ; 0x692 <EVENT_CDC_Device_LineEncodingChanged+0x30>
+ 776: 80 8d ldd r24, Z+24 ; 0x18
+ 778: 82 30 cpi r24, 0x02 ; 2
+ 77a: 09 f4 brne .+2 ; 0x77e <EVENT_CDC_Device_LineEncodingChanged+0x30>
ConfigMask |= (1 << USBS1);
- 690: 18 60 ori r17, 0x08 ; 8
+ 77c: 18 60 ori r17, 0x08 ; 8
switch (CDCInterfaceInfo->State.LineEncoding.DataBits)
- 692: 82 8d ldd r24, Z+26 ; 0x1a
- 694: 87 30 cpi r24, 0x07 ; 7
- 696: 31 f0 breq .+12 ; 0x6a4 <EVENT_CDC_Device_LineEncodingChanged+0x42>
- 698: 88 30 cpi r24, 0x08 ; 8
- 69a: 31 f0 breq .+12 ; 0x6a8 <EVENT_CDC_Device_LineEncodingChanged+0x46>
- 69c: 86 30 cpi r24, 0x06 ; 6
- 69e: 29 f4 brne .+10 ; 0x6aa <EVENT_CDC_Device_LineEncodingChanged+0x48>
+ 77e: 82 8d ldd r24, Z+26 ; 0x1a
+ 780: 87 30 cpi r24, 0x07 ; 7
+ 782: 31 f0 breq .+12 ; 0x790 <EVENT_CDC_Device_LineEncodingChanged+0x42>
+ 784: 88 30 cpi r24, 0x08 ; 8
+ 786: 31 f0 breq .+12 ; 0x794 <EVENT_CDC_Device_LineEncodingChanged+0x46>
+ 788: 86 30 cpi r24, 0x06 ; 6
+ 78a: 29 f4 brne .+10 ; 0x796 <EVENT_CDC_Device_LineEncodingChanged+0x48>
{
case 6:
ConfigMask |= (1 << UCSZ10);
- 6a0: 12 60 ori r17, 0x02 ; 2
+ 78c: 12 60 ori r17, 0x02 ; 2
break;
- 6a2: 03 c0 rjmp .+6 ; 0x6aa <EVENT_CDC_Device_LineEncodingChanged+0x48>
+ 78e: 03 c0 rjmp .+6 ; 0x796 <EVENT_CDC_Device_LineEncodingChanged+0x48>
case 7:
ConfigMask |= (1 << UCSZ11);
- 6a4: 14 60 ori r17, 0x04 ; 4
+ 790: 14 60 ori r17, 0x04 ; 4
break;
- 6a6: 01 c0 rjmp .+2 ; 0x6aa <EVENT_CDC_Device_LineEncodingChanged+0x48>
+ 792: 01 c0 rjmp .+2 ; 0x796 <EVENT_CDC_Device_LineEncodingChanged+0x48>
case 8:
ConfigMask |= ((1 << UCSZ11) | (1 << UCSZ10));
- 6a8: 16 60 ori r17, 0x06 ; 6
+ 794: 16 60 ori r17, 0x06 ; 6
break;
}
/* Must turn off USART before reconfiguring it, otherwise incorrect operation may occur */
UCSR1B = 0;
- 6aa: 10 92 c9 00 sts 0x00C9, r1
+ 796: 10 92 c9 00 sts 0x00C9, r1
UCSR1A = 0;
- 6ae: 10 92 c8 00 sts 0x00C8, r1
+ 79a: 10 92 c8 00 sts 0x00C8, r1
UCSR1C = 0;
- 6b2: 10 92 ca 00 sts 0x00CA, r1
+ 79e: 10 92 ca 00 sts 0x00CA, r1
/* Set the new baud rate before configuring the USART */
UBRR1 = SERIAL_2X_UBBRVAL(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
- 6b6: c4 88 ldd r12, Z+20 ; 0x14
- 6b8: d5 88 ldd r13, Z+21 ; 0x15
- 6ba: e6 88 ldd r14, Z+22 ; 0x16
- 6bc: f7 88 ldd r15, Z+23 ; 0x17
- 6be: c7 01 movw r24, r14
- 6c0: b6 01 movw r22, r12
- 6c2: 96 95 lsr r25
- 6c4: 87 95 ror r24
- 6c6: 77 95 ror r23
- 6c8: 67 95 ror r22
- 6ca: bd d7 rcall .+3962 ; 0x1646 <__floatunsisf>
- 6cc: 20 e0 ldi r18, 0x00 ; 0
- 6ce: 34 e2 ldi r19, 0x24 ; 36
- 6d0: 44 ef ldi r20, 0xF4 ; 244
- 6d2: 59 e4 ldi r21, 0x49 ; 73
- 6d4: bc d6 rcall .+3448 ; 0x144e <__addsf3>
- 6d6: 4b 01 movw r8, r22
- 6d8: 5c 01 movw r10, r24
- 6da: c7 01 movw r24, r14
- 6dc: b6 01 movw r22, r12
- 6de: b3 d7 rcall .+3942 ; 0x1646 <__floatunsisf>
- 6e0: 9b 01 movw r18, r22
- 6e2: ac 01 movw r20, r24
- 6e4: c5 01 movw r24, r10
- 6e6: b4 01 movw r22, r8
- 6e8: 1a d7 rcall .+3636 ; 0x151e <__divsf3>
- 6ea: 20 e0 ldi r18, 0x00 ; 0
- 6ec: 30 e0 ldi r19, 0x00 ; 0
- 6ee: 40 e8 ldi r20, 0x80 ; 128
- 6f0: 5f e3 ldi r21, 0x3F ; 63
- 6f2: ac d6 rcall .+3416 ; 0x144c <__subsf3>
- 6f4: 7c d7 rcall .+3832 ; 0x15ee <__fixunssfsi>
- 6f6: 70 93 cd 00 sts 0x00CD, r23
- 6fa: 60 93 cc 00 sts 0x00CC, r22
+ 7a2: c4 88 ldd r12, Z+20 ; 0x14
+ 7a4: d5 88 ldd r13, Z+21 ; 0x15
+ 7a6: e6 88 ldd r14, Z+22 ; 0x16
+ 7a8: f7 88 ldd r15, Z+23 ; 0x17
+ 7aa: c7 01 movw r24, r14
+ 7ac: b6 01 movw r22, r12
+ 7ae: 96 95 lsr r25
+ 7b0: 87 95 ror r24
+ 7b2: 77 95 ror r23
+ 7b4: 67 95 ror r22
+ 7b6: 0e 94 5b 0c call 0x18b6 ; 0x18b6 <__floatunsisf>
+ 7ba: 20 e0 ldi r18, 0x00 ; 0
+ 7bc: 34 e2 ldi r19, 0x24 ; 36
+ 7be: 44 ef ldi r20, 0xF4 ; 244
+ 7c0: 59 e4 ldi r21, 0x49 ; 73
+ 7c2: 7d d7 rcall .+3834 ; 0x16be <__addsf3>
+ 7c4: 4b 01 movw r8, r22
+ 7c6: 5c 01 movw r10, r24
+ 7c8: c7 01 movw r24, r14
+ 7ca: b6 01 movw r22, r12
+ 7cc: 0e 94 5b 0c call 0x18b6 ; 0x18b6 <__floatunsisf>
+ 7d0: 9b 01 movw r18, r22
+ 7d2: ac 01 movw r20, r24
+ 7d4: c5 01 movw r24, r10
+ 7d6: b4 01 movw r22, r8
+ 7d8: da d7 rcall .+4020 ; 0x178e <__divsf3>
+ 7da: 20 e0 ldi r18, 0x00 ; 0
+ 7dc: 30 e0 ldi r19, 0x00 ; 0
+ 7de: 40 e8 ldi r20, 0x80 ; 128
+ 7e0: 5f e3 ldi r21, 0x3F ; 63
+ 7e2: 6c d7 rcall .+3800 ; 0x16bc <__subsf3>
+ 7e4: 0e 94 2f 0c call 0x185e ; 0x185e <__fixunssfsi>
+ 7e8: 70 93 cd 00 sts 0x00CD, r23
+ 7ec: 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;
- 6fe: 10 93 ca 00 sts 0x00CA, r17
+ 7f0: 10 93 ca 00 sts 0x00CA, r17
UCSR1A = (1 << U2X1);
- 702: 82 e0 ldi r24, 0x02 ; 2
- 704: 80 93 c8 00 sts 0x00C8, r24
+ 7f4: 82 e0 ldi r24, 0x02 ; 2
+ 7f6: 80 93 c8 00 sts 0x00C8, r24
UCSR1B = ((1 << RXCIE1) | (1 << TXEN1) | (1 << RXEN1));
- 708: 88 e9 ldi r24, 0x98 ; 152
- 70a: 80 93 c9 00 sts 0x00C9, r24
+ 7fa: 88 e9 ldi r24, 0x98 ; 152
+ 7fc: 80 93 c9 00 sts 0x00C9, r24
}
- 70e: 1f 91 pop r17
- 710: ff 90 pop r15
- 712: ef 90 pop r14
- 714: df 90 pop r13
- 716: cf 90 pop r12
- 718: bf 90 pop r11
- 71a: af 90 pop r10
- 71c: 9f 90 pop r9
- 71e: 8f 90 pop r8
- 720: 08 95 ret
+ 800: 1f 91 pop r17
+ 802: ff 90 pop r15
+ 804: ef 90 pop r14
+ 806: df 90 pop r13
+ 808: cf 90 pop r12
+ 80a: bf 90 pop r11
+ 80c: af 90 pop r10
+ 80e: 9f 90 pop r9
+ 810: 8f 90 pop r8
+ 812: 08 95 ret
-00000722 <uart_putc>:
+00000814 <uart_putc>:
void uart_putc(unsigned char data)
{
- 722: 68 2f mov r22, r24
+ 814: 68 2f mov r22, r24
if (USB_DeviceState == DEVICE_STATE_Configured){
- 724: 8e b3 in r24, 0x1e ; 30
- 726: 84 30 cpi r24, 0x04 ; 4
- 728: 19 f4 brne .+6 ; 0x730 <uart_putc+0xe>
+ 816: 8e b3 in r24, 0x1e ; 30
+ 818: 84 30 cpi r24, 0x04 ; 4
+ 81a: 19 f4 brne .+6 ; 0x822 <uart_putc+0xe>
RingBuffer_Insert(&USARTtoUSB_Buffer, data);
- 72a: 8e ee ldi r24, 0xEE ; 238
- 72c: 91 e0 ldi r25, 0x01 ; 1
- 72e: 20 cd rjmp .-1472 ; 0x170 <RingBuffer_Insert>
- 730: 08 95 ret
+ 81c: 86 ef ldi r24, 0xF6 ; 246
+ 81e: 91 e0 ldi r25, 0x01 ; 1
+ 820: a7 cc rjmp .-1714 ; 0x170 <RingBuffer_Insert>
+ 822: 08 95 ret
-00000732 <uart_puts>:
+00000824 <uart_puts>:
}
}
void uart_puts(const char *s )
{
- 732: ef 92 push r14
- 734: ff 92 push r15
- 736: cf 93 push r28
- 738: df 93 push r29
- 73a: e8 2e mov r14, r24
- 73c: e7 01 movw r28, r14
- 73e: 7e 01 movw r14, r28
- 740: f9 2e mov r15, r25
- 742: e7 01 movw r28, r14
+ 824: ef 92 push r14
+ 826: ff 92 push r15
+ 828: cf 93 push r28
+ 82a: df 93 push r29
+ 82c: e8 2e mov r14, r24
+ 82e: e7 01 movw r28, r14
+ 830: 7e 01 movw r14, r28
+ 832: f9 2e mov r15, r25
+ 834: e7 01 movw r28, r14
while (*s)
- 744: 01 c0 rjmp .+2 ; 0x748 <uart_puts+0x16>
+ 836: 01 c0 rjmp .+2 ; 0x83a <uart_puts+0x16>
uart_putc(*s++);
- 746: ed df rcall .-38 ; 0x722 <uart_putc>
+ 838: ed df rcall .-38 ; 0x814 <uart_putc>
}
void uart_puts(const char *s )
{
while (*s)
- 748: 89 91 ld r24, Y+
- 74a: 88 23 and r24, r24
- 74c: e1 f7 brne .-8 ; 0x746 <uart_puts+0x14>
+ 83a: 89 91 ld r24, Y+
+ 83c: 88 23 and r24, r24
+ 83e: e1 f7 brne .-8 ; 0x838 <uart_puts+0x14>
uart_putc(*s++);
}/* uart_puts */
- 74e: df 91 pop r29
- 750: cf 91 pop r28
- 752: ff 90 pop r15
- 754: ef 90 pop r14
- 756: 08 95 ret
+ 840: df 91 pop r29
+ 842: cf 91 pop r28
+ 844: ff 90 pop r15
+ 846: ef 90 pop r14
+ 848: 08 95 ret
-00000758 <my_uitoa>:
+0000084a <my_uitoa>:
// convert an unsigned integer to string
void my_uitoa(uint32_t zahl, char* string, uint8_t no_digits) {
- 758: 2f 92 push r2
- 75a: 3f 92 push r3
- 75c: 4f 92 push r4
- 75e: 5f 92 push r5
- 760: 6f 92 push r6
- 762: 7f 92 push r7
- 764: 8f 92 push r8
- 766: 9f 92 push r9
- 768: af 92 push r10
- 76a: bf 92 push r11
- 76c: cf 92 push r12
- 76e: df 92 push r13
- 770: ef 92 push r14
- 772: ff 92 push r15
- 774: 0f 93 push r16
- 776: 1f 93 push r17
- 778: cf 93 push r28
- 77a: df 93 push r29
- 77c: 7b 01 movw r14, r22
- 77e: 8c 01 movw r16, r24
+ 84a: 2f 92 push r2
+ 84c: 3f 92 push r3
+ 84e: 4f 92 push r4
+ 850: 5f 92 push r5
+ 852: 6f 92 push r6
+ 854: 7f 92 push r7
+ 856: 8f 92 push r8
+ 858: 9f 92 push r9
+ 85a: af 92 push r10
+ 85c: bf 92 push r11
+ 85e: cf 92 push r12
+ 860: df 92 push r13
+ 862: ef 92 push r14
+ 864: ff 92 push r15
+ 866: 0f 93 push r16
+ 868: 1f 93 push r17
+ 86a: cf 93 push r28
+ 86c: df 93 push r29
+ 86e: 7b 01 movw r14, r22
+ 870: 8c 01 movw r16, r24
int8_t i; // schleifenzähler
string[no_digits] = '\0'; // String Terminator
- 780: 82 2f mov r24, r18
- 782: 90 e0 ldi r25, 0x00 ; 0
- 784: fa 01 movw r30, r20
- 786: e8 0f add r30, r24
- 788: f9 1f adc r31, r25
- 78a: 10 82 st Z, r1
+ 872: 82 2f mov r24, r18
+ 874: 90 e0 ldi r25, 0x00 ; 0
+ 876: fa 01 movw r30, r20
+ 878: e8 0f add r30, r24
+ 87a: f9 1f adc r31, r25
+ 87c: 10 82 st Z, r1
for (i = (no_digits - 1); i >= 0; i--) {
- 78c: d2 2e mov r13, r18
- 78e: da 94 dec r13
+ 87e: d2 2e mov r13, r18
+ 880: da 94 dec r13
}/* uart_puts */
// convert an unsigned integer to string
void my_uitoa(uint32_t zahl, char* string, uint8_t no_digits) {
- 790: 4d 2c mov r4, r13
- 792: 55 24 eor r5, r5
- 794: 47 fc sbrc r4, 7
- 796: 50 94 com r5
- 798: ea 01 movw r28, r20
- 79a: c4 0d add r28, r4
- 79c: d5 1d adc r29, r5
+ 882: 4d 2c mov r4, r13
+ 884: 55 24 eor r5, r5
+ 886: 47 fc sbrc r4, 7
+ 888: 50 94 com r5
+ 88a: ea 01 movw r28, r20
+ 88c: c4 0d add r28, r4
+ 88e: d5 1d adc r29, r5
int8_t i; // schleifenzähler
string[no_digits] = '\0'; // String Terminator
for (i = (no_digits - 1); i >= 0; i--) {
- 79e: aa 24 eor r10, r10
- 7a0: bb 24 eor r11, r11
+ 890: aa 24 eor r10, r10
+ 892: bb 24 eor r11, r11
if (zahl == 0 && i < (no_digits - 1)) {
string[i] = ' ';
} else {
string[i] = (zahl % 10) + '0';
- 7a2: ba e0 ldi r27, 0x0A ; 10
- 7a4: 6b 2e mov r6, r27
- 7a6: 71 2c mov r7, r1
- 7a8: 81 2c mov r8, r1
- 7aa: 91 2c mov r9, r1
+ 894: aa e0 ldi r26, 0x0A ; 10
+ 896: 6a 2e mov r6, r26
+ 898: 71 2c mov r7, r1
+ 89a: 81 2c mov r8, r1
+ 89c: 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)) {
- 7ac: 1c 01 movw r2, r24
- 7ae: 08 94 sec
- 7b0: 21 08 sbc r2, r1
- 7b2: 31 08 sbc r3, r1
+ 89e: 1c 01 movw r2, r24
+ 8a0: 08 94 sec
+ 8a2: 21 08 sbc r2, r1
+ 8a4: 31 08 sbc r3, r1
string[i] = ' ';
- 7b4: a0 e2 ldi r26, 0x20 ; 32
- 7b6: ca 2e mov r12, r26
+ 8a6: f0 e2 ldi r31, 0x20 ; 32
+ 8a8: cf 2e mov r12, r31
// 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--) {
- 7b8: 20 c0 rjmp .+64 ; 0x7fa <my_uitoa+0xa2>
+ 8aa: 22 c0 rjmp .+68 ; 0x8f0 <my_uitoa+0xa6>
if (zahl == 0 && i < (no_digits - 1)) {
- 7ba: e1 14 cp r14, r1
- 7bc: f1 04 cpc r15, r1
- 7be: 01 05 cpc r16, r1
- 7c0: 11 05 cpc r17, r1
- 7c2: 41 f4 brne .+16 ; 0x7d4 <my_uitoa+0x7c>
+ 8ac: e1 14 cp r14, r1
+ 8ae: f1 04 cpc r15, r1
+ 8b0: 01 05 cpc r16, r1
+ 8b2: 11 05 cpc r17, r1
+ 8b4: 41 f4 brne .+16 ; 0x8c6 <my_uitoa+0x7c>
}/* uart_puts */
// convert an unsigned integer to string
void my_uitoa(uint32_t zahl, char* string, uint8_t no_digits) {
- 7c4: c5 01 movw r24, r10
- 7c6: 84 0d add r24, r4
- 7c8: 95 1d adc r25, r5
+ 8b6: c5 01 movw r24, r10
+ 8b8: 84 0d add r24, r4
+ 8ba: 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)) {
- 7ca: 82 15 cp r24, r2
- 7cc: 93 05 cpc r25, r3
- 7ce: 14 f4 brge .+4 ; 0x7d4 <my_uitoa+0x7c>
+ 8bc: 82 15 cp r24, r2
+ 8be: 93 05 cpc r25, r3
+ 8c0: 14 f4 brge .+4 ; 0x8c6 <my_uitoa+0x7c>
string[i] = ' ';
- 7d0: c8 82 st Y, r12
- 7d2: 07 c0 rjmp .+14 ; 0x7e2 <my_uitoa+0x8a>
+ 8c2: c8 82 st Y, r12
+ 8c4: 08 c0 rjmp .+16 ; 0x8d6 <my_uitoa+0x8c>
} else {
string[i] = (zahl % 10) + '0';
- 7d4: c8 01 movw r24, r16
- 7d6: b7 01 movw r22, r14
- 7d8: a4 01 movw r20, r8
- 7da: 93 01 movw r18, r6
- 7dc: ea d7 rcall .+4052 ; 0x17b2 <__udivmodsi4>
- 7de: 60 5d subi r22, 0xD0 ; 208
- 7e0: 68 83 st Y, r22
+ 8c6: c8 01 movw r24, r16
+ 8c8: b7 01 movw r22, r14
+ 8ca: a4 01 movw r20, r8
+ 8cc: 93 01 movw r18, r6
+ 8ce: 0e 94 38 0d call 0x1a70 ; 0x1a70 <__udivmodsi4>
+ 8d2: 60 5d subi r22, 0xD0 ; 208
+ 8d4: 68 83 st Y, r22
} // Modulo rechnen, dann den ASCII-Code von '0' addieren
zahl /= 10;
- 7e2: c8 01 movw r24, r16
- 7e4: b7 01 movw r22, r14
- 7e6: a4 01 movw r20, r8
- 7e8: 93 01 movw r18, r6
- 7ea: e3 d7 rcall .+4038 ; 0x17b2 <__udivmodsi4>
- 7ec: 79 01 movw r14, r18
- 7ee: 8a 01 movw r16, r20
+ 8d6: c8 01 movw r24, r16
+ 8d8: b7 01 movw r22, r14
+ 8da: a4 01 movw r20, r8
+ 8dc: 93 01 movw r18, r6
+ 8de: 0e 94 38 0d call 0x1a70 ; 0x1a70 <__udivmodsi4>
+ 8e2: 79 01 movw r14, r18
+ 8e4: 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--) {
- 7f0: da 94 dec r13
- 7f2: 21 97 sbiw r28, 0x01 ; 1
- 7f4: 08 94 sec
- 7f6: a1 08 sbc r10, r1
- 7f8: b1 08 sbc r11, r1
- 7fa: d7 fe sbrs r13, 7
- 7fc: de cf rjmp .-68 ; 0x7ba <my_uitoa+0x62>
+ 8e6: da 94 dec r13
+ 8e8: 21 97 sbiw r28, 0x01 ; 1
+ 8ea: 08 94 sec
+ 8ec: a1 08 sbc r10, r1
+ 8ee: b1 08 sbc r11, r1
+ 8f0: d7 fe sbrs r13, 7
+ 8f2: dc cf rjmp .-72 ; 0x8ac <my_uitoa+0x62>
string[i] = (zahl % 10) + '0';
} // Modulo rechnen, dann den ASCII-Code von '0' addieren
zahl /= 10;
}
}
- 7fe: df 91 pop r29
- 800: cf 91 pop r28
- 802: 1f 91 pop r17
- 804: 0f 91 pop r16
- 806: ff 90 pop r15
- 808: ef 90 pop r14
- 80a: df 90 pop r13
- 80c: cf 90 pop r12
- 80e: bf 90 pop r11
- 810: af 90 pop r10
- 812: 9f 90 pop r9
- 814: 8f 90 pop r8
- 816: 7f 90 pop r7
- 818: 6f 90 pop r6
- 81a: 5f 90 pop r5
- 81c: 4f 90 pop r4
- 81e: 3f 90 pop r3
- 820: 2f 90 pop r2
- 822: 08 95 ret
+ 8f4: df 91 pop r29
+ 8f6: cf 91 pop r28
+ 8f8: 1f 91 pop r17
+ 8fa: 0f 91 pop r16
+ 8fc: ff 90 pop r15
+ 8fe: ef 90 pop r14
+ 900: df 90 pop r13
+ 902: cf 90 pop r12
+ 904: bf 90 pop r11
+ 906: af 90 pop r10
+ 908: 9f 90 pop r9
+ 90a: 8f 90 pop r8
+ 90c: 7f 90 pop r7
+ 90e: 6f 90 pop r6
+ 910: 5f 90 pop r5
+ 912: 4f 90 pop r4
+ 914: 3f 90 pop r3
+ 916: 2f 90 pop r2
+ 918: 08 95 ret
+
+0000091a <init_motors>:
+ PORTY2 |= ((byte & (1<<2))>>2)<<Y2;
+ PORTY3 |= ((byte & (1<<3))>>3)<<Y3;
+}
+
+void init_motors(void){
+ set_x(0);
+ 91a: 80 e0 ldi r24, 0x00 ; 0
+ 91c: 5d dc rcall .-1862 ; 0x1d8 <set_x>
+ set_y(0);
+ 91e: 80 e0 ldi r24, 0x00 ; 0
+ 920: 96 dc rcall .-1748 ; 0x24e <set_y>
+ DDRX0 |= (1<<X0);
+ 922: 22 9a sbi 0x04, 2 ; 4
+ DDRX1 |= (1<<X1);
+ 924: 23 9a sbi 0x04, 3 ; 4
+ DDRX2 |= (1<<X2);
+ 926: 24 9a sbi 0x04, 4 ; 4
+ DDRX3 |= (1<<X3);
+ 928: 25 9a sbi 0x04, 5 ; 4
+ DDRY0 |= (1<<Y0);
+ 92a: 27 9a sbi 0x04, 7 ; 4
+ DDRY1 |= (1<<Y1);
+ 92c: 26 9a sbi 0x04, 6 ; 4
+ DDRY2 |= (1<<Y2);
+ 92e: 3f 9a sbi 0x07, 7 ; 7
+ DDRY3 |= (1<<Y3);
+ 930: 3e 9a sbi 0x07, 6 ; 7
+}
+ 932: 08 95 ret
+
+00000934 <motor_step>:
+
+
+
+uint8_t motor_step(uint8_t motor, int8_t direction) { // motor: M1 or M2, direction +1 or -1, 0 for coil deactivation
+ 934: 0f 93 push r16
+ 936: 1f 93 push r17
+ 938: 16 2f mov r17, r22
+ 93a: 82 30 cpi r24, 0x02 ; 2
+ 93c: 50 f4 brcc .+20 ; 0x952 <motor_step+0x1e>
+ 93e: a8 2f mov r26, r24
+ 940: b0 e0 ldi r27, 0x00 ; 0
+ 942: aa 0f add r26, r26
+ 944: bb 1f adc r27, r27
+ 946: aa 59 subi r26, 0x9A ; 154
+ 948: be 4f sbci r27, 0xFE ; 254
+ 94a: 2d 91 ld r18, X+
+ 94c: 3c 91 ld r19, X
+ 94e: 11 97 sbiw r26, 0x01 ; 1
+ 950: 02 c0 rjmp .+4 ; 0x956 <motor_step+0x22>
+ 952: 2c ee ldi r18, 0xEC ; 236
+ 954: 30 e0 ldi r19, 0x00 ; 0
+ case Y:
+ setport = &set_y;
+ break;
+ }
+
+ next_phase = (phase_memory[motor] + 4 + direction) % 4;
+ 956: e8 2f mov r30, r24
+ 958: f0 e0 ldi r31, 0x00 ; 0
+ 95a: 81 2f mov r24, r17
+ 95c: 99 27 eor r25, r25
+ 95e: 87 fd sbrc r24, 7
+ 960: 90 95 com r25
+ 962: 04 96 adiw r24, 0x04 ; 4
+ 964: ea 57 subi r30, 0x7A ; 122
+ 966: fd 4f sbci r31, 0xFD ; 253
+ 968: 40 81 ld r20, Z
+ 96a: 84 0f add r24, r20
+ 96c: 91 1d adc r25, r1
+ 96e: 64 e0 ldi r22, 0x04 ; 4
+ 970: 70 e0 ldi r23, 0x00 ; 0
+ 972: 0e 94 25 0d call 0x1a4a ; 0x1a4a <__divmodhi4>
+ phase_memory[motor] = next_phase;
+ 976: 80 83 st Z, r24
+
+
+ next_pattern = phase_pattern[next_phase];
+ 978: e8 2f mov r30, r24
+ 97a: f0 e0 ldi r31, 0x00 ; 0
+ 97c: e0 5a subi r30, 0xA0 ; 160
+ 97e: fe 4f sbci r31, 0xFE ; 254
+ 980: 00 81 ld r16, Z
+ if (direction != 0) {
+ 982: 11 23 and r17, r17
+ 984: 11 f0 breq .+4 ; 0x98a <motor_step+0x56>
+ (*setport)(next_pattern);
+ 986: 80 2f mov r24, r16
+ 988: 01 c0 rjmp .+2 ; 0x98c <motor_step+0x58>
+ } else {
+ (*setport)(0);
+ 98a: 80 e0 ldi r24, 0x00 ; 0
+ 98c: f9 01 movw r30, r18
+ 98e: 09 95 icall
+ }
+
+ return next_pattern;
+
+}
+ 990: 80 2f mov r24, r16
+ 992: 1f 91 pop r17
+ 994: 0f 91 pop r16
+ 996: 08 95 ret
+
+00000998 <sign>:
+
+int8_t sign(int16_t x) {
+ return (x > 0) - (x < 0);
+ 998: 21 e0 ldi r18, 0x01 ; 1
+ 99a: 18 16 cp r1, r24
+ 99c: 19 06 cpc r1, r25
+ 99e: 0c f0 brlt .+2 ; 0x9a2 <sign+0xa>
+ 9a0: 20 e0 ldi r18, 0x00 ; 0
+ 9a2: 89 2f mov r24, r25
+ 9a4: 88 1f adc r24, r24
+ 9a6: 88 27 eor r24, r24
+ 9a8: 88 1f adc r24, r24
+}
+ 9aa: 28 1b sub r18, r24
+ 9ac: 82 2f mov r24, r18
+ 9ae: 08 95 ret
+
+000009b0 <move_plate>:
+
+void move_plate(int16_t dx, int16_t dy){
+ 9b0: 1f 93 push r17
+ static int16_t todo_x,todo_y = 0;
+ int8_t signum;
+ todo_x += dx;
+ 9b2: 20 91 84 02 lds r18, 0x0284
+ 9b6: 30 91 85 02 lds r19, 0x0285
+ 9ba: 28 0f add r18, r24
+ 9bc: 39 1f adc r19, r25
+ 9be: 30 93 85 02 sts 0x0285, r19
+ 9c2: 20 93 84 02 sts 0x0284, r18
+ todo_y += dy;
+ 9c6: 80 91 82 02 lds r24, 0x0282
+ 9ca: 90 91 83 02 lds r25, 0x0283
+ 9ce: 86 0f add r24, r22
+ 9d0: 97 1f adc r25, r23
+ 9d2: 90 93 83 02 sts 0x0283, r25
+ 9d6: 80 93 82 02 sts 0x0282, r24
+
+ signum = sign(todo_x);
+ 9da: c9 01 movw r24, r18
+ 9dc: dd df rcall .-70 ; 0x998 <sign>
+ 9de: 18 2f mov r17, r24
+ motor_step(X,signum);
+ 9e0: 80 e0 ldi r24, 0x00 ; 0
+ 9e2: 61 2f mov r22, r17
+ 9e4: a7 df rcall .-178 ; 0x934 <motor_step>
+ todo_x -= signum;
+ 9e6: 81 2f mov r24, r17
+ 9e8: 99 27 eor r25, r25
+ 9ea: 87 fd sbrc r24, 7
+ 9ec: 90 95 com r25
+ 9ee: 20 91 84 02 lds r18, 0x0284
+ 9f2: 30 91 85 02 lds r19, 0x0285
+ 9f6: 28 1b sub r18, r24
+ 9f8: 39 0b sbc r19, r25
+ 9fa: 30 93 85 02 sts 0x0285, r19
+ 9fe: 20 93 84 02 sts 0x0284, r18
+
+ signum = sign(todo_y);
+ a02: 80 91 82 02 lds r24, 0x0282
+ a06: 90 91 83 02 lds r25, 0x0283
+ a0a: c6 df rcall .-116 ; 0x998 <sign>
+ a0c: 18 2f mov r17, r24
+ motor_step(Y,signum);
+ a0e: 81 e0 ldi r24, 0x01 ; 1
+ a10: 61 2f mov r22, r17
+ a12: 90 df rcall .-224 ; 0x934 <motor_step>
+ todo_y -= signum;
+ a14: 81 2f mov r24, r17
+ a16: 99 27 eor r25, r25
+ a18: 87 fd sbrc r24, 7
+ a1a: 90 95 com r25
+ a1c: 20 91 82 02 lds r18, 0x0282
+ a20: 30 91 83 02 lds r19, 0x0283
+ a24: 28 1b sub r18, r24
+ a26: 39 0b sbc r19, r25
+ a28: 30 93 83 02 sts 0x0283, r19
+ a2c: 20 93 82 02 sts 0x0282, r18
+
+
+}
+ a30: 1f 91 pop r17
+ a32: 08 95 ret
+
+00000a34 <main>:
+
+
-00000824 <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)
{
- 824: cf 92 push r12
- 826: df 92 push r13
- 828: ef 92 push r14
- 82a: ff 92 push r15
- 82c: 0f 93 push r16
- 82e: 1f 93 push r17
- 830: df 93 push r29
- 832: cf 93 push r28
- 834: cd b7 in r28, 0x3d ; 61
- 836: de b7 in r29, 0x3e ; 62
- 838: 60 97 sbiw r28, 0x10 ; 16
- 83a: 0f b6 in r0, 0x3f ; 63
- 83c: f8 94 cli
- 83e: de bf out 0x3e, r29 ; 62
- 840: 0f be out 0x3f, r0 ; 63
- 842: cd bf out 0x3d, r28 ; 61
+ a34: af 92 push r10
+ a36: bf 92 push r11
+ a38: cf 92 push r12
+ a3a: df 92 push r13
+ a3c: ef 92 push r14
+ a3e: ff 92 push r15
+ a40: 0f 93 push r16
+ a42: 1f 93 push r17
+ a44: df 93 push r29
+ a46: cf 93 push r28
+ a48: cd b7 in r28, 0x3d ; 61
+ a4a: de b7 in r29, 0x3e ; 62
+ a4c: 60 97 sbiw r28, 0x10 ; 16
+ a4e: 0f b6 in r0, 0x3f ; 63
+ a50: f8 94 cli
+ a52: de bf out 0x3e, r29 ; 62
+ a54: 0f be out 0x3f, r0 ; 63
+ a56: cd bf out 0x3d, r28 ; 61
+
+ init_motors();
+ a58: 60 df rcall .-320 ; 0x91a <init_motors>
+
char dummy;
uint8_t field_val = 0;
SetupHardware();
- 844: c7 de rcall .-626 ; 0x5d4 <SetupHardware>
+ a5a: 32 de rcall .-924 ; 0x6c0 <SetupHardware>
RingBuffer_InitBuffer(&USBtoUSART_Buffer, USBtoUSART_Buffer_Data, sizeof(USBtoUSART_Buffer_Data));
- 846: 82 e6 ldi r24, 0x62 ; 98
- 848: 91 e0 ldi r25, 0x01 ; 1
- 84a: 6e e6 ldi r22, 0x6E ; 110
- 84c: 71 e0 ldi r23, 0x01 ; 1
- 84e: c4 dc rcall .-1656 ; 0x1d8 <RingBuffer_InitBuffer.clone.0>
+ a5c: 8a e6 ldi r24, 0x6A ; 106
+ a5e: 91 e0 ldi r25, 0x01 ; 1
+ a60: 66 e7 ldi r22, 0x76 ; 118
+ a62: 71 e0 ldi r23, 0x01 ; 1
+ a64: 2e dc rcall .-1956 ; 0x2c2 <RingBuffer_InitBuffer.clone.0>
RingBuffer_InitBuffer(&USARTtoUSB_Buffer, USARTtoUSB_Buffer_Data, sizeof(USARTtoUSB_Buffer_Data));
- 850: 8e ee ldi r24, 0xEE ; 238
- 852: 91 e0 ldi r25, 0x01 ; 1
- 854: 6a ef ldi r22, 0xFA ; 250
- 856: 71 e0 ldi r23, 0x01 ; 1
- 858: bf dc rcall .-1666 ; 0x1d8 <RingBuffer_InitBuffer.clone.0>
+ a66: 86 ef ldi r24, 0xF6 ; 246
+ a68: 91 e0 ldi r25, 0x01 ; 1
+ a6a: 62 e0 ldi r22, 0x02 ; 2
+ a6c: 72 e0 ldi r23, 0x02 ; 2
+ a6e: 29 dc rcall .-1966 ; 0x2c2 <RingBuffer_InitBuffer.clone.0>
static inline void GlobalInterruptEnable(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
sei();
- 85a: 78 94 sei
+ a70: 78 94 sei
// LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
GlobalInterruptEnable();
touchpad_init(); // you need to call this to setup the I/O pin!
- 85c: ff dd rcall .-1026 ; 0x45c <touchpad_init>
- 85e: 8f ef ldi r24, 0xFF ; 255
- 860: 99 e6 ldi r25, 0x69 ; 105
- 862: a8 e1 ldi r26, 0x18 ; 24
- 864: 81 50 subi r24, 0x01 ; 1
- 866: 90 40 sbci r25, 0x00 ; 0
- 868: a0 40 sbci r26, 0x00 ; 0
- 86a: e1 f7 brne .-8 ; 0x864 <main+0x40>
- 86c: 00 c0 rjmp .+0 ; 0x86e <main+0x4a>
- 86e: 00 00 nop
+ a72: 69 dd rcall .-1326 ; 0x546 <touchpad_init>
+ a74: 8f ef ldi r24, 0xFF ; 255
+ a76: 99 e6 ldi r25, 0x69 ; 105
+ a78: a8 e1 ldi r26, 0x18 ; 24
+ a7a: 81 50 subi r24, 0x01 ; 1
+ a7c: 90 40 sbci r25, 0x00 ; 0
+ a7e: a0 40 sbci r26, 0x00 ; 0
+ a80: e1 f7 brne .-8 ; 0xa7a <main+0x46>
+ a82: 00 c0 rjmp .+0 ; 0xa84 <main+0x50>
+ a84: 00 00 nop
_delay_ms(500);
sei();
- 870: 78 94 sei
- // -------------------------
- // | left | down | right |
- // -------------------------
-
-// uart_puts("you selected the keypad demo modus:\n\r");
- touchpad_set_abs_mode(); // keypad functionality uses the "absolute mode"
- 872: 05 de rcall .-1014 ; 0x47e <touchpad_set_abs_mode>
- // 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");
+ a86: 78 94 sei
+
+ uint16_t loopcounter=0;
+
+ char stringbuffer[16];
+
touchpad_set_abs_mode();// tell the touchpad you want to use it in the "absolute mode"
- 874: 04 de rcall .-1016 ; 0x47e <touchpad_set_abs_mode>
+ a88: 6f dd rcall .-1314 ; 0x568 <touchpad_set_abs_mode>
}
// end of absolute mode demo block
//
// #elif DEMO_MODE == RELATIVE_MODE
// begin of relative mode demo block
uart_puts("you selected the relative position demo modus:\n\r");
- 876: 80 e0 ldi r24, 0x00 ; 0
- 878: 91 e0 ldi r25, 0x01 ; 1
- 87a: 5b df rcall .-330 ; 0x732 <uart_puts>
+ a8a: 80 e0 ldi r24, 0x00 ; 0
+ a8c: 91 e0 ldi r25, 0x01 ; 1
+ a8e: ca de rcall .-620 ; 0x824 <uart_puts>
touchpad_set_rel_mode_100dpi();// use touchpad in relative mode
- 87c: 1e de rcall .-964 ; 0x4ba <touchpad_set_rel_mode_100dpi>
+ a90: 89 dd rcall .-1262 ; 0x5a4 <touchpad_set_rel_mode_100dpi>
// touchpad_set_rel_mode_200dpi(); // uncomment this line if you want double resolution
uint8_t x, y = 0;
- 87e: dd 24 eor r13, r13
+ a92: dd 24 eor r13, r13
} else {
y = (y + dy);
}
uart_puts("x_pos: ");
my_uitoa(x, stringbuffer, 4);
- 880: 8e 01 movw r16, r28
- 882: 0f 5f subi r16, 0xFF ; 255
- 884: 1f 4f sbci r17, 0xFF ; 255
-// #elif DEMO_MODE == RELATIVE_MODE
-// begin of relative mode demo block
- uart_puts("you selected the relative position demo modus:\n\r");
- touchpad_set_rel_mode_100dpi();// use touchpad in relative mode
-// touchpad_set_rel_mode_200dpi(); // uncomment this line if you want double resolution
+ a94: 8e 01 movw r16, r28
+ a96: 0f 5f subi r16, 0xFF ; 255
+ a98: 1f 4f sbci r17, 0xFF ; 255
uint8_t x, y = 0;
- 886: ee 24 eor r14, r14
- 888: ff 24 eor r15, r15
int8_t dx, dy = 0;
while (1) {
Usb2SerialTask();
- 88a: 4b de rcall .-874 ; 0x522 <Usb2SerialTask>
- loopcounter++;
- 88c: 08 94 sec
- 88e: e1 1c adc r14, r1
- 890: f1 1c adc r15, r1
- if(loopcounter<2000) {
- 892: 90 ed ldi r25, 0xD0 ; 208
- 894: e9 16 cp r14, r25
- 896: 97 e0 ldi r25, 0x07 ; 7
- 898: f9 06 cpc r15, r25
- 89a: b9 f7 brne .-18 ; 0x88a <main+0x66>
- continue;
- }
- loopcounter=0;
+ a9a: b8 dd rcall .-1168 ; 0x60c <Usb2SerialTask>
+// if(loopcounter<2000) {
+// continue;
+// }
+// loopcounter=0;
touchpad_read(); // read data from touchpad
- 89c: e7 dd rcall .-1074 ; 0x46c <touchpad_read>
+ a9c: 5c dd rcall .-1352 ; 0x556 <touchpad_read>
dx = delta_x();// returns the amount your finger has moved in x direction since last readout
- 89e: 31 de rcall .-926 ; 0x502 <delta_x>
- 8a0: e8 2e mov r14, r24
+ a9e: a6 dd rcall .-1204 ; 0x5ec <delta_x>
+ aa0: a8 2e mov r10, r24
dy = delta_y();// returns the amount your finger has moved in y direction since last readout
- 8a2: 1f de rcall .-962 ; 0x4e2 <delta_y>
+ aa2: 94 dd rcall .-1240 ; 0x5cc <delta_y>
// increment/decrement some dummy variables with the
if (x + dx > 255) {
- 8a4: 2e 2d mov r18, r14
- 8a6: 33 27 eor r19, r19
- 8a8: 27 fd sbrc r18, 7
- 8aa: 30 95 com r19
- 8ac: 2c 0d add r18, r12
- 8ae: 31 1d adc r19, r1
- 8b0: 2f 3f cpi r18, 0xFF ; 255
- 8b2: 31 05 cpc r19, r1
- 8b4: 09 f0 breq .+2 ; 0x8b8 <main+0x94>
- 8b6: 24 f4 brge .+8 ; 0x8c0 <main+0x9c>
+ aa4: ea 2c mov r14, r10
+ aa6: ff 24 eor r15, r15
+ aa8: e7 fc sbrc r14, 7
+ aaa: f0 94 com r15
+ aac: 97 01 movw r18, r14
+ aae: 2c 0d add r18, r12
+ ab0: 31 1d adc r19, r1
+ ab2: 2f 3f cpi r18, 0xFF ; 255
+ ab4: 31 05 cpc r19, r1
+ ab6: 09 f0 breq .+2 ; 0xaba <main+0x86>
+ ab8: 24 f4 brge .+8 ; 0xac2 <main+0x8e>
x = 255;
} else if (x + dx < 0) {
- 8b8: 37 fd sbrc r19, 7
- 8ba: 05 c0 rjmp .+10 ; 0x8c6 <main+0xa2>
+ aba: 37 fd sbrc r19, 7
+ abc: 05 c0 rjmp .+10 ; 0xac8 <main+0x94>
x = 0;
} else {
x = (x + dx);
- 8bc: ce 0c add r12, r14
- 8be: 04 c0 rjmp .+8 ; 0x8c8 <main+0xa4>
+ abe: ca 0c add r12, r10
+ ac0: 04 c0 rjmp .+8 ; 0xaca <main+0x96>
dx = delta_x();// returns the amount your finger has moved in x direction since last readout
dy = delta_y();// returns the amount your finger has moved in y direction since last readout
// increment/decrement some dummy variables with the
if (x + dx > 255) {
x = 255;
- 8c0: cc 24 eor r12, r12
- 8c2: ca 94 dec r12
- 8c4: 01 c0 rjmp .+2 ; 0x8c8 <main+0xa4>
+ ac2: cc 24 eor r12, r12
+ ac4: ca 94 dec r12
+ ac6: 01 c0 rjmp .+2 ; 0xaca <main+0x96>
} else if (x + dx < 0) {
x = 0;
- 8c6: cc 24 eor r12, r12
+ ac8: cc 24 eor r12, r12
} else {
x = (x + dx);
}
if (y + dy > 255) {
- 8c8: 28 2f mov r18, r24
- 8ca: 33 27 eor r19, r19
- 8cc: 27 fd sbrc r18, 7
- 8ce: 30 95 com r19
- 8d0: 2d 0d add r18, r13
- 8d2: 31 1d adc r19, r1
- 8d4: 2f 3f cpi r18, 0xFF ; 255
- 8d6: 31 05 cpc r19, r1
- 8d8: 09 f0 breq .+2 ; 0x8dc <main+0xb8>
- 8da: 24 f4 brge .+8 ; 0x8e4 <main+0xc0>
+ aca: a8 2e mov r10, r24
+ acc: bb 24 eor r11, r11
+ ace: a7 fc sbrc r10, 7
+ ad0: b0 94 com r11
+ ad2: 95 01 movw r18, r10
+ ad4: 2d 0d add r18, r13
+ ad6: 31 1d adc r19, r1
+ ad8: 2f 3f cpi r18, 0xFF ; 255
+ ada: 31 05 cpc r19, r1
+ adc: 09 f0 breq .+2 ; 0xae0 <main+0xac>
+ ade: 24 f4 brge .+8 ; 0xae8 <main+0xb4>
y = 255;
} else if (y + dy < 0) {
- 8dc: 37 fd sbrc r19, 7
- 8de: 05 c0 rjmp .+10 ; 0x8ea <main+0xc6>
+ ae0: 37 fd sbrc r19, 7
+ ae2: 05 c0 rjmp .+10 ; 0xaee <main+0xba>
y = 0;
} else {
y = (y + dy);
- 8e0: d8 0e add r13, r24
- 8e2: 04 c0 rjmp .+8 ; 0x8ec <main+0xc8>
+ ae4: d8 0e add r13, r24
+ ae6: 04 c0 rjmp .+8 ; 0xaf0 <main+0xbc>
} else {
x = (x + dx);
}
if (y + dy > 255) {
y = 255;
- 8e4: dd 24 eor r13, r13
- 8e6: da 94 dec r13
- 8e8: 01 c0 rjmp .+2 ; 0x8ec <main+0xc8>
+ ae8: dd 24 eor r13, r13
+ aea: da 94 dec r13
+ aec: 01 c0 rjmp .+2 ; 0xaf0 <main+0xbc>
} else if (y + dy < 0) {
y = 0;
- 8ea: dd 24 eor r13, r13
+ aee: dd 24 eor r13, r13
} else {
y = (y + dy);
}
uart_puts("x_pos: ");
- 8ec: 81 e3 ldi r24, 0x31 ; 49
- 8ee: 91 e0 ldi r25, 0x01 ; 1
- 8f0: 20 df rcall .-448 ; 0x732 <uart_puts>
+ af0: 81 e3 ldi r24, 0x31 ; 49
+ af2: 91 e0 ldi r25, 0x01 ; 1
+ af4: 97 de rcall .-722 ; 0x824 <uart_puts>
my_uitoa(x, stringbuffer, 4);
- 8f2: 6c 2d mov r22, r12
- 8f4: 70 e0 ldi r23, 0x00 ; 0
- 8f6: 80 e0 ldi r24, 0x00 ; 0
- 8f8: 90 e0 ldi r25, 0x00 ; 0
- 8fa: a8 01 movw r20, r16
- 8fc: 24 e0 ldi r18, 0x04 ; 4
- 8fe: 2c df rcall .-424 ; 0x758 <my_uitoa>
+ af6: 6c 2d mov r22, r12
+ af8: 70 e0 ldi r23, 0x00 ; 0
+ afa: 80 e0 ldi r24, 0x00 ; 0
+ afc: 90 e0 ldi r25, 0x00 ; 0
+ afe: a8 01 movw r20, r16
+ b00: 24 e0 ldi r18, 0x04 ; 4
+ b02: a3 de rcall .-698 ; 0x84a <my_uitoa>
uart_puts(stringbuffer);
- 900: c8 01 movw r24, r16
- 902: 17 df rcall .-466 ; 0x732 <uart_puts>
+ b04: c8 01 movw r24, r16
+ b06: 8e de rcall .-740 ; 0x824 <uart_puts>
uart_puts(" y_pos: ");
- 904: 89 e3 ldi r24, 0x39 ; 57
- 906: 91 e0 ldi r25, 0x01 ; 1
- 908: 14 df rcall .-472 ; 0x732 <uart_puts>
+ b08: 89 e3 ldi r24, 0x39 ; 57
+ b0a: 91 e0 ldi r25, 0x01 ; 1
+ b0c: 8b de rcall .-746 ; 0x824 <uart_puts>
my_uitoa(y, stringbuffer, 4);
- 90a: 6d 2d mov r22, r13
- 90c: 70 e0 ldi r23, 0x00 ; 0
- 90e: 80 e0 ldi r24, 0x00 ; 0
- 910: 90 e0 ldi r25, 0x00 ; 0
- 912: a8 01 movw r20, r16
- 914: 24 e0 ldi r18, 0x04 ; 4
- 916: 20 df rcall .-448 ; 0x758 <my_uitoa>
+ b0e: 6d 2d mov r22, r13
+ b10: 70 e0 ldi r23, 0x00 ; 0
+ b12: 80 e0 ldi r24, 0x00 ; 0
+ b14: 90 e0 ldi r25, 0x00 ; 0
+ b16: a8 01 movw r20, r16
+ b18: 24 e0 ldi r18, 0x04 ; 4
+ b1a: 97 de rcall .-722 ; 0x84a <my_uitoa>
uart_puts(stringbuffer);
- 918: c8 01 movw r24, r16
- 91a: 0b df rcall .-490 ; 0x732 <uart_puts>
+ b1c: c8 01 movw r24, r16
+ b1e: 82 de rcall .-764 ; 0x824 <uart_puts>
uart_puts("\r");
- 91c: 83 e4 ldi r24, 0x43 ; 67
- 91e: 91 e0 ldi r25, 0x01 ; 1
- 920: 08 df rcall .-496 ; 0x732 <uart_puts>
- 922: b1 cf rjmp .-158 ; 0x886 <main+0x62>
+ b20: 83 e4 ldi r24, 0x43 ; 67
+ b22: 91 e0 ldi r25, 0x01 ; 1
+ b24: 7f de rcall .-770 ; 0x824 <uart_puts>
+ b26: af e3 ldi r26, 0x3F ; 63
+ b28: bc e9 ldi r27, 0x9C ; 156
+ b2a: 11 97 sbiw r26, 0x01 ; 1
+ b2c: f1 f7 brne .-4 ; 0xb2a <main+0xf6>
+ b2e: 00 c0 rjmp .+0 ; 0xb30 <main+0xfc>
+ b30: 00 00 nop
+
+ _delay_ms(10);
+ move_plate(dx>>0,dy>>0);
+ b32: c7 01 movw r24, r14
+ b34: b5 01 movw r22, r10
+ b36: 3c df rcall .-392 ; 0x9b0 <move_plate>
+
-00000924 <CALLBACK_USB_GetDescriptor>:
+ }
+ b38: b0 cf rjmp .-160 ; 0xa9a <main+0x66>
+
+00000b3a <CALLBACK_USB_GetDescriptor>:
const uint8_t DescriptorNumber = (wValue & 0xFF);
const void* Address = NULL;
uint16_t Size = NO_DESCRIPTOR;
switch (DescriptorType)
- 924: 92 30 cpi r25, 0x02 ; 2
- 926: 29 f0 breq .+10 ; 0x932 <CALLBACK_USB_GetDescriptor+0xe>
- 928: 93 30 cpi r25, 0x03 ; 3
- 92a: 41 f0 breq .+16 ; 0x93c <CALLBACK_USB_GetDescriptor+0x18>
- 92c: 91 30 cpi r25, 0x01 ; 1
- 92e: e9 f4 brne .+58 ; 0x96a <CALLBACK_USB_GetDescriptor+0x46>
- 930: 17 c0 rjmp .+46 ; 0x960 <CALLBACK_USB_GetDescriptor+0x3c>
+ b3a: 92 30 cpi r25, 0x02 ; 2
+ b3c: 29 f0 breq .+10 ; 0xb48 <CALLBACK_USB_GetDescriptor+0xe>
+ b3e: 93 30 cpi r25, 0x03 ; 3
+ b40: 41 f0 breq .+16 ; 0xb52 <CALLBACK_USB_GetDescriptor+0x18>
+ b42: 91 30 cpi r25, 0x01 ; 1
+ b44: e9 f4 brne .+58 ; 0xb80 <CALLBACK_USB_GetDescriptor+0x46>
+ b46: 17 c0 rjmp .+46 ; 0xb76 <CALLBACK_USB_GetDescriptor+0x3c>
Address = &DeviceDescriptor;
Size = sizeof(USB_Descriptor_Device_t);
break;
case DTYPE_Configuration:
Address = &ConfigurationDescriptor;
Size = sizeof(USB_Descriptor_Configuration_t);
- 932: 2e e3 ldi r18, 0x3E ; 62
- 934: 30 e0 ldi r19, 0x00 ; 0
+ b48: 2e e3 ldi r18, 0x3E ; 62
+ b4a: 30 e0 ldi r19, 0x00 ; 0
case DTYPE_Device:
Address = &DeviceDescriptor;
Size = sizeof(USB_Descriptor_Device_t);
break;
case DTYPE_Configuration:
Address = &ConfigurationDescriptor;
- 936: ea ea ldi r30, 0xAA ; 170
- 938: f0 e0 ldi r31, 0x00 ; 0
+ b4c: ea ea ldi r30, 0xAA ; 170
+ b4e: f0 e0 ldi r31, 0x00 ; 0
Size = sizeof(USB_Descriptor_Configuration_t);
break;
- 93a: 1b c0 rjmp .+54 ; 0x972 <CALLBACK_USB_GetDescriptor+0x4e>
+ b50: 1b c0 rjmp .+54 ; 0xb88 <CALLBACK_USB_GetDescriptor+0x4e>
case DTYPE_String:
switch (DescriptorNumber)
- 93c: 81 30 cpi r24, 0x01 ; 1
- 93e: 41 f0 breq .+16 ; 0x950 <CALLBACK_USB_GetDescriptor+0x2c>
- 940: 81 30 cpi r24, 0x01 ; 1
- 942: 18 f0 brcs .+6 ; 0x94a <CALLBACK_USB_GetDescriptor+0x26>
- 944: 82 30 cpi r24, 0x02 ; 2
- 946: 89 f4 brne .+34 ; 0x96a <CALLBACK_USB_GetDescriptor+0x46>
- 948: 06 c0 rjmp .+12 ; 0x956 <CALLBACK_USB_GetDescriptor+0x32>
+ b52: 81 30 cpi r24, 0x01 ; 1
+ b54: 41 f0 breq .+16 ; 0xb66 <CALLBACK_USB_GetDescriptor+0x2c>
+ b56: 81 30 cpi r24, 0x01 ; 1
+ b58: 18 f0 brcs .+6 ; 0xb60 <CALLBACK_USB_GetDescriptor+0x26>
+ b5a: 82 30 cpi r24, 0x02 ; 2
+ b5c: 89 f4 brne .+34 ; 0xb80 <CALLBACK_USB_GetDescriptor+0x46>
+ b5e: 06 c0 rjmp .+12 ; 0xb6c <CALLBACK_USB_GetDescriptor+0x32>
{
case 0x00:
Address = &LanguageString;
Size = pgm_read_byte(&LanguageString.Header.Size);
- 94a: e8 ee ldi r30, 0xE8 ; 232
- 94c: f0 e0 ldi r31, 0x00 ; 0
- 94e: 05 c0 rjmp .+10 ; 0x95a <CALLBACK_USB_GetDescriptor+0x36>
+ b60: e8 ee ldi r30, 0xE8 ; 232
+ b62: f0 e0 ldi r31, 0x00 ; 0
+ b64: 05 c0 rjmp .+10 ; 0xb70 <CALLBACK_USB_GetDescriptor+0x36>
break;
case 0x01:
Address = &ManufacturerString;
Size = pgm_read_byte(&ManufacturerString.Header.Size);
- 950: ec ee ldi r30, 0xEC ; 236
- 952: f0 e0 ldi r31, 0x00 ; 0
- 954: 02 c0 rjmp .+4 ; 0x95a <CALLBACK_USB_GetDescriptor+0x36>
+ b66: ec ee ldi r30, 0xEC ; 236
+ b68: f0 e0 ldi r31, 0x00 ; 0
+ b6a: 02 c0 rjmp .+4 ; 0xb70 <CALLBACK_USB_GetDescriptor+0x36>
break;
case 0x02:
Address = &ProductString;
Size = pgm_read_byte(&ProductString.Header.Size);
- 956: e6 e0 ldi r30, 0x06 ; 6
- 958: f1 e0 ldi r31, 0x01 ; 1
- 95a: 24 91 lpm r18, Z+
- 95c: 30 e0 ldi r19, 0x00 ; 0
+ b6c: e6 e0 ldi r30, 0x06 ; 6
+ b6e: f1 e0 ldi r31, 0x01 ; 1
+ b70: 24 91 lpm r18, Z+
+ b72: 30 e0 ldi r19, 0x00 ; 0
break;
- 95e: 09 c0 rjmp .+18 ; 0x972 <CALLBACK_USB_GetDescriptor+0x4e>
+ b74: 09 c0 rjmp .+18 ; 0xb88 <CALLBACK_USB_GetDescriptor+0x4e>
switch (DescriptorType)
{
case DTYPE_Device:
Address = &DeviceDescriptor;
Size = sizeof(USB_Descriptor_Device_t);
- 960: 22 e1 ldi r18, 0x12 ; 18
- 962: 30 e0 ldi r19, 0x00 ; 0
+ b76: 22 e1 ldi r18, 0x12 ; 18
+ b78: 30 e0 ldi r19, 0x00 ; 0
uint16_t Size = NO_DESCRIPTOR;
switch (DescriptorType)
{
case DTYPE_Device:
Address = &DeviceDescriptor;
- 964: e8 e9 ldi r30, 0x98 ; 152
- 966: f0 e0 ldi r31, 0x00 ; 0
- 968: 04 c0 rjmp .+8 ; 0x972 <CALLBACK_USB_GetDescriptor+0x4e>
+ b7a: e8 e9 ldi r30, 0x98 ; 152
+ b7c: f0 e0 ldi r31, 0x00 ; 0
+ b7e: 04 c0 rjmp .+8 ; 0xb88 <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;
- 96a: 20 e0 ldi r18, 0x00 ; 0
- 96c: 30 e0 ldi r19, 0x00 ; 0
+ b80: 20 e0 ldi r18, 0x00 ; 0
+ b82: 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;
- 96e: e0 e0 ldi r30, 0x00 ; 0
- 970: f0 e0 ldi r31, 0x00 ; 0
+ b84: e0 e0 ldi r30, 0x00 ; 0
+ b86: f0 e0 ldi r31, 0x00 ; 0
}
break;
}
*DescriptorAddress = Address;
- 972: da 01 movw r26, r20
- 974: 11 96 adiw r26, 0x01 ; 1
- 976: fc 93 st X, r31
- 978: ee 93 st -X, r30
+ b88: da 01 movw r26, r20
+ b8a: 11 96 adiw r26, 0x01 ; 1
+ b8c: fc 93 st X, r31
+ b8e: ee 93 st -X, r30
return Size;
}
- 97a: c9 01 movw r24, r18
- 97c: 08 95 ret
+ b90: c9 01 movw r24, r18
+ b92: 08 95 ret
-0000097e <Endpoint_Write_Control_Stream_LE>:
+00000b94 <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));
- 97e: 28 2f mov r18, r24
- 980: 39 2f mov r19, r25
- 982: f9 01 movw r30, r18
+ b94: 28 2f mov r18, r24
+ b96: 39 2f mov r19, r25
+ b98: f9 01 movw r30, r18
bool LastPacketFull = false;
if (Length > USB_ControlRequest.wLength)
- 984: 80 91 95 02 lds r24, 0x0295
- 988: 90 91 96 02 lds r25, 0x0296
- 98c: 86 17 cp r24, r22
- 98e: 97 07 cpc r25, r23
- 990: 18 f4 brcc .+6 ; 0x998 <Endpoint_Write_Control_Stream_LE+0x1a>
- 992: bc 01 movw r22, r24
- 994: 20 e0 ldi r18, 0x00 ; 0
- 996: 35 c0 rjmp .+106 ; 0xa02 <Endpoint_Write_Control_Stream_LE+0x84>
+ b9a: 80 91 a2 02 lds r24, 0x02A2
+ b9e: 90 91 a3 02 lds r25, 0x02A3
+ ba2: 86 17 cp r24, r22
+ ba4: 97 07 cpc r25, r23
+ ba6: 18 f4 brcc .+6 ; 0xbae <Endpoint_Write_Control_Stream_LE+0x1a>
+ ba8: bc 01 movw r22, r24
+ baa: 20 e0 ldi r18, 0x00 ; 0
+ bac: 34 c0 rjmp .+104 ; 0xc16 <Endpoint_Write_Control_Stream_LE+0x82>
Length = USB_ControlRequest.wLength;
else if (!(Length))
- 998: 61 15 cp r22, r1
- 99a: 71 05 cpc r23, r1
- 99c: d9 f7 brne .-10 ; 0x994 <Endpoint_Write_Control_Stream_LE+0x16>
+ bae: 61 15 cp r22, r1
+ bb0: 71 05 cpc r23, r1
+ bb2: d9 f7 brne .-10 ; 0xbaa <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));
- 99e: 80 91 e8 00 lds r24, 0x00E8
- 9a2: 8e 77 andi r24, 0x7E ; 126
- 9a4: 80 93 e8 00 sts 0x00E8, r24
- 9a8: f5 cf rjmp .-22 ; 0x994 <Endpoint_Write_Control_Stream_LE+0x16>
+ bb4: 80 91 e8 00 lds r24, 0x00E8
+ bb8: 8e 77 andi r24, 0x7E ; 126
+ bba: 80 93 e8 00 sts 0x00E8, r24
+ bbe: f5 cf rjmp .-22 ; 0xbaa <Endpoint_Write_Control_Stream_LE+0x16>
Endpoint_ClearIN();
while (Length || LastPacketFull)
{
uint8_t USB_DeviceState_LCL = USB_DeviceState;
- 9aa: 80 91 8e 02 lds r24, 0x028E
+ bc0: 8e b3 in r24, 0x1e ; 30
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
- 9ae: 88 23 and r24, r24
- 9b0: f1 f1 breq .+124 ; 0xa2e <Endpoint_Write_Control_Stream_LE+0xb0>
+ bc2: 88 23 and r24, r24
+ bc4: e9 f1 breq .+122 ; 0xc40 <Endpoint_Write_Control_Stream_LE+0xac>
return ENDPOINT_RWCSTREAM_DeviceDisconnected;
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
- 9b2: 85 30 cpi r24, 0x05 ; 5
- 9b4: c1 f1 breq .+112 ; 0xa26 <Endpoint_Write_Control_Stream_LE+0xa8>
+ bc6: 85 30 cpi r24, 0x05 ; 5
+ bc8: b9 f1 breq .+110 ; 0xc38 <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);
- 9b6: 80 91 e8 00 lds r24, 0x00E8
+ bca: 80 91 e8 00 lds r24, 0x00E8
return ENDPOINT_RWCSTREAM_BusSuspended;
else if (Endpoint_IsSETUPReceived())
- 9ba: 83 fd sbrc r24, 3
- 9bc: 36 c0 rjmp .+108 ; 0xa2a <Endpoint_Write_Control_Stream_LE+0xac>
+ bce: 83 fd sbrc r24, 3
+ bd0: 35 c0 rjmp .+106 ; 0xc3c <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);
- 9be: 80 91 e8 00 lds r24, 0x00E8
+ bd2: 80 91 e8 00 lds r24, 0x00E8
return ENDPOINT_RWCSTREAM_HostAborted;
else if (Endpoint_IsOUTReceived())
- 9c2: 82 fd sbrc r24, 2
- 9c4: 2a c0 rjmp .+84 ; 0xa1a <Endpoint_Write_Control_Stream_LE+0x9c>
+ bd6: 82 fd sbrc r24, 2
+ bd8: 29 c0 rjmp .+82 ; 0xc2c <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);
- 9c6: 80 91 e8 00 lds r24, 0x00E8
+ bda: 80 91 e8 00 lds r24, 0x00E8
break;
if (Endpoint_IsINReady())
- 9ca: 80 ff sbrs r24, 0
- 9cc: 1a c0 rjmp .+52 ; 0xa02 <Endpoint_Write_Control_Stream_LE+0x84>
+ bde: 80 ff sbrs r24, 0
+ be0: 1a c0 rjmp .+52 ; 0xc16 <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;
- 9ce: 80 91 f2 00 lds r24, 0x00F2
- 9d2: 90 e0 ldi r25, 0x00 ; 0
+ be2: 80 91 f2 00 lds r24, 0x00F2
+ be6: 90 e0 ldi r25, 0x00 ; 0
{
uint16_t BytesInEndpoint = Endpoint_BytesInEndpoint();
while (Length && (BytesInEndpoint < USB_Device_ControlEndpointSize))
- 9d4: 06 c0 rjmp .+12 ; 0x9e2 <Endpoint_Write_Control_Stream_LE+0x64>
+ be8: 06 c0 rjmp .+12 ; 0xbf6 <Endpoint_Write_Control_Stream_LE+0x62>
{
TEMPLATE_TRANSFER_BYTE(DataStream);
- 9d6: 21 91 ld r18, Z+
+ bea: 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;
- 9d8: 20 93 f1 00 sts 0x00F1, r18
+ bec: 20 93 f1 00 sts 0x00F1, r18
TEMPLATE_BUFFER_MOVE(DataStream, 1);
Length--;
- 9dc: 61 50 subi r22, 0x01 ; 1
- 9de: 70 40 sbci r23, 0x00 ; 0
+ bf0: 61 50 subi r22, 0x01 ; 1
+ bf2: 70 40 sbci r23, 0x00 ; 0
BytesInEndpoint++;
- 9e0: 01 96 adiw r24, 0x01 ; 1
+ bf4: 01 96 adiw r24, 0x01 ; 1
if (Endpoint_IsINReady())
{
uint16_t BytesInEndpoint = Endpoint_BytesInEndpoint();
while (Length && (BytesInEndpoint < USB_Device_ControlEndpointSize))
- 9e2: 61 15 cp r22, r1
- 9e4: 71 05 cpc r23, r1
- 9e6: 19 f0 breq .+6 ; 0x9ee <Endpoint_Write_Control_Stream_LE+0x70>
- 9e8: 88 30 cpi r24, 0x08 ; 8
- 9ea: 91 05 cpc r25, r1
- 9ec: a0 f3 brcs .-24 ; 0x9d6 <Endpoint_Write_Control_Stream_LE+0x58>
+ bf6: 61 15 cp r22, r1
+ bf8: 71 05 cpc r23, r1
+ bfa: 19 f0 breq .+6 ; 0xc02 <Endpoint_Write_Control_Stream_LE+0x6e>
+ bfc: 88 30 cpi r24, 0x08 ; 8
+ bfe: 91 05 cpc r25, r1
+ c00: a0 f3 brcs .-24 ; 0xbea <Endpoint_Write_Control_Stream_LE+0x56>
TEMPLATE_BUFFER_MOVE(DataStream, 1);
Length--;
BytesInEndpoint++;
}
LastPacketFull = (BytesInEndpoint == USB_Device_ControlEndpointSize);
- 9ee: 21 e0 ldi r18, 0x01 ; 1
- 9f0: 88 30 cpi r24, 0x08 ; 8
- 9f2: 91 05 cpc r25, r1
- 9f4: 09 f0 breq .+2 ; 0x9f8 <Endpoint_Write_Control_Stream_LE+0x7a>
- 9f6: 20 e0 ldi r18, 0x00 ; 0
+ c02: 21 e0 ldi r18, 0x01 ; 1
+ c04: 88 30 cpi r24, 0x08 ; 8
+ c06: 91 05 cpc r25, r1
+ c08: 09 f0 breq .+2 ; 0xc0c <Endpoint_Write_Control_Stream_LE+0x78>
+ c0a: 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));
- 9f8: 80 91 e8 00 lds r24, 0x00E8
- 9fc: 8e 77 andi r24, 0x7E ; 126
- 9fe: 80 93 e8 00 sts 0x00E8, r24
+ c0c: 80 91 e8 00 lds r24, 0x00E8
+ c10: 8e 77 andi r24, 0x7E ; 126
+ c12: 80 93 e8 00 sts 0x00E8, r24
if (Length > USB_ControlRequest.wLength)
Length = USB_ControlRequest.wLength;
else if (!(Length))
Endpoint_ClearIN();
while (Length || LastPacketFull)
- a02: 61 15 cp r22, r1
- a04: 71 05 cpc r23, r1
- a06: 89 f6 brne .-94 ; 0x9aa <Endpoint_Write_Control_Stream_LE+0x2c>
- a08: 22 23 and r18, r18
- a0a: 79 f6 brne .-98 ; 0x9aa <Endpoint_Write_Control_Stream_LE+0x2c>
- a0c: 06 c0 rjmp .+12 ; 0xa1a <Endpoint_Write_Control_Stream_LE+0x9c>
+ c16: 61 15 cp r22, r1
+ c18: 71 05 cpc r23, r1
+ c1a: 91 f6 brne .-92 ; 0xbc0 <Endpoint_Write_Control_Stream_LE+0x2c>
+ c1c: 22 23 and r18, r18
+ c1e: 81 f6 brne .-96 ; 0xbc0 <Endpoint_Write_Control_Stream_LE+0x2c>
+ c20: 05 c0 rjmp .+10 ; 0xc2c <Endpoint_Write_Control_Stream_LE+0x98>
}
}
while (!(Endpoint_IsOUTReceived()))
{
uint8_t USB_DeviceState_LCL = USB_DeviceState;
- a0e: 80 91 8e 02 lds r24, 0x028E
+ c22: 8e b3 in r24, 0x1e ; 30
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
- a12: 88 23 and r24, r24
- a14: 61 f0 breq .+24 ; 0xa2e <Endpoint_Write_Control_Stream_LE+0xb0>
+ c24: 88 23 and r24, r24
+ c26: 61 f0 breq .+24 ; 0xc40 <Endpoint_Write_Control_Stream_LE+0xac>
return ENDPOINT_RWCSTREAM_DeviceDisconnected;
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
- a16: 85 30 cpi r24, 0x05 ; 5
- a18: 61 f0 breq .+24 ; 0xa32 <Endpoint_Write_Control_Stream_LE+0xb4>
+ c28: 85 30 cpi r24, 0x05 ; 5
+ c2a: 61 f0 breq .+24 ; 0xc44 <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);
- a1a: 80 91 e8 00 lds r24, 0x00E8
+ c2c: 80 91 e8 00 lds r24, 0x00E8
LastPacketFull = (BytesInEndpoint == USB_Device_ControlEndpointSize);
Endpoint_ClearIN();
}
}
while (!(Endpoint_IsOUTReceived()))
- a1e: 82 ff sbrs r24, 2
- a20: f6 cf rjmp .-20 ; 0xa0e <Endpoint_Write_Control_Stream_LE+0x90>
+ c30: 82 ff sbrs r24, 2
+ c32: f7 cf rjmp .-18 ; 0xc22 <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;
- a22: 80 e0 ldi r24, 0x00 ; 0
- a24: 08 95 ret
+ c34: 80 e0 ldi r24, 0x00 ; 0
+ c36: 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;
- a26: 83 e0 ldi r24, 0x03 ; 3
- a28: 08 95 ret
+ c38: 83 e0 ldi r24, 0x03 ; 3
+ c3a: 08 95 ret
else if (Endpoint_IsSETUPReceived())
return ENDPOINT_RWCSTREAM_HostAborted;
- a2a: 81 e0 ldi r24, 0x01 ; 1
- a2c: 08 95 ret
+ c3c: 81 e0 ldi r24, 0x01 ; 1
+ c3e: 08 95 ret
while (!(Endpoint_IsOUTReceived()))
{
uint8_t USB_DeviceState_LCL = USB_DeviceState;
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
return ENDPOINT_RWCSTREAM_DeviceDisconnected;
- a2e: 82 e0 ldi r24, 0x02 ; 2
- a30: 08 95 ret
+ c40: 82 e0 ldi r24, 0x02 ; 2
+ c42: 08 95 ret
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
return ENDPOINT_RWCSTREAM_BusSuspended;
- a32: 83 e0 ldi r24, 0x03 ; 3
+ c44: 83 e0 ldi r24, 0x03 ; 3
}
return ENDPOINT_RWCSTREAM_NoError;
}
- a34: 08 95 ret
+ c46: 08 95 ret
-00000a36 <Endpoint_Write_Control_PStream_LE>:
+00000c48 <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));
- a36: e8 2f mov r30, r24
- a38: f9 2f mov r31, r25
+ c48: e8 2f mov r30, r24
+ c4a: f9 2f mov r31, r25
bool LastPacketFull = false;
if (Length > USB_ControlRequest.wLength)
- a3a: 80 91 95 02 lds r24, 0x0295
- a3e: 90 91 96 02 lds r25, 0x0296
- a42: 86 17 cp r24, r22
- a44: 97 07 cpc r25, r23
- a46: 18 f4 brcc .+6 ; 0xa4e <Endpoint_Write_Control_PStream_LE+0x18>
- a48: bc 01 movw r22, r24
- a4a: 20 e0 ldi r18, 0x00 ; 0
- a4c: 37 c0 rjmp .+110 ; 0xabc <Endpoint_Write_Control_PStream_LE+0x86>
+ c4c: 80 91 a2 02 lds r24, 0x02A2
+ c50: 90 91 a3 02 lds r25, 0x02A3
+ c54: 86 17 cp r24, r22
+ c56: 97 07 cpc r25, r23
+ c58: 18 f4 brcc .+6 ; 0xc60 <Endpoint_Write_Control_PStream_LE+0x18>
+ c5a: bc 01 movw r22, r24
+ c5c: 20 e0 ldi r18, 0x00 ; 0
+ c5e: 36 c0 rjmp .+108 ; 0xccc <Endpoint_Write_Control_PStream_LE+0x84>
Length = USB_ControlRequest.wLength;
else if (!(Length))
- a4e: 61 15 cp r22, r1
- a50: 71 05 cpc r23, r1
- a52: d9 f7 brne .-10 ; 0xa4a <Endpoint_Write_Control_PStream_LE+0x14>
+ c60: 61 15 cp r22, r1
+ c62: 71 05 cpc r23, r1
+ c64: d9 f7 brne .-10 ; 0xc5c <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));
- a54: 80 91 e8 00 lds r24, 0x00E8
- a58: 8e 77 andi r24, 0x7E ; 126
- a5a: 80 93 e8 00 sts 0x00E8, r24
- a5e: f5 cf rjmp .-22 ; 0xa4a <Endpoint_Write_Control_PStream_LE+0x14>
+ c66: 80 91 e8 00 lds r24, 0x00E8
+ c6a: 8e 77 andi r24, 0x7E ; 126
+ c6c: 80 93 e8 00 sts 0x00E8, r24
+ c70: f5 cf rjmp .-22 ; 0xc5c <Endpoint_Write_Control_PStream_LE+0x14>
Endpoint_ClearIN();
while (Length || LastPacketFull)
{
uint8_t USB_DeviceState_LCL = USB_DeviceState;
- a60: 80 91 8e 02 lds r24, 0x028E
+ c72: 8e b3 in r24, 0x1e ; 30
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
- a64: 88 23 and r24, r24
- a66: 09 f4 brne .+2 ; 0xa6a <Endpoint_Write_Control_PStream_LE+0x34>
- a68: 3f c0 rjmp .+126 ; 0xae8 <Endpoint_Write_Control_PStream_LE+0xb2>
+ c74: 88 23 and r24, r24
+ c76: 09 f4 brne .+2 ; 0xc7a <Endpoint_Write_Control_PStream_LE+0x32>
+ c78: 3e c0 rjmp .+124 ; 0xcf6 <Endpoint_Write_Control_PStream_LE+0xae>
return ENDPOINT_RWCSTREAM_DeviceDisconnected;
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
- a6a: 85 30 cpi r24, 0x05 ; 5
- a6c: c9 f1 breq .+114 ; 0xae0 <Endpoint_Write_Control_PStream_LE+0xaa>
+ c7a: 85 30 cpi r24, 0x05 ; 5
+ c7c: c1 f1 breq .+112 ; 0xcee <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);
- a6e: 80 91 e8 00 lds r24, 0x00E8
+ c7e: 80 91 e8 00 lds r24, 0x00E8
return ENDPOINT_RWCSTREAM_BusSuspended;
else if (Endpoint_IsSETUPReceived())
- a72: 83 fd sbrc r24, 3
- a74: 37 c0 rjmp .+110 ; 0xae4 <Endpoint_Write_Control_PStream_LE+0xae>
+ c82: 83 fd sbrc r24, 3
+ c84: 36 c0 rjmp .+108 ; 0xcf2 <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);
- a76: 80 91 e8 00 lds r24, 0x00E8
+ c86: 80 91 e8 00 lds r24, 0x00E8
return ENDPOINT_RWCSTREAM_HostAborted;
else if (Endpoint_IsOUTReceived())
- a7a: 82 fd sbrc r24, 2
- a7c: 2b c0 rjmp .+86 ; 0xad4 <Endpoint_Write_Control_PStream_LE+0x9e>
+ c8a: 82 fd sbrc r24, 2
+ c8c: 2a c0 rjmp .+84 ; 0xce2 <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);
- a7e: 80 91 e8 00 lds r24, 0x00E8
+ c8e: 80 91 e8 00 lds r24, 0x00E8
break;
if (Endpoint_IsINReady())
- a82: 80 ff sbrs r24, 0
- a84: 1b c0 rjmp .+54 ; 0xabc <Endpoint_Write_Control_PStream_LE+0x86>
+ c92: 80 ff sbrs r24, 0
+ c94: 1b c0 rjmp .+54 ; 0xccc <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;
- a86: 80 91 f2 00 lds r24, 0x00F2
- a8a: 90 e0 ldi r25, 0x00 ; 0
+ c96: 80 91 f2 00 lds r24, 0x00F2
+ c9a: 90 e0 ldi r25, 0x00 ; 0
{
uint16_t BytesInEndpoint = Endpoint_BytesInEndpoint();
while (Length && (BytesInEndpoint < USB_Device_ControlEndpointSize))
- a8c: 07 c0 rjmp .+14 ; 0xa9c <Endpoint_Write_Control_PStream_LE+0x66>
+ c9c: 07 c0 rjmp .+14 ; 0xcac <Endpoint_Write_Control_PStream_LE+0x64>
{
TEMPLATE_TRANSFER_BYTE(DataStream);
- a8e: 24 91 lpm r18, Z+
+ c9e: 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;
- a90: 20 93 f1 00 sts 0x00F1, r18
+ ca0: 20 93 f1 00 sts 0x00F1, r18
TEMPLATE_BUFFER_MOVE(DataStream, 1);
- a94: 31 96 adiw r30, 0x01 ; 1
+ ca4: 31 96 adiw r30, 0x01 ; 1
Length--;
- a96: 61 50 subi r22, 0x01 ; 1
- a98: 70 40 sbci r23, 0x00 ; 0
+ ca6: 61 50 subi r22, 0x01 ; 1
+ ca8: 70 40 sbci r23, 0x00 ; 0
BytesInEndpoint++;
- a9a: 01 96 adiw r24, 0x01 ; 1
+ caa: 01 96 adiw r24, 0x01 ; 1
if (Endpoint_IsINReady())
{
uint16_t BytesInEndpoint = Endpoint_BytesInEndpoint();
while (Length && (BytesInEndpoint < USB_Device_ControlEndpointSize))
- a9c: 61 15 cp r22, r1
- a9e: 71 05 cpc r23, r1
- aa0: 19 f0 breq .+6 ; 0xaa8 <Endpoint_Write_Control_PStream_LE+0x72>
- aa2: 88 30 cpi r24, 0x08 ; 8
- aa4: 91 05 cpc r25, r1
- aa6: 98 f3 brcs .-26 ; 0xa8e <Endpoint_Write_Control_PStream_LE+0x58>
+ cac: 61 15 cp r22, r1
+ cae: 71 05 cpc r23, r1
+ cb0: 19 f0 breq .+6 ; 0xcb8 <Endpoint_Write_Control_PStream_LE+0x70>
+ cb2: 88 30 cpi r24, 0x08 ; 8
+ cb4: 91 05 cpc r25, r1
+ cb6: 98 f3 brcs .-26 ; 0xc9e <Endpoint_Write_Control_PStream_LE+0x56>
TEMPLATE_BUFFER_MOVE(DataStream, 1);
Length--;
BytesInEndpoint++;
}
LastPacketFull = (BytesInEndpoint == USB_Device_ControlEndpointSize);
- aa8: 21 e0 ldi r18, 0x01 ; 1
- aaa: 88 30 cpi r24, 0x08 ; 8
- aac: 91 05 cpc r25, r1
- aae: 09 f0 breq .+2 ; 0xab2 <Endpoint_Write_Control_PStream_LE+0x7c>
- ab0: 20 e0 ldi r18, 0x00 ; 0
+ cb8: 21 e0 ldi r18, 0x01 ; 1
+ cba: 88 30 cpi r24, 0x08 ; 8
+ cbc: 91 05 cpc r25, r1
+ cbe: 09 f0 breq .+2 ; 0xcc2 <Endpoint_Write_Control_PStream_LE+0x7a>
+ cc0: 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));
- ab2: 80 91 e8 00 lds r24, 0x00E8
- ab6: 8e 77 andi r24, 0x7E ; 126
- ab8: 80 93 e8 00 sts 0x00E8, r24
+ cc2: 80 91 e8 00 lds r24, 0x00E8
+ cc6: 8e 77 andi r24, 0x7E ; 126
+ cc8: 80 93 e8 00 sts 0x00E8, r24
if (Length > USB_ControlRequest.wLength)
Length = USB_ControlRequest.wLength;
else if (!(Length))
Endpoint_ClearIN();
while (Length || LastPacketFull)
- abc: 61 15 cp r22, r1
- abe: 71 05 cpc r23, r1
- ac0: 79 f6 brne .-98 ; 0xa60 <Endpoint_Write_Control_PStream_LE+0x2a>
- ac2: 22 23 and r18, r18
- ac4: 69 f6 brne .-102 ; 0xa60 <Endpoint_Write_Control_PStream_LE+0x2a>
- ac6: 06 c0 rjmp .+12 ; 0xad4 <Endpoint_Write_Control_PStream_LE+0x9e>
+ ccc: 61 15 cp r22, r1
+ cce: 71 05 cpc r23, r1
+ cd0: 81 f6 brne .-96 ; 0xc72 <Endpoint_Write_Control_PStream_LE+0x2a>
+ cd2: 22 23 and r18, r18
+ cd4: 71 f6 brne .-100 ; 0xc72 <Endpoint_Write_Control_PStream_LE+0x2a>
+ cd6: 05 c0 rjmp .+10 ; 0xce2 <Endpoint_Write_Control_PStream_LE+0x9a>
}
}
while (!(Endpoint_IsOUTReceived()))
{
uint8_t USB_DeviceState_LCL = USB_DeviceState;
- ac8: 80 91 8e 02 lds r24, 0x028E
+ cd8: 8e b3 in r24, 0x1e ; 30
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
- acc: 88 23 and r24, r24
- ace: 61 f0 breq .+24 ; 0xae8 <Endpoint_Write_Control_PStream_LE+0xb2>
+ cda: 88 23 and r24, r24
+ cdc: 61 f0 breq .+24 ; 0xcf6 <Endpoint_Write_Control_PStream_LE+0xae>
return ENDPOINT_RWCSTREAM_DeviceDisconnected;
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
- ad0: 85 30 cpi r24, 0x05 ; 5
- ad2: 61 f0 breq .+24 ; 0xaec <Endpoint_Write_Control_PStream_LE+0xb6>
+ cde: 85 30 cpi r24, 0x05 ; 5
+ ce0: 61 f0 breq .+24 ; 0xcfa <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);
- ad4: 80 91 e8 00 lds r24, 0x00E8
+ ce2: 80 91 e8 00 lds r24, 0x00E8
LastPacketFull = (BytesInEndpoint == USB_Device_ControlEndpointSize);
Endpoint_ClearIN();
}
}
while (!(Endpoint_IsOUTReceived()))
- ad8: 82 ff sbrs r24, 2
- ada: f6 cf rjmp .-20 ; 0xac8 <Endpoint_Write_Control_PStream_LE+0x92>
+ ce6: 82 ff sbrs r24, 2
+ ce8: f7 cf rjmp .-18 ; 0xcd8 <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;
- adc: 80 e0 ldi r24, 0x00 ; 0
- ade: 08 95 ret
+ cea: 80 e0 ldi r24, 0x00 ; 0
+ cec: 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;
- ae0: 83 e0 ldi r24, 0x03 ; 3
- ae2: 08 95 ret
+ cee: 83 e0 ldi r24, 0x03 ; 3
+ cf0: 08 95 ret
else if (Endpoint_IsSETUPReceived())
return ENDPOINT_RWCSTREAM_HostAborted;
- ae4: 81 e0 ldi r24, 0x01 ; 1
- ae6: 08 95 ret
+ cf2: 81 e0 ldi r24, 0x01 ; 1
+ cf4: 08 95 ret
while (!(Endpoint_IsOUTReceived()))
{
uint8_t USB_DeviceState_LCL = USB_DeviceState;
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
return ENDPOINT_RWCSTREAM_DeviceDisconnected;
- ae8: 82 e0 ldi r24, 0x02 ; 2
- aea: 08 95 ret
+ cf6: 82 e0 ldi r24, 0x02 ; 2
+ cf8: 08 95 ret
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
return ENDPOINT_RWCSTREAM_BusSuspended;
- aec: 83 e0 ldi r24, 0x03 ; 3
+ cfa: 83 e0 ldi r24, 0x03 ; 3
}
return ENDPOINT_RWCSTREAM_NoError;
}
- aee: 08 95 ret
+ cfc: 08 95 ret
-00000af0 <Endpoint_ConfigureEndpoint_Prv>:
+00000cfe <Endpoint_ConfigureEndpoint_Prv>:
UECFG0X = UECFG0XData;
UECFG1X = UECFG1XData;
return Endpoint_IsConfigured();
#else
for (uint8_t EPNum = Number; EPNum < ENDPOINT_TOTAL_ENDPOINTS; EPNum++)
- af0: 98 2f mov r25, r24
- af2: 2c c0 rjmp .+88 ; 0xb4c <Endpoint_ConfigureEndpoint_Prv+0x5c>
+ cfe: 98 2f mov r25, r24
+ d00: 2c c0 rjmp .+88 ; 0xd5a <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);
- af4: 29 2f mov r18, r25
- af6: 2f 70 andi r18, 0x0F ; 15
- af8: 20 93 e9 00 sts 0x00E9, r18
+ d02: 29 2f mov r18, r25
+ d04: 2f 70 andi r18, 0x0F ; 15
+ d06: 20 93 e9 00 sts 0x00E9, r18
uint8_t UECFG1XTemp;
uint8_t UEIENXTemp;
Endpoint_SelectEndpoint(EPNum);
if (EPNum == Number)
- afc: 98 17 cp r25, r24
- afe: 39 f0 breq .+14 ; 0xb0e <Endpoint_ConfigureEndpoint_Prv+0x1e>
+ d0a: 98 17 cp r25, r24
+ d0c: 39 f0 breq .+14 ; 0xd1c <Endpoint_ConfigureEndpoint_Prv+0x1e>
UECFG1XTemp = UECFG1XData;
UEIENXTemp = 0;
}
else
{
UECFG0XTemp = UECFG0X;
- b00: 70 91 ec 00 lds r23, 0x00EC
+ d0e: 70 91 ec 00 lds r23, 0x00EC
UECFG1XTemp = UECFG1X;
- b04: 20 91 ed 00 lds r18, 0x00ED
+ d12: 20 91 ed 00 lds r18, 0x00ED
UEIENXTemp = UEIENX;
- b08: 50 91 f0 00 lds r21, 0x00F0
- b0c: 03 c0 rjmp .+6 ; 0xb14 <Endpoint_ConfigureEndpoint_Prv+0x24>
+ d16: 50 91 f0 00 lds r21, 0x00F0
+ d1a: 03 c0 rjmp .+6 ; 0xd22 <Endpoint_ConfigureEndpoint_Prv+0x24>
Endpoint_SelectEndpoint(EPNum);
if (EPNum == Number)
{
UECFG0XTemp = UECFG0XData;
UECFG1XTemp = UECFG1XData;
- b0e: 24 2f mov r18, r20
+ d1c: 24 2f mov r18, r20
Endpoint_SelectEndpoint(EPNum);
if (EPNum == Number)
{
UECFG0XTemp = UECFG0XData;
- b10: 76 2f mov r23, r22
+ d1e: 76 2f mov r23, r22
UECFG1XTemp = UECFG1XData;
UEIENXTemp = 0;
- b12: 50 e0 ldi r21, 0x00 ; 0
+ d20: 50 e0 ldi r21, 0x00 ; 0
UECFG0XTemp = UECFG0X;
UECFG1XTemp = UECFG1X;
UEIENXTemp = UEIENX;
}
if (!(UECFG1XTemp & (1 << ALLOC)))
- b14: 21 ff sbrs r18, 1
- b16: 19 c0 rjmp .+50 ; 0xb4a <Endpoint_ConfigureEndpoint_Prv+0x5a>
+ d22: 21 ff sbrs r18, 1
+ d24: 19 c0 rjmp .+50 ; 0xd58 <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);
- b18: 30 91 eb 00 lds r19, 0x00EB
- b1c: 3e 7f andi r19, 0xFE ; 254
- b1e: 30 93 eb 00 sts 0x00EB, r19
+ d26: 30 91 eb 00 lds r19, 0x00EB
+ d2a: 3e 7f andi r19, 0xFE ; 254
+ d2c: 30 93 eb 00 sts 0x00EB, r19
continue;
Endpoint_DisableEndpoint();
UECFG1X &= ~(1 << ALLOC);
- b22: 30 91 ed 00 lds r19, 0x00ED
- b26: 3d 7f andi r19, 0xFD ; 253
- b28: 30 93 ed 00 sts 0x00ED, r19
+ d30: 30 91 ed 00 lds r19, 0x00ED
+ d34: 3d 7f andi r19, 0xFD ; 253
+ d36: 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);
- b2c: 30 91 eb 00 lds r19, 0x00EB
- b30: 31 60 ori r19, 0x01 ; 1
- b32: 30 93 eb 00 sts 0x00EB, r19
+ d3a: 30 91 eb 00 lds r19, 0x00EB
+ d3e: 31 60 ori r19, 0x01 ; 1
+ d40: 30 93 eb 00 sts 0x00EB, r19
Endpoint_EnableEndpoint();
UECFG0X = UECFG0XTemp;
- b36: 70 93 ec 00 sts 0x00EC, r23
+ d44: 70 93 ec 00 sts 0x00EC, r23
UECFG1X = UECFG1XTemp;
- b3a: 20 93 ed 00 sts 0x00ED, r18
+ d48: 20 93 ed 00 sts 0x00ED, r18
UEIENX = UEIENXTemp;
- b3e: 50 93 f0 00 sts 0x00F0, r21
+ d4c: 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);
- b42: 20 91 ee 00 lds r18, 0x00EE
+ d50: 20 91 ee 00 lds r18, 0x00EE
if (!(Endpoint_IsConfigured()))
- b46: 27 ff sbrs r18, 7
- b48: 08 c0 rjmp .+16 ; 0xb5a <Endpoint_ConfigureEndpoint_Prv+0x6a>
+ d54: 27 ff sbrs r18, 7
+ d56: 08 c0 rjmp .+16 ; 0xd68 <Endpoint_ConfigureEndpoint_Prv+0x6a>
UECFG0X = UECFG0XData;
UECFG1X = UECFG1XData;
return Endpoint_IsConfigured();
#else
for (uint8_t EPNum = Number; EPNum < ENDPOINT_TOTAL_ENDPOINTS; EPNum++)
- b4a: 9f 5f subi r25, 0xFF ; 255
- b4c: 95 30 cpi r25, 0x05 ; 5
- b4e: 90 f2 brcs .-92 ; 0xaf4 <Endpoint_ConfigureEndpoint_Prv+0x4>
+ d58: 9f 5f subi r25, 0xFF ; 255
+ d5a: 95 30 cpi r25, 0x05 ; 5
+ d5c: 90 f2 brcs .-92 ; 0xd02 <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);
- b50: 8f 70 andi r24, 0x0F ; 15
- b52: 80 93 e9 00 sts 0x00E9, r24
+ d5e: 8f 70 andi r24, 0x0F ; 15
+ d60: 80 93 e9 00 sts 0x00E9, r24
if (!(Endpoint_IsConfigured()))
return false;
}
Endpoint_SelectEndpoint(Number);
return true;
- b56: 81 e0 ldi r24, 0x01 ; 1
- b58: 08 95 ret
+ d64: 81 e0 ldi r24, 0x01 ; 1
+ d66: 08 95 ret
UECFG0X = UECFG0XTemp;
UECFG1X = UECFG1XTemp;
UEIENX = UEIENXTemp;
if (!(Endpoint_IsConfigured()))
return false;
- b5a: 80 e0 ldi r24, 0x00 ; 0
+ d68: 80 e0 ldi r24, 0x00 ; 0
}
Endpoint_SelectEndpoint(Number);
return true;
#endif
}
- b5c: 08 95 ret
+ d6a: 08 95 ret
-00000b5e <Endpoint_ConfigureEndpointTable>:
+00000d6c <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)
{
- b5e: ef 92 push r14
- b60: ff 92 push r15
- b62: 0f 93 push r16
- b64: 1f 93 push r17
- b66: cf 93 push r28
- b68: df 93 push r29
- b6a: 16 2f mov r17, r22
+ d6c: ef 92 push r14
+ d6e: ff 92 push r15
+ d70: 0f 93 push r16
+ d72: 1f 93 push r17
+ d74: cf 93 push r28
+ d76: df 93 push r29
+ d78: 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;
- b6c: e8 2e mov r14, r24
- b6e: e7 01 movw r28, r14
- b70: 7e 01 movw r14, r28
- b72: f9 2e mov r15, r25
- b74: e7 01 movw r28, r14
+ d7a: e8 2e mov r14, r24
+ d7c: e7 01 movw r28, r14
+ d7e: 7e 01 movw r14, r28
+ d80: f9 2e mov r15, r25
+ d82: 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++)
- b76: 00 e0 ldi r16, 0x00 ; 0
- b78: 2a c0 rjmp .+84 ; 0xbce <Endpoint_ConfigureEndpointTable+0x70>
+ d84: 00 e0 ldi r16, 0x00 ; 0
+ d86: 2a c0 rjmp .+84 ; 0xddc <Endpoint_ConfigureEndpointTable+0x70>
{
if (!(Table[i].Address))
- b7a: 98 81 ld r25, Y
- b7c: 99 23 and r25, r25
- b7e: 29 f1 breq .+74 ; 0xbca <Endpoint_ConfigureEndpointTable+0x6c>
+ d88: 98 81 ld r25, Y
+ d8a: 99 23 and r25, r25
+ d8c: 29 f1 breq .+74 ; 0xdd8 <Endpoint_ConfigureEndpointTable+0x6c>
continue;
if (!(Endpoint_ConfigureEndpoint(Table[i].Address, Table[i].Type, Table[i].Size, Table[i].Banks)))
- b80: 6b 81 ldd r22, Y+3 ; 0x03
- b82: e9 81 ldd r30, Y+1 ; 0x01
- b84: fa 81 ldd r31, Y+2 ; 0x02
- b86: 2c 81 ldd r18, Y+4 ; 0x04
+ d8e: 6b 81 ldd r22, Y+3 ; 0x03
+ d90: e9 81 ldd r30, Y+1 ; 0x01
+ d92: fa 81 ldd r31, Y+2 ; 0x02
+ d94: 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);
- b88: 89 2f mov r24, r25
- b8a: 8f 70 andi r24, 0x0F ; 15
+ d96: 89 2f mov r24, r25
+ d98: 8f 70 andi r24, 0x0F ; 15
if (Number >= ENDPOINT_TOTAL_ENDPOINTS)
- b8c: 85 30 cpi r24, 0x05 ; 5
- b8e: 18 f5 brcc .+70 ; 0xbd6 <Endpoint_ConfigureEndpointTable+0x78>
+ d9a: 85 30 cpi r24, 0x05 ; 5
+ d9c: 18 f5 brcc .+70 ; 0xde4 <Endpoint_ConfigureEndpointTable+0x78>
return false;
return Endpoint_ConfigureEndpoint_Prv(Number,
((Type << EPTYPE0) | ((Address & ENDPOINT_DIR_IN) ? (1 << EPDIR) : 0)),
- b90: 62 95 swap r22
- b92: 66 0f add r22, r22
- b94: 66 0f add r22, r22
- b96: 60 7c andi r22, 0xC0 ; 192
- b98: 99 1f adc r25, r25
- b9a: 99 27 eor r25, r25
- b9c: 99 1f adc r25, r25
+ d9e: 62 95 swap r22
+ da0: 66 0f add r22, r22
+ da2: 66 0f add r22, r22
+ da4: 60 7c andi r22, 0xC0 ; 192
+ da6: 99 1f adc r25, r25
+ da8: 99 27 eor r25, r25
+ daa: 99 1f adc r25, r25
uint8_t Number = (Address & ENDPOINT_EPNUM_MASK);
if (Number >= ENDPOINT_TOTAL_ENDPOINTS)
return false;
return Endpoint_ConfigureEndpoint_Prv(Number,
- b9e: 69 2b or r22, r25
- ba0: 22 30 cpi r18, 0x02 ; 2
- ba2: 10 f0 brcs .+4 ; 0xba8 <Endpoint_ConfigureEndpointTable+0x4a>
- ba4: 96 e0 ldi r25, 0x06 ; 6
- ba6: 01 c0 rjmp .+2 ; 0xbaa <Endpoint_ConfigureEndpointTable+0x4c>
- ba8: 92 e0 ldi r25, 0x02 ; 2
+ dac: 69 2b or r22, r25
+ dae: 22 30 cpi r18, 0x02 ; 2
+ db0: 10 f0 brcs .+4 ; 0xdb6 <Endpoint_ConfigureEndpointTable+0x4a>
+ db2: 96 e0 ldi r25, 0x06 ; 6
+ db4: 01 c0 rjmp .+2 ; 0xdb8 <Endpoint_ConfigureEndpointTable+0x4c>
+ db6: 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;
- baa: 28 e0 ldi r18, 0x08 ; 8
- bac: 30 e0 ldi r19, 0x00 ; 0
+ db8: 28 e0 ldi r18, 0x08 ; 8
+ dba: 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;
- bae: 40 e0 ldi r20, 0x00 ; 0
- bb0: 03 c0 rjmp .+6 ; 0xbb8 <Endpoint_ConfigureEndpointTable+0x5a>
+ dbc: 40 e0 ldi r20, 0x00 ; 0
+ dbe: 03 c0 rjmp .+6 ; 0xdc6 <Endpoint_ConfigureEndpointTable+0x5a>
uint16_t CheckBytes = 8;
while (CheckBytes < Bytes)
{
MaskVal++;
- bb2: 4f 5f subi r20, 0xFF ; 255
+ dc0: 4f 5f subi r20, 0xFF ; 255
CheckBytes <<= 1;
- bb4: 22 0f add r18, r18
- bb6: 33 1f adc r19, r19
+ dc2: 22 0f add r18, r18
+ dc4: 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)
- bb8: 2e 17 cp r18, r30
- bba: 3f 07 cpc r19, r31
- bbc: d0 f3 brcs .-12 ; 0xbb2 <Endpoint_ConfigureEndpointTable+0x54>
+ dc6: 2e 17 cp r18, r30
+ dc8: 3f 07 cpc r19, r31
+ dca: d0 f3 brcs .-12 ; 0xdc0 <Endpoint_ConfigureEndpointTable+0x54>
{
MaskVal++;
CheckBytes <<= 1;
}
return (MaskVal << EPSIZE0);
- bbe: 42 95 swap r20
- bc0: 40 7f andi r20, 0xF0 ; 240
+ dcc: 42 95 swap r20
+ dce: 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,
- bc2: 49 2b or r20, r25
- bc4: 95 df rcall .-214 ; 0xaf0 <Endpoint_ConfigureEndpoint_Prv>
- bc6: 88 23 and r24, r24
- bc8: 31 f0 breq .+12 ; 0xbd6 <Endpoint_ConfigureEndpointTable+0x78>
+ dd0: 49 2b or r20, r25
+ dd2: 95 df rcall .-214 ; 0xcfe <Endpoint_ConfigureEndpoint_Prv>
+ dd4: 88 23 and r24, r24
+ dd6: 31 f0 breq .+12 ; 0xde4 <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++)
- bca: 0f 5f subi r16, 0xFF ; 255
- bcc: 25 96 adiw r28, 0x05 ; 5
- bce: 01 17 cp r16, r17
- bd0: a0 f2 brcs .-88 ; 0xb7a <Endpoint_ConfigureEndpointTable+0x1c>
+ dd8: 0f 5f subi r16, 0xFF ; 255
+ dda: 25 96 adiw r28, 0x05 ; 5
+ ddc: 01 17 cp r16, r17
+ dde: a0 f2 brcs .-88 ; 0xd88 <Endpoint_ConfigureEndpointTable+0x1c>
if (!(Endpoint_ConfigureEndpoint(Table[i].Address, Table[i].Type, Table[i].Size, Table[i].Banks)))
return false;
}
return true;
- bd2: 81 e0 ldi r24, 0x01 ; 1
- bd4: 01 c0 rjmp .+2 ; 0xbd8 <Endpoint_ConfigureEndpointTable+0x7a>
+ de0: 81 e0 ldi r24, 0x01 ; 1
+ de2: 01 c0 rjmp .+2 ; 0xde6 <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;
- bd6: 80 e0 ldi r24, 0x00 ; 0
+ de4: 80 e0 ldi r24, 0x00 ; 0
}
return true;
}
- bd8: df 91 pop r29
- bda: cf 91 pop r28
- bdc: 1f 91 pop r17
- bde: 0f 91 pop r16
- be0: ff 90 pop r15
- be2: ef 90 pop r14
- be4: 08 95 ret
-
-00000be6 <Endpoint_ClearStatusStage>:
+ de6: df 91 pop r29
+ de8: cf 91 pop r28
+ dea: 1f 91 pop r17
+ dec: 0f 91 pop r16
+ dee: ff 90 pop r15
+ df0: ef 90 pop r14
+ df2: 08 95 ret
+
+00000df4 <Endpoint_ClearStatusStage>:
}
}
void Endpoint_ClearStatusStage(void)
{
if (USB_ControlRequest.bmRequestType & REQDIR_DEVICETOHOST)
- be6: 80 91 8f 02 lds r24, 0x028F
- bea: 87 ff sbrs r24, 7
- bec: 13 c0 rjmp .+38 ; 0xc14 <Endpoint_ClearStatusStage+0x2e>
- bee: 04 c0 rjmp .+8 ; 0xbf8 <Endpoint_ClearStatusStage+0x12>
+ df4: 80 91 9c 02 lds r24, 0x029C
+ df8: 87 ff sbrs r24, 7
+ dfa: 11 c0 rjmp .+34 ; 0xe1e <Endpoint_ClearStatusStage+0x2a>
+ dfc: 03 c0 rjmp .+6 ; 0xe04 <Endpoint_ClearStatusStage+0x10>
{
while (!(Endpoint_IsOUTReceived()))
{
if (USB_DeviceState == DEVICE_STATE_Unattached)
- bf0: 80 91 8e 02 lds r24, 0x028E
- bf4: 88 23 and r24, r24
- bf6: b9 f0 breq .+46 ; 0xc26 <Endpoint_ClearStatusStage+0x40>
+ dfe: 8e b3 in r24, 0x1e ; 30
+ e00: 88 23 and r24, r24
+ e02: b1 f0 breq .+44 ; 0xe30 <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);
- bf8: 80 91 e8 00 lds r24, 0x00E8
+ e04: 80 91 e8 00 lds r24, 0x00E8
void Endpoint_ClearStatusStage(void)
{
if (USB_ControlRequest.bmRequestType & REQDIR_DEVICETOHOST)
{
while (!(Endpoint_IsOUTReceived()))
- bfc: 82 ff sbrs r24, 2
- bfe: f8 cf rjmp .-16 ; 0xbf0 <Endpoint_ClearStatusStage+0xa>
+ e08: 82 ff sbrs r24, 2
+ e0a: f9 cf rjmp .-14 ; 0xdfe <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));
- c00: 80 91 e8 00 lds r24, 0x00E8
- c04: 8b 77 andi r24, 0x7B ; 123
- c06: 80 93 e8 00 sts 0x00E8, r24
- c0a: 08 95 ret
+ e0c: 80 91 e8 00 lds r24, 0x00E8
+ e10: 8b 77 andi r24, 0x7B ; 123
+ e12: 80 93 e8 00 sts 0x00E8, r24
+ e16: 08 95 ret
}
else
{
while (!(Endpoint_IsINReady()))
{
if (USB_DeviceState == DEVICE_STATE_Unattached)
- c0c: 80 91 8e 02 lds r24, 0x028E
- c10: 88 23 and r24, r24
- c12: 49 f0 breq .+18 ; 0xc26 <Endpoint_ClearStatusStage+0x40>
+ e18: 8e b3 in r24, 0x1e ; 30
+ e1a: 88 23 and r24, r24
+ e1c: 49 f0 breq .+18 ; 0xe30 <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);
- c14: 80 91 e8 00 lds r24, 0x00E8
+ e1e: 80 91 e8 00 lds r24, 0x00E8
Endpoint_ClearOUT();
}
else
{
while (!(Endpoint_IsINReady()))
- c18: 80 ff sbrs r24, 0
- c1a: f8 cf rjmp .-16 ; 0xc0c <Endpoint_ClearStatusStage+0x26>
+ e22: 80 ff sbrs r24, 0
+ e24: f9 cf rjmp .-14 ; 0xe18 <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));
- c1c: 80 91 e8 00 lds r24, 0x00E8
- c20: 8e 77 andi r24, 0x7E ; 126
- c22: 80 93 e8 00 sts 0x00E8, r24
- c26: 08 95 ret
+ e26: 80 91 e8 00 lds r24, 0x00E8
+ e2a: 8e 77 andi r24, 0x7E ; 126
+ e2c: 80 93 e8 00 sts 0x00E8, r24
+ e30: 08 95 ret
-00000c28 <Endpoint_WaitUntilReady>:
+00000e32 <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;
- c28: 80 91 e4 00 lds r24, 0x00E4
- c2c: 90 91 e5 00 lds r25, 0x00E5
+ e32: 80 91 e4 00 lds r24, 0x00E4
+ e36: 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;
- c30: 44 e6 ldi r20, 0x64 ; 100
+ e3a: 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;
- c32: 20 91 ec 00 lds r18, 0x00EC
- c36: 20 ff sbrs r18, 0
- c38: 26 c0 rjmp .+76 ; 0xc86 <Endpoint_WaitUntilReady+0x5e>
+ e3c: 20 91 ec 00 lds r18, 0x00EC
+ e40: 20 ff sbrs r18, 0
+ e42: 25 c0 rjmp .+74 ; 0xe8e <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);
- c3a: 20 91 e8 00 lds r18, 0x00E8
+ e44: 20 91 e8 00 lds r18, 0x00E8
for (;;)
{
if (Endpoint_GetEndpointDirection() == ENDPOINT_DIR_IN)
{
if (Endpoint_IsINReady())
- c3e: 20 fd sbrc r18, 0
- c40: 16 c0 rjmp .+44 ; 0xc6e <Endpoint_WaitUntilReady+0x46>
+ e48: 20 fd sbrc r18, 0
+ e4a: 15 c0 rjmp .+42 ; 0xe76 <Endpoint_WaitUntilReady+0x44>
{
if (Endpoint_IsOUTReceived())
return ENDPOINT_READYWAIT_NoError;
}
uint8_t USB_DeviceState_LCL = USB_DeviceState;
- c42: 20 91 8e 02 lds r18, 0x028E
+ e4c: 2e b3 in r18, 0x1e ; 30
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
- c46: 22 23 and r18, r18
- c48: a1 f0 breq .+40 ; 0xc72 <Endpoint_WaitUntilReady+0x4a>
+ e4e: 22 23 and r18, r18
+ e50: a1 f0 breq .+40 ; 0xe7a <Endpoint_WaitUntilReady+0x48>
return ENDPOINT_READYWAIT_DeviceDisconnected;
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
- c4a: 25 30 cpi r18, 0x05 ; 5
- c4c: a1 f0 breq .+40 ; 0xc76 <Endpoint_WaitUntilReady+0x4e>
+ e52: 25 30 cpi r18, 0x05 ; 5
+ e54: a1 f0 breq .+40 ; 0xe7e <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);
- c4e: 20 91 eb 00 lds r18, 0x00EB
+ e56: 20 91 eb 00 lds r18, 0x00EB
return ENDPOINT_READYWAIT_BusSuspended;
else if (Endpoint_IsStalled())
- c52: 25 fd sbrc r18, 5
- c54: 12 c0 rjmp .+36 ; 0xc7a <Endpoint_WaitUntilReady+0x52>
- c56: 20 91 e4 00 lds r18, 0x00E4
- c5a: 30 91 e5 00 lds r19, 0x00E5
+ e5a: 25 fd sbrc r18, 5
+ e5c: 12 c0 rjmp .+36 ; 0xe82 <Endpoint_WaitUntilReady+0x50>
+ e5e: 20 91 e4 00 lds r18, 0x00E4
+ e62: 30 91 e5 00 lds r19, 0x00E5
return ENDPOINT_READYWAIT_EndpointStalled;
uint16_t CurrentFrameNumber = USB_Device_GetFrameNumber();
if (CurrentFrameNumber != PreviousFrameNumber)
- c5e: 28 17 cp r18, r24
- c60: 39 07 cpc r19, r25
- c62: 39 f3 breq .-50 ; 0xc32 <Endpoint_WaitUntilReady+0xa>
+ e66: 28 17 cp r18, r24
+ e68: 39 07 cpc r19, r25
+ e6a: 41 f3 breq .-48 ; 0xe3c <Endpoint_WaitUntilReady+0xa>
{
PreviousFrameNumber = CurrentFrameNumber;
if (!(TimeoutMSRem--))
- c64: 44 23 and r20, r20
- c66: 59 f0 breq .+22 ; 0xc7e <Endpoint_WaitUntilReady+0x56>
- c68: 41 50 subi r20, 0x01 ; 1
- c6a: c9 01 movw r24, r18
- c6c: e2 cf rjmp .-60 ; 0xc32 <Endpoint_WaitUntilReady+0xa>
+ e6c: 44 23 and r20, r20
+ e6e: 59 f0 breq .+22 ; 0xe86 <Endpoint_WaitUntilReady+0x54>
+ e70: 41 50 subi r20, 0x01 ; 1
+ e72: c9 01 movw r24, r18
+ e74: e3 cf rjmp .-58 ; 0xe3c <Endpoint_WaitUntilReady+0xa>
for (;;)
{
if (Endpoint_GetEndpointDirection() == ENDPOINT_DIR_IN)
{
if (Endpoint_IsINReady())
return ENDPOINT_READYWAIT_NoError;
- c6e: 80 e0 ldi r24, 0x00 ; 0
- c70: 08 95 ret
+ e76: 80 e0 ldi r24, 0x00 ; 0
+ e78: 08 95 ret
}
uint8_t USB_DeviceState_LCL = USB_DeviceState;
if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
return ENDPOINT_READYWAIT_DeviceDisconnected;
- c72: 82 e0 ldi r24, 0x02 ; 2
- c74: 08 95 ret
+ e7a: 82 e0 ldi r24, 0x02 ; 2
+ e7c: 08 95 ret
else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
return ENDPOINT_READYWAIT_BusSuspended;
- c76: 83 e0 ldi r24, 0x03 ; 3
- c78: 08 95 ret
+ e7e: 83 e0 ldi r24, 0x03 ; 3
+ e80: 08 95 ret
else if (Endpoint_IsStalled())
return ENDPOINT_READYWAIT_EndpointStalled;
- c7a: 81 e0 ldi r24, 0x01 ; 1
- c7c: 08 95 ret
+ e82: 81 e0 ldi r24, 0x01 ; 1
+ e84: 08 95 ret
if (CurrentFrameNumber != PreviousFrameNumber)
{
PreviousFrameNumber = CurrentFrameNumber;
if (!(TimeoutMSRem--))
return ENDPOINT_READYWAIT_Timeout;
- c7e: 84 e0 ldi r24, 0x04 ; 4
- c80: 08 95 ret
+ e86: 84 e0 ldi r24, 0x04 ; 4
+ e88: 08 95 ret
return ENDPOINT_READYWAIT_NoError;
}
else
{
if (Endpoint_IsOUTReceived())
return ENDPOINT_READYWAIT_NoError;
- c82: 80 e0 ldi r24, 0x00 ; 0
+ e8a: 80 e0 ldi r24, 0x00 ; 0
if (!(TimeoutMSRem--))
return ENDPOINT_READYWAIT_Timeout;
}
}
}
- c84: 08 95 ret
+ e8c: 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);
- c86: 20 91 e8 00 lds r18, 0x00E8
+ e8e: 20 91 e8 00 lds r18, 0x00E8
if (Endpoint_IsINReady())
return ENDPOINT_READYWAIT_NoError;
}
else
{
if (Endpoint_IsOUTReceived())
- c8a: 22 ff sbrs r18, 2
- c8c: da cf rjmp .-76 ; 0xc42 <Endpoint_WaitUntilReady+0x1a>
- c8e: f9 cf rjmp .-14 ; 0xc82 <Endpoint_WaitUntilReady+0x5a>
+ e92: 22 ff sbrs r18, 2
+ e94: db cf rjmp .-74 ; 0xe4c <Endpoint_WaitUntilReady+0x1a>
+ e96: f9 cf rjmp .-14 ; 0xe8a <Endpoint_WaitUntilReady+0x58>
-00000c90 <USB_ResetInterface>:
+00000e98 <USB_ResetInterface>:
{
#if defined(USB_CAN_BE_BOTH)
bool UIDModeSelectEnabled = ((UHWCON & (1 << UIDE)) != 0);
#endif
USB_INT_DisableAllInterrupts();
- c90: 41 d0 rcall .+130 ; 0xd14 <USB_INT_DisableAllInterrupts>
+ e98: 40 d0 rcall .+128 ; 0xf1a <USB_INT_DisableAllInterrupts>
USB_INT_ClearAllInterrupts();
- c92: 43 d0 rcall .+134 ; 0xd1a <USB_INT_ClearAllInterrupts>
+ e9a: 42 d0 rcall .+132 ; 0xf20 <USB_INT_ClearAllInterrupts>
}
static inline void USB_Controller_Reset(void) ATTR_ALWAYS_INLINE;
static inline void USB_Controller_Reset(void)
{
USBCON &= ~(1 << USBE);
- c94: 80 91 d8 00 lds r24, 0x00D8
- c98: 8f 77 andi r24, 0x7F ; 127
- c9a: 80 93 d8 00 sts 0x00D8, r24
+ e9c: 80 91 d8 00 lds r24, 0x00D8
+ ea0: 8f 77 andi r24, 0x7F ; 127
+ ea2: 80 93 d8 00 sts 0x00D8, r24
USBCON |= (1 << USBE);
- c9e: 80 91 d8 00 lds r24, 0x00D8
- ca2: 80 68 ori r24, 0x80 ; 128
- ca4: 80 93 d8 00 sts 0x00D8, r24
+ ea6: 80 91 d8 00 lds r24, 0x00D8
+ eaa: 80 68 ori r24, 0x80 ; 128
+ eac: 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);
- ca8: 80 91 d8 00 lds r24, 0x00D8
- cac: 8f 7d andi r24, 0xDF ; 223
- cae: 80 93 d8 00 sts 0x00D8, r24
+ eb0: 80 91 d8 00 lds r24, 0x00D8
+ eb4: 8f 7d andi r24, 0xDF ; 223
+ eb6: 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;
- cb2: 84 e0 ldi r24, 0x04 ; 4
- cb4: 89 bd out 0x29, r24 ; 41
+ eba: 84 e0 ldi r24, 0x04 ; 4
+ ebc: 89 bd out 0x29, r24 ; 41
PLLCSR = (USB_PLL_PSC | (1 << PLLE));
- cb6: 86 e0 ldi r24, 0x06 ; 6
- cb8: 89 bd out 0x29, r24 ; 41
+ ebe: 86 e0 ldi r24, 0x06 ; 6
+ ec0: 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()));
- cba: 09 b4 in r0, 0x29 ; 41
- cbc: 00 fe sbrs r0, 0
- cbe: fd cf rjmp .-6 ; 0xcba <USB_ResetInterface+0x2a>
+ ec2: 09 b4 in r0, 0x29 ; 41
+ ec4: 00 fe sbrs r0, 0
+ ec6: fd cf rjmp .-6 ; 0xec2 <USB_ResetInterface+0x2a>
}
#if defined(USB_CAN_BE_DEVICE)
static void USB_Init_Device(void)
{
USB_DeviceState = DEVICE_STATE_Unattached;
- cc0: 10 92 8e 02 sts 0x028E, r1
+ ec8: 1e ba out 0x1e, r1 ; 30
USB_Device_ConfigurationNumber = 0;
- cc4: 10 92 8a 02 sts 0x028A, r1
+ eca: 10 92 98 02 sts 0x0298, r1
#if !defined(NO_DEVICE_REMOTE_WAKEUP)
USB_Device_RemoteWakeupEnabled = false;
- cc8: 10 92 8c 02 sts 0x028C, r1
+ ece: 10 92 9a 02 sts 0x029A, r1
#endif
#if !defined(NO_DEVICE_SELF_POWER)
USB_Device_CurrentlySelfPowered = false;
- ccc: 10 92 8b 02 sts 0x028B, r1
+ ed2: 10 92 99 02 sts 0x0299, r1
uint8_t Number = (Address & ENDPOINT_EPNUM_MASK);
if (Number >= ENDPOINT_TOTAL_ENDPOINTS)
return false;
return Endpoint_ConfigureEndpoint_Prv(Number,
- cd0: 80 e0 ldi r24, 0x00 ; 0
- cd2: 60 e0 ldi r22, 0x00 ; 0
- cd4: 42 e0 ldi r20, 0x02 ; 2
- cd6: 0c df rcall .-488 ; 0xaf0 <Endpoint_ConfigureEndpoint_Prv>
+ ed6: 80 e0 ldi r24, 0x00 ; 0
+ ed8: 60 e0 ldi r22, 0x00 ; 0
+ eda: 42 e0 ldi r20, 0x02 ; 2
+ edc: 10 df rcall .-480 ; 0xcfe <Endpoint_ConfigureEndpoint_Prv>
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
UDINT &= ~(1 << WAKEUPI);
break;
case USB_INT_SUSPI:
UDINT &= ~(1 << SUSPI);
- cd8: 80 91 e1 00 lds r24, 0x00E1
- cdc: 8e 7f andi r24, 0xFE ; 254
- cde: 80 93 e1 00 sts 0x00E1, r24
+ ede: 80 91 e1 00 lds r24, 0x00E1
+ ee2: 8e 7f andi r24, 0xFE ; 254
+ ee4: 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);
- ce2: 80 91 e2 00 lds r24, 0x00E2
- ce6: 81 60 ori r24, 0x01 ; 1
- ce8: 80 93 e2 00 sts 0x00E2, r24
+ ee8: 80 91 e2 00 lds r24, 0x00E2
+ eec: 81 60 ori r24, 0x01 ; 1
+ eee: 80 93 e2 00 sts 0x00E2, r24
break;
case USB_INT_EORSTI:
UDIEN |= (1 << EORSTE);
- cec: 80 91 e2 00 lds r24, 0x00E2
- cf0: 88 60 ori r24, 0x08 ; 8
- cf2: 80 93 e2 00 sts 0x00E2, r24
+ ef2: 80 91 e2 00 lds r24, 0x00E2
+ ef6: 88 60 ori r24, 0x08 ; 8
+ ef8: 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);
- cf6: 80 91 e0 00 lds r24, 0x00E0
- cfa: 8e 7f andi r24, 0xFE ; 254
- cfc: 80 93 e0 00 sts 0x00E0, r24
+ efc: 80 91 e0 00 lds r24, 0x00E0
+ f00: 8e 7f andi r24, 0xFE ; 254
+ f02: 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
}
- d00: 08 95 ret
+ f06: 08 95 ret
-00000d02 <USB_Init>:
+00000f08 <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);
- d02: e3 e6 ldi r30, 0x63 ; 99
- d04: f0 e0 ldi r31, 0x00 ; 0
- d06: 80 81 ld r24, Z
- d08: 8e 7f andi r24, 0xFE ; 254
- d0a: 80 83 st Z, r24
+ f08: e3 e6 ldi r30, 0x63 ; 99
+ f0a: f0 e0 ldi r31, 0x00 ; 0
+ f0c: 80 81 ld r24, Z
+ f0e: 8e 7f andi r24, 0xFE ; 254
+ f10: 80 83 st Z, r24
UHWCON &= ~(1 << UIDE);
USB_CurrentMode = Mode;
}
#endif
USB_IsInitialized = true;
- d0c: 81 e0 ldi r24, 0x01 ; 1
- d0e: 80 93 8d 02 sts 0x028D, r24
+ f12: 81 e0 ldi r24, 0x01 ; 1
+ f14: 80 93 9b 02 sts 0x029B, r24
USB_ResetInterface();
}
- d12: be cf rjmp .-132 ; 0xc90 <USB_ResetInterface>
+ f18: bf cf rjmp .-130 ; 0xe98 <USB_ResetInterface>
-00000d14 <USB_INT_DisableAllInterrupts>:
+00000f1a <USB_INT_DisableAllInterrupts>:
#if defined(USB_CAN_BE_HOST)
UHIEN = 0;
#endif
#if defined(USB_CAN_BE_DEVICE)
UDIEN = 0;
- d14: 10 92 e2 00 sts 0x00E2, r1
+ f1a: 10 92 e2 00 sts 0x00E2, r1
#endif
}
- d18: 08 95 ret
+ f1e: 08 95 ret
-00000d1a <USB_INT_ClearAllInterrupts>:
+00000f20 <USB_INT_ClearAllInterrupts>:
#if defined(USB_CAN_BE_HOST)
UHINT = 0;
#endif
#if defined(USB_CAN_BE_DEVICE)
UDINT = 0;
- d1a: 10 92 e1 00 sts 0x00E1, r1
+ f20: 10 92 e1 00 sts 0x00E1, r1
#endif
}
- d1e: 08 95 ret
+ f24: 08 95 ret
-00000d20 <__vector_11>:
+00000f26 <__vector_11>:
ISR(USB_GEN_vect, ISR_BLOCK)
{
- d20: 1f 92 push r1
- d22: 0f 92 push r0
- d24: 0f b6 in r0, 0x3f ; 63
- d26: 0f 92 push r0
- d28: 11 24 eor r1, r1
- d2a: 2f 93 push r18
- d2c: 3f 93 push r19
- d2e: 4f 93 push r20
- d30: 5f 93 push r21
- d32: 6f 93 push r22
- d34: 7f 93 push r23
- d36: 8f 93 push r24
- d38: 9f 93 push r25
- d3a: af 93 push r26
- d3c: bf 93 push r27
- d3e: ef 93 push r30
- d40: ff 93 push r31
+ f26: 1f 92 push r1
+ f28: 0f 92 push r0
+ f2a: 0f b6 in r0, 0x3f ; 63
+ f2c: 0f 92 push r0
+ f2e: 11 24 eor r1, r1
+ f30: 2f 93 push r18
+ f32: 3f 93 push r19
+ f34: 4f 93 push r20
+ f36: 5f 93 push r21
+ f38: 6f 93 push r22
+ f3a: 7f 93 push r23
+ f3c: 8f 93 push r24
+ f3e: 9f 93 push r25
+ f40: af 93 push r26
+ f42: bf 93 push r27
+ f44: ef 93 push r30
+ f46: 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));
- d42: 80 91 e1 00 lds r24, 0x00E1
+ f48: 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))
- d46: 82 ff sbrs r24, 2
- d48: 0a c0 rjmp .+20 ; 0xd5e <__vector_11+0x3e>
+ f4c: 82 ff sbrs r24, 2
+ f4e: 0a c0 rjmp .+20 ; 0xf64 <__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));
- d4a: 80 91 e2 00 lds r24, 0x00E2
- d4e: 82 ff sbrs r24, 2
- d50: 06 c0 rjmp .+12 ; 0xd5e <__vector_11+0x3e>
+ f50: 80 91 e2 00 lds r24, 0x00E2
+ f54: 82 ff sbrs r24, 2
+ f56: 06 c0 rjmp .+12 ; 0xf64 <__vector_11+0x3e>
break;
case USB_INT_EORSTI:
UDINT &= ~(1 << EORSTI);
break;
case USB_INT_SOFI:
UDINT &= ~(1 << SOFI);
- d52: 80 91 e1 00 lds r24, 0x00E1
- d56: 8b 7f andi r24, 0xFB ; 251
- d58: 80 93 e1 00 sts 0x00E1, r24
+ f58: 80 91 e1 00 lds r24, 0x00E1
+ f5c: 8b 7f andi r24, 0xFB ; 251
+ f5e: 80 93 e1 00 sts 0x00E1, r24
{
USB_INT_Clear(USB_INT_SOFI);
EVENT_USB_Device_StartOfFrame();
- d5c: e6 d1 rcall .+972 ; 0x112a <USB_Event_Stub>
+ f62: 21 d2 rcall .+1090 ; 0x13a6 <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));
- d5e: 80 91 e1 00 lds r24, 0x00E1
+ f64: 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))
- d62: 80 ff sbrs r24, 0
- d64: 17 c0 rjmp .+46 ; 0xd94 <__vector_11+0x74>
+ f68: 80 ff sbrs r24, 0
+ f6a: 16 c0 rjmp .+44 ; 0xf98 <__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));
- d66: 80 91 e2 00 lds r24, 0x00E2
- d6a: 80 ff sbrs r24, 0
- d6c: 13 c0 rjmp .+38 ; 0xd94 <__vector_11+0x74>
+ f6c: 80 91 e2 00 lds r24, 0x00E2
+ f70: 80 ff sbrs r24, 0
+ f72: 12 c0 rjmp .+36 ; 0xf98 <__vector_11+0x72>
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
UDIEN &= ~(1 << WAKEUPE);
break;
case USB_INT_SUSPI:
UDIEN &= ~(1 << SUSPE);
- d6e: 80 91 e2 00 lds r24, 0x00E2
- d72: 8e 7f andi r24, 0xFE ; 254
- d74: 80 93 e2 00 sts 0x00E2, r24
+ f74: 80 91 e2 00 lds r24, 0x00E2
+ f78: 8e 7f andi r24, 0xFE ; 254
+ f7a: 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);
- d78: 80 91 e2 00 lds r24, 0x00E2
- d7c: 80 61 ori r24, 0x10 ; 16
- d7e: 80 93 e2 00 sts 0x00E2, r24
+ f7e: 80 91 e2 00 lds r24, 0x00E2
+ f82: 80 61 ori r24, 0x10 ; 16
+ f84: 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);
- d82: 80 91 d8 00 lds r24, 0x00D8
- d86: 80 62 ori r24, 0x20 ; 32
- d88: 80 93 d8 00 sts 0x00D8, r24
+ f88: 80 91 d8 00 lds r24, 0x00D8
+ f8c: 80 62 ori r24, 0x20 ; 32
+ f8e: 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;
- d8c: 19 bc out 0x29, r1 ; 41
+ f92: 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;
- d8e: 10 92 8e 02 sts 0x028E, r1
+ f94: 1e ba out 0x1e, r1 ; 30
EVENT_USB_Device_Disconnect();
- d92: 36 dc rcall .-1940 ; 0x600 <EVENT_USB_Device_Disconnect>
+ f96: aa db rcall .-2220 ; 0x6ec <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));
- d94: 80 91 e1 00 lds r24, 0x00E1
+ f98: 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))
- d98: 84 ff sbrs r24, 4
- d9a: 2d c0 rjmp .+90 ; 0xdf6 <__vector_11+0xd6>
+ f9c: 84 ff sbrs r24, 4
+ f9e: 2c c0 rjmp .+88 ; 0xff8 <__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));
- d9c: 80 91 e2 00 lds r24, 0x00E2
- da0: 84 ff sbrs r24, 4
- da2: 29 c0 rjmp .+82 ; 0xdf6 <__vector_11+0xd6>
+ fa0: 80 91 e2 00 lds r24, 0x00E2
+ fa4: 84 ff sbrs r24, 4
+ fa6: 28 c0 rjmp .+80 ; 0xff8 <__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;
- da4: 84 e0 ldi r24, 0x04 ; 4
- da6: 89 bd out 0x29, r24 ; 41
+ fa8: 84 e0 ldi r24, 0x04 ; 4
+ faa: 89 bd out 0x29, r24 ; 41
PLLCSR = (USB_PLL_PSC | (1 << PLLE));
- da8: 86 e0 ldi r24, 0x06 ; 6
- daa: 89 bd out 0x29, r24 ; 41
+ fac: 86 e0 ldi r24, 0x06 ; 6
+ fae: 89 bd out 0x29, r24 ; 41
{
if (!(USB_Options & USB_OPT_MANUAL_PLL))
{
USB_PLL_On();
while (!(USB_PLL_IsReady()));
- dac: 09 b4 in r0, 0x29 ; 41
- dae: 00 fe sbrs r0, 0
- db0: fd cf rjmp .-6 ; 0xdac <__vector_11+0x8c>
+ fb0: 09 b4 in r0, 0x29 ; 41
+ fb2: 00 fe sbrs r0, 0
+ fb4: fd cf rjmp .-6 ; 0xfb0 <__vector_11+0x8a>
}
static inline void USB_CLK_Unfreeze(void) ATTR_ALWAYS_INLINE;
static inline void USB_CLK_Unfreeze(void)
{
USBCON &= ~(1 << FRZCLK);
- db2: 80 91 d8 00 lds r24, 0x00D8
- db6: 8f 7d andi r24, 0xDF ; 223
- db8: 80 93 d8 00 sts 0x00D8, r24
+ fb6: 80 91 d8 00 lds r24, 0x00D8
+ fba: 8f 7d andi r24, 0xDF ; 223
+ fbc: 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);
- dbc: 80 91 e1 00 lds r24, 0x00E1
- dc0: 8f 7e andi r24, 0xEF ; 239
- dc2: 80 93 e1 00 sts 0x00E1, r24
+ fc0: 80 91 e1 00 lds r24, 0x00E1
+ fc4: 8f 7e andi r24, 0xEF ; 239
+ fc6: 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);
- dc6: 80 91 e2 00 lds r24, 0x00E2
- dca: 8f 7e andi r24, 0xEF ; 239
- dcc: 80 93 e2 00 sts 0x00E2, r24
+ fca: 80 91 e2 00 lds r24, 0x00E2
+ fce: 8f 7e andi r24, 0xEF ; 239
+ fd0: 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);
- dd0: 80 91 e2 00 lds r24, 0x00E2
- dd4: 81 60 ori r24, 0x01 ; 1
- dd6: 80 93 e2 00 sts 0x00E2, r24
+ fd4: 80 91 e2 00 lds r24, 0x00E2
+ fd8: 81 60 ori r24, 0x01 ; 1
+ fda: 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)
- dda: 80 91 8a 02 lds r24, 0x028A
- dde: 88 23 and r24, r24
- de0: 21 f4 brne .+8 ; 0xdea <__vector_11+0xca>
+ fde: 80 91 98 02 lds r24, 0x0298
+ fe2: 88 23 and r24, r24
+ fe4: 21 f4 brne .+8 ; 0xfee <__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));
- de2: 80 91 e3 00 lds r24, 0x00E3
+ fe6: 80 91 e3 00 lds r24, 0x00E3
USB_DeviceState = DEVICE_STATE_Configured;
else
USB_DeviceState = (USB_Device_IsAddressSet()) ? DEVICE_STATE_Configured : DEVICE_STATE_Powered;
- de6: 87 ff sbrs r24, 7
- de8: 02 c0 rjmp .+4 ; 0xdee <__vector_11+0xce>
- dea: 84 e0 ldi r24, 0x04 ; 4
- dec: 01 c0 rjmp .+2 ; 0xdf0 <__vector_11+0xd0>
- dee: 81 e0 ldi r24, 0x01 ; 1
- df0: 80 93 8e 02 sts 0x028E, r24
+ fea: 87 ff sbrs r24, 7
+ fec: 02 c0 rjmp .+4 ; 0xff2 <__vector_11+0xcc>
+ fee: 84 e0 ldi r24, 0x04 ; 4
+ ff0: 01 c0 rjmp .+2 ; 0xff4 <__vector_11+0xce>
+ ff2: 81 e0 ldi r24, 0x01 ; 1
+ ff4: 8e bb out 0x1e, r24 ; 30
#if defined(USB_SERIES_2_AVR) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
EVENT_USB_Device_Connect();
- df4: 04 dc rcall .-2040 ; 0x5fe <EVENT_USB_Device_Connect>
+ ff6: 79 db rcall .-2318 ; 0x6ea <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));
- df6: 80 91 e1 00 lds r24, 0x00E1
+ ff8: 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))
- dfa: 83 ff sbrs r24, 3
- dfc: 22 c0 rjmp .+68 ; 0xe42 <__vector_11+0x122>
+ ffc: 83 ff sbrs r24, 3
+ ffe: 26 c0 rjmp .+76 ; 0x104c <__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));
- dfe: 80 91 e2 00 lds r24, 0x00E2
- e02: 83 ff sbrs r24, 3
- e04: 1e c0 rjmp .+60 ; 0xe42 <__vector_11+0x122>
+ 1000: 80 91 e2 00 lds r24, 0x00E2
+ 1004: 83 ff sbrs r24, 3
+ 1006: 22 c0 rjmp .+68 ; 0x104c <__vector_11+0x126>
break;
case USB_INT_SUSPI:
UDINT &= ~(1 << SUSPI);
break;
case USB_INT_EORSTI:
UDINT &= ~(1 << EORSTI);
- e06: 80 91 e1 00 lds r24, 0x00E1
- e0a: 87 7f andi r24, 0xF7 ; 247
- e0c: 80 93 e1 00 sts 0x00E1, r24
+ 1008: 80 91 e1 00 lds r24, 0x00E1
+ 100c: 87 7f andi r24, 0xF7 ; 247
+ 100e: 80 93 e1 00 sts 0x00E1, r24
{
USB_INT_Clear(USB_INT_EORSTI);
USB_DeviceState = DEVICE_STATE_Default;
- e10: 82 e0 ldi r24, 0x02 ; 2
- e12: 80 93 8e 02 sts 0x028E, r24
+ 1012: 82 e0 ldi r24, 0x02 ; 2
+ 1014: 8e bb out 0x1e, r24 ; 30
USB_Device_ConfigurationNumber = 0;
- e16: 10 92 8a 02 sts 0x028A, r1
+ 1016: 10 92 98 02 sts 0x0298, r1
#if defined(USB_CAN_BE_DEVICE)
case USB_INT_WAKEUPI:
UDINT &= ~(1 << WAKEUPI);
break;
case USB_INT_SUSPI:
UDINT &= ~(1 << SUSPI);
- e1a: 80 91 e1 00 lds r24, 0x00E1
- e1e: 8e 7f andi r24, 0xFE ; 254
- e20: 80 93 e1 00 sts 0x00E1, r24
+ 101a: 80 91 e1 00 lds r24, 0x00E1
+ 101e: 8e 7f andi r24, 0xFE ; 254
+ 1020: 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);
- e24: 80 91 e2 00 lds r24, 0x00E2
- e28: 8e 7f andi r24, 0xFE ; 254
- e2a: 80 93 e2 00 sts 0x00E2, r24
+ 1024: 80 91 e2 00 lds r24, 0x00E2
+ 1028: 8e 7f andi r24, 0xFE ; 254
+ 102a: 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);
- e2e: 80 91 e2 00 lds r24, 0x00E2
- e32: 80 61 ori r24, 0x10 ; 16
- e34: 80 93 e2 00 sts 0x00E2, r24
+ 102e: 80 91 e2 00 lds r24, 0x00E2
+ 1032: 80 61 ori r24, 0x10 ; 16
+ 1034: 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,
- e38: 80 e0 ldi r24, 0x00 ; 0
- e3a: 60 e0 ldi r22, 0x00 ; 0
- e3c: 42 e0 ldi r20, 0x02 ; 2
- e3e: 58 de rcall .-848 ; 0xaf0 <Endpoint_ConfigureEndpoint_Prv>
+ 1038: 80 e0 ldi r24, 0x00 ; 0
+ 103a: 60 e0 ldi r22, 0x00 ; 0
+ 103c: 42 e0 ldi r20, 0x02 ; 2
+ 103e: 5f de rcall .-834 ; 0xcfe <Endpoint_ConfigureEndpoint_Prv>
+ break;
+ case USB_INT_SOFI:
+ UDIEN |= (1 << SOFE);
+ break;
+ case USB_INT_RXSTPI:
+ UEIENX |= (1 << RXSTPE);
+ 1040: 80 91 f0 00 lds r24, 0x00F0
+ 1044: 88 60 ori r24, 0x08 ; 8
+ 1046: 80 93 f0 00 sts 0x00F0, r24
#if defined(INTERRUPT_CONTROL_ENDPOINT)
USB_INT_Enable(USB_INT_RXSTPI);
#endif
EVENT_USB_Device_Reset();
- e40: 74 d1 rcall .+744 ; 0x112a <USB_Event_Stub>
+ 104a: ad d1 rcall .+858 ; 0x13a6 <USB_Event_Stub>
USB_ResetInterface();
EVENT_USB_UIDChange();
}
#endif
}
- e42: ff 91 pop r31
- e44: ef 91 pop r30
- e46: bf 91 pop r27
- e48: af 91 pop r26
- e4a: 9f 91 pop r25
- e4c: 8f 91 pop r24
- e4e: 7f 91 pop r23
- e50: 6f 91 pop r22
- e52: 5f 91 pop r21
- e54: 4f 91 pop r20
- e56: 3f 91 pop r19
- e58: 2f 91 pop r18
- e5a: 0f 90 pop r0
- e5c: 0f be out 0x3f, r0 ; 63
- e5e: 0f 90 pop r0
- e60: 1f 90 pop r1
- e62: 18 95 reti
-
-00000e64 <USB_Device_ProcessControlRequest>:
+ 104c: ff 91 pop r31
+ 104e: ef 91 pop r30
+ 1050: bf 91 pop r27
+ 1052: af 91 pop r26
+ 1054: 9f 91 pop r25
+ 1056: 8f 91 pop r24
+ 1058: 7f 91 pop r23
+ 105a: 6f 91 pop r22
+ 105c: 5f 91 pop r21
+ 105e: 4f 91 pop r20
+ 1060: 3f 91 pop r19
+ 1062: 2f 91 pop r18
+ 1064: 0f 90 pop r0
+ 1066: 0f be out 0x3f, r0 ; 63
+ 1068: 0f 90 pop r0
+ 106a: 1f 90 pop r1
+ 106c: 18 95 reti
+
+0000106e <__vector_12>:
+
+#if defined(INTERRUPT_CONTROL_ENDPOINT) && defined(USB_CAN_BE_DEVICE)
+ISR(USB_COM_vect, ISR_BLOCK)
+{
+ 106e: 1f 92 push r1
+ 1070: 0f 92 push r0
+ 1072: 0f b6 in r0, 0x3f ; 63
+ 1074: 0f 92 push r0
+ 1076: 11 24 eor r1, r1
+ 1078: 1f 93 push r17
+ 107a: 2f 93 push r18
+ 107c: 3f 93 push r19
+ 107e: 4f 93 push r20
+ 1080: 5f 93 push r21
+ 1082: 6f 93 push r22
+ 1084: 7f 93 push r23
+ 1086: 8f 93 push r24
+ 1088: 9f 93 push r25
+ 108a: af 93 push r26
+ 108c: bf 93 push r27
+ 108e: ef 93 push r30
+ 1090: 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());
+ 1092: 10 91 e9 00 lds r17, 0x00E9
+ 1096: 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;
+ 1098: 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);
+ 109c: 10 92 e9 00 sts 0x00E9, r1
+ break;
+ case USB_INT_SOFI:
+ UDIEN &= ~(1 << SOFE);
+ break;
+ case USB_INT_RXSTPI:
+ UEIENX &= ~(1 << RXSTPE);
+ 10a0: 80 91 f0 00 lds r24, 0x00F0
+ 10a4: 87 7f andi r24, 0xF7 ; 247
+ 10a6: 80 93 f0 00 sts 0x00F0, r24
+ static inline void GlobalInterruptEnable(void)
+ {
+ GCC_MEMORY_BARRIER();
+
+ #if (ARCH == ARCH_AVR8)
+ sei();
+ 10aa: 78 94 sei
+ Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
+ USB_INT_Disable(USB_INT_RXSTPI);
+
+ GlobalInterruptEnable();
+
+ USB_Device_ProcessControlRequest();
+ 10ac: 1b d0 rcall .+54 ; 0x10e4 <USB_Device_ProcessControlRequest>
+ 10ae: 10 92 e9 00 sts 0x00E9, r1
+ break;
+ case USB_INT_SOFI:
+ UDIEN |= (1 << SOFE);
+ break;
+ case USB_INT_RXSTPI:
+ UEIENX |= (1 << RXSTPE);
+ 10b2: 80 91 f0 00 lds r24, 0x00F0
+ 10b6: 88 60 ori r24, 0x08 ; 8
+ 10b8: 80 93 f0 00 sts 0x00F0, r24
+ 10bc: 10 93 e9 00 sts 0x00E9, r17
+
+ Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
+ USB_INT_Enable(USB_INT_RXSTPI);
+ Endpoint_SelectEndpoint(PrevSelectedEndpoint);
+}
+ 10c0: ff 91 pop r31
+ 10c2: ef 91 pop r30
+ 10c4: bf 91 pop r27
+ 10c6: af 91 pop r26
+ 10c8: 9f 91 pop r25
+ 10ca: 8f 91 pop r24
+ 10cc: 7f 91 pop r23
+ 10ce: 6f 91 pop r22
+ 10d0: 5f 91 pop r21
+ 10d2: 4f 91 pop r20
+ 10d4: 3f 91 pop r19
+ 10d6: 2f 91 pop r18
+ 10d8: 1f 91 pop r17
+ 10da: 0f 90 pop r0
+ 10dc: 0f be out 0x3f, r0 ; 63
+ 10de: 0f 90 pop r0
+ 10e0: 1f 90 pop r1
+ 10e2: 18 95 reti
+
+000010e4 <USB_Device_ProcessControlRequest>:
#if !defined(NO_DEVICE_REMOTE_WAKEUP)
bool USB_Device_RemoteWakeupEnabled;
#endif
void USB_Device_ProcessControlRequest(void)
{
- e64: 1f 93 push r17
- e66: df 93 push r29
- e68: cf 93 push r28
- e6a: cd b7 in r28, 0x3d ; 61
- e6c: de b7 in r29, 0x3e ; 62
- e6e: ac 97 sbiw r28, 0x2c ; 44
- e70: 0f b6 in r0, 0x3f ; 63
- e72: f8 94 cli
- e74: de bf out 0x3e, r29 ; 62
- e76: 0f be out 0x3f, r0 ; 63
- e78: cd bf out 0x3d, r28 ; 61
+ 10e4: 1f 93 push r17
+ 10e6: df 93 push r29
+ 10e8: cf 93 push r28
+ 10ea: cd b7 in r28, 0x3d ; 61
+ 10ec: de b7 in r29, 0x3e ; 62
+ 10ee: ac 97 sbiw r28, 0x2c ; 44
+ 10f0: 0f b6 in r0, 0x3f ; 63
+ 10f2: f8 94 cli
+ 10f4: de bf out 0x3e, r29 ; 62
+ 10f6: 0f be out 0x3f, r0 ; 63
+ 10f8: 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;
- e7a: ef e8 ldi r30, 0x8F ; 143
- e7c: f2 e0 ldi r31, 0x02 ; 2
+ 10fa: ec e9 ldi r30, 0x9C ; 156
+ 10fc: 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;
- e7e: 80 91 f1 00 lds r24, 0x00F1
+ 10fe: 80 91 f1 00 lds r24, 0x00F1
for (uint8_t RequestHeaderByte = 0; RequestHeaderByte < sizeof(USB_Request_Header_t); RequestHeaderByte++)
*(RequestHeader++) = Endpoint_Read_8();
- e82: 81 93 st Z+, r24
+ 1102: 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++)
- e84: 22 e0 ldi r18, 0x02 ; 2
- e86: e7 39 cpi r30, 0x97 ; 151
- e88: f2 07 cpc r31, r18
- e8a: c9 f7 brne .-14 ; 0xe7e <USB_Device_ProcessControlRequest+0x1a>
+ 1104: 22 e0 ldi r18, 0x02 ; 2
+ 1106: e4 3a cpi r30, 0xA4 ; 164
+ 1108: f2 07 cpc r31, r18
+ 110a: c9 f7 brne .-14 ; 0x10fe <USB_Device_ProcessControlRequest+0x1a>
*(RequestHeader++) = Endpoint_Read_8();
#endif
EVENT_USB_Device_ControlRequest();
- e8c: bd db rcall .-2182 ; 0x608 <EVENT_USB_Device_ControlRequest>
+ 110c: f3 da rcall .-2586 ; 0x6f4 <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);
- e8e: 80 91 e8 00 lds r24, 0x00E8
+ 110e: 80 91 e8 00 lds r24, 0x00E8
if (Endpoint_IsSETUPReceived())
- e92: 83 ff sbrs r24, 3
- e94: 32 c1 rjmp .+612 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
+ 1112: 83 ff sbrs r24, 3
+ 1114: 30 c1 rjmp .+608 ; 0x1376 <USB_Device_ProcessControlRequest+0x292>
{
uint8_t bmRequestType = USB_ControlRequest.bmRequestType;
- e96: 80 91 8f 02 lds r24, 0x028F
+ 1116: 80 91 9c 02 lds r24, 0x029C
switch (USB_ControlRequest.bRequest)
- e9a: 20 91 90 02 lds r18, 0x0290
- e9e: 25 30 cpi r18, 0x05 ; 5
- ea0: 09 f4 brne .+2 ; 0xea4 <USB_Device_ProcessControlRequest+0x40>
- ea2: 84 c0 rjmp .+264 ; 0xfac <USB_Device_ProcessControlRequest+0x148>
- ea4: 26 30 cpi r18, 0x06 ; 6
- ea6: 40 f4 brcc .+16 ; 0xeb8 <USB_Device_ProcessControlRequest+0x54>
- ea8: 21 30 cpi r18, 0x01 ; 1
- eaa: a1 f1 breq .+104 ; 0xf14 <USB_Device_ProcessControlRequest+0xb0>
- eac: 21 30 cpi r18, 0x01 ; 1
- eae: 70 f0 brcs .+28 ; 0xecc <USB_Device_ProcessControlRequest+0x68>
- eb0: 23 30 cpi r18, 0x03 ; 3
- eb2: 09 f0 breq .+2 ; 0xeb6 <USB_Device_ProcessControlRequest+0x52>
- eb4: 22 c1 rjmp .+580 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
- eb6: 2e c0 rjmp .+92 ; 0xf14 <USB_Device_ProcessControlRequest+0xb0>
- eb8: 28 30 cpi r18, 0x08 ; 8
- eba: 09 f4 brne .+2 ; 0xebe <USB_Device_ProcessControlRequest+0x5a>
- ebc: f0 c0 rjmp .+480 ; 0x109e <USB_Device_ProcessControlRequest+0x23a>
- ebe: 29 30 cpi r18, 0x09 ; 9
- ec0: 09 f4 brne .+2 ; 0xec4 <USB_Device_ProcessControlRequest+0x60>
- ec2: ff c0 rjmp .+510 ; 0x10c2 <USB_Device_ProcessControlRequest+0x25e>
- ec4: 26 30 cpi r18, 0x06 ; 6
- ec6: 09 f0 breq .+2 ; 0xeca <USB_Device_ProcessControlRequest+0x66>
- ec8: 18 c1 rjmp .+560 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
- eca: 93 c0 rjmp .+294 ; 0xff2 <USB_Device_ProcessControlRequest+0x18e>
+ 111a: 20 91 9d 02 lds r18, 0x029D
+ 111e: 25 30 cpi r18, 0x05 ; 5
+ 1120: 09 f4 brne .+2 ; 0x1124 <USB_Device_ProcessControlRequest+0x40>
+ 1122: 84 c0 rjmp .+264 ; 0x122c <USB_Device_ProcessControlRequest+0x148>
+ 1124: 26 30 cpi r18, 0x06 ; 6
+ 1126: 40 f4 brcc .+16 ; 0x1138 <USB_Device_ProcessControlRequest+0x54>
+ 1128: 21 30 cpi r18, 0x01 ; 1
+ 112a: a1 f1 breq .+104 ; 0x1194 <USB_Device_ProcessControlRequest+0xb0>
+ 112c: 21 30 cpi r18, 0x01 ; 1
+ 112e: 70 f0 brcs .+28 ; 0x114c <USB_Device_ProcessControlRequest+0x68>
+ 1130: 23 30 cpi r18, 0x03 ; 3
+ 1132: 09 f0 breq .+2 ; 0x1136 <USB_Device_ProcessControlRequest+0x52>
+ 1134: 20 c1 rjmp .+576 ; 0x1376 <USB_Device_ProcessControlRequest+0x292>
+ 1136: 2e c0 rjmp .+92 ; 0x1194 <USB_Device_ProcessControlRequest+0xb0>
+ 1138: 28 30 cpi r18, 0x08 ; 8
+ 113a: 09 f4 brne .+2 ; 0x113e <USB_Device_ProcessControlRequest+0x5a>
+ 113c: ef c0 rjmp .+478 ; 0x131c <USB_Device_ProcessControlRequest+0x238>
+ 113e: 29 30 cpi r18, 0x09 ; 9
+ 1140: 09 f4 brne .+2 ; 0x1144 <USB_Device_ProcessControlRequest+0x60>
+ 1142: fe c0 rjmp .+508 ; 0x1340 <USB_Device_ProcessControlRequest+0x25c>
+ 1144: 26 30 cpi r18, 0x06 ; 6
+ 1146: 09 f0 breq .+2 ; 0x114a <USB_Device_ProcessControlRequest+0x66>
+ 1148: 16 c1 rjmp .+556 ; 0x1376 <USB_Device_ProcessControlRequest+0x292>
+ 114a: 92 c0 rjmp .+292 ; 0x1270 <USB_Device_ProcessControlRequest+0x18c>
{
case REQ_GetStatus:
if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
- ecc: 80 38 cpi r24, 0x80 ; 128
- ece: 21 f0 breq .+8 ; 0xed8 <USB_Device_ProcessControlRequest+0x74>
- ed0: 82 38 cpi r24, 0x82 ; 130
- ed2: 09 f0 breq .+2 ; 0xed6 <USB_Device_ProcessControlRequest+0x72>
- ed4: 12 c1 rjmp .+548 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
- ed6: 08 c0 rjmp .+16 ; 0xee8 <USB_Device_ProcessControlRequest+0x84>
+ 114c: 80 38 cpi r24, 0x80 ; 128
+ 114e: 21 f0 breq .+8 ; 0x1158 <USB_Device_ProcessControlRequest+0x74>
+ 1150: 82 38 cpi r24, 0x82 ; 130
+ 1152: 09 f0 breq .+2 ; 0x1156 <USB_Device_ProcessControlRequest+0x72>
+ 1154: 10 c1 rjmp .+544 ; 0x1376 <USB_Device_ProcessControlRequest+0x292>
+ 1156: 08 c0 rjmp .+16 ; 0x1168 <USB_Device_ProcessControlRequest+0x84>
Endpoint_ClearOUT();
}
static void USB_Device_GetStatus(void)
{
uint8_t CurrentStatus = 0;
- ed8: 80 91 8b 02 lds r24, 0x028B
+ 1158: 80 91 99 02 lds r24, 0x0299
if (USB_Device_CurrentlySelfPowered)
CurrentStatus |= FEATURE_SELFPOWERED_ENABLED;
#endif
#if !defined(NO_DEVICE_REMOTE_WAKEUP)
if (USB_Device_RemoteWakeupEnabled)
- edc: 90 91 8c 02 lds r25, 0x028C
- ee0: 99 23 and r25, r25
- ee2: 71 f0 breq .+28 ; 0xf00 <USB_Device_ProcessControlRequest+0x9c>
+ 115c: 90 91 9a 02 lds r25, 0x029A
+ 1160: 99 23 and r25, r25
+ 1162: 71 f0 breq .+28 ; 0x1180 <USB_Device_ProcessControlRequest+0x9c>
CurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
- ee4: 82 60 ori r24, 0x02 ; 2
- ee6: 0c c0 rjmp .+24 ; 0xf00 <USB_Device_ProcessControlRequest+0x9c>
+ 1164: 82 60 ori r24, 0x02 ; 2
+ 1166: 0c c0 rjmp .+24 ; 0x1180 <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);
- ee8: 80 91 93 02 lds r24, 0x0293
- eec: 8f 70 andi r24, 0x0F ; 15
- eee: 80 93 e9 00 sts 0x00E9, r24
+ 1168: 80 91 a0 02 lds r24, 0x02A0
+ 116c: 8f 70 andi r24, 0x0F ; 15
+ 116e: 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);
- ef2: 90 91 eb 00 lds r25, 0x00EB
+ 1172: 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();
- ef6: 81 e0 ldi r24, 0x01 ; 1
- ef8: 95 ff sbrs r25, 5
- efa: 80 e0 ldi r24, 0x00 ; 0
+ 1176: 81 e0 ldi r24, 0x01 ; 1
+ 1178: 95 ff sbrs r25, 5
+ 117a: 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);
- efc: 10 92 e9 00 sts 0x00E9, r1
+ 117c: 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);
- f00: 90 91 e8 00 lds r25, 0x00E8
- f04: 97 7f andi r25, 0xF7 ; 247
- f06: 90 93 e8 00 sts 0x00E8, r25
+ 1180: 90 91 e8 00 lds r25, 0x00E8
+ 1184: 97 7f andi r25, 0xF7 ; 247
+ 1186: 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);
- f0a: 80 93 f1 00 sts 0x00F1, r24
+ 118a: 80 93 f1 00 sts 0x00F1, r24
UEDATX = (Data >> 8);
- f0e: 10 92 f1 00 sts 0x00F1, r1
- f12: d0 c0 rjmp .+416 ; 0x10b4 <USB_Device_ProcessControlRequest+0x250>
+ 118e: 10 92 f1 00 sts 0x00F1, r1
+ 1192: cf c0 rjmp .+414 ; 0x1332 <USB_Device_ProcessControlRequest+0x24e>
}
break;
case REQ_ClearFeature:
case REQ_SetFeature:
if ((bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE)) ||
- f14: 88 23 and r24, r24
- f16: 19 f0 breq .+6 ; 0xf1e <USB_Device_ProcessControlRequest+0xba>
- f18: 82 30 cpi r24, 0x02 ; 2
- f1a: 09 f0 breq .+2 ; 0xf1e <USB_Device_ProcessControlRequest+0xba>
- f1c: ee c0 rjmp .+476 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
+ 1194: 88 23 and r24, r24
+ 1196: 19 f0 breq .+6 ; 0x119e <USB_Device_ProcessControlRequest+0xba>
+ 1198: 82 30 cpi r24, 0x02 ; 2
+ 119a: 09 f0 breq .+2 ; 0x119e <USB_Device_ProcessControlRequest+0xba>
+ 119c: ec c0 rjmp .+472 ; 0x1376 <USB_Device_ProcessControlRequest+0x292>
Endpoint_ClearStatusStage();
}
static void USB_Device_ClearSetFeature(void)
{
switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT)
- f1e: 90 e0 ldi r25, 0x00 ; 0
- f20: 8f 71 andi r24, 0x1F ; 31
- f22: 90 70 andi r25, 0x00 ; 0
- f24: 00 97 sbiw r24, 0x00 ; 0
- f26: 29 f0 breq .+10 ; 0xf32 <USB_Device_ProcessControlRequest+0xce>
- f28: 82 30 cpi r24, 0x02 ; 2
- f2a: 91 05 cpc r25, r1
- f2c: 09 f0 breq .+2 ; 0xf30 <USB_Device_ProcessControlRequest+0xcc>
- f2e: e5 c0 rjmp .+458 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
- f30: 0b c0 rjmp .+22 ; 0xf48 <USB_Device_ProcessControlRequest+0xe4>
+ 119e: 90 e0 ldi r25, 0x00 ; 0
+ 11a0: 8f 71 andi r24, 0x1F ; 31
+ 11a2: 90 70 andi r25, 0x00 ; 0
+ 11a4: 00 97 sbiw r24, 0x00 ; 0
+ 11a6: 29 f0 breq .+10 ; 0x11b2 <USB_Device_ProcessControlRequest+0xce>
+ 11a8: 82 30 cpi r24, 0x02 ; 2
+ 11aa: 91 05 cpc r25, r1
+ 11ac: 09 f0 breq .+2 ; 0x11b0 <USB_Device_ProcessControlRequest+0xcc>
+ 11ae: e3 c0 rjmp .+454 ; 0x1376 <USB_Device_ProcessControlRequest+0x292>
+ 11b0: 0b c0 rjmp .+22 ; 0x11c8 <USB_Device_ProcessControlRequest+0xe4>
{
#if !defined(NO_DEVICE_REMOTE_WAKEUP)
case REQREC_DEVICE:
if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_DeviceRemoteWakeup)
- f32: 80 91 91 02 lds r24, 0x0291
- f36: 81 30 cpi r24, 0x01 ; 1
- f38: 09 f0 breq .+2 ; 0xf3c <USB_Device_ProcessControlRequest+0xd8>
- f3a: df c0 rjmp .+446 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
+ 11b2: 80 91 9e 02 lds r24, 0x029E
+ 11b6: 81 30 cpi r24, 0x01 ; 1
+ 11b8: 09 f0 breq .+2 ; 0x11bc <USB_Device_ProcessControlRequest+0xd8>
+ 11ba: dd c0 rjmp .+442 ; 0x1376 <USB_Device_ProcessControlRequest+0x292>
USB_Device_RemoteWakeupEnabled = (USB_ControlRequest.bRequest == REQ_SetFeature);
- f3c: 23 30 cpi r18, 0x03 ; 3
- f3e: 09 f0 breq .+2 ; 0xf42 <USB_Device_ProcessControlRequest+0xde>
- f40: 80 e0 ldi r24, 0x00 ; 0
- f42: 80 93 8c 02 sts 0x028C, r24
- f46: 2c c0 rjmp .+88 ; 0xfa0 <USB_Device_ProcessControlRequest+0x13c>
+ 11bc: 23 30 cpi r18, 0x03 ; 3
+ 11be: 09 f0 breq .+2 ; 0x11c2 <USB_Device_ProcessControlRequest+0xde>
+ 11c0: 80 e0 ldi r24, 0x00 ; 0
+ 11c2: 80 93 9a 02 sts 0x029A, r24
+ 11c6: 2c c0 rjmp .+88 ; 0x1220 <USB_Device_ProcessControlRequest+0x13c>
break;
#endif
#if !defined(CONTROL_ONLY_DEVICE)
case REQREC_ENDPOINT:
if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_EndpointHalt)
- f48: 80 91 91 02 lds r24, 0x0291
- f4c: 88 23 and r24, r24
- f4e: 41 f5 brne .+80 ; 0xfa0 <USB_Device_ProcessControlRequest+0x13c>
+ 11c8: 80 91 9e 02 lds r24, 0x029E
+ 11cc: 88 23 and r24, r24
+ 11ce: 41 f5 brne .+80 ; 0x1220 <USB_Device_ProcessControlRequest+0x13c>
{
uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
- f50: 20 91 93 02 lds r18, 0x0293
- f54: 2f 70 andi r18, 0x0F ; 15
+ 11d0: 20 91 a0 02 lds r18, 0x02A0
+ 11d4: 2f 70 andi r18, 0x0F ; 15
if (EndpointIndex == ENDPOINT_CONTROLEP)
- f56: 09 f4 brne .+2 ; 0xf5a <USB_Device_ProcessControlRequest+0xf6>
- f58: d0 c0 rjmp .+416 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
+ 11d6: 09 f4 brne .+2 ; 0x11da <USB_Device_ProcessControlRequest+0xf6>
+ 11d8: ce c0 rjmp .+412 ; 0x1376 <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);
- f5a: 20 93 e9 00 sts 0x00E9, r18
+ 11da: 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);
- f5e: 80 91 eb 00 lds r24, 0x00EB
+ 11de: 80 91 eb 00 lds r24, 0x00EB
return;
Endpoint_SelectEndpoint(EndpointIndex);
if (Endpoint_IsEnabled())
- f62: 80 ff sbrs r24, 0
- f64: 1d c0 rjmp .+58 ; 0xfa0 <USB_Device_ProcessControlRequest+0x13c>
+ 11e2: 80 ff sbrs r24, 0
+ 11e4: 1d c0 rjmp .+58 ; 0x1220 <USB_Device_ProcessControlRequest+0x13c>
{
if (USB_ControlRequest.bRequest == REQ_SetFeature)
- f66: 80 91 90 02 lds r24, 0x0290
- f6a: 83 30 cpi r24, 0x03 ; 3
- f6c: 21 f4 brne .+8 ; 0xf76 <USB_Device_ProcessControlRequest+0x112>
+ 11e6: 80 91 9d 02 lds r24, 0x029D
+ 11ea: 83 30 cpi r24, 0x03 ; 3
+ 11ec: 21 f4 brne .+8 ; 0x11f6 <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);
- f6e: 80 91 eb 00 lds r24, 0x00EB
- f72: 80 62 ori r24, 0x20 ; 32
- f74: 13 c0 rjmp .+38 ; 0xf9c <USB_Device_ProcessControlRequest+0x138>
+ 11ee: 80 91 eb 00 lds r24, 0x00EB
+ 11f2: 80 62 ori r24, 0x20 ; 32
+ 11f4: 13 c0 rjmp .+38 ; 0x121c <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);
- f76: 80 91 eb 00 lds r24, 0x00EB
- f7a: 80 61 ori r24, 0x10 ; 16
- f7c: 80 93 eb 00 sts 0x00EB, r24
+ 11f6: 80 91 eb 00 lds r24, 0x00EB
+ 11fa: 80 61 ori r24, 0x10 ; 16
+ 11fc: 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));
- f80: 81 e0 ldi r24, 0x01 ; 1
- f82: 90 e0 ldi r25, 0x00 ; 0
- f84: 02 c0 rjmp .+4 ; 0xf8a <USB_Device_ProcessControlRequest+0x126>
- f86: 88 0f add r24, r24
- f88: 99 1f adc r25, r25
- f8a: 2a 95 dec r18
- f8c: e2 f7 brpl .-8 ; 0xf86 <USB_Device_ProcessControlRequest+0x122>
- f8e: 80 93 ea 00 sts 0x00EA, r24
+ 1200: 81 e0 ldi r24, 0x01 ; 1
+ 1202: 90 e0 ldi r25, 0x00 ; 0
+ 1204: 02 c0 rjmp .+4 ; 0x120a <USB_Device_ProcessControlRequest+0x126>
+ 1206: 88 0f add r24, r24
+ 1208: 99 1f adc r25, r25
+ 120a: 2a 95 dec r18
+ 120c: e2 f7 brpl .-8 ; 0x1206 <USB_Device_ProcessControlRequest+0x122>
+ 120e: 80 93 ea 00 sts 0x00EA, r24
UERST = 0;
- f92: 10 92 ea 00 sts 0x00EA, r1
+ 1212: 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);
- f96: 80 91 eb 00 lds r24, 0x00EB
- f9a: 88 60 ori r24, 0x08 ; 8
- f9c: 80 93 eb 00 sts 0x00EB, r24
+ 1216: 80 91 eb 00 lds r24, 0x00EB
+ 121a: 88 60 ori r24, 0x08 ; 8
+ 121c: 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);
- fa0: 10 92 e9 00 sts 0x00E9, r1
+ 1220: 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);
- fa4: 80 91 e8 00 lds r24, 0x00E8
- fa8: 87 7f andi r24, 0xF7 ; 247
- faa: 87 c0 rjmp .+270 ; 0x10ba <USB_Device_ProcessControlRequest+0x256>
+ 1224: 80 91 e8 00 lds r24, 0x00E8
+ 1228: 87 7f andi r24, 0xF7 ; 247
+ 122a: 86 c0 rjmp .+268 ; 0x1338 <USB_Device_ProcessControlRequest+0x254>
USB_Device_ClearSetFeature();
}
break;
case REQ_SetAddress:
if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
- fac: 88 23 and r24, r24
- fae: 09 f0 breq .+2 ; 0xfb2 <USB_Device_ProcessControlRequest+0x14e>
- fb0: a4 c0 rjmp .+328 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
+ 122c: 88 23 and r24, r24
+ 122e: 09 f0 breq .+2 ; 0x1232 <USB_Device_ProcessControlRequest+0x14e>
+ 1230: a2 c0 rjmp .+324 ; 0x1376 <USB_Device_ProcessControlRequest+0x292>
}
}
static void USB_Device_SetAddress(void)
{
uint8_t DeviceAddress = (USB_ControlRequest.wValue & 0x7F);
- fb2: 10 91 91 02 lds r17, 0x0291
- fb6: 1f 77 andi r17, 0x7F ; 127
+ 1232: 10 91 9e 02 lds r17, 0x029E
+ 1236: 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);
- fb8: 80 91 e3 00 lds r24, 0x00E3
- fbc: 80 78 andi r24, 0x80 ; 128
- fbe: 81 2b or r24, r17
- fc0: 80 93 e3 00 sts 0x00E3, r24
- fc4: 80 91 e8 00 lds r24, 0x00E8
- fc8: 87 7f andi r24, 0xF7 ; 247
- fca: 80 93 e8 00 sts 0x00E8, r24
+ 1238: 80 91 e3 00 lds r24, 0x00E3
+ 123c: 80 78 andi r24, 0x80 ; 128
+ 123e: 81 2b or r24, r17
+ 1240: 80 93 e3 00 sts 0x00E3, r24
+ 1244: 80 91 e8 00 lds r24, 0x00E8
+ 1248: 87 7f andi r24, 0xF7 ; 247
+ 124a: 80 93 e8 00 sts 0x00E8, r24
USB_Device_SetDeviceAddress(DeviceAddress);
Endpoint_ClearSETUP();
Endpoint_ClearStatusStage();
- fce: 0b de rcall .-1002 ; 0xbe6 <Endpoint_ClearStatusStage>
+ 124e: d2 dd rcall .-1116 ; 0xdf4 <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);
- fd0: 80 91 e8 00 lds r24, 0x00E8
+ 1250: 80 91 e8 00 lds r24, 0x00E8
while (!(Endpoint_IsINReady()));
- fd4: 80 ff sbrs r24, 0
- fd6: fc cf rjmp .-8 ; 0xfd0 <USB_Device_ProcessControlRequest+0x16c>
+ 1254: 80 ff sbrs r24, 0
+ 1256: fc cf rjmp .-8 ; 0x1250 <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);
- fd8: 80 91 e3 00 lds r24, 0x00E3
- fdc: 80 68 ori r24, 0x80 ; 128
- fde: 80 93 e3 00 sts 0x00E3, r24
+ 1258: 80 91 e3 00 lds r24, 0x00E3
+ 125c: 80 68 ori r24, 0x80 ; 128
+ 125e: 80 93 e3 00 sts 0x00E3, r24
USB_Device_EnableDeviceAddress(DeviceAddress);
USB_DeviceState = (DeviceAddress) ? DEVICE_STATE_Addressed : DEVICE_STATE_Default;
- fe2: 11 23 and r17, r17
- fe4: 11 f0 breq .+4 ; 0xfea <USB_Device_ProcessControlRequest+0x186>
- fe6: 83 e0 ldi r24, 0x03 ; 3
- fe8: 01 c0 rjmp .+2 ; 0xfec <USB_Device_ProcessControlRequest+0x188>
- fea: 82 e0 ldi r24, 0x02 ; 2
- fec: 80 93 8e 02 sts 0x028E, r24
- ff0: 84 c0 rjmp .+264 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
+ 1262: 11 23 and r17, r17
+ 1264: 11 f0 breq .+4 ; 0x126a <USB_Device_ProcessControlRequest+0x186>
+ 1266: 83 e0 ldi r24, 0x03 ; 3
+ 1268: 01 c0 rjmp .+2 ; 0x126c <USB_Device_ProcessControlRequest+0x188>
+ 126a: 82 e0 ldi r24, 0x02 ; 2
+ 126c: 8e bb out 0x1e, r24 ; 30
+ 126e: 83 c0 rjmp .+262 ; 0x1376 <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)) ||
- ff2: 80 58 subi r24, 0x80 ; 128
- ff4: 82 30 cpi r24, 0x02 ; 2
- ff6: 08 f0 brcs .+2 ; 0xffa <USB_Device_ProcessControlRequest+0x196>
- ff8: 80 c0 rjmp .+256 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
+ 1270: 80 58 subi r24, 0x80 ; 128
+ 1272: 82 30 cpi r24, 0x02 ; 2
+ 1274: 08 f0 brcs .+2 ; 0x1278 <USB_Device_ProcessControlRequest+0x194>
+ 1276: 7f c0 rjmp .+254 ; 0x1376 <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))
- ffa: 80 91 91 02 lds r24, 0x0291
- ffe: 90 91 92 02 lds r25, 0x0292
- 1002: 23 e0 ldi r18, 0x03 ; 3
- 1004: 8c 3d cpi r24, 0xDC ; 220
- 1006: 92 07 cpc r25, r18
- 1008: 91 f5 brne .+100 ; 0x106e <USB_Device_ProcessControlRequest+0x20a>
+ 1278: 80 91 9e 02 lds r24, 0x029E
+ 127c: 90 91 9f 02 lds r25, 0x029F
+ 1280: 23 e0 ldi r18, 0x03 ; 3
+ 1282: 8c 3d cpi r24, 0xDC ; 220
+ 1284: 92 07 cpc r25, r18
+ 1286: 91 f5 brne .+100 ; 0x12ec <USB_Device_ProcessControlRequest+0x208>
{
USB_Descriptor_Header_t Header;
uint16_t UnicodeString[INTERNAL_SERIAL_LENGTH_BITS / 4];
} SignatureDescriptor;
SignatureDescriptor.Header.Type = DTYPE_String;
- 100a: 83 e0 ldi r24, 0x03 ; 3
- 100c: 8c 83 std Y+4, r24 ; 0x04
+ 1288: 83 e0 ldi r24, 0x03 ; 3
+ 128a: 8c 83 std Y+4, r24 ; 0x04
SignatureDescriptor.Header.Size = USB_STRING_LEN(INTERNAL_SERIAL_LENGTH_BITS / 4);
- 100e: 8a e2 ldi r24, 0x2A ; 42
- 1010: 8b 83 std Y+3, r24 ; 0x03
+ 128c: 8a e2 ldi r24, 0x2A ; 42
+ 128e: 8b 83 std Y+3, r24 ; 0x03
static inline uint_reg_t GetGlobalInterruptMask(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
return SREG;
- 1012: 5f b7 in r21, 0x3f ; 63
+ 1290: 5f b7 in r21, 0x3f ; 63
static inline void GlobalInterruptDisable(void)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
cli();
- 1014: f8 94 cli
+ 1292: f8 94 cli
__builtin_ssrf(AVR32_SR_GM_OFFSET);
#elif (ARCH == ARCH_XMEGA)
cli();
#endif
GCC_MEMORY_BARRIER();
- 1016: de 01 movw r26, r28
- 1018: 15 96 adiw r26, 0x05 ; 5
- 101a: 80 e0 ldi r24, 0x00 ; 0
- 101c: 90 e0 ldi r25, 0x00 ; 0
+ 1294: de 01 movw r26, r28
+ 1296: 15 96 adiw r26, 0x05 ; 5
+ 1298: 80 e0 ldi r24, 0x00 ; 0
+ 129a: 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;
- 101e: 4e e0 ldi r20, 0x0E ; 14
+ 129c: 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);
- 1020: 61 e2 ldi r22, 0x21 ; 33
- 1022: e4 2f mov r30, r20
- 1024: f0 e0 ldi r31, 0x00 ; 0
- 1026: 60 93 57 00 sts 0x0057, r22
- 102a: e4 91 lpm r30, Z+
+ 129e: 61 e2 ldi r22, 0x21 ; 33
+ 12a0: e4 2f mov r30, r20
+ 12a2: f0 e0 ldi r31, 0x00 ; 0
+ 12a4: 60 93 57 00 sts 0x0057, r22
+ 12a8: e4 91 lpm r30, Z+
if (SerialCharNum & 0x01)
- 102c: 80 ff sbrs r24, 0
- 102e: 03 c0 rjmp .+6 ; 0x1036 <USB_Device_ProcessControlRequest+0x1d2>
+ 12aa: 80 ff sbrs r24, 0
+ 12ac: 03 c0 rjmp .+6 ; 0x12b4 <USB_Device_ProcessControlRequest+0x1d0>
{
SerialByte >>= 4;
- 1030: e2 95 swap r30
- 1032: ef 70 andi r30, 0x0F ; 15
+ 12ae: e2 95 swap r30
+ 12b0: ef 70 andi r30, 0x0F ; 15
SigReadAddress++;
- 1034: 4f 5f subi r20, 0xFF ; 255
+ 12b2: 4f 5f subi r20, 0xFF ; 255
}
SerialByte &= 0x0F;
- 1036: ef 70 andi r30, 0x0F ; 15
- 1038: 2e 2f mov r18, r30
- 103a: 30 e0 ldi r19, 0x00 ; 0
+ 12b4: ef 70 andi r30, 0x0F ; 15
+ 12b6: 2e 2f mov r18, r30
+ 12b8: 30 e0 ldi r19, 0x00 ; 0
UnicodeString[SerialCharNum] = cpu_to_le16((SerialByte >= 10) ?
- 103c: ea 30 cpi r30, 0x0A ; 10
- 103e: 18 f0 brcs .+6 ; 0x1046 <USB_Device_ProcessControlRequest+0x1e2>
- 1040: 29 5c subi r18, 0xC9 ; 201
- 1042: 3f 4f sbci r19, 0xFF ; 255
- 1044: 02 c0 rjmp .+4 ; 0x104a <USB_Device_ProcessControlRequest+0x1e6>
- 1046: 20 5d subi r18, 0xD0 ; 208
- 1048: 3f 4f sbci r19, 0xFF ; 255
- 104a: 2d 93 st X+, r18
- 104c: 3d 93 st X+, r19
- 104e: 01 96 adiw r24, 0x01 ; 1
+ 12ba: ea 30 cpi r30, 0x0A ; 10
+ 12bc: 18 f0 brcs .+6 ; 0x12c4 <USB_Device_ProcessControlRequest+0x1e0>
+ 12be: 29 5c subi r18, 0xC9 ; 201
+ 12c0: 3f 4f sbci r19, 0xFF ; 255
+ 12c2: 02 c0 rjmp .+4 ; 0x12c8 <USB_Device_ProcessControlRequest+0x1e4>
+ 12c4: 20 5d subi r18, 0xD0 ; 208
+ 12c6: 3f 4f sbci r19, 0xFF ; 255
+ 12c8: 2d 93 st X+, r18
+ 12ca: 3d 93 st X+, r19
+ 12cc: 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++)
- 1050: 84 31 cpi r24, 0x14 ; 20
- 1052: 91 05 cpc r25, r1
- 1054: 31 f7 brne .-52 ; 0x1022 <USB_Device_ProcessControlRequest+0x1be>
+ 12ce: 84 31 cpi r24, 0x14 ; 20
+ 12d0: 91 05 cpc r25, r1
+ 12d2: 31 f7 brne .-52 ; 0x12a0 <USB_Device_ProcessControlRequest+0x1bc>
static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
{
GCC_MEMORY_BARRIER();
#if (ARCH == ARCH_AVR8)
SREG = GlobalIntState;
- 1056: 5f bf out 0x3f, r21 ; 63
+ 12d4: 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);
- 1058: 80 91 e8 00 lds r24, 0x00E8
- 105c: 87 7f andi r24, 0xF7 ; 247
- 105e: 80 93 e8 00 sts 0x00E8, r24
+ 12d6: 80 91 e8 00 lds r24, 0x00E8
+ 12da: 87 7f andi r24, 0xF7 ; 247
+ 12dc: 80 93 e8 00 sts 0x00E8, r24
USB_Device_GetSerialString(SignatureDescriptor.UnicodeString);
Endpoint_ClearSETUP();
Endpoint_Write_Control_Stream_LE(&SignatureDescriptor, sizeof(SignatureDescriptor));
- 1062: ce 01 movw r24, r28
- 1064: 03 96 adiw r24, 0x03 ; 3
- 1066: 6a e2 ldi r22, 0x2A ; 42
- 1068: 70 e0 ldi r23, 0x00 ; 0
- 106a: 89 dc rcall .-1774 ; 0x97e <Endpoint_Write_Control_Stream_LE>
- 106c: 12 c0 rjmp .+36 ; 0x1092 <USB_Device_ProcessControlRequest+0x22e>
+ 12e0: ce 01 movw r24, r28
+ 12e2: 03 96 adiw r24, 0x03 ; 3
+ 12e4: 6a e2 ldi r22, 0x2A ; 42
+ 12e6: 70 e0 ldi r23, 0x00 ; 0
+ 12e8: 55 dc rcall .-1878 ; 0xb94 <Endpoint_Write_Control_Stream_LE>
+ 12ea: 12 c0 rjmp .+36 ; 0x1310 <USB_Device_ProcessControlRequest+0x22c>
USB_Device_GetInternalSerialDescriptor();
return;
}
#endif
if ((DescriptorSize = CALLBACK_USB_GetDescriptor(USB_ControlRequest.wValue, USB_ControlRequest.wIndex,
- 106e: 60 91 93 02 lds r22, 0x0293
- 1072: ae 01 movw r20, r28
- 1074: 4f 5f subi r20, 0xFF ; 255
- 1076: 5f 4f sbci r21, 0xFF ; 255
- 1078: 55 dc rcall .-1878 ; 0x924 <CALLBACK_USB_GetDescriptor>
- 107a: bc 01 movw r22, r24
- 107c: 00 97 sbiw r24, 0x00 ; 0
- 107e: 09 f4 brne .+2 ; 0x1082 <USB_Device_ProcessControlRequest+0x21e>
- 1080: 3c c0 rjmp .+120 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
- 1082: 80 91 e8 00 lds r24, 0x00E8
- 1086: 87 7f andi r24, 0xF7 ; 247
- 1088: 80 93 e8 00 sts 0x00E8, r24
+ 12ec: 60 91 a0 02 lds r22, 0x02A0
+ 12f0: ae 01 movw r20, r28
+ 12f2: 4f 5f subi r20, 0xFF ; 255
+ 12f4: 5f 4f sbci r21, 0xFF ; 255
+ 12f6: 21 dc rcall .-1982 ; 0xb3a <CALLBACK_USB_GetDescriptor>
+ 12f8: bc 01 movw r22, r24
+ 12fa: 00 97 sbiw r24, 0x00 ; 0
+ 12fc: 09 f4 brne .+2 ; 0x1300 <USB_Device_ProcessControlRequest+0x21c>
+ 12fe: 3b c0 rjmp .+118 ; 0x1376 <USB_Device_ProcessControlRequest+0x292>
+ 1300: 80 91 e8 00 lds r24, 0x00E8
+ 1304: 87 7f andi r24, 0xF7 ; 247
+ 1306: 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);
- 108c: 89 81 ldd r24, Y+1 ; 0x01
- 108e: 9a 81 ldd r25, Y+2 ; 0x02
- 1090: d2 dc rcall .-1628 ; 0xa36 <Endpoint_Write_Control_PStream_LE>
+ 130a: 89 81 ldd r24, Y+1 ; 0x01
+ 130c: 9a 81 ldd r25, Y+2 ; 0x02
+ 130e: 9c dc rcall .-1736 ; 0xc48 <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));
- 1092: 80 91 e8 00 lds r24, 0x00E8
- 1096: 8b 77 andi r24, 0x7B ; 123
- 1098: 80 93 e8 00 sts 0x00E8, r24
- 109c: 2e c0 rjmp .+92 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
+ 1310: 80 91 e8 00 lds r24, 0x00E8
+ 1314: 8b 77 andi r24, 0x7B ; 123
+ 1316: 80 93 e8 00 sts 0x00E8, r24
+ 131a: 2d c0 rjmp .+90 ; 0x1376 <USB_Device_ProcessControlRequest+0x292>
USB_Device_GetDescriptor();
}
break;
case REQ_GetConfiguration:
if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE))
- 109e: 80 38 cpi r24, 0x80 ; 128
- 10a0: 61 f5 brne .+88 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
+ 131c: 80 38 cpi r24, 0x80 ; 128
+ 131e: 59 f5 brne .+86 ; 0x1376 <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);
- 10a2: 80 91 e8 00 lds r24, 0x00E8
- 10a6: 87 7f andi r24, 0xF7 ; 247
- 10a8: 80 93 e8 00 sts 0x00E8, r24
+ 1320: 80 91 e8 00 lds r24, 0x00E8
+ 1324: 87 7f andi r24, 0xF7 ; 247
+ 1326: 80 93 e8 00 sts 0x00E8, r24
static void USB_Device_GetConfiguration(void)
{
Endpoint_ClearSETUP();
Endpoint_Write_8(USB_Device_ConfigurationNumber);
- 10ac: 80 91 8a 02 lds r24, 0x028A
+ 132a: 80 91 98 02 lds r24, 0x0298
* \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;
- 10b0: 80 93 f1 00 sts 0x00F1, r24
+ 132e: 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));
- 10b4: 80 91 e8 00 lds r24, 0x00E8
- 10b8: 8e 77 andi r24, 0x7E ; 126
- 10ba: 80 93 e8 00 sts 0x00E8, r24
+ 1332: 80 91 e8 00 lds r24, 0x00E8
+ 1336: 8e 77 andi r24, 0x7E ; 126
+ 1338: 80 93 e8 00 sts 0x00E8, r24
Endpoint_ClearIN();
Endpoint_ClearStatusStage();
- 10be: 93 dd rcall .-1242 ; 0xbe6 <Endpoint_ClearStatusStage>
- 10c0: 1c c0 rjmp .+56 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
+ 133c: 5b dd rcall .-1354 ; 0xdf4 <Endpoint_ClearStatusStage>
+ 133e: 1b c0 rjmp .+54 ; 0x1376 <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))
- 10c2: 88 23 and r24, r24
- 10c4: d1 f4 brne .+52 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
+ 1340: 88 23 and r24, r24
+ 1342: c9 f4 brne .+50 ; 0x1376 <USB_Device_ProcessControlRequest+0x292>
}
static void USB_Device_SetConfiguration(void)
{
#if defined(FIXED_NUM_CONFIGURATIONS)
if ((uint8_t)USB_ControlRequest.wValue > FIXED_NUM_CONFIGURATIONS)
- 10c6: 90 91 91 02 lds r25, 0x0291
- 10ca: 92 30 cpi r25, 0x02 ; 2
- 10cc: b0 f4 brcc .+44 ; 0x10fa <USB_Device_ProcessControlRequest+0x296>
+ 1344: 90 91 9e 02 lds r25, 0x029E
+ 1348: 92 30 cpi r25, 0x02 ; 2
+ 134a: a8 f4 brcc .+42 ; 0x1376 <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);
- 10ce: 80 91 e8 00 lds r24, 0x00E8
- 10d2: 87 7f andi r24, 0xF7 ; 247
- 10d4: 80 93 e8 00 sts 0x00E8, r24
+ 134c: 80 91 e8 00 lds r24, 0x00E8
+ 1350: 87 7f andi r24, 0xF7 ; 247
+ 1352: 80 93 e8 00 sts 0x00E8, r24
#endif
#endif
Endpoint_ClearSETUP();
USB_Device_ConfigurationNumber = (uint8_t)USB_ControlRequest.wValue;
- 10d8: 90 93 8a 02 sts 0x028A, r25
+ 1356: 90 93 98 02 sts 0x0298, r25
Endpoint_ClearStatusStage();
- 10dc: 84 dd rcall .-1272 ; 0xbe6 <Endpoint_ClearStatusStage>
+ 135a: 4c dd rcall .-1384 ; 0xdf4 <Endpoint_ClearStatusStage>
if (USB_Device_ConfigurationNumber)
- 10de: 80 91 8a 02 lds r24, 0x028A
- 10e2: 88 23 and r24, r24
- 10e4: 21 f4 brne .+8 ; 0x10ee <USB_Device_ProcessControlRequest+0x28a>
+ 135c: 80 91 98 02 lds r24, 0x0298
+ 1360: 88 23 and r24, r24
+ 1362: 21 f4 brne .+8 ; 0x136c <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));
- 10e6: 80 91 e3 00 lds r24, 0x00E3
+ 1364: 80 91 e3 00 lds r24, 0x00E3
USB_DeviceState = DEVICE_STATE_Configured;
else
USB_DeviceState = (USB_Device_IsAddressSet()) ? DEVICE_STATE_Configured : DEVICE_STATE_Powered;
- 10ea: 87 ff sbrs r24, 7
- 10ec: 02 c0 rjmp .+4 ; 0x10f2 <USB_Device_ProcessControlRequest+0x28e>
- 10ee: 84 e0 ldi r24, 0x04 ; 4
- 10f0: 01 c0 rjmp .+2 ; 0x10f4 <USB_Device_ProcessControlRequest+0x290>
- 10f2: 81 e0 ldi r24, 0x01 ; 1
- 10f4: 80 93 8e 02 sts 0x028E, r24
+ 1368: 87 ff sbrs r24, 7
+ 136a: 02 c0 rjmp .+4 ; 0x1370 <USB_Device_ProcessControlRequest+0x28c>
+ 136c: 84 e0 ldi r24, 0x04 ; 4
+ 136e: 01 c0 rjmp .+2 ; 0x1372 <USB_Device_ProcessControlRequest+0x28e>
+ 1370: 81 e0 ldi r24, 0x01 ; 1
+ 1372: 8e bb out 0x1e, r24 ; 30
EVENT_USB_Device_ConfigurationChanged();
- 10f8: 84 da rcall .-2808 ; 0x602 <EVENT_USB_Device_ConfigurationChanged>
+ 1374: bc d9 rcall .-3208 ; 0x6ee <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);
- 10fa: 80 91 e8 00 lds r24, 0x00E8
+ 1376: 80 91 e8 00 lds r24, 0x00E8
default:
break;
}
}
if (Endpoint_IsSETUPReceived())
- 10fe: 83 ff sbrs r24, 3
- 1100: 0a c0 rjmp .+20 ; 0x1116 <USB_Device_ProcessControlRequest+0x2b2>
+ 137a: 83 ff sbrs r24, 3
+ 137c: 0a c0 rjmp .+20 ; 0x1392 <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);
- 1102: 80 91 e8 00 lds r24, 0x00E8
- 1106: 87 7f andi r24, 0xF7 ; 247
- 1108: 80 93 e8 00 sts 0x00E8, r24
+ 137e: 80 91 e8 00 lds r24, 0x00E8
+ 1382: 87 7f andi r24, 0xF7 ; 247
+ 1384: 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);
- 110c: 80 91 eb 00 lds r24, 0x00EB
- 1110: 80 62 ori r24, 0x20 ; 32
- 1112: 80 93 eb 00 sts 0x00EB, r24
+ 1388: 80 91 eb 00 lds r24, 0x00EB
+ 138c: 80 62 ori r24, 0x20 ; 32
+ 138e: 80 93 eb 00 sts 0x00EB, r24
{
Endpoint_ClearSETUP();
Endpoint_StallTransaction();
}
}
- 1116: ac 96 adiw r28, 0x2c ; 44
- 1118: 0f b6 in r0, 0x3f ; 63
- 111a: f8 94 cli
- 111c: de bf out 0x3e, r29 ; 62
- 111e: 0f be out 0x3f, r0 ; 63
- 1120: cd bf out 0x3d, r28 ; 61
- 1122: cf 91 pop r28
- 1124: df 91 pop r29
- 1126: 1f 91 pop r17
- 1128: 08 95 ret
-
-0000112a <USB_Event_Stub>:
+ 1392: ac 96 adiw r28, 0x2c ; 44
+ 1394: 0f b6 in r0, 0x3f ; 63
+ 1396: f8 94 cli
+ 1398: de bf out 0x3e, r29 ; 62
+ 139a: 0f be out 0x3f, r0 ; 63
+ 139c: cd bf out 0x3d, r28 ; 61
+ 139e: cf 91 pop r28
+ 13a0: df 91 pop r29
+ 13a2: 1f 91 pop r17
+ 13a4: 08 95 ret
+
+000013a6 <USB_Event_Stub>:
#include "Events.h"
void USB_Event_Stub(void)
{
}
- 112a: 08 95 ret
+ 13a6: 08 95 ret
-0000112c <USB_USBTask>:
+000013a8 <USB_USBTask>:
#if defined(USB_CAN_BE_DEVICE) && !defined(DEVICE_STATE_AS_GPIOR)
volatile uint8_t USB_DeviceState;
#endif
void USB_USBTask(void)
{
- 112c: 1f 93 push r17
+ 13a8: 1f 93 push r17
}
#if defined(USB_CAN_BE_DEVICE)
static void USB_DeviceTask(void)
{
if (USB_DeviceState == DEVICE_STATE_Unattached)
- 112e: 80 91 8e 02 lds r24, 0x028E
- 1132: 88 23 and r24, r24
- 1134: a9 f0 breq .+42 ; 0x1160 <USB_USBTask+0x34>
+ 13aa: 8e b3 in r24, 0x1e ; 30
+ 13ac: 88 23 and r24, r24
+ 13ae: a9 f0 breq .+42 ; 0x13da <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());
- 1136: 80 91 e9 00 lds r24, 0x00E9
- 113a: 8f 70 andi r24, 0x0F ; 15
+ 13b0: 80 91 e9 00 lds r24, 0x00E9
+ 13b4: 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;
- 113c: 90 91 ec 00 lds r25, 0x00EC
- 1140: 90 ff sbrs r25, 0
- 1142: 02 c0 rjmp .+4 ; 0x1148 <USB_USBTask+0x1c>
- 1144: 10 e8 ldi r17, 0x80 ; 128
- 1146: 01 c0 rjmp .+2 ; 0x114a <USB_USBTask+0x1e>
- 1148: 10 e0 ldi r17, 0x00 ; 0
+ 13b6: 90 91 ec 00 lds r25, 0x00EC
+ 13ba: 90 ff sbrs r25, 0
+ 13bc: 02 c0 rjmp .+4 ; 0x13c2 <USB_USBTask+0x1a>
+ 13be: 10 e8 ldi r17, 0x80 ; 128
+ 13c0: 01 c0 rjmp .+2 ; 0x13c4 <USB_USBTask+0x1c>
+ 13c2: 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());
- 114a: 18 2b or r17, r24
+ 13c4: 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);
- 114c: 10 92 e9 00 sts 0x00E9, r1
+ 13c6: 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);
- 1150: 80 91 e8 00 lds r24, 0x00E8
+ 13ca: 80 91 e8 00 lds r24, 0x00E8
uint8_t PrevEndpoint = Endpoint_GetCurrentEndpoint();
Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
if (Endpoint_IsSETUPReceived())
- 1154: 83 ff sbrs r24, 3
- 1156: 01 c0 rjmp .+2 ; 0x115a <USB_USBTask+0x2e>
+ 13ce: 83 ff sbrs r24, 3
+ 13d0: 01 c0 rjmp .+2 ; 0x13d4 <USB_USBTask+0x2c>
USB_Device_ProcessControlRequest();
- 1158: 85 de rcall .-758 ; 0xe64 <USB_Device_ProcessControlRequest>
+ 13d2: 88 de rcall .-752 ; 0x10e4 <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);
- 115a: 1f 70 andi r17, 0x0F ; 15
- 115c: 10 93 e9 00 sts 0x00E9, r17
+ 13d4: 1f 70 andi r17, 0x0F ; 15
+ 13d6: 10 93 e9 00 sts 0x00E9, r17
#elif defined(USB_CAN_BE_HOST)
USB_HostTask();
#elif defined(USB_CAN_BE_DEVICE)
USB_DeviceTask();
#endif
}
- 1160: 1f 91 pop r17
- 1162: 08 95 ret
+ 13da: 1f 91 pop r17
+ 13dc: 08 95 ret
-00001164 <CDC_Device_ProcessControlRequest>:
+000013de <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)
{
- 1164: cf 93 push r28
- 1166: df 93 push r29
- 1168: ec 01 movw r28, r24
+ 13de: cf 93 push r28
+ 13e0: df 93 push r29
+ 13e2: 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);
- 116a: 80 91 e8 00 lds r24, 0x00E8
+ 13e4: 80 91 e8 00 lds r24, 0x00E8
if (!(Endpoint_IsSETUPReceived()))
- 116e: 83 ff sbrs r24, 3
- 1170: a3 c0 rjmp .+326 ; 0x12b8 <CDC_Device_ProcessControlRequest+0x154>
+ 13e8: 83 ff sbrs r24, 3
+ 13ea: a2 c0 rjmp .+324 ; 0x1530 <CDC_Device_ProcessControlRequest+0x152>
return;
if (USB_ControlRequest.wIndex != CDCInterfaceInfo->Config.ControlInterfaceNumber)
- 1172: 88 81 ld r24, Y
- 1174: 90 e0 ldi r25, 0x00 ; 0
- 1176: 20 91 93 02 lds r18, 0x0293
- 117a: 30 91 94 02 lds r19, 0x0294
- 117e: 28 17 cp r18, r24
- 1180: 39 07 cpc r19, r25
- 1182: 09 f0 breq .+2 ; 0x1186 <CDC_Device_ProcessControlRequest+0x22>
- 1184: 99 c0 rjmp .+306 ; 0x12b8 <CDC_Device_ProcessControlRequest+0x154>
+ 13ec: 88 81 ld r24, Y
+ 13ee: 90 e0 ldi r25, 0x00 ; 0
+ 13f0: 20 91 a0 02 lds r18, 0x02A0
+ 13f4: 30 91 a1 02 lds r19, 0x02A1
+ 13f8: 28 17 cp r18, r24
+ 13fa: 39 07 cpc r19, r25
+ 13fc: 09 f0 breq .+2 ; 0x1400 <CDC_Device_ProcessControlRequest+0x22>
+ 13fe: 98 c0 rjmp .+304 ; 0x1530 <CDC_Device_ProcessControlRequest+0x152>
return;
switch (USB_ControlRequest.bRequest)
- 1186: 80 91 90 02 lds r24, 0x0290
- 118a: 81 32 cpi r24, 0x21 ; 33
- 118c: 69 f0 breq .+26 ; 0x11a8 <CDC_Device_ProcessControlRequest+0x44>
- 118e: 82 32 cpi r24, 0x22 ; 34
- 1190: 20 f4 brcc .+8 ; 0x119a <CDC_Device_ProcessControlRequest+0x36>
- 1192: 80 32 cpi r24, 0x20 ; 32
- 1194: 09 f0 breq .+2 ; 0x1198 <CDC_Device_ProcessControlRequest+0x34>
- 1196: 90 c0 rjmp .+288 ; 0x12b8 <CDC_Device_ProcessControlRequest+0x154>
- 1198: 3c c0 rjmp .+120 ; 0x1212 <CDC_Device_ProcessControlRequest+0xae>
- 119a: 82 32 cpi r24, 0x22 ; 34
- 119c: 09 f4 brne .+2 ; 0x11a0 <CDC_Device_ProcessControlRequest+0x3c>
- 119e: 6b c0 rjmp .+214 ; 0x1276 <CDC_Device_ProcessControlRequest+0x112>
- 11a0: 83 32 cpi r24, 0x23 ; 35
- 11a2: 09 f0 breq .+2 ; 0x11a6 <CDC_Device_ProcessControlRequest+0x42>
- 11a4: 89 c0 rjmp .+274 ; 0x12b8 <CDC_Device_ProcessControlRequest+0x154>
- 11a6: 7a c0 rjmp .+244 ; 0x129c <CDC_Device_ProcessControlRequest+0x138>
+ 1400: 80 91 9d 02 lds r24, 0x029D
+ 1404: 81 32 cpi r24, 0x21 ; 33
+ 1406: 69 f0 breq .+26 ; 0x1422 <CDC_Device_ProcessControlRequest+0x44>
+ 1408: 82 32 cpi r24, 0x22 ; 34
+ 140a: 20 f4 brcc .+8 ; 0x1414 <CDC_Device_ProcessControlRequest+0x36>
+ 140c: 80 32 cpi r24, 0x20 ; 32
+ 140e: 09 f0 breq .+2 ; 0x1412 <CDC_Device_ProcessControlRequest+0x34>
+ 1410: 8f c0 rjmp .+286 ; 0x1530 <CDC_Device_ProcessControlRequest+0x152>
+ 1412: 3c c0 rjmp .+120 ; 0x148c <CDC_Device_ProcessControlRequest+0xae>
+ 1414: 82 32 cpi r24, 0x22 ; 34
+ 1416: 09 f4 brne .+2 ; 0x141a <CDC_Device_ProcessControlRequest+0x3c>
+ 1418: 6a c0 rjmp .+212 ; 0x14ee <CDC_Device_ProcessControlRequest+0x110>
+ 141a: 83 32 cpi r24, 0x23 ; 35
+ 141c: 09 f0 breq .+2 ; 0x1420 <CDC_Device_ProcessControlRequest+0x42>
+ 141e: 88 c0 rjmp .+272 ; 0x1530 <CDC_Device_ProcessControlRequest+0x152>
+ 1420: 79 c0 rjmp .+242 ; 0x1514 <CDC_Device_ProcessControlRequest+0x136>
{
case CDC_REQ_GetLineEncoding:
if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
- 11a8: 80 91 8f 02 lds r24, 0x028F
- 11ac: 81 3a cpi r24, 0xA1 ; 161
- 11ae: 09 f0 breq .+2 ; 0x11b2 <CDC_Device_ProcessControlRequest+0x4e>
- 11b0: 83 c0 rjmp .+262 ; 0x12b8 <CDC_Device_ProcessControlRequest+0x154>
+ 1422: 80 91 9c 02 lds r24, 0x029C
+ 1426: 81 3a cpi r24, 0xA1 ; 161
+ 1428: 09 f0 breq .+2 ; 0x142c <CDC_Device_ProcessControlRequest+0x4e>
+ 142a: 82 c0 rjmp .+260 ; 0x1530 <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);
- 11b2: 80 91 e8 00 lds r24, 0x00E8
- 11b6: 87 7f andi r24, 0xF7 ; 247
- 11b8: 80 93 e8 00 sts 0x00E8, r24
+ 142c: 80 91 e8 00 lds r24, 0x00E8
+ 1430: 87 7f andi r24, 0xF7 ; 247
+ 1432: 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);
- 11bc: 80 91 e8 00 lds r24, 0x00E8
+ 1436: 80 91 e8 00 lds r24, 0x00E8
{
Endpoint_ClearSETUP();
while (!(Endpoint_IsINReady()));
- 11c0: 80 ff sbrs r24, 0
- 11c2: fc cf rjmp .-8 ; 0x11bc <CDC_Device_ProcessControlRequest+0x58>
+ 143a: 80 ff sbrs r24, 0
+ 143c: fc cf rjmp .-8 ; 0x1436 <CDC_Device_ProcessControlRequest+0x58>
Endpoint_Write_32_LE(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
- 11c4: 8c 89 ldd r24, Y+20 ; 0x14
- 11c6: 9d 89 ldd r25, Y+21 ; 0x15
- 11c8: ae 89 ldd r26, Y+22 ; 0x16
- 11ca: bf 89 ldd r27, Y+23 ; 0x17
+ 143e: 8c 89 ldd r24, Y+20 ; 0x14
+ 1440: 9d 89 ldd r25, Y+21 ; 0x15
+ 1442: ae 89 ldd r26, Y+22 ; 0x16
+ 1444: 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);
- 11cc: 80 93 f1 00 sts 0x00F1, r24
+ 1446: 80 93 f1 00 sts 0x00F1, r24
UEDATX = (Data >> 8);
- 11d0: 29 2f mov r18, r25
- 11d2: 3a 2f mov r19, r26
- 11d4: 4b 2f mov r20, r27
- 11d6: 55 27 eor r21, r21
- 11d8: 20 93 f1 00 sts 0x00F1, r18
+ 144a: 29 2f mov r18, r25
+ 144c: 3a 2f mov r19, r26
+ 144e: 4b 2f mov r20, r27
+ 1450: 55 27 eor r21, r21
+ 1452: 20 93 f1 00 sts 0x00F1, r18
UEDATX = (Data >> 16);
- 11dc: 9d 01 movw r18, r26
- 11de: 44 27 eor r20, r20
- 11e0: 55 27 eor r21, r21
- 11e2: 20 93 f1 00 sts 0x00F1, r18
+ 1456: 9d 01 movw r18, r26
+ 1458: 44 27 eor r20, r20
+ 145a: 55 27 eor r21, r21
+ 145c: 20 93 f1 00 sts 0x00F1, r18
UEDATX = (Data >> 24);
- 11e6: 8b 2f mov r24, r27
- 11e8: 99 27 eor r25, r25
- 11ea: aa 27 eor r26, r26
- 11ec: bb 27 eor r27, r27
- 11ee: 80 93 f1 00 sts 0x00F1, r24
+ 1460: 8b 2f mov r24, r27
+ 1462: 99 27 eor r25, r25
+ 1464: aa 27 eor r26, r26
+ 1466: bb 27 eor r27, r27
+ 1468: 80 93 f1 00 sts 0x00F1, r24
Endpoint_Write_8(CDCInterfaceInfo->State.LineEncoding.CharFormat);
- 11f2: 88 8d ldd r24, Y+24 ; 0x18
+ 146c: 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;
- 11f4: 80 93 f1 00 sts 0x00F1, r24
+ 146e: 80 93 f1 00 sts 0x00F1, r24
Endpoint_Write_8(CDCInterfaceInfo->State.LineEncoding.ParityType);
- 11f8: 89 8d ldd r24, Y+25 ; 0x19
- 11fa: 80 93 f1 00 sts 0x00F1, r24
+ 1472: 89 8d ldd r24, Y+25 ; 0x19
+ 1474: 80 93 f1 00 sts 0x00F1, r24
Endpoint_Write_8(CDCInterfaceInfo->State.LineEncoding.DataBits);
- 11fe: 8a 8d ldd r24, Y+26 ; 0x1a
- 1200: 80 93 f1 00 sts 0x00F1, r24
+ 1478: 8a 8d ldd r24, Y+26 ; 0x1a
+ 147a: 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));
- 1204: 80 91 e8 00 lds r24, 0x00E8
- 1208: 8e 77 andi r24, 0x7E ; 126
- 120a: 80 93 e8 00 sts 0x00E8, r24
+ 147e: 80 91 e8 00 lds r24, 0x00E8
+ 1482: 8e 77 andi r24, 0x7E ; 126
+ 1484: 80 93 e8 00 sts 0x00E8, r24
Endpoint_ClearIN();
Endpoint_ClearStatusStage();
- 120e: eb dc rcall .-1578 ; 0xbe6 <Endpoint_ClearStatusStage>
- 1210: 53 c0 rjmp .+166 ; 0x12b8 <CDC_Device_ProcessControlRequest+0x154>
+ 1488: b5 dc rcall .-1686 ; 0xdf4 <Endpoint_ClearStatusStage>
+ 148a: 52 c0 rjmp .+164 ; 0x1530 <CDC_Device_ProcessControlRequest+0x152>
}
break;
case CDC_REQ_SetLineEncoding:
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
- 1212: 80 91 8f 02 lds r24, 0x028F
- 1216: 81 32 cpi r24, 0x21 ; 33
- 1218: 09 f0 breq .+2 ; 0x121c <CDC_Device_ProcessControlRequest+0xb8>
- 121a: 4e c0 rjmp .+156 ; 0x12b8 <CDC_Device_ProcessControlRequest+0x154>
+ 148c: 80 91 9c 02 lds r24, 0x029C
+ 1490: 81 32 cpi r24, 0x21 ; 33
+ 1492: 09 f0 breq .+2 ; 0x1496 <CDC_Device_ProcessControlRequest+0xb8>
+ 1494: 4d c0 rjmp .+154 ; 0x1530 <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);
- 121c: 80 91 e8 00 lds r24, 0x00E8
- 1220: 87 7f andi r24, 0xF7 ; 247
- 1222: 80 93 e8 00 sts 0x00E8, r24
+ 1496: 80 91 e8 00 lds r24, 0x00E8
+ 149a: 87 7f andi r24, 0xF7 ; 247
+ 149c: 80 93 e8 00 sts 0x00E8, r24
{
Endpoint_ClearSETUP();
while (!(Endpoint_IsOUTReceived()))
- 1226: 05 c0 rjmp .+10 ; 0x1232 <CDC_Device_ProcessControlRequest+0xce>
+ 14a0: 04 c0 rjmp .+8 ; 0x14aa <CDC_Device_ProcessControlRequest+0xcc>
{
if (USB_DeviceState == DEVICE_STATE_Unattached)
- 1228: 80 91 8e 02 lds r24, 0x028E
- 122c: 88 23 and r24, r24
- 122e: 09 f4 brne .+2 ; 0x1232 <CDC_Device_ProcessControlRequest+0xce>
- 1230: 43 c0 rjmp .+134 ; 0x12b8 <CDC_Device_ProcessControlRequest+0x154>
+ 14a2: 8e b3 in r24, 0x1e ; 30
+ 14a4: 88 23 and r24, r24
+ 14a6: 09 f4 brne .+2 ; 0x14aa <CDC_Device_ProcessControlRequest+0xcc>
+ 14a8: 43 c0 rjmp .+134 ; 0x1530 <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);
- 1232: 80 91 e8 00 lds r24, 0x00E8
+ 14aa: 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()))
- 1236: 82 ff sbrs r24, 2
- 1238: f7 cf rjmp .-18 ; 0x1228 <CDC_Device_ProcessControlRequest+0xc4>
+ 14ae: 82 ff sbrs r24, 2
+ 14b0: f8 cf rjmp .-16 ; 0x14a2 <CDC_Device_ProcessControlRequest+0xc4>
{
uint32_t Value;
uint8_t Bytes[4];
} Data;
Data.Bytes[0] = UEDATX;
- 123a: 30 91 f1 00 lds r19, 0x00F1
+ 14b2: 30 91 f1 00 lds r19, 0x00F1
Data.Bytes[1] = UEDATX;
- 123e: 20 91 f1 00 lds r18, 0x00F1
+ 14b6: 20 91 f1 00 lds r18, 0x00F1
Data.Bytes[2] = UEDATX;
- 1242: 90 91 f1 00 lds r25, 0x00F1
+ 14ba: 90 91 f1 00 lds r25, 0x00F1
Data.Bytes[3] = UEDATX;
- 1246: 80 91 f1 00 lds r24, 0x00F1
+ 14be: 80 91 f1 00 lds r24, 0x00F1
{
if (USB_DeviceState == DEVICE_STATE_Unattached)
return;
}
CDCInterfaceInfo->State.LineEncoding.BaudRateBPS = Endpoint_Read_32_LE();
- 124a: 3c 8b std Y+20, r19 ; 0x14
- 124c: 2d 8b std Y+21, r18 ; 0x15
- 124e: 9e 8b std Y+22, r25 ; 0x16
- 1250: 8f 8b std Y+23, r24 ; 0x17
+ 14c2: 3c 8b std Y+20, r19 ; 0x14
+ 14c4: 2d 8b std Y+21, r18 ; 0x15
+ 14c6: 9e 8b std Y+22, r25 ; 0x16
+ 14c8: 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;
- 1252: 80 91 f1 00 lds r24, 0x00F1
+ 14ca: 80 91 f1 00 lds r24, 0x00F1
CDCInterfaceInfo->State.LineEncoding.CharFormat = Endpoint_Read_8();
- 1256: 88 8f std Y+24, r24 ; 0x18
- 1258: 80 91 f1 00 lds r24, 0x00F1
+ 14ce: 88 8f std Y+24, r24 ; 0x18
+ 14d0: 80 91 f1 00 lds r24, 0x00F1
CDCInterfaceInfo->State.LineEncoding.ParityType = Endpoint_Read_8();
- 125c: 89 8f std Y+25, r24 ; 0x19
- 125e: 80 91 f1 00 lds r24, 0x00F1
+ 14d4: 89 8f std Y+25, r24 ; 0x19
+ 14d6: 80 91 f1 00 lds r24, 0x00F1
CDCInterfaceInfo->State.LineEncoding.DataBits = Endpoint_Read_8();
- 1262: 8a 8f std Y+26, r24 ; 0x1a
+ 14da: 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));
- 1264: 80 91 e8 00 lds r24, 0x00E8
- 1268: 8b 77 andi r24, 0x7B ; 123
- 126a: 80 93 e8 00 sts 0x00E8, r24
+ 14dc: 80 91 e8 00 lds r24, 0x00E8
+ 14e0: 8b 77 andi r24, 0x7B ; 123
+ 14e2: 80 93 e8 00 sts 0x00E8, r24
Endpoint_ClearOUT();
Endpoint_ClearStatusStage();
- 126e: bb dc rcall .-1674 ; 0xbe6 <Endpoint_ClearStatusStage>
+ 14e6: 86 dc rcall .-1780 ; 0xdf4 <Endpoint_ClearStatusStage>
EVENT_CDC_Device_LineEncodingChanged(CDCInterfaceInfo);
- 1270: ce 01 movw r24, r28
- 1272: f7 d9 rcall .-3090 ; 0x662 <EVENT_CDC_Device_LineEncodingChanged>
- 1274: 21 c0 rjmp .+66 ; 0x12b8 <CDC_Device_ProcessControlRequest+0x154>
+ 14e8: ce 01 movw r24, r28
+ 14ea: 31 d9 rcall .-3486 ; 0x74e <EVENT_CDC_Device_LineEncodingChanged>
+ 14ec: 21 c0 rjmp .+66 ; 0x1530 <CDC_Device_ProcessControlRequest+0x152>
}
break;
case CDC_REQ_SetControlLineState:
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
- 1276: 80 91 8f 02 lds r24, 0x028F
- 127a: 81 32 cpi r24, 0x21 ; 33
- 127c: e9 f4 brne .+58 ; 0x12b8 <CDC_Device_ProcessControlRequest+0x154>
+ 14ee: 80 91 9c 02 lds r24, 0x029C
+ 14f2: 81 32 cpi r24, 0x21 ; 33
+ 14f4: e9 f4 brne .+58 ; 0x1530 <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);
- 127e: 80 91 e8 00 lds r24, 0x00E8
- 1282: 87 7f andi r24, 0xF7 ; 247
- 1284: 80 93 e8 00 sts 0x00E8, r24
+ 14f6: 80 91 e8 00 lds r24, 0x00E8
+ 14fa: 87 7f andi r24, 0xF7 ; 247
+ 14fc: 80 93 e8 00 sts 0x00E8, r24
{
Endpoint_ClearSETUP();
Endpoint_ClearStatusStage();
- 1288: ae dc rcall .-1700 ; 0xbe6 <Endpoint_ClearStatusStage>
+ 1500: 79 dc rcall .-1806 ; 0xdf4 <Endpoint_ClearStatusStage>
CDCInterfaceInfo->State.ControlLineStates.HostToDevice = USB_ControlRequest.wValue;
- 128a: 80 91 91 02 lds r24, 0x0291
- 128e: 90 91 92 02 lds r25, 0x0292
- 1292: 99 8b std Y+17, r25 ; 0x11
- 1294: 88 8b std Y+16, r24 ; 0x10
+ 1502: 80 91 9e 02 lds r24, 0x029E
+ 1506: 90 91 9f 02 lds r25, 0x029F
+ 150a: 99 8b std Y+17, r25 ; 0x11
+ 150c: 88 8b std Y+16, r24 ; 0x10
EVENT_CDC_Device_ControLineStateChanged(CDCInterfaceInfo);
- 1296: ce 01 movw r24, r28
- 1298: d8 d0 rcall .+432 ; 0x144a <CDC_Device_Event_Stub>
- 129a: 0e c0 rjmp .+28 ; 0x12b8 <CDC_Device_ProcessControlRequest+0x154>
+ 150e: ce 01 movw r24, r28
+ 1510: d4 d0 rcall .+424 ; 0x16ba <CDC_Device_Event_Stub>
+ 1512: 0e c0 rjmp .+28 ; 0x1530 <CDC_Device_ProcessControlRequest+0x152>
}
break;
case CDC_REQ_SendBreak:
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
- 129c: 80 91 8f 02 lds r24, 0x028F
- 12a0: 81 32 cpi r24, 0x21 ; 33
- 12a2: 51 f4 brne .+20 ; 0x12b8 <CDC_Device_ProcessControlRequest+0x154>
- 12a4: 80 91 e8 00 lds r24, 0x00E8
- 12a8: 87 7f andi r24, 0xF7 ; 247
- 12aa: 80 93 e8 00 sts 0x00E8, r24
+ 1514: 80 91 9c 02 lds r24, 0x029C
+ 1518: 81 32 cpi r24, 0x21 ; 33
+ 151a: 51 f4 brne .+20 ; 0x1530 <CDC_Device_ProcessControlRequest+0x152>
+ 151c: 80 91 e8 00 lds r24, 0x00E8
+ 1520: 87 7f andi r24, 0xF7 ; 247
+ 1522: 80 93 e8 00 sts 0x00E8, r24
{
Endpoint_ClearSETUP();
Endpoint_ClearStatusStage();
- 12ae: 9b dc rcall .-1738 ; 0xbe6 <Endpoint_ClearStatusStage>
+ 1526: 66 dc rcall .-1844 ; 0xdf4 <Endpoint_ClearStatusStage>
EVENT_CDC_Device_BreakSent(CDCInterfaceInfo, (uint8_t)USB_ControlRequest.wValue);
- 12b0: ce 01 movw r24, r28
- 12b2: 60 91 91 02 lds r22, 0x0291
- 12b6: c9 d0 rcall .+402 ; 0x144a <CDC_Device_Event_Stub>
+ 1528: ce 01 movw r24, r28
+ 152a: 60 91 9e 02 lds r22, 0x029E
+ 152e: c5 d0 rcall .+394 ; 0x16ba <CDC_Device_Event_Stub>
}
break;
}
}
- 12b8: df 91 pop r29
- 12ba: cf 91 pop r28
- 12bc: 08 95 ret
+ 1530: df 91 pop r29
+ 1532: cf 91 pop r28
+ 1534: 08 95 ret
-000012be <CDC_Device_ConfigureEndpoints>:
+00001536 <CDC_Device_ConfigureEndpoints>:
bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{
- 12be: cf 93 push r28
- 12c0: df 93 push r29
- 12c2: ec 01 movw r28, r24
+ 1536: cf 93 push r28
+ 1538: df 93 push r29
+ 153a: ec 01 movw r28, r24
memset(&CDCInterfaceInfo->State, 0x00, sizeof(CDCInterfaceInfo->State));
- 12c4: 40 96 adiw r24, 0x10 ; 16
- 12c6: fc 01 movw r30, r24
- 12c8: 8b e0 ldi r24, 0x0B ; 11
- 12ca: df 01 movw r26, r30
- 12cc: 1d 92 st X+, r1
- 12ce: 8a 95 dec r24
- 12d0: e9 f7 brne .-6 ; 0x12cc <CDC_Device_ConfigureEndpoints+0xe>
+ 153c: 40 96 adiw r24, 0x10 ; 16
+ 153e: fc 01 movw r30, r24
+ 1540: 8b e0 ldi r24, 0x0B ; 11
+ 1542: df 01 movw r26, r30
+ 1544: 1d 92 st X+, r1
+ 1546: 8a 95 dec r24
+ 1548: e9 f7 brne .-6 ; 0x1544 <CDC_Device_ConfigureEndpoints+0xe>
CDCInterfaceInfo->Config.DataINEndpoint.Type = EP_TYPE_BULK;
- 12d2: 82 e0 ldi r24, 0x02 ; 2
- 12d4: 8c 83 std Y+4, r24 ; 0x04
+ 154a: 82 e0 ldi r24, 0x02 ; 2
+ 154c: 8c 83 std Y+4, r24 ; 0x04
CDCInterfaceInfo->Config.DataOUTEndpoint.Type = EP_TYPE_BULK;
- 12d6: 89 87 std Y+9, r24 ; 0x09
+ 154e: 89 87 std Y+9, r24 ; 0x09
CDCInterfaceInfo->Config.NotificationEndpoint.Type = EP_TYPE_INTERRUPT;
- 12d8: 83 e0 ldi r24, 0x03 ; 3
- 12da: 8e 87 std Y+14, r24 ; 0x0e
+ 1550: 83 e0 ldi r24, 0x03 ; 3
+ 1552: 8e 87 std Y+14, r24 ; 0x0e
if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.DataINEndpoint, 1)))
- 12dc: ce 01 movw r24, r28
- 12de: 01 96 adiw r24, 0x01 ; 1
- 12e0: 61 e0 ldi r22, 0x01 ; 1
- 12e2: 3d dc rcall .-1926 ; 0xb5e <Endpoint_ConfigureEndpointTable>
- 12e4: 88 23 and r24, r24
- 12e6: 59 f0 breq .+22 ; 0x12fe <CDC_Device_ConfigureEndpoints+0x40>
+ 1554: ce 01 movw r24, r28
+ 1556: 01 96 adiw r24, 0x01 ; 1
+ 1558: 61 e0 ldi r22, 0x01 ; 1
+ 155a: 08 dc rcall .-2032 ; 0xd6c <Endpoint_ConfigureEndpointTable>
+ 155c: 88 23 and r24, r24
+ 155e: 59 f0 breq .+22 ; 0x1576 <CDC_Device_ConfigureEndpoints+0x40>
return false;
if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.DataOUTEndpoint, 1)))
- 12e8: ce 01 movw r24, r28
- 12ea: 06 96 adiw r24, 0x06 ; 6
- 12ec: 61 e0 ldi r22, 0x01 ; 1
- 12ee: 37 dc rcall .-1938 ; 0xb5e <Endpoint_ConfigureEndpointTable>
- 12f0: 88 23 and r24, r24
- 12f2: 29 f0 breq .+10 ; 0x12fe <CDC_Device_ConfigureEndpoints+0x40>
+ 1560: ce 01 movw r24, r28
+ 1562: 06 96 adiw r24, 0x06 ; 6
+ 1564: 61 e0 ldi r22, 0x01 ; 1
+ 1566: 02 dc rcall .-2044 ; 0xd6c <Endpoint_ConfigureEndpointTable>
+ 1568: 88 23 and r24, r24
+ 156a: 29 f0 breq .+10 ; 0x1576 <CDC_Device_ConfigureEndpoints+0x40>
return false;
if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.NotificationEndpoint, 1)))
- 12f4: ce 01 movw r24, r28
- 12f6: 0b 96 adiw r24, 0x0b ; 11
- 12f8: 61 e0 ldi r22, 0x01 ; 1
- 12fa: 31 dc rcall .-1950 ; 0xb5e <Endpoint_ConfigureEndpointTable>
- 12fc: 01 c0 rjmp .+2 ; 0x1300 <CDC_Device_ConfigureEndpoints+0x42>
+ 156c: ce 01 movw r24, r28
+ 156e: 0b 96 adiw r24, 0x0b ; 11
+ 1570: 61 e0 ldi r22, 0x01 ; 1
+ 1572: fc db rcall .-2056 ; 0xd6c <Endpoint_ConfigureEndpointTable>
+ 1574: 01 c0 rjmp .+2 ; 0x1578 <CDC_Device_ConfigureEndpoints+0x42>
if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.DataINEndpoint, 1)))
return false;
if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.DataOUTEndpoint, 1)))
return false;
- 12fe: 80 e0 ldi r24, 0x00 ; 0
+ 1576: 80 e0 ldi r24, 0x00 ; 0
if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.NotificationEndpoint, 1)))
return false;
return true;
}
- 1300: df 91 pop r29
- 1302: cf 91 pop r28
- 1304: 08 95 ret
+ 1578: df 91 pop r29
+ 157a: cf 91 pop r28
+ 157c: 08 95 ret
-00001306 <CDC_Device_SendByte>:
+0000157e <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)
{
- 1306: df 93 push r29
- 1308: cf 93 push r28
- 130a: 0f 92 push r0
- 130c: cd b7 in r28, 0x3d ; 61
- 130e: de b7 in r29, 0x3e ; 62
- 1310: fc 01 movw r30, r24
+ 157e: df 93 push r29
+ 1580: cf 93 push r28
+ 1582: 0f 92 push r0
+ 1584: cd b7 in r28, 0x3d ; 61
+ 1586: de b7 in r29, 0x3e ; 62
+ 1588: fc 01 movw r30, r24
if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
- 1312: 80 91 8e 02 lds r24, 0x028E
- 1316: 84 30 cpi r24, 0x04 ; 4
- 1318: f9 f4 brne .+62 ; 0x1358 <CDC_Device_SendByte+0x52>
- 131a: 24 89 ldd r18, Z+20 ; 0x14
- 131c: 35 89 ldd r19, Z+21 ; 0x15
- 131e: 46 89 ldd r20, Z+22 ; 0x16
- 1320: 57 89 ldd r21, Z+23 ; 0x17
- 1322: 21 15 cp r18, r1
- 1324: 31 05 cpc r19, r1
- 1326: 41 05 cpc r20, r1
- 1328: 51 05 cpc r21, r1
- 132a: b1 f0 breq .+44 ; 0x1358 <CDC_Device_SendByte+0x52>
+ 158a: 8e b3 in r24, 0x1e ; 30
+ 158c: 84 30 cpi r24, 0x04 ; 4
+ 158e: f9 f4 brne .+62 ; 0x15ce <CDC_Device_SendByte+0x50>
+ 1590: 24 89 ldd r18, Z+20 ; 0x14
+ 1592: 35 89 ldd r19, Z+21 ; 0x15
+ 1594: 46 89 ldd r20, Z+22 ; 0x16
+ 1596: 57 89 ldd r21, Z+23 ; 0x17
+ 1598: 21 15 cp r18, r1
+ 159a: 31 05 cpc r19, r1
+ 159c: 41 05 cpc r20, r1
+ 159e: 51 05 cpc r21, r1
+ 15a0: b1 f0 breq .+44 ; 0x15ce <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);
- 132c: 81 81 ldd r24, Z+1 ; 0x01
- 132e: 8f 70 andi r24, 0x0F ; 15
- 1330: 80 93 e9 00 sts 0x00E9, r24
+ 15a2: 81 81 ldd r24, Z+1 ; 0x01
+ 15a4: 8f 70 andi r24, 0x0F ; 15
+ 15a6: 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);
- 1334: 80 91 e8 00 lds r24, 0x00E8
+ 15aa: 80 91 e8 00 lds r24, 0x00E8
return ENDPOINT_RWSTREAM_DeviceDisconnected;
Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
if (!(Endpoint_IsReadWriteAllowed()))
- 1338: 85 fd sbrc r24, 5
- 133a: 0a c0 rjmp .+20 ; 0x1350 <CDC_Device_SendByte+0x4a>
+ 15ae: 85 fd sbrc r24, 5
+ 15b0: 0a c0 rjmp .+20 ; 0x15c6 <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));
- 133c: 80 91 e8 00 lds r24, 0x00E8
- 1340: 8e 77 andi r24, 0x7E ; 126
- 1342: 80 93 e8 00 sts 0x00E8, r24
+ 15b2: 80 91 e8 00 lds r24, 0x00E8
+ 15b6: 8e 77 andi r24, 0x7E ; 126
+ 15b8: 80 93 e8 00 sts 0x00E8, r24
{
Endpoint_ClearIN();
uint8_t ErrorCode;
if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
- 1346: 69 83 std Y+1, r22 ; 0x01
- 1348: 6f dc rcall .-1826 ; 0xc28 <Endpoint_WaitUntilReady>
- 134a: 69 81 ldd r22, Y+1 ; 0x01
- 134c: 88 23 and r24, r24
- 134e: 29 f4 brne .+10 ; 0x135a <CDC_Device_SendByte+0x54>
+ 15bc: 69 83 std Y+1, r22 ; 0x01
+ 15be: 39 dc rcall .-1934 ; 0xe32 <Endpoint_WaitUntilReady>
+ 15c0: 69 81 ldd r22, Y+1 ; 0x01
+ 15c2: 88 23 and r24, r24
+ 15c4: 29 f4 brne .+10 ; 0x15d0 <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;
- 1350: 60 93 f1 00 sts 0x00F1, r22
+ 15c6: 60 93 f1 00 sts 0x00F1, r22
return ErrorCode;
}
Endpoint_Write_8(Data);
return ENDPOINT_READYWAIT_NoError;
- 1354: 80 e0 ldi r24, 0x00 ; 0
- 1356: 01 c0 rjmp .+2 ; 0x135a <CDC_Device_SendByte+0x54>
+ 15ca: 80 e0 ldi r24, 0x00 ; 0
+ 15cc: 01 c0 rjmp .+2 ; 0x15d0 <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;
- 1358: 82 e0 ldi r24, 0x02 ; 2
+ 15ce: 82 e0 ldi r24, 0x02 ; 2
return ErrorCode;
}
Endpoint_Write_8(Data);
return ENDPOINT_READYWAIT_NoError;
}
- 135a: 0f 90 pop r0
- 135c: cf 91 pop r28
- 135e: df 91 pop r29
- 1360: 08 95 ret
+ 15d0: 0f 90 pop r0
+ 15d2: cf 91 pop r28
+ 15d4: df 91 pop r29
+ 15d6: 08 95 ret
-00001362 <CDC_Device_Flush>:
+000015d8 <CDC_Device_Flush>:
uint8_t CDC_Device_Flush(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{
- 1362: fc 01 movw r30, r24
+ 15d8: fc 01 movw r30, r24
if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
- 1364: 80 91 8e 02 lds r24, 0x028E
- 1368: 84 30 cpi r24, 0x04 ; 4
- 136a: 19 f5 brne .+70 ; 0x13b2 <CDC_Device_Flush+0x50>
- 136c: 24 89 ldd r18, Z+20 ; 0x14
- 136e: 35 89 ldd r19, Z+21 ; 0x15
- 1370: 46 89 ldd r20, Z+22 ; 0x16
- 1372: 57 89 ldd r21, Z+23 ; 0x17
- 1374: 21 15 cp r18, r1
- 1376: 31 05 cpc r19, r1
- 1378: 41 05 cpc r20, r1
- 137a: 51 05 cpc r21, r1
- 137c: d1 f0 breq .+52 ; 0x13b2 <CDC_Device_Flush+0x50>
+ 15da: 8e b3 in r24, 0x1e ; 30
+ 15dc: 84 30 cpi r24, 0x04 ; 4
+ 15de: 19 f5 brne .+70 ; 0x1626 <CDC_Device_Flush+0x4e>
+ 15e0: 24 89 ldd r18, Z+20 ; 0x14
+ 15e2: 35 89 ldd r19, Z+21 ; 0x15
+ 15e4: 46 89 ldd r20, Z+22 ; 0x16
+ 15e6: 57 89 ldd r21, Z+23 ; 0x17
+ 15e8: 21 15 cp r18, r1
+ 15ea: 31 05 cpc r19, r1
+ 15ec: 41 05 cpc r20, r1
+ 15ee: 51 05 cpc r21, r1
+ 15f0: d1 f0 breq .+52 ; 0x1626 <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);
- 137e: 81 81 ldd r24, Z+1 ; 0x01
- 1380: 8f 70 andi r24, 0x0F ; 15
- 1382: 80 93 e9 00 sts 0x00E9, r24
+ 15f2: 81 81 ldd r24, Z+1 ; 0x01
+ 15f4: 8f 70 andi r24, 0x0F ; 15
+ 15f6: 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;
- 1386: 80 91 f2 00 lds r24, 0x00F2
+ 15fa: 80 91 f2 00 lds r24, 0x00F2
uint8_t ErrorCode;
Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
if (!(Endpoint_BytesInEndpoint()))
- 138a: 88 23 and r24, r24
- 138c: a1 f0 breq .+40 ; 0x13b6 <CDC_Device_Flush+0x54>
+ 15fe: 88 23 and r24, r24
+ 1600: a1 f0 breq .+40 ; 0x162a <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);
- 138e: 90 91 e8 00 lds r25, 0x00E8
+ 1602: 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));
- 1392: 80 91 e8 00 lds r24, 0x00E8
- 1396: 8e 77 andi r24, 0x7E ; 126
- 1398: 80 93 e8 00 sts 0x00E8, r24
+ 1606: 80 91 e8 00 lds r24, 0x00E8
+ 160a: 8e 77 andi r24, 0x7E ; 126
+ 160c: 80 93 e8 00 sts 0x00E8, r24
bool BankFull = !(Endpoint_IsReadWriteAllowed());
Endpoint_ClearIN();
if (BankFull)
- 139c: 95 fd sbrc r25, 5
- 139e: 0d c0 rjmp .+26 ; 0x13ba <CDC_Device_Flush+0x58>
+ 1610: 95 fd sbrc r25, 5
+ 1612: 0d c0 rjmp .+26 ; 0x162e <CDC_Device_Flush+0x56>
{
if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
- 13a0: 43 dc rcall .-1914 ; 0xc28 <Endpoint_WaitUntilReady>
- 13a2: 88 23 and r24, r24
- 13a4: 59 f4 brne .+22 ; 0x13bc <CDC_Device_Flush+0x5a>
- 13a6: 90 91 e8 00 lds r25, 0x00E8
- 13aa: 9e 77 andi r25, 0x7E ; 126
- 13ac: 90 93 e8 00 sts 0x00E8, r25
- 13b0: 08 95 ret
+ 1614: 0e dc rcall .-2020 ; 0xe32 <Endpoint_WaitUntilReady>
+ 1616: 88 23 and r24, r24
+ 1618: 59 f4 brne .+22 ; 0x1630 <CDC_Device_Flush+0x58>
+ 161a: 90 91 e8 00 lds r25, 0x00E8
+ 161e: 9e 77 andi r25, 0x7E ; 126
+ 1620: 90 93 e8 00 sts 0x00E8, r25
+ 1624: 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;
- 13b2: 82 e0 ldi r24, 0x02 ; 2
- 13b4: 08 95 ret
+ 1626: 82 e0 ldi r24, 0x02 ; 2
+ 1628: 08 95 ret
uint8_t ErrorCode;
Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
if (!(Endpoint_BytesInEndpoint()))
return ENDPOINT_READYWAIT_NoError;
- 13b6: 80 e0 ldi r24, 0x00 ; 0
- 13b8: 08 95 ret
+ 162a: 80 e0 ldi r24, 0x00 ; 0
+ 162c: 08 95 ret
return ErrorCode;
Endpoint_ClearIN();
}
return ENDPOINT_READYWAIT_NoError;
- 13ba: 80 e0 ldi r24, 0x00 ; 0
+ 162e: 80 e0 ldi r24, 0x00 ; 0
}
- 13bc: 08 95 ret
+ 1630: 08 95 ret
-000013be <CDC_Device_USBTask>:
+00001632 <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))
- 13be: 20 91 8e 02 lds r18, 0x028E
- 13c2: 24 30 cpi r18, 0x04 ; 4
- 13c4: 99 f4 brne .+38 ; 0x13ec <CDC_Device_USBTask+0x2e>
- 13c6: fc 01 movw r30, r24
- 13c8: 24 89 ldd r18, Z+20 ; 0x14
- 13ca: 35 89 ldd r19, Z+21 ; 0x15
- 13cc: 46 89 ldd r20, Z+22 ; 0x16
- 13ce: 57 89 ldd r21, Z+23 ; 0x17
- 13d0: 21 15 cp r18, r1
- 13d2: 31 05 cpc r19, r1
- 13d4: 41 05 cpc r20, r1
- 13d6: 51 05 cpc r21, r1
- 13d8: 49 f0 breq .+18 ; 0x13ec <CDC_Device_USBTask+0x2e>
+ 1632: 2e b3 in r18, 0x1e ; 30
+ 1634: 24 30 cpi r18, 0x04 ; 4
+ 1636: 99 f4 brne .+38 ; 0x165e <CDC_Device_USBTask+0x2c>
+ 1638: fc 01 movw r30, r24
+ 163a: 24 89 ldd r18, Z+20 ; 0x14
+ 163c: 35 89 ldd r19, Z+21 ; 0x15
+ 163e: 46 89 ldd r20, Z+22 ; 0x16
+ 1640: 57 89 ldd r21, Z+23 ; 0x17
+ 1642: 21 15 cp r18, r1
+ 1644: 31 05 cpc r19, r1
+ 1646: 41 05 cpc r20, r1
+ 1648: 51 05 cpc r21, r1
+ 164a: 49 f0 breq .+18 ; 0x165e <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);
- 13da: 21 81 ldd r18, Z+1 ; 0x01
- 13dc: 2f 70 andi r18, 0x0F ; 15
- 13de: 20 93 e9 00 sts 0x00E9, r18
+ 164c: 21 81 ldd r18, Z+1 ; 0x01
+ 164e: 2f 70 andi r18, 0x0F ; 15
+ 1650: 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);
- 13e2: 20 91 e8 00 lds r18, 0x00E8
+ 1654: 20 91 e8 00 lds r18, 0x00E8
return;
#if !defined(NO_CLASS_DRIVER_AUTOFLUSH)
Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
if (Endpoint_IsINReady())
- 13e6: 20 ff sbrs r18, 0
- 13e8: 01 c0 rjmp .+2 ; 0x13ec <CDC_Device_USBTask+0x2e>
+ 1658: 20 ff sbrs r18, 0
+ 165a: 01 c0 rjmp .+2 ; 0x165e <CDC_Device_USBTask+0x2c>
CDC_Device_Flush(CDCInterfaceInfo);
- 13ea: bb cf rjmp .-138 ; 0x1362 <CDC_Device_Flush>
- 13ec: 08 95 ret
+ 165c: bd cf rjmp .-134 ; 0x15d8 <CDC_Device_Flush>
+ 165e: 08 95 ret
-000013ee <CDC_Device_ReceiveByte>:
+00001660 <CDC_Device_ReceiveByte>:
return 0;
}
}
int16_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{
- 13ee: fc 01 movw r30, r24
+ 1660: fc 01 movw r30, r24
if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
- 13f0: 80 91 8e 02 lds r24, 0x028E
- 13f4: 84 30 cpi r24, 0x04 ; 4
- 13f6: 29 f5 brne .+74 ; 0x1442 <CDC_Device_ReceiveByte+0x54>
- 13f8: 24 89 ldd r18, Z+20 ; 0x14
- 13fa: 35 89 ldd r19, Z+21 ; 0x15
- 13fc: 46 89 ldd r20, Z+22 ; 0x16
- 13fe: 57 89 ldd r21, Z+23 ; 0x17
- 1400: 21 15 cp r18, r1
- 1402: 31 05 cpc r19, r1
- 1404: 41 05 cpc r20, r1
- 1406: 51 05 cpc r21, r1
- 1408: e1 f0 breq .+56 ; 0x1442 <CDC_Device_ReceiveByte+0x54>
+ 1662: 8e b3 in r24, 0x1e ; 30
+ 1664: 84 30 cpi r24, 0x04 ; 4
+ 1666: 29 f5 brne .+74 ; 0x16b2 <CDC_Device_ReceiveByte+0x52>
+ 1668: 24 89 ldd r18, Z+20 ; 0x14
+ 166a: 35 89 ldd r19, Z+21 ; 0x15
+ 166c: 46 89 ldd r20, Z+22 ; 0x16
+ 166e: 57 89 ldd r21, Z+23 ; 0x17
+ 1670: 21 15 cp r18, r1
+ 1672: 31 05 cpc r19, r1
+ 1674: 41 05 cpc r20, r1
+ 1676: 51 05 cpc r21, r1
+ 1678: e1 f0 breq .+56 ; 0x16b2 <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);
- 140a: 86 81 ldd r24, Z+6 ; 0x06
- 140c: 8f 70 andi r24, 0x0F ; 15
- 140e: 80 93 e9 00 sts 0x00E9, r24
+ 167a: 86 81 ldd r24, Z+6 ; 0x06
+ 167c: 8f 70 andi r24, 0x0F ; 15
+ 167e: 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);
- 1412: 80 91 e8 00 lds r24, 0x00E8
+ 1682: 80 91 e8 00 lds r24, 0x00E8
int16_t ReceivedByte = -1;
Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpoint.Address);
if (Endpoint_IsOUTReceived())
- 1416: 82 ff sbrs r24, 2
- 1418: 14 c0 rjmp .+40 ; 0x1442 <CDC_Device_ReceiveByte+0x54>
+ 1686: 82 ff sbrs r24, 2
+ 1688: 14 c0 rjmp .+40 ; 0x16b2 <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;
- 141a: 80 91 f2 00 lds r24, 0x00F2
+ 168a: 80 91 f2 00 lds r24, 0x00F2
{
if (Endpoint_BytesInEndpoint())
- 141e: 88 23 and r24, r24
- 1420: 21 f0 breq .+8 ; 0x142a <CDC_Device_ReceiveByte+0x3c>
+ 168e: 88 23 and r24, r24
+ 1690: 21 f0 breq .+8 ; 0x169a <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;
- 1422: 20 91 f1 00 lds r18, 0x00F1
+ 1692: 20 91 f1 00 lds r18, 0x00F1
ReceivedByte = Endpoint_Read_8();
- 1426: 30 e0 ldi r19, 0x00 ; 0
- 1428: 02 c0 rjmp .+4 ; 0x142e <CDC_Device_ReceiveByte+0x40>
+ 1696: 30 e0 ldi r19, 0x00 ; 0
+ 1698: 02 c0 rjmp .+4 ; 0x169e <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;
- 142a: 2f ef ldi r18, 0xFF ; 255
- 142c: 3f ef ldi r19, 0xFF ; 255
+ 169a: 2f ef ldi r18, 0xFF ; 255
+ 169c: 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;
- 142e: 80 91 f2 00 lds r24, 0x00F2
+ 169e: 80 91 f2 00 lds r24, 0x00F2
if (Endpoint_IsOUTReceived())
{
if (Endpoint_BytesInEndpoint())
ReceivedByte = Endpoint_Read_8();
if (!(Endpoint_BytesInEndpoint()))
- 1432: 88 23 and r24, r24
- 1434: 41 f4 brne .+16 ; 0x1446 <CDC_Device_ReceiveByte+0x58>
+ 16a2: 88 23 and r24, r24
+ 16a4: 41 f4 brne .+16 ; 0x16b6 <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));
- 1436: 80 91 e8 00 lds r24, 0x00E8
- 143a: 8b 77 andi r24, 0x7B ; 123
- 143c: 80 93 e8 00 sts 0x00E8, r24
- 1440: 02 c0 rjmp .+4 ; 0x1446 <CDC_Device_ReceiveByte+0x58>
+ 16a6: 80 91 e8 00 lds r24, 0x00E8
+ 16aa: 8b 77 andi r24, 0x7B ; 123
+ 16ac: 80 93 e8 00 sts 0x00E8, r24
+ 16b0: 02 c0 rjmp .+4 ; 0x16b6 <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;
- 1442: 2f ef ldi r18, 0xFF ; 255
- 1444: 3f ef ldi r19, 0xFF ; 255
+ 16b2: 2f ef ldi r18, 0xFF ; 255
+ 16b4: 3f ef ldi r19, 0xFF ; 255
if (!(Endpoint_BytesInEndpoint()))
Endpoint_ClearOUT();
}
return ReceivedByte;
}
- 1446: c9 01 movw r24, r18
- 1448: 08 95 ret
+ 16b6: c9 01 movw r24, r18
+ 16b8: 08 95 ret
-0000144a <CDC_Device_Event_Stub>:
+000016ba <CDC_Device_Event_Stub>:
#endif
void CDC_Device_Event_Stub(void)
{
}
- 144a: 08 95 ret
-
-0000144c <__subsf3>:
- 144c: 50 58 subi r21, 0x80 ; 128
-
-0000144e <__addsf3>:
- 144e: bb 27 eor r27, r27
- 1450: aa 27 eor r26, r26
- 1452: 0e d0 rcall .+28 ; 0x1470 <__addsf3x>
- 1454: 70 c1 rjmp .+736 ; 0x1736 <__fp_round>
- 1456: 61 d1 rcall .+706 ; 0x171a <__fp_pscA>
- 1458: 30 f0 brcs .+12 ; 0x1466 <__addsf3+0x18>
- 145a: 66 d1 rcall .+716 ; 0x1728 <__fp_pscB>
- 145c: 20 f0 brcs .+8 ; 0x1466 <__addsf3+0x18>
- 145e: 31 f4 brne .+12 ; 0x146c <__addsf3+0x1e>
- 1460: 9f 3f cpi r25, 0xFF ; 255
- 1462: 11 f4 brne .+4 ; 0x1468 <__addsf3+0x1a>
- 1464: 1e f4 brtc .+6 ; 0x146c <__addsf3+0x1e>
- 1466: 56 c1 rjmp .+684 ; 0x1714 <__fp_nan>
- 1468: 0e f4 brtc .+2 ; 0x146c <__addsf3+0x1e>
- 146a: e0 95 com r30
- 146c: e7 fb bst r30, 7
- 146e: 4c c1 rjmp .+664 ; 0x1708 <__fp_inf>
-
-00001470 <__addsf3x>:
- 1470: e9 2f mov r30, r25
- 1472: 72 d1 rcall .+740 ; 0x1758 <__fp_split3>
- 1474: 80 f3 brcs .-32 ; 0x1456 <__addsf3+0x8>
- 1476: ba 17 cp r27, r26
- 1478: 62 07 cpc r22, r18
- 147a: 73 07 cpc r23, r19
- 147c: 84 07 cpc r24, r20
- 147e: 95 07 cpc r25, r21
- 1480: 18 f0 brcs .+6 ; 0x1488 <__addsf3x+0x18>
- 1482: 71 f4 brne .+28 ; 0x14a0 <__addsf3x+0x30>
- 1484: 9e f5 brtc .+102 ; 0x14ec <__addsf3x+0x7c>
- 1486: 8a c1 rjmp .+788 ; 0x179c <__fp_zero>
- 1488: 0e f4 brtc .+2 ; 0x148c <__addsf3x+0x1c>
- 148a: e0 95 com r30
- 148c: 0b 2e mov r0, r27
- 148e: ba 2f mov r27, r26
- 1490: a0 2d mov r26, r0
- 1492: 0b 01 movw r0, r22
- 1494: b9 01 movw r22, r18
- 1496: 90 01 movw r18, r0
- 1498: 0c 01 movw r0, r24
- 149a: ca 01 movw r24, r20
- 149c: a0 01 movw r20, r0
- 149e: 11 24 eor r1, r1
- 14a0: ff 27 eor r31, r31
- 14a2: 59 1b sub r21, r25
- 14a4: 99 f0 breq .+38 ; 0x14cc <__addsf3x+0x5c>
- 14a6: 59 3f cpi r21, 0xF9 ; 249
- 14a8: 50 f4 brcc .+20 ; 0x14be <__addsf3x+0x4e>
- 14aa: 50 3e cpi r21, 0xE0 ; 224
- 14ac: 68 f1 brcs .+90 ; 0x1508 <__addsf3x+0x98>
- 14ae: 1a 16 cp r1, r26
- 14b0: f0 40 sbci r31, 0x00 ; 0
- 14b2: a2 2f mov r26, r18
- 14b4: 23 2f mov r18, r19
- 14b6: 34 2f mov r19, r20
- 14b8: 44 27 eor r20, r20
- 14ba: 58 5f subi r21, 0xF8 ; 248
- 14bc: f3 cf rjmp .-26 ; 0x14a4 <__addsf3x+0x34>
- 14be: 46 95 lsr r20
- 14c0: 37 95 ror r19
- 14c2: 27 95 ror r18
- 14c4: a7 95 ror r26
- 14c6: f0 40 sbci r31, 0x00 ; 0
- 14c8: 53 95 inc r21
- 14ca: c9 f7 brne .-14 ; 0x14be <__addsf3x+0x4e>
- 14cc: 7e f4 brtc .+30 ; 0x14ec <__addsf3x+0x7c>
- 14ce: 1f 16 cp r1, r31
- 14d0: ba 0b sbc r27, r26
- 14d2: 62 0b sbc r22, r18
- 14d4: 73 0b sbc r23, r19
- 14d6: 84 0b sbc r24, r20
- 14d8: ba f0 brmi .+46 ; 0x1508 <__addsf3x+0x98>
- 14da: 91 50 subi r25, 0x01 ; 1
- 14dc: a1 f0 breq .+40 ; 0x1506 <__addsf3x+0x96>
- 14de: ff 0f add r31, r31
- 14e0: bb 1f adc r27, r27
- 14e2: 66 1f adc r22, r22
- 14e4: 77 1f adc r23, r23
- 14e6: 88 1f adc r24, r24
- 14e8: c2 f7 brpl .-16 ; 0x14da <__addsf3x+0x6a>
- 14ea: 0e c0 rjmp .+28 ; 0x1508 <__addsf3x+0x98>
- 14ec: ba 0f add r27, r26
- 14ee: 62 1f adc r22, r18
- 14f0: 73 1f adc r23, r19
- 14f2: 84 1f adc r24, r20
- 14f4: 48 f4 brcc .+18 ; 0x1508 <__addsf3x+0x98>
- 14f6: 87 95 ror r24
- 14f8: 77 95 ror r23
- 14fa: 67 95 ror r22
- 14fc: b7 95 ror r27
- 14fe: f7 95 ror r31
- 1500: 9e 3f cpi r25, 0xFE ; 254
- 1502: 08 f0 brcs .+2 ; 0x1506 <__addsf3x+0x96>
- 1504: b3 cf rjmp .-154 ; 0x146c <__addsf3+0x1e>
- 1506: 93 95 inc r25
- 1508: 88 0f add r24, r24
- 150a: 08 f0 brcs .+2 ; 0x150e <__addsf3x+0x9e>
- 150c: 99 27 eor r25, r25
- 150e: ee 0f add r30, r30
- 1510: 97 95 ror r25
- 1512: 87 95 ror r24
- 1514: 08 95 ret
-
-00001516 <__cmpsf2>:
- 1516: d4 d0 rcall .+424 ; 0x16c0 <__fp_cmp>
- 1518: 08 f4 brcc .+2 ; 0x151c <__cmpsf2+0x6>
- 151a: 81 e0 ldi r24, 0x01 ; 1
- 151c: 08 95 ret
-
-0000151e <__divsf3>:
- 151e: 0c d0 rcall .+24 ; 0x1538 <__divsf3x>
- 1520: 0a c1 rjmp .+532 ; 0x1736 <__fp_round>
- 1522: 02 d1 rcall .+516 ; 0x1728 <__fp_pscB>
- 1524: 40 f0 brcs .+16 ; 0x1536 <__divsf3+0x18>
- 1526: f9 d0 rcall .+498 ; 0x171a <__fp_pscA>
- 1528: 30 f0 brcs .+12 ; 0x1536 <__divsf3+0x18>
- 152a: 21 f4 brne .+8 ; 0x1534 <__divsf3+0x16>
- 152c: 5f 3f cpi r21, 0xFF ; 255
- 152e: 19 f0 breq .+6 ; 0x1536 <__divsf3+0x18>
- 1530: eb c0 rjmp .+470 ; 0x1708 <__fp_inf>
- 1532: 51 11 cpse r21, r1
- 1534: 34 c1 rjmp .+616 ; 0x179e <__fp_szero>
- 1536: ee c0 rjmp .+476 ; 0x1714 <__fp_nan>
-
-00001538 <__divsf3x>:
- 1538: 0f d1 rcall .+542 ; 0x1758 <__fp_split3>
- 153a: 98 f3 brcs .-26 ; 0x1522 <__divsf3+0x4>
-
-0000153c <__divsf3_pse>:
- 153c: 99 23 and r25, r25
- 153e: c9 f3 breq .-14 ; 0x1532 <__divsf3+0x14>
- 1540: 55 23 and r21, r21
- 1542: b1 f3 breq .-20 ; 0x1530 <__divsf3+0x12>
- 1544: 95 1b sub r25, r21
- 1546: 55 0b sbc r21, r21
- 1548: bb 27 eor r27, r27
- 154a: aa 27 eor r26, r26
- 154c: 62 17 cp r22, r18
- 154e: 73 07 cpc r23, r19
- 1550: 84 07 cpc r24, r20
- 1552: 38 f0 brcs .+14 ; 0x1562 <__divsf3_pse+0x26>
- 1554: 9f 5f subi r25, 0xFF ; 255
- 1556: 5f 4f sbci r21, 0xFF ; 255
- 1558: 22 0f add r18, r18
- 155a: 33 1f adc r19, r19
- 155c: 44 1f adc r20, r20
- 155e: aa 1f adc r26, r26
- 1560: a9 f3 breq .-22 ; 0x154c <__divsf3_pse+0x10>
- 1562: 33 d0 rcall .+102 ; 0x15ca <__divsf3_pse+0x8e>
- 1564: 0e 2e mov r0, r30
- 1566: 3a f0 brmi .+14 ; 0x1576 <__divsf3_pse+0x3a>
- 1568: e0 e8 ldi r30, 0x80 ; 128
- 156a: 30 d0 rcall .+96 ; 0x15cc <__divsf3_pse+0x90>
- 156c: 91 50 subi r25, 0x01 ; 1
- 156e: 50 40 sbci r21, 0x00 ; 0
- 1570: e6 95 lsr r30
- 1572: 00 1c adc r0, r0
- 1574: ca f7 brpl .-14 ; 0x1568 <__divsf3_pse+0x2c>
- 1576: 29 d0 rcall .+82 ; 0x15ca <__divsf3_pse+0x8e>
- 1578: fe 2f mov r31, r30
- 157a: 27 d0 rcall .+78 ; 0x15ca <__divsf3_pse+0x8e>
- 157c: 66 0f add r22, r22
- 157e: 77 1f adc r23, r23
- 1580: 88 1f adc r24, r24
- 1582: bb 1f adc r27, r27
- 1584: 26 17 cp r18, r22
- 1586: 37 07 cpc r19, r23
- 1588: 48 07 cpc r20, r24
- 158a: ab 07 cpc r26, r27
- 158c: b0 e8 ldi r27, 0x80 ; 128
- 158e: 09 f0 breq .+2 ; 0x1592 <__divsf3_pse+0x56>
- 1590: bb 0b sbc r27, r27
- 1592: 80 2d mov r24, r0
- 1594: bf 01 movw r22, r30
- 1596: ff 27 eor r31, r31
- 1598: 93 58 subi r25, 0x83 ; 131
- 159a: 5f 4f sbci r21, 0xFF ; 255
- 159c: 2a f0 brmi .+10 ; 0x15a8 <__divsf3_pse+0x6c>
- 159e: 9e 3f cpi r25, 0xFE ; 254
- 15a0: 51 05 cpc r21, r1
- 15a2: 68 f0 brcs .+26 ; 0x15be <__divsf3_pse+0x82>
- 15a4: b1 c0 rjmp .+354 ; 0x1708 <__fp_inf>
- 15a6: fb c0 rjmp .+502 ; 0x179e <__fp_szero>
- 15a8: 5f 3f cpi r21, 0xFF ; 255
- 15aa: ec f3 brlt .-6 ; 0x15a6 <__divsf3_pse+0x6a>
- 15ac: 98 3e cpi r25, 0xE8 ; 232
- 15ae: dc f3 brlt .-10 ; 0x15a6 <__divsf3_pse+0x6a>
- 15b0: 86 95 lsr r24
- 15b2: 77 95 ror r23
- 15b4: 67 95 ror r22
- 15b6: b7 95 ror r27
- 15b8: f7 95 ror r31
- 15ba: 9f 5f subi r25, 0xFF ; 255
- 15bc: c9 f7 brne .-14 ; 0x15b0 <__divsf3_pse+0x74>
- 15be: 88 0f add r24, r24
- 15c0: 91 1d adc r25, r1
- 15c2: 96 95 lsr r25
- 15c4: 87 95 ror r24
- 15c6: 97 f9 bld r25, 7
- 15c8: 08 95 ret
- 15ca: e1 e0 ldi r30, 0x01 ; 1
- 15cc: 66 0f add r22, r22
- 15ce: 77 1f adc r23, r23
- 15d0: 88 1f adc r24, r24
- 15d2: bb 1f adc r27, r27
- 15d4: 62 17 cp r22, r18
- 15d6: 73 07 cpc r23, r19
- 15d8: 84 07 cpc r24, r20
- 15da: ba 07 cpc r27, r26
- 15dc: 20 f0 brcs .+8 ; 0x15e6 <__divsf3_pse+0xaa>
- 15de: 62 1b sub r22, r18
- 15e0: 73 0b sbc r23, r19
- 15e2: 84 0b sbc r24, r20
- 15e4: ba 0b sbc r27, r26
- 15e6: ee 1f adc r30, r30
- 15e8: 88 f7 brcc .-30 ; 0x15cc <__divsf3_pse+0x90>
- 15ea: e0 95 com r30
- 15ec: 08 95 ret
-
-000015ee <__fixunssfsi>:
- 15ee: bc d0 rcall .+376 ; 0x1768 <__fp_splitA>
- 15f0: 88 f0 brcs .+34 ; 0x1614 <__fixunssfsi+0x26>
- 15f2: 9f 57 subi r25, 0x7F ; 127
- 15f4: 90 f0 brcs .+36 ; 0x161a <__fixunssfsi+0x2c>
- 15f6: b9 2f mov r27, r25
- 15f8: 99 27 eor r25, r25
- 15fa: b7 51 subi r27, 0x17 ; 23
- 15fc: a0 f0 brcs .+40 ; 0x1626 <__fixunssfsi+0x38>
- 15fe: d1 f0 breq .+52 ; 0x1634 <__fixunssfsi+0x46>
- 1600: 66 0f add r22, r22
- 1602: 77 1f adc r23, r23
- 1604: 88 1f adc r24, r24
- 1606: 99 1f adc r25, r25
- 1608: 1a f0 brmi .+6 ; 0x1610 <__fixunssfsi+0x22>
- 160a: ba 95 dec r27
- 160c: c9 f7 brne .-14 ; 0x1600 <__fixunssfsi+0x12>
- 160e: 12 c0 rjmp .+36 ; 0x1634 <__fixunssfsi+0x46>
- 1610: b1 30 cpi r27, 0x01 ; 1
- 1612: 81 f0 breq .+32 ; 0x1634 <__fixunssfsi+0x46>
- 1614: c3 d0 rcall .+390 ; 0x179c <__fp_zero>
- 1616: b1 e0 ldi r27, 0x01 ; 1
- 1618: 08 95 ret
- 161a: c0 c0 rjmp .+384 ; 0x179c <__fp_zero>
- 161c: 67 2f mov r22, r23
- 161e: 78 2f mov r23, r24
- 1620: 88 27 eor r24, r24
- 1622: b8 5f subi r27, 0xF8 ; 248
- 1624: 39 f0 breq .+14 ; 0x1634 <__fixunssfsi+0x46>
- 1626: b9 3f cpi r27, 0xF9 ; 249
- 1628: cc f3 brlt .-14 ; 0x161c <__fixunssfsi+0x2e>
- 162a: 86 95 lsr r24
- 162c: 77 95 ror r23
- 162e: 67 95 ror r22
- 1630: b3 95 inc r27
- 1632: d9 f7 brne .-10 ; 0x162a <__fixunssfsi+0x3c>
- 1634: 3e f4 brtc .+14 ; 0x1644 <__fixunssfsi+0x56>
- 1636: 90 95 com r25
- 1638: 80 95 com r24
- 163a: 70 95 com r23
- 163c: 61 95 neg r22
- 163e: 7f 4f sbci r23, 0xFF ; 255
- 1640: 8f 4f sbci r24, 0xFF ; 255
- 1642: 9f 4f sbci r25, 0xFF ; 255
- 1644: 08 95 ret
-
-00001646 <__floatunsisf>:
- 1646: e8 94 clt
- 1648: 09 c0 rjmp .+18 ; 0x165c <__floatsisf+0x12>
-
-0000164a <__floatsisf>:
- 164a: 97 fb bst r25, 7
- 164c: 3e f4 brtc .+14 ; 0x165c <__floatsisf+0x12>
- 164e: 90 95 com r25
- 1650: 80 95 com r24
- 1652: 70 95 com r23
- 1654: 61 95 neg r22
- 1656: 7f 4f sbci r23, 0xFF ; 255
- 1658: 8f 4f sbci r24, 0xFF ; 255
- 165a: 9f 4f sbci r25, 0xFF ; 255
- 165c: 99 23 and r25, r25
- 165e: a9 f0 breq .+42 ; 0x168a <__floatsisf+0x40>
- 1660: f9 2f mov r31, r25
- 1662: 96 e9 ldi r25, 0x96 ; 150
- 1664: bb 27 eor r27, r27
- 1666: 93 95 inc r25
- 1668: f6 95 lsr r31
- 166a: 87 95 ror r24
- 166c: 77 95 ror r23
- 166e: 67 95 ror r22
- 1670: b7 95 ror r27
- 1672: f1 11 cpse r31, r1
- 1674: f8 cf rjmp .-16 ; 0x1666 <__floatsisf+0x1c>
- 1676: fa f4 brpl .+62 ; 0x16b6 <__floatsisf+0x6c>
- 1678: bb 0f add r27, r27
- 167a: 11 f4 brne .+4 ; 0x1680 <__floatsisf+0x36>
- 167c: 60 ff sbrs r22, 0
- 167e: 1b c0 rjmp .+54 ; 0x16b6 <__floatsisf+0x6c>
- 1680: 6f 5f subi r22, 0xFF ; 255
- 1682: 7f 4f sbci r23, 0xFF ; 255
- 1684: 8f 4f sbci r24, 0xFF ; 255
- 1686: 9f 4f sbci r25, 0xFF ; 255
- 1688: 16 c0 rjmp .+44 ; 0x16b6 <__floatsisf+0x6c>
- 168a: 88 23 and r24, r24
- 168c: 11 f0 breq .+4 ; 0x1692 <__floatsisf+0x48>
- 168e: 96 e9 ldi r25, 0x96 ; 150
- 1690: 11 c0 rjmp .+34 ; 0x16b4 <__floatsisf+0x6a>
- 1692: 77 23 and r23, r23
- 1694: 21 f0 breq .+8 ; 0x169e <__floatsisf+0x54>
- 1696: 9e e8 ldi r25, 0x8E ; 142
- 1698: 87 2f mov r24, r23
- 169a: 76 2f mov r23, r22
- 169c: 05 c0 rjmp .+10 ; 0x16a8 <__floatsisf+0x5e>
- 169e: 66 23 and r22, r22
- 16a0: 71 f0 breq .+28 ; 0x16be <__floatsisf+0x74>
- 16a2: 96 e8 ldi r25, 0x86 ; 134
- 16a4: 86 2f mov r24, r22
- 16a6: 70 e0 ldi r23, 0x00 ; 0
- 16a8: 60 e0 ldi r22, 0x00 ; 0
- 16aa: 2a f0 brmi .+10 ; 0x16b6 <__floatsisf+0x6c>
- 16ac: 9a 95 dec r25
- 16ae: 66 0f add r22, r22
- 16b0: 77 1f adc r23, r23
- 16b2: 88 1f adc r24, r24
- 16b4: da f7 brpl .-10 ; 0x16ac <__floatsisf+0x62>
- 16b6: 88 0f add r24, r24
- 16b8: 96 95 lsr r25
- 16ba: 87 95 ror r24
- 16bc: 97 f9 bld r25, 7
- 16be: 08 95 ret
-
-000016c0 <__fp_cmp>:
- 16c0: 99 0f add r25, r25
- 16c2: 00 08 sbc r0, r0
- 16c4: 55 0f add r21, r21
- 16c6: aa 0b sbc r26, r26
- 16c8: e0 e8 ldi r30, 0x80 ; 128
- 16ca: fe ef ldi r31, 0xFE ; 254
- 16cc: 16 16 cp r1, r22
- 16ce: 17 06 cpc r1, r23
- 16d0: e8 07 cpc r30, r24
- 16d2: f9 07 cpc r31, r25
- 16d4: c0 f0 brcs .+48 ; 0x1706 <__fp_cmp+0x46>
- 16d6: 12 16 cp r1, r18
- 16d8: 13 06 cpc r1, r19
- 16da: e4 07 cpc r30, r20
- 16dc: f5 07 cpc r31, r21
- 16de: 98 f0 brcs .+38 ; 0x1706 <__fp_cmp+0x46>
- 16e0: 62 1b sub r22, r18
- 16e2: 73 0b sbc r23, r19
- 16e4: 84 0b sbc r24, r20
- 16e6: 95 0b sbc r25, r21
- 16e8: 39 f4 brne .+14 ; 0x16f8 <__fp_cmp+0x38>
- 16ea: 0a 26 eor r0, r26
- 16ec: 61 f0 breq .+24 ; 0x1706 <__fp_cmp+0x46>
- 16ee: 23 2b or r18, r19
- 16f0: 24 2b or r18, r20
- 16f2: 25 2b or r18, r21
- 16f4: 21 f4 brne .+8 ; 0x16fe <__fp_cmp+0x3e>
- 16f6: 08 95 ret
- 16f8: 0a 26 eor r0, r26
- 16fa: 09 f4 brne .+2 ; 0x16fe <__fp_cmp+0x3e>
- 16fc: a1 40 sbci r26, 0x01 ; 1
- 16fe: a6 95 lsr r26
- 1700: 8f ef ldi r24, 0xFF ; 255
- 1702: 81 1d adc r24, r1
- 1704: 81 1d adc r24, r1
- 1706: 08 95 ret
-
-00001708 <__fp_inf>:
- 1708: 97 f9 bld r25, 7
- 170a: 9f 67 ori r25, 0x7F ; 127
- 170c: 80 e8 ldi r24, 0x80 ; 128
- 170e: 70 e0 ldi r23, 0x00 ; 0
- 1710: 60 e0 ldi r22, 0x00 ; 0
- 1712: 08 95 ret
-
-00001714 <__fp_nan>:
- 1714: 9f ef ldi r25, 0xFF ; 255
- 1716: 80 ec ldi r24, 0xC0 ; 192
- 1718: 08 95 ret
-
-0000171a <__fp_pscA>:
- 171a: 00 24 eor r0, r0
- 171c: 0a 94 dec r0
- 171e: 16 16 cp r1, r22
- 1720: 17 06 cpc r1, r23
- 1722: 18 06 cpc r1, r24
- 1724: 09 06 cpc r0, r25
- 1726: 08 95 ret
-
-00001728 <__fp_pscB>:
- 1728: 00 24 eor r0, r0
- 172a: 0a 94 dec r0
- 172c: 12 16 cp r1, r18
- 172e: 13 06 cpc r1, r19
- 1730: 14 06 cpc r1, r20
- 1732: 05 06 cpc r0, r21
- 1734: 08 95 ret
-
-00001736 <__fp_round>:
- 1736: 09 2e mov r0, r25
- 1738: 03 94 inc r0
- 173a: 00 0c add r0, r0
- 173c: 11 f4 brne .+4 ; 0x1742 <__fp_round+0xc>
- 173e: 88 23 and r24, r24
- 1740: 52 f0 brmi .+20 ; 0x1756 <__fp_round+0x20>
- 1742: bb 0f add r27, r27
- 1744: 40 f4 brcc .+16 ; 0x1756 <__fp_round+0x20>
- 1746: bf 2b or r27, r31
- 1748: 11 f4 brne .+4 ; 0x174e <__fp_round+0x18>
- 174a: 60 ff sbrs r22, 0
- 174c: 04 c0 rjmp .+8 ; 0x1756 <__fp_round+0x20>
- 174e: 6f 5f subi r22, 0xFF ; 255
- 1750: 7f 4f sbci r23, 0xFF ; 255
- 1752: 8f 4f sbci r24, 0xFF ; 255
- 1754: 9f 4f sbci r25, 0xFF ; 255
- 1756: 08 95 ret
-
-00001758 <__fp_split3>:
- 1758: 57 fd sbrc r21, 7
- 175a: 90 58 subi r25, 0x80 ; 128
- 175c: 44 0f add r20, r20
- 175e: 55 1f adc r21, r21
- 1760: 59 f0 breq .+22 ; 0x1778 <__fp_splitA+0x10>
- 1762: 5f 3f cpi r21, 0xFF ; 255
- 1764: 71 f0 breq .+28 ; 0x1782 <__fp_splitA+0x1a>
- 1766: 47 95 ror r20
-
-00001768 <__fp_splitA>:
- 1768: 88 0f add r24, r24
- 176a: 97 fb bst r25, 7
- 176c: 99 1f adc r25, r25
- 176e: 61 f0 breq .+24 ; 0x1788 <__fp_splitA+0x20>
- 1770: 9f 3f cpi r25, 0xFF ; 255
- 1772: 79 f0 breq .+30 ; 0x1792 <__fp_splitA+0x2a>
- 1774: 87 95 ror r24
- 1776: 08 95 ret
- 1778: 12 16 cp r1, r18
- 177a: 13 06 cpc r1, r19
- 177c: 14 06 cpc r1, r20
- 177e: 55 1f adc r21, r21
- 1780: f2 cf rjmp .-28 ; 0x1766 <__fp_split3+0xe>
- 1782: 46 95 lsr r20
- 1784: f1 df rcall .-30 ; 0x1768 <__fp_splitA>
- 1786: 08 c0 rjmp .+16 ; 0x1798 <__fp_splitA+0x30>
- 1788: 16 16 cp r1, r22
- 178a: 17 06 cpc r1, r23
- 178c: 18 06 cpc r1, r24
- 178e: 99 1f adc r25, r25
- 1790: f1 cf rjmp .-30 ; 0x1774 <__fp_splitA+0xc>
- 1792: 86 95 lsr r24
- 1794: 71 05 cpc r23, r1
- 1796: 61 05 cpc r22, r1
- 1798: 08 94 sec
- 179a: 08 95 ret
-
-0000179c <__fp_zero>:
- 179c: e8 94 clt
-
-0000179e <__fp_szero>:
- 179e: bb 27 eor r27, r27
- 17a0: 66 27 eor r22, r22
- 17a2: 77 27 eor r23, r23
- 17a4: cb 01 movw r24, r22
- 17a6: 97 f9 bld r25, 7
- 17a8: 08 95 ret
-
-000017aa <__gesf2>:
- 17aa: 8a df rcall .-236 ; 0x16c0 <__fp_cmp>
- 17ac: 08 f4 brcc .+2 ; 0x17b0 <__gesf2+0x6>
- 17ae: 8f ef ldi r24, 0xFF ; 255
- 17b0: 08 95 ret
-
-000017b2 <__udivmodsi4>:
- 17b2: a1 e2 ldi r26, 0x21 ; 33
- 17b4: 1a 2e mov r1, r26
- 17b6: aa 1b sub r26, r26
- 17b8: bb 1b sub r27, r27
- 17ba: fd 01 movw r30, r26
- 17bc: 0d c0 rjmp .+26 ; 0x17d8 <__udivmodsi4_ep>
-
-000017be <__udivmodsi4_loop>:
- 17be: aa 1f adc r26, r26
- 17c0: bb 1f adc r27, r27
- 17c2: ee 1f adc r30, r30
- 17c4: ff 1f adc r31, r31
- 17c6: a2 17 cp r26, r18
- 17c8: b3 07 cpc r27, r19
- 17ca: e4 07 cpc r30, r20
- 17cc: f5 07 cpc r31, r21
- 17ce: 20 f0 brcs .+8 ; 0x17d8 <__udivmodsi4_ep>
- 17d0: a2 1b sub r26, r18
- 17d2: b3 0b sbc r27, r19
- 17d4: e4 0b sbc r30, r20
- 17d6: f5 0b sbc r31, r21
-
-000017d8 <__udivmodsi4_ep>:
- 17d8: 66 1f adc r22, r22
- 17da: 77 1f adc r23, r23
- 17dc: 88 1f adc r24, r24
- 17de: 99 1f adc r25, r25
- 17e0: 1a 94 dec r1
- 17e2: 69 f7 brne .-38 ; 0x17be <__udivmodsi4_loop>
- 17e4: 60 95 com r22
- 17e6: 70 95 com r23
- 17e8: 80 95 com r24
- 17ea: 90 95 com r25
- 17ec: 9b 01 movw r18, r22
- 17ee: ac 01 movw r20, r24
- 17f0: bd 01 movw r22, r26
- 17f2: cf 01 movw r24, r30
- 17f4: 08 95 ret
-
-000017f6 <_exit>:
- 17f6: f8 94 cli
-
-000017f8 <__stop_program>:
- 17f8: ff cf rjmp .-2 ; 0x17f8 <__stop_program>
+ 16ba: 08 95 ret
+
+000016bc <__subsf3>:
+ 16bc: 50 58 subi r21, 0x80 ; 128
+
+000016be <__addsf3>:
+ 16be: bb 27 eor r27, r27
+ 16c0: aa 27 eor r26, r26
+ 16c2: 0e d0 rcall .+28 ; 0x16e0 <__addsf3x>
+ 16c4: 70 c1 rjmp .+736 ; 0x19a6 <__fp_round>
+ 16c6: 61 d1 rcall .+706 ; 0x198a <__fp_pscA>
+ 16c8: 30 f0 brcs .+12 ; 0x16d6 <__addsf3+0x18>
+ 16ca: 66 d1 rcall .+716 ; 0x1998 <__fp_pscB>
+ 16cc: 20 f0 brcs .+8 ; 0x16d6 <__addsf3+0x18>
+ 16ce: 31 f4 brne .+12 ; 0x16dc <__addsf3+0x1e>
+ 16d0: 9f 3f cpi r25, 0xFF ; 255
+ 16d2: 11 f4 brne .+4 ; 0x16d8 <__addsf3+0x1a>
+ 16d4: 1e f4 brtc .+6 ; 0x16dc <__addsf3+0x1e>
+ 16d6: 56 c1 rjmp .+684 ; 0x1984 <__fp_nan>
+ 16d8: 0e f4 brtc .+2 ; 0x16dc <__addsf3+0x1e>
+ 16da: e0 95 com r30
+ 16dc: e7 fb bst r30, 7
+ 16de: 4c c1 rjmp .+664 ; 0x1978 <__fp_inf>
+
+000016e0 <__addsf3x>:
+ 16e0: e9 2f mov r30, r25
+ 16e2: 72 d1 rcall .+740 ; 0x19c8 <__fp_split3>
+ 16e4: 80 f3 brcs .-32 ; 0x16c6 <__addsf3+0x8>
+ 16e6: ba 17 cp r27, r26
+ 16e8: 62 07 cpc r22, r18
+ 16ea: 73 07 cpc r23, r19
+ 16ec: 84 07 cpc r24, r20
+ 16ee: 95 07 cpc r25, r21
+ 16f0: 18 f0 brcs .+6 ; 0x16f8 <__addsf3x+0x18>
+ 16f2: 71 f4 brne .+28 ; 0x1710 <__addsf3x+0x30>
+ 16f4: 9e f5 brtc .+102 ; 0x175c <__addsf3x+0x7c>
+ 16f6: 8a c1 rjmp .+788 ; 0x1a0c <__fp_zero>
+ 16f8: 0e f4 brtc .+2 ; 0x16fc <__addsf3x+0x1c>
+ 16fa: e0 95 com r30
+ 16fc: 0b 2e mov r0, r27
+ 16fe: ba 2f mov r27, r26
+ 1700: a0 2d mov r26, r0
+ 1702: 0b 01 movw r0, r22
+ 1704: b9 01 movw r22, r18
+ 1706: 90 01 movw r18, r0
+ 1708: 0c 01 movw r0, r24
+ 170a: ca 01 movw r24, r20
+ 170c: a0 01 movw r20, r0
+ 170e: 11 24 eor r1, r1
+ 1710: ff 27 eor r31, r31
+ 1712: 59 1b sub r21, r25
+ 1714: 99 f0 breq .+38 ; 0x173c <__addsf3x+0x5c>
+ 1716: 59 3f cpi r21, 0xF9 ; 249
+ 1718: 50 f4 brcc .+20 ; 0x172e <__addsf3x+0x4e>
+ 171a: 50 3e cpi r21, 0xE0 ; 224
+ 171c: 68 f1 brcs .+90 ; 0x1778 <__addsf3x+0x98>
+ 171e: 1a 16 cp r1, r26
+ 1720: f0 40 sbci r31, 0x00 ; 0
+ 1722: a2 2f mov r26, r18
+ 1724: 23 2f mov r18, r19
+ 1726: 34 2f mov r19, r20
+ 1728: 44 27 eor r20, r20
+ 172a: 58 5f subi r21, 0xF8 ; 248
+ 172c: f3 cf rjmp .-26 ; 0x1714 <__addsf3x+0x34>
+ 172e: 46 95 lsr r20
+ 1730: 37 95 ror r19
+ 1732: 27 95 ror r18
+ 1734: a7 95 ror r26
+ 1736: f0 40 sbci r31, 0x00 ; 0
+ 1738: 53 95 inc r21
+ 173a: c9 f7 brne .-14 ; 0x172e <__addsf3x+0x4e>
+ 173c: 7e f4 brtc .+30 ; 0x175c <__addsf3x+0x7c>
+ 173e: 1f 16 cp r1, r31
+ 1740: ba 0b sbc r27, r26
+ 1742: 62 0b sbc r22, r18
+ 1744: 73 0b sbc r23, r19
+ 1746: 84 0b sbc r24, r20
+ 1748: ba f0 brmi .+46 ; 0x1778 <__addsf3x+0x98>
+ 174a: 91 50 subi r25, 0x01 ; 1
+ 174c: a1 f0 breq .+40 ; 0x1776 <__addsf3x+0x96>
+ 174e: ff 0f add r31, r31
+ 1750: bb 1f adc r27, r27
+ 1752: 66 1f adc r22, r22
+ 1754: 77 1f adc r23, r23
+ 1756: 88 1f adc r24, r24
+ 1758: c2 f7 brpl .-16 ; 0x174a <__addsf3x+0x6a>
+ 175a: 0e c0 rjmp .+28 ; 0x1778 <__addsf3x+0x98>
+ 175c: ba 0f add r27, r26
+ 175e: 62 1f adc r22, r18
+ 1760: 73 1f adc r23, r19
+ 1762: 84 1f adc r24, r20
+ 1764: 48 f4 brcc .+18 ; 0x1778 <__addsf3x+0x98>
+ 1766: 87 95 ror r24
+ 1768: 77 95 ror r23
+ 176a: 67 95 ror r22
+ 176c: b7 95 ror r27
+ 176e: f7 95 ror r31
+ 1770: 9e 3f cpi r25, 0xFE ; 254
+ 1772: 08 f0 brcs .+2 ; 0x1776 <__addsf3x+0x96>
+ 1774: b3 cf rjmp .-154 ; 0x16dc <__addsf3+0x1e>
+ 1776: 93 95 inc r25
+ 1778: 88 0f add r24, r24
+ 177a: 08 f0 brcs .+2 ; 0x177e <__addsf3x+0x9e>
+ 177c: 99 27 eor r25, r25
+ 177e: ee 0f add r30, r30
+ 1780: 97 95 ror r25
+ 1782: 87 95 ror r24
+ 1784: 08 95 ret
+
+00001786 <__cmpsf2>:
+ 1786: d4 d0 rcall .+424 ; 0x1930 <__fp_cmp>
+ 1788: 08 f4 brcc .+2 ; 0x178c <__cmpsf2+0x6>
+ 178a: 81 e0 ldi r24, 0x01 ; 1
+ 178c: 08 95 ret
+
+0000178e <__divsf3>:
+ 178e: 0c d0 rcall .+24 ; 0x17a8 <__divsf3x>
+ 1790: 0a c1 rjmp .+532 ; 0x19a6 <__fp_round>
+ 1792: 02 d1 rcall .+516 ; 0x1998 <__fp_pscB>
+ 1794: 40 f0 brcs .+16 ; 0x17a6 <__divsf3+0x18>
+ 1796: f9 d0 rcall .+498 ; 0x198a <__fp_pscA>
+ 1798: 30 f0 brcs .+12 ; 0x17a6 <__divsf3+0x18>
+ 179a: 21 f4 brne .+8 ; 0x17a4 <__divsf3+0x16>
+ 179c: 5f 3f cpi r21, 0xFF ; 255
+ 179e: 19 f0 breq .+6 ; 0x17a6 <__divsf3+0x18>
+ 17a0: eb c0 rjmp .+470 ; 0x1978 <__fp_inf>
+ 17a2: 51 11 cpse r21, r1
+ 17a4: 34 c1 rjmp .+616 ; 0x1a0e <__fp_szero>
+ 17a6: ee c0 rjmp .+476 ; 0x1984 <__fp_nan>
+
+000017a8 <__divsf3x>:
+ 17a8: 0f d1 rcall .+542 ; 0x19c8 <__fp_split3>
+ 17aa: 98 f3 brcs .-26 ; 0x1792 <__divsf3+0x4>
+
+000017ac <__divsf3_pse>:
+ 17ac: 99 23 and r25, r25
+ 17ae: c9 f3 breq .-14 ; 0x17a2 <__divsf3+0x14>
+ 17b0: 55 23 and r21, r21
+ 17b2: b1 f3 breq .-20 ; 0x17a0 <__divsf3+0x12>
+ 17b4: 95 1b sub r25, r21
+ 17b6: 55 0b sbc r21, r21
+ 17b8: bb 27 eor r27, r27
+ 17ba: aa 27 eor r26, r26
+ 17bc: 62 17 cp r22, r18
+ 17be: 73 07 cpc r23, r19
+ 17c0: 84 07 cpc r24, r20
+ 17c2: 38 f0 brcs .+14 ; 0x17d2 <__divsf3_pse+0x26>
+ 17c4: 9f 5f subi r25, 0xFF ; 255
+ 17c6: 5f 4f sbci r21, 0xFF ; 255
+ 17c8: 22 0f add r18, r18
+ 17ca: 33 1f adc r19, r19
+ 17cc: 44 1f adc r20, r20
+ 17ce: aa 1f adc r26, r26
+ 17d0: a9 f3 breq .-22 ; 0x17bc <__divsf3_pse+0x10>
+ 17d2: 33 d0 rcall .+102 ; 0x183a <__divsf3_pse+0x8e>
+ 17d4: 0e 2e mov r0, r30
+ 17d6: 3a f0 brmi .+14 ; 0x17e6 <__divsf3_pse+0x3a>
+ 17d8: e0 e8 ldi r30, 0x80 ; 128
+ 17da: 30 d0 rcall .+96 ; 0x183c <__divsf3_pse+0x90>
+ 17dc: 91 50 subi r25, 0x01 ; 1
+ 17de: 50 40 sbci r21, 0x00 ; 0
+ 17e0: e6 95 lsr r30
+ 17e2: 00 1c adc r0, r0
+ 17e4: ca f7 brpl .-14 ; 0x17d8 <__divsf3_pse+0x2c>
+ 17e6: 29 d0 rcall .+82 ; 0x183a <__divsf3_pse+0x8e>
+ 17e8: fe 2f mov r31, r30
+ 17ea: 27 d0 rcall .+78 ; 0x183a <__divsf3_pse+0x8e>
+ 17ec: 66 0f add r22, r22
+ 17ee: 77 1f adc r23, r23
+ 17f0: 88 1f adc r24, r24
+ 17f2: bb 1f adc r27, r27
+ 17f4: 26 17 cp r18, r22
+ 17f6: 37 07 cpc r19, r23
+ 17f8: 48 07 cpc r20, r24
+ 17fa: ab 07 cpc r26, r27
+ 17fc: b0 e8 ldi r27, 0x80 ; 128
+ 17fe: 09 f0 breq .+2 ; 0x1802 <__divsf3_pse+0x56>
+ 1800: bb 0b sbc r27, r27
+ 1802: 80 2d mov r24, r0
+ 1804: bf 01 movw r22, r30
+ 1806: ff 27 eor r31, r31
+ 1808: 93 58 subi r25, 0x83 ; 131
+ 180a: 5f 4f sbci r21, 0xFF ; 255
+ 180c: 2a f0 brmi .+10 ; 0x1818 <__divsf3_pse+0x6c>
+ 180e: 9e 3f cpi r25, 0xFE ; 254
+ 1810: 51 05 cpc r21, r1
+ 1812: 68 f0 brcs .+26 ; 0x182e <__divsf3_pse+0x82>
+ 1814: b1 c0 rjmp .+354 ; 0x1978 <__fp_inf>
+ 1816: fb c0 rjmp .+502 ; 0x1a0e <__fp_szero>
+ 1818: 5f 3f cpi r21, 0xFF ; 255
+ 181a: ec f3 brlt .-6 ; 0x1816 <__divsf3_pse+0x6a>
+ 181c: 98 3e cpi r25, 0xE8 ; 232
+ 181e: dc f3 brlt .-10 ; 0x1816 <__divsf3_pse+0x6a>
+ 1820: 86 95 lsr r24
+ 1822: 77 95 ror r23
+ 1824: 67 95 ror r22
+ 1826: b7 95 ror r27
+ 1828: f7 95 ror r31
+ 182a: 9f 5f subi r25, 0xFF ; 255
+ 182c: c9 f7 brne .-14 ; 0x1820 <__divsf3_pse+0x74>
+ 182e: 88 0f add r24, r24
+ 1830: 91 1d adc r25, r1
+ 1832: 96 95 lsr r25
+ 1834: 87 95 ror r24
+ 1836: 97 f9 bld r25, 7
+ 1838: 08 95 ret
+ 183a: e1 e0 ldi r30, 0x01 ; 1
+ 183c: 66 0f add r22, r22
+ 183e: 77 1f adc r23, r23
+ 1840: 88 1f adc r24, r24
+ 1842: bb 1f adc r27, r27
+ 1844: 62 17 cp r22, r18
+ 1846: 73 07 cpc r23, r19
+ 1848: 84 07 cpc r24, r20
+ 184a: ba 07 cpc r27, r26
+ 184c: 20 f0 brcs .+8 ; 0x1856 <__divsf3_pse+0xaa>
+ 184e: 62 1b sub r22, r18
+ 1850: 73 0b sbc r23, r19
+ 1852: 84 0b sbc r24, r20
+ 1854: ba 0b sbc r27, r26
+ 1856: ee 1f adc r30, r30
+ 1858: 88 f7 brcc .-30 ; 0x183c <__divsf3_pse+0x90>
+ 185a: e0 95 com r30
+ 185c: 08 95 ret
+
+0000185e <__fixunssfsi>:
+ 185e: bc d0 rcall .+376 ; 0x19d8 <__fp_splitA>
+ 1860: 88 f0 brcs .+34 ; 0x1884 <__fixunssfsi+0x26>
+ 1862: 9f 57 subi r25, 0x7F ; 127
+ 1864: 90 f0 brcs .+36 ; 0x188a <__fixunssfsi+0x2c>
+ 1866: b9 2f mov r27, r25
+ 1868: 99 27 eor r25, r25
+ 186a: b7 51 subi r27, 0x17 ; 23
+ 186c: a0 f0 brcs .+40 ; 0x1896 <__fixunssfsi+0x38>
+ 186e: d1 f0 breq .+52 ; 0x18a4 <__fixunssfsi+0x46>
+ 1870: 66 0f add r22, r22
+ 1872: 77 1f adc r23, r23
+ 1874: 88 1f adc r24, r24
+ 1876: 99 1f adc r25, r25
+ 1878: 1a f0 brmi .+6 ; 0x1880 <__fixunssfsi+0x22>
+ 187a: ba 95 dec r27
+ 187c: c9 f7 brne .-14 ; 0x1870 <__fixunssfsi+0x12>
+ 187e: 12 c0 rjmp .+36 ; 0x18a4 <__fixunssfsi+0x46>
+ 1880: b1 30 cpi r27, 0x01 ; 1
+ 1882: 81 f0 breq .+32 ; 0x18a4 <__fixunssfsi+0x46>
+ 1884: c3 d0 rcall .+390 ; 0x1a0c <__fp_zero>
+ 1886: b1 e0 ldi r27, 0x01 ; 1
+ 1888: 08 95 ret
+ 188a: c0 c0 rjmp .+384 ; 0x1a0c <__fp_zero>
+ 188c: 67 2f mov r22, r23
+ 188e: 78 2f mov r23, r24
+ 1890: 88 27 eor r24, r24
+ 1892: b8 5f subi r27, 0xF8 ; 248
+ 1894: 39 f0 breq .+14 ; 0x18a4 <__fixunssfsi+0x46>
+ 1896: b9 3f cpi r27, 0xF9 ; 249
+ 1898: cc f3 brlt .-14 ; 0x188c <__fixunssfsi+0x2e>
+ 189a: 86 95 lsr r24
+ 189c: 77 95 ror r23
+ 189e: 67 95 ror r22
+ 18a0: b3 95 inc r27
+ 18a2: d9 f7 brne .-10 ; 0x189a <__fixunssfsi+0x3c>
+ 18a4: 3e f4 brtc .+14 ; 0x18b4 <__fixunssfsi+0x56>
+ 18a6: 90 95 com r25
+ 18a8: 80 95 com r24
+ 18aa: 70 95 com r23
+ 18ac: 61 95 neg r22
+ 18ae: 7f 4f sbci r23, 0xFF ; 255
+ 18b0: 8f 4f sbci r24, 0xFF ; 255
+ 18b2: 9f 4f sbci r25, 0xFF ; 255
+ 18b4: 08 95 ret
+
+000018b6 <__floatunsisf>:
+ 18b6: e8 94 clt
+ 18b8: 09 c0 rjmp .+18 ; 0x18cc <__floatsisf+0x12>
+
+000018ba <__floatsisf>:
+ 18ba: 97 fb bst r25, 7
+ 18bc: 3e f4 brtc .+14 ; 0x18cc <__floatsisf+0x12>
+ 18be: 90 95 com r25
+ 18c0: 80 95 com r24
+ 18c2: 70 95 com r23
+ 18c4: 61 95 neg r22
+ 18c6: 7f 4f sbci r23, 0xFF ; 255
+ 18c8: 8f 4f sbci r24, 0xFF ; 255
+ 18ca: 9f 4f sbci r25, 0xFF ; 255
+ 18cc: 99 23 and r25, r25
+ 18ce: a9 f0 breq .+42 ; 0x18fa <__floatsisf+0x40>
+ 18d0: f9 2f mov r31, r25
+ 18d2: 96 e9 ldi r25, 0x96 ; 150
+ 18d4: bb 27 eor r27, r27
+ 18d6: 93 95 inc r25
+ 18d8: f6 95 lsr r31
+ 18da: 87 95 ror r24
+ 18dc: 77 95 ror r23
+ 18de: 67 95 ror r22
+ 18e0: b7 95 ror r27
+ 18e2: f1 11 cpse r31, r1
+ 18e4: f8 cf rjmp .-16 ; 0x18d6 <__floatsisf+0x1c>
+ 18e6: fa f4 brpl .+62 ; 0x1926 <__floatsisf+0x6c>
+ 18e8: bb 0f add r27, r27
+ 18ea: 11 f4 brne .+4 ; 0x18f0 <__floatsisf+0x36>
+ 18ec: 60 ff sbrs r22, 0
+ 18ee: 1b c0 rjmp .+54 ; 0x1926 <__floatsisf+0x6c>
+ 18f0: 6f 5f subi r22, 0xFF ; 255
+ 18f2: 7f 4f sbci r23, 0xFF ; 255
+ 18f4: 8f 4f sbci r24, 0xFF ; 255
+ 18f6: 9f 4f sbci r25, 0xFF ; 255
+ 18f8: 16 c0 rjmp .+44 ; 0x1926 <__floatsisf+0x6c>
+ 18fa: 88 23 and r24, r24
+ 18fc: 11 f0 breq .+4 ; 0x1902 <__floatsisf+0x48>
+ 18fe: 96 e9 ldi r25, 0x96 ; 150
+ 1900: 11 c0 rjmp .+34 ; 0x1924 <__floatsisf+0x6a>
+ 1902: 77 23 and r23, r23
+ 1904: 21 f0 breq .+8 ; 0x190e <__floatsisf+0x54>
+ 1906: 9e e8 ldi r25, 0x8E ; 142
+ 1908: 87 2f mov r24, r23
+ 190a: 76 2f mov r23, r22
+ 190c: 05 c0 rjmp .+10 ; 0x1918 <__floatsisf+0x5e>
+ 190e: 66 23 and r22, r22
+ 1910: 71 f0 breq .+28 ; 0x192e <__floatsisf+0x74>
+ 1912: 96 e8 ldi r25, 0x86 ; 134
+ 1914: 86 2f mov r24, r22
+ 1916: 70 e0 ldi r23, 0x00 ; 0
+ 1918: 60 e0 ldi r22, 0x00 ; 0
+ 191a: 2a f0 brmi .+10 ; 0x1926 <__floatsisf+0x6c>
+ 191c: 9a 95 dec r25
+ 191e: 66 0f add r22, r22
+ 1920: 77 1f adc r23, r23
+ 1922: 88 1f adc r24, r24
+ 1924: da f7 brpl .-10 ; 0x191c <__floatsisf+0x62>
+ 1926: 88 0f add r24, r24
+ 1928: 96 95 lsr r25
+ 192a: 87 95 ror r24
+ 192c: 97 f9 bld r25, 7
+ 192e: 08 95 ret
+
+00001930 <__fp_cmp>:
+ 1930: 99 0f add r25, r25
+ 1932: 00 08 sbc r0, r0
+ 1934: 55 0f add r21, r21
+ 1936: aa 0b sbc r26, r26
+ 1938: e0 e8 ldi r30, 0x80 ; 128
+ 193a: fe ef ldi r31, 0xFE ; 254
+ 193c: 16 16 cp r1, r22
+ 193e: 17 06 cpc r1, r23
+ 1940: e8 07 cpc r30, r24
+ 1942: f9 07 cpc r31, r25
+ 1944: c0 f0 brcs .+48 ; 0x1976 <__fp_cmp+0x46>
+ 1946: 12 16 cp r1, r18
+ 1948: 13 06 cpc r1, r19
+ 194a: e4 07 cpc r30, r20
+ 194c: f5 07 cpc r31, r21
+ 194e: 98 f0 brcs .+38 ; 0x1976 <__fp_cmp+0x46>
+ 1950: 62 1b sub r22, r18
+ 1952: 73 0b sbc r23, r19
+ 1954: 84 0b sbc r24, r20
+ 1956: 95 0b sbc r25, r21
+ 1958: 39 f4 brne .+14 ; 0x1968 <__fp_cmp+0x38>
+ 195a: 0a 26 eor r0, r26
+ 195c: 61 f0 breq .+24 ; 0x1976 <__fp_cmp+0x46>
+ 195e: 23 2b or r18, r19
+ 1960: 24 2b or r18, r20
+ 1962: 25 2b or r18, r21
+ 1964: 21 f4 brne .+8 ; 0x196e <__fp_cmp+0x3e>
+ 1966: 08 95 ret
+ 1968: 0a 26 eor r0, r26
+ 196a: 09 f4 brne .+2 ; 0x196e <__fp_cmp+0x3e>
+ 196c: a1 40 sbci r26, 0x01 ; 1
+ 196e: a6 95 lsr r26
+ 1970: 8f ef ldi r24, 0xFF ; 255
+ 1972: 81 1d adc r24, r1
+ 1974: 81 1d adc r24, r1
+ 1976: 08 95 ret
+
+00001978 <__fp_inf>:
+ 1978: 97 f9 bld r25, 7
+ 197a: 9f 67 ori r25, 0x7F ; 127
+ 197c: 80 e8 ldi r24, 0x80 ; 128
+ 197e: 70 e0 ldi r23, 0x00 ; 0
+ 1980: 60 e0 ldi r22, 0x00 ; 0
+ 1982: 08 95 ret
+
+00001984 <__fp_nan>:
+ 1984: 9f ef ldi r25, 0xFF ; 255
+ 1986: 80 ec ldi r24, 0xC0 ; 192
+ 1988: 08 95 ret
+
+0000198a <__fp_pscA>:
+ 198a: 00 24 eor r0, r0
+ 198c: 0a 94 dec r0
+ 198e: 16 16 cp r1, r22
+ 1990: 17 06 cpc r1, r23
+ 1992: 18 06 cpc r1, r24
+ 1994: 09 06 cpc r0, r25
+ 1996: 08 95 ret
+
+00001998 <__fp_pscB>:
+ 1998: 00 24 eor r0, r0
+ 199a: 0a 94 dec r0
+ 199c: 12 16 cp r1, r18
+ 199e: 13 06 cpc r1, r19
+ 19a0: 14 06 cpc r1, r20
+ 19a2: 05 06 cpc r0, r21
+ 19a4: 08 95 ret
+
+000019a6 <__fp_round>:
+ 19a6: 09 2e mov r0, r25
+ 19a8: 03 94 inc r0
+ 19aa: 00 0c add r0, r0
+ 19ac: 11 f4 brne .+4 ; 0x19b2 <__fp_round+0xc>
+ 19ae: 88 23 and r24, r24
+ 19b0: 52 f0 brmi .+20 ; 0x19c6 <__fp_round+0x20>
+ 19b2: bb 0f add r27, r27
+ 19b4: 40 f4 brcc .+16 ; 0x19c6 <__fp_round+0x20>
+ 19b6: bf 2b or r27, r31
+ 19b8: 11 f4 brne .+4 ; 0x19be <__fp_round+0x18>
+ 19ba: 60 ff sbrs r22, 0
+ 19bc: 04 c0 rjmp .+8 ; 0x19c6 <__fp_round+0x20>
+ 19be: 6f 5f subi r22, 0xFF ; 255
+ 19c0: 7f 4f sbci r23, 0xFF ; 255
+ 19c2: 8f 4f sbci r24, 0xFF ; 255
+ 19c4: 9f 4f sbci r25, 0xFF ; 255
+ 19c6: 08 95 ret
+
+000019c8 <__fp_split3>:
+ 19c8: 57 fd sbrc r21, 7
+ 19ca: 90 58 subi r25, 0x80 ; 128
+ 19cc: 44 0f add r20, r20
+ 19ce: 55 1f adc r21, r21
+ 19d0: 59 f0 breq .+22 ; 0x19e8 <__fp_splitA+0x10>
+ 19d2: 5f 3f cpi r21, 0xFF ; 255
+ 19d4: 71 f0 breq .+28 ; 0x19f2 <__fp_splitA+0x1a>
+ 19d6: 47 95 ror r20
+
+000019d8 <__fp_splitA>:
+ 19d8: 88 0f add r24, r24
+ 19da: 97 fb bst r25, 7
+ 19dc: 99 1f adc r25, r25
+ 19de: 61 f0 breq .+24 ; 0x19f8 <__fp_splitA+0x20>
+ 19e0: 9f 3f cpi r25, 0xFF ; 255
+ 19e2: 79 f0 breq .+30 ; 0x1a02 <__fp_splitA+0x2a>
+ 19e4: 87 95 ror r24
+ 19e6: 08 95 ret
+ 19e8: 12 16 cp r1, r18
+ 19ea: 13 06 cpc r1, r19
+ 19ec: 14 06 cpc r1, r20
+ 19ee: 55 1f adc r21, r21
+ 19f0: f2 cf rjmp .-28 ; 0x19d6 <__fp_split3+0xe>
+ 19f2: 46 95 lsr r20
+ 19f4: f1 df rcall .-30 ; 0x19d8 <__fp_splitA>
+ 19f6: 08 c0 rjmp .+16 ; 0x1a08 <__fp_splitA+0x30>
+ 19f8: 16 16 cp r1, r22
+ 19fa: 17 06 cpc r1, r23
+ 19fc: 18 06 cpc r1, r24
+ 19fe: 99 1f adc r25, r25
+ 1a00: f1 cf rjmp .-30 ; 0x19e4 <__fp_splitA+0xc>
+ 1a02: 86 95 lsr r24
+ 1a04: 71 05 cpc r23, r1
+ 1a06: 61 05 cpc r22, r1
+ 1a08: 08 94 sec
+ 1a0a: 08 95 ret
+
+00001a0c <__fp_zero>:
+ 1a0c: e8 94 clt
+
+00001a0e <__fp_szero>:
+ 1a0e: bb 27 eor r27, r27
+ 1a10: 66 27 eor r22, r22
+ 1a12: 77 27 eor r23, r23
+ 1a14: cb 01 movw r24, r22
+ 1a16: 97 f9 bld r25, 7
+ 1a18: 08 95 ret
+
+00001a1a <__gesf2>:
+ 1a1a: 8a df rcall .-236 ; 0x1930 <__fp_cmp>
+ 1a1c: 08 f4 brcc .+2 ; 0x1a20 <__gesf2+0x6>
+ 1a1e: 8f ef ldi r24, 0xFF ; 255
+ 1a20: 08 95 ret
+
+00001a22 <__udivmodhi4>:
+ 1a22: aa 1b sub r26, r26
+ 1a24: bb 1b sub r27, r27
+ 1a26: 51 e1 ldi r21, 0x11 ; 17
+ 1a28: 07 c0 rjmp .+14 ; 0x1a38 <__udivmodhi4_ep>
+
+00001a2a <__udivmodhi4_loop>:
+ 1a2a: aa 1f adc r26, r26
+ 1a2c: bb 1f adc r27, r27
+ 1a2e: a6 17 cp r26, r22
+ 1a30: b7 07 cpc r27, r23
+ 1a32: 10 f0 brcs .+4 ; 0x1a38 <__udivmodhi4_ep>
+ 1a34: a6 1b sub r26, r22
+ 1a36: b7 0b sbc r27, r23
+
+00001a38 <__udivmodhi4_ep>:
+ 1a38: 88 1f adc r24, r24
+ 1a3a: 99 1f adc r25, r25
+ 1a3c: 5a 95 dec r21
+ 1a3e: a9 f7 brne .-22 ; 0x1a2a <__udivmodhi4_loop>
+ 1a40: 80 95 com r24
+ 1a42: 90 95 com r25
+ 1a44: bc 01 movw r22, r24
+ 1a46: cd 01 movw r24, r26
+ 1a48: 08 95 ret
+
+00001a4a <__divmodhi4>:
+ 1a4a: 97 fb bst r25, 7
+ 1a4c: 09 2e mov r0, r25
+ 1a4e: 07 26 eor r0, r23
+ 1a50: 0a d0 rcall .+20 ; 0x1a66 <__divmodhi4_neg1>
+ 1a52: 77 fd sbrc r23, 7
+ 1a54: 04 d0 rcall .+8 ; 0x1a5e <__divmodhi4_neg2>
+ 1a56: e5 df rcall .-54 ; 0x1a22 <__udivmodhi4>
+ 1a58: 06 d0 rcall .+12 ; 0x1a66 <__divmodhi4_neg1>
+ 1a5a: 00 20 and r0, r0
+ 1a5c: 1a f4 brpl .+6 ; 0x1a64 <__divmodhi4_exit>
+
+00001a5e <__divmodhi4_neg2>:
+ 1a5e: 70 95 com r23
+ 1a60: 61 95 neg r22
+ 1a62: 7f 4f sbci r23, 0xFF ; 255
+
+00001a64 <__divmodhi4_exit>:
+ 1a64: 08 95 ret
+
+00001a66 <__divmodhi4_neg1>:
+ 1a66: f6 f7 brtc .-4 ; 0x1a64 <__divmodhi4_exit>
+ 1a68: 90 95 com r25
+ 1a6a: 81 95 neg r24
+ 1a6c: 9f 4f sbci r25, 0xFF ; 255
+ 1a6e: 08 95 ret
+
+00001a70 <__udivmodsi4>:
+ 1a70: a1 e2 ldi r26, 0x21 ; 33
+ 1a72: 1a 2e mov r1, r26
+ 1a74: aa 1b sub r26, r26
+ 1a76: bb 1b sub r27, r27
+ 1a78: fd 01 movw r30, r26
+ 1a7a: 0d c0 rjmp .+26 ; 0x1a96 <__udivmodsi4_ep>
+
+00001a7c <__udivmodsi4_loop>:
+ 1a7c: aa 1f adc r26, r26
+ 1a7e: bb 1f adc r27, r27
+ 1a80: ee 1f adc r30, r30
+ 1a82: ff 1f adc r31, r31
+ 1a84: a2 17 cp r26, r18
+ 1a86: b3 07 cpc r27, r19
+ 1a88: e4 07 cpc r30, r20
+ 1a8a: f5 07 cpc r31, r21
+ 1a8c: 20 f0 brcs .+8 ; 0x1a96 <__udivmodsi4_ep>
+ 1a8e: a2 1b sub r26, r18
+ 1a90: b3 0b sbc r27, r19
+ 1a92: e4 0b sbc r30, r20
+ 1a94: f5 0b sbc r31, r21
+
+00001a96 <__udivmodsi4_ep>:
+ 1a96: 66 1f adc r22, r22
+ 1a98: 77 1f adc r23, r23
+ 1a9a: 88 1f adc r24, r24
+ 1a9c: 99 1f adc r25, r25
+ 1a9e: 1a 94 dec r1
+ 1aa0: 69 f7 brne .-38 ; 0x1a7c <__udivmodsi4_loop>
+ 1aa2: 60 95 com r22
+ 1aa4: 70 95 com r23
+ 1aa6: 80 95 com r24
+ 1aa8: 90 95 com r25
+ 1aaa: 9b 01 movw r18, r22
+ 1aac: ac 01 movw r20, r24
+ 1aae: bd 01 movw r22, r26
+ 1ab0: cf 01 movw r24, r30
+ 1ab2: 08 95 ret
+
+00001ab4 <_exit>:
+ 1ab4: f8 94 cli
+
+00001ab6 <__stop_program>:
+ 1ab6: ff cf rjmp .-2 ; 0x1ab6 <__stop_program>
jspc29 / coral.git / commitdiff