E:\Temp\arduino_build_733275/sketch_sep11a.ino.elf: file format elf32-avr Sections: Idx Name Size VMA LMA File off Algn 0 .data 00000026 00800100 00000dfc 00000e90 2**0 CONTENTS, ALLOC, LOAD, DATA 1 .text 00000dfc 00000000 00000000 00000094 2**1 CONTENTS, ALLOC, LOAD, READONLY, CODE 2 .bss 0000006f 00800126 00800126 00000eb6 2**0 ALLOC 3 .comment 00000011 00000000 00000000 00000eb6 2**0 CONTENTS, READONLY 4 .note.gnu.avr.deviceinfo 00000040 00000000 00000000 00000ec8 2**2 CONTENTS, READONLY 5 .debug_aranges 00000030 00000000 00000000 00000f08 2**0 CONTENTS, READONLY, DEBUGGING 6 .debug_info 000032ce 00000000 00000000 00000f38 2**0 CONTENTS, READONLY, DEBUGGING 7 .debug_abbrev 0000106b 00000000 00000000 00004206 2**0 CONTENTS, READONLY, DEBUGGING 8 .debug_line 00000d34 00000000 00000000 00005271 2**0 CONTENTS, READONLY, DEBUGGING 9 .debug_frame 00000388 00000000 00000000 00005fa8 2**2 CONTENTS, READONLY, DEBUGGING 10 .debug_str 00000ed5 00000000 00000000 00006330 2**0 CONTENTS, READONLY, DEBUGGING 11 .debug_loc 00001892 00000000 00000000 00007205 2**0 CONTENTS, READONLY, DEBUGGING 12 .debug_ranges 00000288 00000000 00000000 00008a97 2**0 CONTENTS, READONLY, DEBUGGING Disassembly of section .text: 00000000 <__vectors>: 0: 0c 94 92 00 jmp 0x124 ; 0x124 <__ctors_end> 4: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 8: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> c: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 10: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 14: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 18: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 1c: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 20: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 24: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 28: 0c 94 4d 03 jmp 0x69a ; 0x69a <__vector_10> 2c: 0c 94 bf 03 jmp 0x77e ; 0x77e <__vector_11> 30: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 34: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 38: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 3c: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 40: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 44: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 48: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 4c: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 50: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 54: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 58: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 5c: 0c 94 ef 05 jmp 0xbde ; 0xbde <__vector_23> 60: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 64: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 68: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 6c: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 70: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 74: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 78: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 7c: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 80: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 84: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 88: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 8c: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 90: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 94: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 98: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 9c: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> a0: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> a4: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> a8: 0c 94 ba 00 jmp 0x174 ; 0x174 <__bad_interrupt> 000000ac <__trampolines_end>: ac: 08 0b sbc r16, r24 ae: 00 02 muls r16, r16 b0: 02 02 muls r16, r18 b2: 01 00 .word 0x0001 ; ???? b4: 09 04 cpc r0, r9 b6: 00 00 nop b8: 01 02 muls r16, r17 ba: 02 00 .word 0x0002 ; ???? bc: 00 05 cpc r16, r0 be: 24 00 .word 0x0024 ; ???? c0: 10 01 movw r2, r0 c2: 05 24 eor r0, r5 c4: 01 01 movw r0, r2 c6: 01 04 cpc r0, r1 c8: 24 02 muls r18, r20 ca: 06 05 cpc r16, r6 cc: 24 06 cpc r2, r20 ce: 00 01 movw r0, r0 d0: 07 05 cpc r16, r7 d2: 81 03 fmuls r16, r17 d4: 10 00 .word 0x0010 ; ???? d6: 40 09 sbc r20, r0 d8: 04 01 movw r0, r8 da: 00 02 muls r16, r16 dc: 0a 00 .word 0x000a ; ???? de: 00 00 nop e0: 07 05 cpc r16, r7 e2: 02 02 muls r16, r18 e4: 40 00 .word 0x0040 ; ???? e6: 00 07 cpc r16, r16 e8: 05 83 std Z+5, r16 ; 0x05 ea: 02 40 sbci r16, 0x02 ; 2 ... 000000ee : ee: 04 03 09 04 .... 000000f2 : f2: 12 01 00 02 ef 02 01 40 41 23 36 80 00 01 01 02 .......@A#6..... 102: 03 01 .. 00000104 : 104: 41 72 64 75 69 6e 6f 20 4c 4c 43 00 Arduino LLC. 00000110 : 110: 41 72 64 75 69 6e 6f 20 4c 65 6f 6e 61 72 64 6f Arduino Leonardo ... 00000122 <__ctors_start>: 122: 39 06 cpc r3, r25 00000124 <__ctors_end>: 124: 11 24 eor r1, r1 126: 1f be out 0x3f, r1 ; 63 128: cf ef ldi r28, 0xFF ; 255 12a: da e0 ldi r29, 0x0A ; 10 12c: de bf out 0x3e, r29 ; 62 12e: cd bf out 0x3d, r28 ; 61 00000130 <__do_copy_data>: 130: 11 e0 ldi r17, 0x01 ; 1 132: a0 e0 ldi r26, 0x00 ; 0 134: b1 e0 ldi r27, 0x01 ; 1 136: ec ef ldi r30, 0xFC ; 252 138: fd e0 ldi r31, 0x0D ; 13 13a: 02 c0 rjmp .+4 ; 0x140 <__do_copy_data+0x10> 13c: 05 90 lpm r0, Z+ 13e: 0d 92 st X+, r0 140: a6 32 cpi r26, 0x26 ; 38 142: b1 07 cpc r27, r17 144: d9 f7 brne .-10 ; 0x13c <__do_copy_data+0xc> 00000146 <__do_clear_bss>: 146: 21 e0 ldi r18, 0x01 ; 1 148: a6 e2 ldi r26, 0x26 ; 38 14a: b1 e0 ldi r27, 0x01 ; 1 14c: 01 c0 rjmp .+2 ; 0x150 <.do_clear_bss_start> 0000014e <.do_clear_bss_loop>: 14e: 1d 92 st X+, r1 00000150 <.do_clear_bss_start>: 150: a5 39 cpi r26, 0x95 ; 149 152: b2 07 cpc r27, r18 154: e1 f7 brne .-8 ; 0x14e <.do_clear_bss_loop> 00000156 <__do_global_ctors>: 156: 10 e0 ldi r17, 0x00 ; 0 158: c2 e9 ldi r28, 0x92 ; 146 15a: d0 e0 ldi r29, 0x00 ; 0 15c: 04 c0 rjmp .+8 ; 0x166 <__do_global_ctors+0x10> 15e: 21 97 sbiw r28, 0x01 ; 1 160: fe 01 movw r30, r28 162: 0e 94 f1 06 call 0xde2 ; 0xde2 <__tablejump2__> 166: c1 39 cpi r28, 0x91 ; 145 168: d1 07 cpc r29, r17 16a: c9 f7 brne .-14 ; 0x15e <__do_global_ctors+0x8> 16c: 0e 94 4e 06 call 0xc9c ; 0xc9c
170: 0c 94 fc 06 jmp 0xdf8 ; 0xdf8 <_exit> 00000174 <__bad_interrupt>: 174: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> 00000178 <_Z8USB_RecvhPvi.constprop.6>: return FifoByteCount(); } // Non Blocking receive // Return number of bytes read int USB_Recv(u8 ep, void* d, int len) 178: fc 01 movw r30, r24 { if (!_usbConfiguration || len < 0) 17a: 80 91 94 01 lds r24, 0x0194 ; 0x800194 <_usbConfiguration> 17e: 81 11 cpse r24, r1 180: 03 c0 rjmp .+6 ; 0x188 <_Z8USB_RecvhPvi.constprop.6+0x10> return -1; 182: 8f ef ldi r24, 0xFF ; 255 184: 9f ef ldi r25, 0xFF ; 255 186: 08 95 ret #define USB_RECV_TIMEOUT class LockEP { u8 _sreg; public: LockEP(u8 ep) : _sreg(SREG) 188: 9f b7 in r25, 0x3f ; 63 { cli(); 18a: f8 94 cli UEDATX = d; } static inline void SetEP(u8 ep) { UENUM = ep; 18c: 82 e0 ldi r24, 0x02 ; 2 18e: 80 93 e9 00 sts 0x00E9, r24 ; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9> } static inline u8 FifoByteCount() { return UEBCLX; 192: 20 91 f2 00 lds r18, 0x00F2 ; 0x8000f2 <__TEXT_REGION_LENGTH__+0x7e00f2> if (!_usbConfiguration || len < 0) return -1; LockEP lock(ep); u8 n = FifoByteCount(); len = min(n,len); 196: 30 e0 ldi r19, 0x00 ; 0 198: 12 16 cp r1, r18 19a: 13 06 cpc r1, r19 19c: 14 f4 brge .+4 ; 0x1a2 <_Z8USB_RecvhPvi.constprop.6+0x2a> 19e: 21 e0 ldi r18, 0x01 ; 1 1a0: 30 e0 ldi r19, 0x00 ; 0 n = len; u8* dst = (u8*)d; while (n--) 1a2: 21 15 cp r18, r1 1a4: 31 05 cpc r19, r1 1a6: 59 f0 breq .+22 ; 0x1be <_Z8USB_RecvhPvi.constprop.6+0x46> RxLEDPulse = TX_RX_LED_PULSE_MS; } static inline u8 Recv8() { RXLED1; // light the RX LED 1a8: 28 98 cbi 0x05, 0 ; 5 RxLEDPulse = TX_RX_LED_PULSE_MS; 1aa: 84 e6 ldi r24, 0x64 ; 100 1ac: 80 93 93 01 sts 0x0193, r24 ; 0x800193 return UEDATX; 1b0: 80 91 f1 00 lds r24, 0x00F1 ; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1> u8 n = FifoByteCount(); len = min(n,len); n = len; u8* dst = (u8*)d; while (n--) *dst++ = Recv8(); 1b4: 80 83 st Z, r24 UENUM = ep; } static inline u8 FifoByteCount() { return UEBCLX; 1b6: 80 91 f2 00 lds r24, 0x00F2 ; 0x8000f2 <__TEXT_REGION_LENGTH__+0x7e00f2> len = min(n,len); n = len; u8* dst = (u8*)d; while (n--) *dst++ = Recv8(); if (len && !FifoByteCount()) // release empty buffer 1ba: 88 23 and r24, r24 1bc: 19 f0 breq .+6 ; 0x1c4 <_Z8USB_RecvhPvi.constprop.6+0x4c> cli(); SetEP(ep & 7); } ~LockEP() { SREG = _sreg; 1be: 9f bf out 0x3f, r25 ; 63 if (!_usbConfiguration || len < 0) return -1; LockEP lock(ep); u8 n = FifoByteCount(); len = min(n,len); 1c0: c9 01 movw r24, r18 1c2: 08 95 ret return UEINTX & (1< 1ca: f9 cf rjmp .-14 ; 0x1be <_Z8USB_RecvhPvi.constprop.6+0x46> 000001cc <_Z13USB_SendSpaceh.constprop.4>: #define USB_RECV_TIMEOUT class LockEP { u8 _sreg; public: LockEP(u8 ep) : _sreg(SREG) 1cc: 2f b7 in r18, 0x3f ; 63 { cli(); 1ce: f8 94 cli UEDATX = d; } static inline void SetEP(u8 ep) { UENUM = ep; 1d0: 83 e0 ldi r24, 0x03 ; 3 1d2: 80 93 e9 00 sts 0x00E9, r24 ; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9> UECONX = (1< // Space in send EP u8 USB_SendSpace(u8 ep) { LockEP lock(ep); if (!ReadWriteAllowed()) 1da: 89 2f mov r24, r25 1dc: 80 72 andi r24, 0x20 ; 32 1de: 95 ff sbrs r25, 5 1e0: 04 c0 rjmp .+8 ; 0x1ea <_Z13USB_SendSpaceh.constprop.4+0x1e> UENUM = ep; } static inline u8 FifoByteCount() { return UEBCLX; 1e2: 90 91 f2 00 lds r25, 0x00F2 ; 0x8000f2 <__TEXT_REGION_LENGTH__+0x7e00f2> u8 USB_SendSpace(u8 ep) { LockEP lock(ep); if (!ReadWriteAllowed()) return 0; return USB_EP_SIZE - FifoByteCount(); 1e6: 80 e4 ldi r24, 0x40 ; 64 1e8: 89 1b sub r24, r25 cli(); SetEP(ep & 7); } ~LockEP() { SREG = _sreg; 1ea: 2f bf out 0x3f, r18 ; 63 { LockEP lock(ep); if (!ReadWriteAllowed()) return 0; return USB_EP_SIZE - FifoByteCount(); } 1ec: 08 95 ret 000001ee <_ZN5Print5writeEPKhj>: // Public Methods ////////////////////////////////////////////////////////////// /* default implementation: may be overridden */ size_t Print::write(const uint8_t *buffer, size_t size) { 1ee: cf 92 push r12 1f0: df 92 push r13 1f2: ef 92 push r14 1f4: ff 92 push r15 1f6: 0f 93 push r16 1f8: 1f 93 push r17 1fa: cf 93 push r28 1fc: df 93 push r29 1fe: 6c 01 movw r12, r24 200: 7a 01 movw r14, r20 202: 8b 01 movw r16, r22 size_t n = 0; 204: c0 e0 ldi r28, 0x00 ; 0 206: d0 e0 ldi r29, 0x00 ; 0 while (size--) { 208: ce 15 cp r28, r14 20a: df 05 cpc r29, r15 20c: 89 f0 breq .+34 ; 0x230 <_ZN5Print5writeEPKhj+0x42> if (write(*buffer++)) n++; 20e: d8 01 movw r26, r16 210: 6d 91 ld r22, X+ 212: 8d 01 movw r16, r26 214: d6 01 movw r26, r12 216: ed 91 ld r30, X+ 218: fc 91 ld r31, X 21a: 01 90 ld r0, Z+ 21c: f0 81 ld r31, Z 21e: e0 2d mov r30, r0 220: c6 01 movw r24, r12 222: 09 95 icall 224: 89 2b or r24, r25 226: 11 f4 brne .+4 ; 0x22c <_ZN5Print5writeEPKhj+0x3e> 228: 7e 01 movw r14, r28 22a: 02 c0 rjmp .+4 ; 0x230 <_ZN5Print5writeEPKhj+0x42> 22c: 21 96 adiw r28, 0x01 ; 1 22e: ec cf rjmp .-40 ; 0x208 <_ZN5Print5writeEPKhj+0x1a> else break; } return n; } 230: c7 01 movw r24, r14 232: df 91 pop r29 234: cf 91 pop r28 236: 1f 91 pop r17 238: 0f 91 pop r16 23a: ff 90 pop r15 23c: ef 90 pop r14 23e: df 90 pop r13 240: cf 90 pop r12 242: 08 95 ret 00000244 <_Z12PluggableUSBv>: // restart USB layer??? } PluggableUSB_& PluggableUSB() { static PluggableUSB_ obj; 244: 80 91 8b 01 lds r24, 0x018B ; 0x80018b <_ZGVZ12PluggableUSBvE3obj> 248: 81 11 cpse r24, r1 24a: 0d c0 rjmp .+26 ; 0x266 <_Z12PluggableUSBv+0x22> return obj; } PluggableUSB_::PluggableUSB_() : lastIf(CDC_ACM_INTERFACE + CDC_INTERFACE_COUNT), lastEp(CDC_FIRST_ENDPOINT + CDC_ENPOINT_COUNT), rootNode(NULL) 24c: 82 e0 ldi r24, 0x02 ; 2 24e: 80 93 87 01 sts 0x0187, r24 ; 0x800187 <_ZZ12PluggableUSBvE3obj> 252: 84 e0 ldi r24, 0x04 ; 4 254: 80 93 88 01 sts 0x0188, r24 ; 0x800188 <_ZZ12PluggableUSBvE3obj+0x1> 258: 10 92 8a 01 sts 0x018A, r1 ; 0x80018a <_ZZ12PluggableUSBvE3obj+0x3> 25c: 10 92 89 01 sts 0x0189, r1 ; 0x800189 <_ZZ12PluggableUSBvE3obj+0x2> // restart USB layer??? } PluggableUSB_& PluggableUSB() { static PluggableUSB_ obj; 260: 81 e0 ldi r24, 0x01 ; 1 262: 80 93 8b 01 sts 0x018B, r24 ; 0x80018b <_ZGVZ12PluggableUSBvE3obj> return obj; } 266: 87 e8 ldi r24, 0x87 ; 135 268: 91 e0 ldi r25, 0x01 ; 1 26a: 08 95 ret 0000026c <_ZN7Serial_5writeEh>: { USB_Flush(CDC_TX); } size_t Serial_::write(uint8_t c) { 26c: cf 93 push r28 26e: df 93 push r29 270: 1f 92 push r1 272: cd b7 in r28, 0x3d ; 61 274: de b7 in r29, 0x3e ; 62 276: 69 83 std Y+1, r22 ; 0x01 return write(&c, 1); 278: dc 01 movw r26, r24 27a: ed 91 ld r30, X+ 27c: fc 91 ld r31, X 27e: 02 80 ldd r0, Z+2 ; 0x02 280: f3 81 ldd r31, Z+3 ; 0x03 282: e0 2d mov r30, r0 284: 41 e0 ldi r20, 0x01 ; 1 286: 50 e0 ldi r21, 0x00 ; 0 288: be 01 movw r22, r28 28a: 6f 5f subi r22, 0xFF ; 255 28c: 7f 4f sbci r23, 0xFF ; 255 28e: 09 95 icall } 290: 0f 90 pop r0 292: df 91 pop r29 294: cf 91 pop r28 296: 08 95 ret 00000298 <_ZN7Serial_5flushEv>: UEDATX = d; } static inline void SetEP(u8 ep) { UENUM = ep; 298: 83 e0 ldi r24, 0x03 ; 3 29a: 80 93 e9 00 sts 0x00E9, r24 ; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9> } static inline u8 FifoByteCount() { return UEBCLX; 29e: 80 91 f2 00 lds r24, 0x00F2 ; 0x8000f2 <__TEXT_REGION_LENGTH__+0x7e00f2> } void USB_Flush(u8 ep) { SetEP(ep); if (FifoByteCount()) 2a2: 88 23 and r24, r24 2a4: 19 f0 breq .+6 ; 0x2ac <_ZN7Serial_5flushEv+0x14> UEINTX = 0x6B; // FIFOCON=0 NAKINI=1 RWAL=1 NAKOUTI=0 RXSTPI=1 RXOUTI=0 STALLEDI=1 TXINI=1 } static inline void ReleaseTX() { UEINTX = 0x3A; // FIFOCON=0 NAKINI=0 RWAL=1 NAKOUTI=1 RXSTPI=1 RXOUTI=0 STALLEDI=1 TXINI=0 2a6: 8a e3 ldi r24, 0x3A ; 58 2a8: 80 93 e8 00 sts 0x00E8, r24 ; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8> 2ac: 08 95 ret 000002ae <_ZN7Serial_17availableForWriteEv>: return USB_Recv(CDC_RX); } int Serial_::availableForWrite(void) { return USB_SendSpace(CDC_TX); 2ae: 0e 94 e6 00 call 0x1cc ; 0x1cc <_Z13USB_SendSpaceh.constprop.4> } 2b2: 90 e0 ldi r25, 0x00 ; 0 2b4: 08 95 ret 000002b6 <_ZN7Serial_4readEv>: peek_buffer = USB_Recv(CDC_RX); return peek_buffer; } int Serial_::read(void) { 2b6: cf 93 push r28 2b8: df 93 push r29 2ba: 1f 92 push r1 2bc: cd b7 in r28, 0x3d ; 61 2be: de b7 in r29, 0x3e ; 62 2c0: fc 01 movw r30, r24 if (peek_buffer >= 0) { 2c2: 84 85 ldd r24, Z+12 ; 0x0c 2c4: 95 85 ldd r25, Z+13 ; 0x0d 2c6: 97 fd sbrc r25, 7 2c8: 05 c0 rjmp .+10 ; 0x2d4 <_ZN7Serial_4readEv+0x1e> int c = peek_buffer; peek_buffer = -1; 2ca: 2f ef ldi r18, 0xFF ; 255 2cc: 3f ef ldi r19, 0xFF ; 255 2ce: 35 87 std Z+13, r19 ; 0x0d 2d0: 24 87 std Z+12, r18 ; 0x0c 2d2: 0b c0 rjmp .+22 ; 0x2ea <_ZN7Serial_4readEv+0x34> // Recv 1 byte if ready int USB_Recv(u8 ep) { u8 c; if (USB_Recv(ep,&c,1) != 1) 2d4: ce 01 movw r24, r28 2d6: 01 96 adiw r24, 0x01 ; 1 2d8: 0e 94 bc 00 call 0x178 ; 0x178 <_Z8USB_RecvhPvi.constprop.6> 2dc: 01 97 sbiw r24, 0x01 ; 1 2de: 19 f4 brne .+6 ; 0x2e6 <_ZN7Serial_4readEv+0x30> return -1; return c; 2e0: 89 81 ldd r24, Y+1 ; 0x01 2e2: 90 e0 ldi r25, 0x00 ; 0 2e4: 02 c0 rjmp .+4 ; 0x2ea <_ZN7Serial_4readEv+0x34> // Recv 1 byte if ready int USB_Recv(u8 ep) { u8 c; if (USB_Recv(ep,&c,1) != 1) return -1; 2e6: 8f ef ldi r24, 0xFF ; 255 2e8: 9f ef ldi r25, 0xFF ; 255 return c; } return USB_Recv(CDC_RX); } 2ea: 0f 90 pop r0 2ec: df 91 pop r29 2ee: cf 91 pop r28 2f0: 08 95 ret 000002f2 <_ZN7Serial_4peekEv>: } return USB_Available(CDC_RX); } int Serial_::peek(void) { 2f2: 0f 93 push r16 2f4: 1f 93 push r17 2f6: cf 93 push r28 2f8: df 93 push r29 2fa: 1f 92 push r1 2fc: cd b7 in r28, 0x3d ; 61 2fe: de b7 in r29, 0x3e ; 62 300: 8c 01 movw r16, r24 if (peek_buffer < 0) 302: fc 01 movw r30, r24 304: 84 85 ldd r24, Z+12 ; 0x0c 306: 95 85 ldd r25, Z+13 ; 0x0d 308: 97 ff sbrs r25, 7 30a: 0e c0 rjmp .+28 ; 0x328 <_ZN7Serial_4peekEv+0x36> // Recv 1 byte if ready int USB_Recv(u8 ep) { u8 c; if (USB_Recv(ep,&c,1) != 1) 30c: ce 01 movw r24, r28 30e: 01 96 adiw r24, 0x01 ; 1 310: 0e 94 bc 00 call 0x178 ; 0x178 <_Z8USB_RecvhPvi.constprop.6> 314: 01 97 sbiw r24, 0x01 ; 1 316: 19 f4 brne .+6 ; 0x31e <_ZN7Serial_4peekEv+0x2c> return -1; return c; 318: 29 81 ldd r18, Y+1 ; 0x01 31a: 30 e0 ldi r19, 0x00 ; 0 31c: 02 c0 rjmp .+4 ; 0x322 <_ZN7Serial_4peekEv+0x30> // Recv 1 byte if ready int USB_Recv(u8 ep) { u8 c; if (USB_Recv(ep,&c,1) != 1) return -1; 31e: 2f ef ldi r18, 0xFF ; 255 320: 3f ef ldi r19, 0xFF ; 255 peek_buffer = USB_Recv(CDC_RX); 322: f8 01 movw r30, r16 324: 35 87 std Z+13, r19 ; 0x0d 326: 24 87 std Z+12, r18 ; 0x0c return peek_buffer; } 328: f8 01 movw r30, r16 32a: 84 85 ldd r24, Z+12 ; 0x0c 32c: 95 85 ldd r25, Z+13 ; 0x0d 32e: 0f 90 pop r0 330: df 91 pop r29 332: cf 91 pop r28 334: 1f 91 pop r17 336: 0f 91 pop r16 338: 08 95 ret 0000033a <_ZN7Serial_9availableEv>: { } int Serial_::available(void) { if (peek_buffer >= 0) { 33a: fc 01 movw r30, r24 33c: 84 85 ldd r24, Z+12 ; 0x0c 33e: 95 85 ldd r25, Z+13 ; 0x0d 340: 97 fd sbrc r25, 7 342: 0b c0 rjmp .+22 ; 0x35a <_ZN7Serial_9availableEv+0x20> #define USB_RECV_TIMEOUT class LockEP { u8 _sreg; public: LockEP(u8 ep) : _sreg(SREG) 344: 9f b7 in r25, 0x3f ; 63 { cli(); 346: f8 94 cli UEDATX = d; } static inline void SetEP(u8 ep) { UENUM = ep; 348: 82 e0 ldi r24, 0x02 ; 2 34a: 80 93 e9 00 sts 0x00E9, r24 ; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9> } static inline u8 FifoByteCount() { return UEBCLX; 34e: 80 91 f2 00 lds r24, 0x00F2 ; 0x8000f2 <__TEXT_REGION_LENGTH__+0x7e00f2> cli(); SetEP(ep & 7); } ~LockEP() { SREG = _sreg; 352: 9f bf out 0x3f, r25 ; 63 return 1 + USB_Available(CDC_RX); 354: 90 e0 ldi r25, 0x00 ; 0 356: 01 96 adiw r24, 0x01 ; 1 358: 08 95 ret #define USB_RECV_TIMEOUT class LockEP { u8 _sreg; public: LockEP(u8 ep) : _sreg(SREG) 35a: 9f b7 in r25, 0x3f ; 63 { cli(); 35c: f8 94 cli UEDATX = d; } static inline void SetEP(u8 ep) { UENUM = ep; 35e: 82 e0 ldi r24, 0x02 ; 2 360: 80 93 e9 00 sts 0x00E9, r24 ; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9> } static inline u8 FifoByteCount() { return UEBCLX; 364: 80 91 f2 00 lds r24, 0x00F2 ; 0x8000f2 <__TEXT_REGION_LENGTH__+0x7e00f2> cli(); SetEP(ep & 7); } ~LockEP() { SREG = _sreg; 368: 9f bf out 0x3f, r25 ; 63 } return USB_Available(CDC_RX); 36a: 90 e0 ldi r25, 0x00 ; 0 } 36c: 08 95 ret 0000036e <_ZN5Print5flushEv>: size_t println(unsigned long, int = DEC); size_t println(double, int = 2); size_t println(const Printable&); size_t println(void); virtual void flush() { /* Empty implementation for backward compatibility */ } 36e: 08 95 ret 00000370 <_ZN5Print17availableForWriteEv>: return write((const uint8_t *)buffer, size); } // default to zero, meaning "a single write may block" // should be overriden by subclasses with buffering virtual int availableForWrite() { return 0; } 370: 80 e0 ldi r24, 0x00 ; 0 372: 90 e0 ldi r25, 0x00 ; 0 374: 08 95 ret 00000376 <_ZL11SendControlh>: } static bool SendControl(u8 d) { if (_cmark < _cend) 376: 40 91 31 01 lds r20, 0x0131 ; 0x800131 <_ZL6_cmark> 37a: 50 91 32 01 lds r21, 0x0132 ; 0x800132 <_ZL6_cmark+0x1> 37e: 20 91 2f 01 lds r18, 0x012F ; 0x80012f <_ZL5_cend> 382: 30 91 30 01 lds r19, 0x0130 ; 0x800130 <_ZL5_cend+0x1> 386: 42 17 cp r20, r18 388: 53 07 cpc r21, r19 38a: b4 f4 brge .+44 ; 0x3b8 <_ZL11SendControlh+0x42> ; } static inline u8 WaitForINOrOUT() { while (!(UEINTX & ((1< 390: 95 70 andi r25, 0x05 ; 5 392: e1 f3 breq .-8 ; 0x38c <_ZL11SendControlh+0x16> ; return (UEINTX & (1< static bool SendControl(u8 d) { if (_cmark < _cend) { if (!WaitForINOrOUT()) 398: 92 fd sbrc r25, 2 39a: 19 c0 rjmp .+50 ; 0x3ce <_ZL11SendControlh+0x58> return UEDATX; } static inline void Send8(u8 d) { UEDATX = d; 39c: 80 93 f1 00 sts 0x00F1, r24 ; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1> if (_cmark < _cend) { if (!WaitForINOrOUT()) return false; Send8(d); if (!((_cmark + 1) & 0x3F)) 3a0: 80 91 31 01 lds r24, 0x0131 ; 0x800131 <_ZL6_cmark> 3a4: 90 91 32 01 lds r25, 0x0132 ; 0x800132 <_ZL6_cmark+0x1> 3a8: 01 96 adiw r24, 0x01 ; 1 3aa: 8f 73 andi r24, 0x3F ; 63 3ac: 99 27 eor r25, r25 3ae: 89 2b or r24, r25 3b0: 19 f4 brne .+6 ; 0x3b8 <_ZL11SendControlh+0x42> ; } static inline void ClearIN(void) { UEINTX = ~(1< return false; Send8(d); if (!((_cmark + 1) & 0x3F)) ClearIN(); // Fifo is full, release this packet } _cmark++; 3b8: 80 91 31 01 lds r24, 0x0131 ; 0x800131 <_ZL6_cmark> 3bc: 90 91 32 01 lds r25, 0x0132 ; 0x800132 <_ZL6_cmark+0x1> 3c0: 01 96 adiw r24, 0x01 ; 1 3c2: 90 93 32 01 sts 0x0132, r25 ; 0x800132 <_ZL6_cmark+0x1> 3c6: 80 93 31 01 sts 0x0131, r24 ; 0x800131 <_ZL6_cmark> return true; 3ca: 81 e0 ldi r24, 0x01 ; 1 3cc: 08 95 ret bool SendControl(u8 d) { if (_cmark < _cend) { if (!WaitForINOrOUT()) return false; 3ce: 80 e0 ldi r24, 0x00 ; 0 if (!((_cmark + 1) & 0x3F)) ClearIN(); // Fifo is full, release this packet } _cmark++; return true; } 3d0: 08 95 ret 000003d2 <_ZL24USB_SendStringDescriptorPKhhh>: } // Send a USB descriptor string. The string is stored in PROGMEM as a // plain ASCII string but is sent out as UTF-16 with the correct 2-byte // prefix static bool USB_SendStringDescriptor(const u8*string_P, u8 string_len, uint8_t flags) { 3d2: cf 92 push r12 3d4: df 92 push r13 3d6: ef 92 push r14 3d8: ff 92 push r15 3da: 0f 93 push r16 3dc: 1f 93 push r17 3de: cf 93 push r28 3e0: df 93 push r29 3e2: 1f 92 push r1 3e4: cd b7 in r28, 0x3d ; 61 3e6: de b7 in r29, 0x3e ; 62 3e8: 18 2f mov r17, r24 3ea: 06 2f mov r16, r22 3ec: e4 2e mov r14, r20 SendControl(2 + string_len * 2); 3ee: 86 2f mov r24, r22 3f0: 88 0f add r24, r24 3f2: 8e 5f subi r24, 0xFE ; 254 3f4: 99 83 std Y+1, r25 ; 0x01 3f6: 0e 94 bb 01 call 0x376 ; 0x376 <_ZL11SendControlh> SendControl(3); 3fa: 83 e0 ldi r24, 0x03 ; 3 3fc: 0e 94 bb 01 call 0x376 ; 0x376 <_ZL11SendControlh> 400: f1 2e mov r15, r17 bool pgm = flags & TRANSFER_PGM; 402: c1 2e mov r12, r17 404: 99 81 ldd r25, Y+1 ; 0x01 406: d9 2e mov r13, r25 408: 8c 2d mov r24, r12 40a: 8f 19 sub r24, r15 for(u8 i = 0; i < string_len; i++) { 40c: 80 17 cp r24, r16 40e: 98 f4 brcc .+38 ; 0x436 <__LOCK_REGION_LENGTH__+0x36> bool r = SendControl(pgm ? pgm_read_byte(&string_P[i]) : string_P[i]); 410: f6 01 movw r30, r12 412: e7 fe sbrs r14, 7 414: 02 c0 rjmp .+4 ; 0x41a <__LOCK_REGION_LENGTH__+0x1a> 416: 84 91 lpm r24, Z 418: 01 c0 rjmp .+2 ; 0x41c <__LOCK_REGION_LENGTH__+0x1c> 41a: 80 81 ld r24, Z 41c: 0e 94 bb 01 call 0x376 ; 0x376 <_ZL11SendControlh> 420: 18 2f mov r17, r24 r &= SendControl(0); // high byte 422: 80 e0 ldi r24, 0x00 ; 0 424: 0e 94 bb 01 call 0x376 ; 0x376 <_ZL11SendControlh> 428: 81 23 and r24, r17 42a: ff ef ldi r31, 0xFF ; 255 42c: cf 1a sub r12, r31 42e: df 0a sbc r13, r31 if(!r) { 430: 81 11 cpse r24, r1 432: ea cf rjmp .-44 ; 0x408 <__LOCK_REGION_LENGTH__+0x8> 434: 01 c0 rjmp .+2 ; 0x438 <__LOCK_REGION_LENGTH__+0x38> return false; } } return true; 436: 81 e0 ldi r24, 0x01 ; 1 } 438: 0f 90 pop r0 43a: df 91 pop r29 43c: cf 91 pop r28 43e: 1f 91 pop r17 440: 0f 91 pop r16 442: ff 90 pop r15 444: ef 90 pop r14 446: df 90 pop r13 448: cf 90 pop r12 44a: 08 95 ret 0000044c <_Z15USB_SendControlhPKvi>: return true; } // Clipped by _cmark/_cend int USB_SendControl(u8 flags, const void* d, int len) { 44c: df 92 push r13 44e: ef 92 push r14 450: ff 92 push r15 452: 0f 93 push r16 454: 1f 93 push r17 456: cf 93 push r28 458: df 93 push r29 45a: d8 2e mov r13, r24 45c: 8a 01 movw r16, r20 45e: 7b 01 movw r14, r22 460: e4 0e add r14, r20 462: f5 1e adc r15, r21 int sent = len; const u8* data = (const u8*)d; bool pgm = flags & TRANSFER_PGM; 464: eb 01 movw r28, r22 while (len--) 466: ce 15 cp r28, r14 468: df 05 cpc r29, r15 46a: 71 f0 breq .+28 ; 0x488 <_Z15USB_SendControlhPKvi+0x3c> { u8 c = pgm ? pgm_read_byte(data++) : *data++; 46c: d7 fe sbrs r13, 7 46e: 03 c0 rjmp .+6 ; 0x476 <_Z15USB_SendControlhPKvi+0x2a> 470: fe 01 movw r30, r28 472: 84 91 lpm r24, Z 474: 01 c0 rjmp .+2 ; 0x478 <_Z15USB_SendControlhPKvi+0x2c> 476: 88 81 ld r24, Y if (!SendControl(c)) 478: 0e 94 bb 01 call 0x376 ; 0x376 <_ZL11SendControlh> 47c: 21 96 adiw r28, 0x01 ; 1 47e: 81 11 cpse r24, r1 480: f2 cf rjmp .-28 ; 0x466 <_Z15USB_SendControlhPKvi+0x1a> return -1; 482: 8f ef ldi r24, 0xFF ; 255 484: 9f ef ldi r25, 0xFF ; 255 486: 01 c0 rjmp .+2 ; 0x48a <_Z15USB_SendControlhPKvi+0x3e> } return sent; 488: c8 01 movw r24, r16 } 48a: df 91 pop r29 48c: cf 91 pop r28 48e: 1f 91 pop r17 490: 0f 91 pop r16 492: ff 90 pop r15 494: ef 90 pop r14 496: df 90 pop r13 498: 08 95 ret 0000049a <_ZL14SendInterfacesv>: } return len; } static u8 SendInterfaces() { 49a: 0f 93 push r16 49c: 1f 93 push r17 49e: cf 93 push r28 4a0: df 93 push r29 4a2: 1f 92 push r1 4a4: cd b7 in r28, 0x3d ; 61 4a6: de b7 in r29, 0x3e ; 62 D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_IN ),USB_ENDPOINT_TYPE_BULK,USB_EP_SIZE,0) }; int CDC_GetInterface(u8* interfaceNum) { interfaceNum[0] += 2; // uses 2 4a8: 82 e0 ldi r24, 0x02 ; 2 4aa: 89 83 std Y+1, r24 ; 0x01 return USB_SendControl(TRANSFER_PGM,&_cdcInterface,sizeof(_cdcInterface)); 4ac: 42 e4 ldi r20, 0x42 ; 66 4ae: 50 e0 ldi r21, 0x00 ; 0 4b0: 6c ea ldi r22, 0xAC ; 172 4b2: 70 e0 ldi r23, 0x00 ; 0 4b4: 80 e8 ldi r24, 0x80 ; 128 4b6: 0e 94 26 02 call 0x44c ; 0x44c <_Z15USB_SendControlhPKvi> u8 interfaces = 0; CDC_GetInterface(&interfaces); #ifdef PLUGGABLE_USB_ENABLED PluggableUSB().getInterface(&interfaces); 4ba: 0e 94 22 01 call 0x244 ; 0x244 <_Z12PluggableUSBv> int PluggableUSB_::getInterface(uint8_t* interfaceCount) { int sent = 0; PluggableUSBModule* node; for (node = rootNode; node; node = node->next) { 4be: dc 01 movw r26, r24 4c0: 12 96 adiw r26, 0x02 ; 2 4c2: 0d 91 ld r16, X+ 4c4: 1c 91 ld r17, X 4c6: 13 97 sbiw r26, 0x03 ; 3 4c8: 01 15 cp r16, r1 4ca: 11 05 cpc r17, r1 4cc: 69 f0 breq .+26 ; 0x4e8 <_ZL14SendInterfacesv+0x4e> int res = node->getInterface(interfaceCount); 4ce: d8 01 movw r26, r16 4d0: ed 91 ld r30, X+ 4d2: fc 91 ld r31, X 4d4: 02 80 ldd r0, Z+2 ; 0x02 4d6: f3 81 ldd r31, Z+3 ; 0x03 4d8: e0 2d mov r30, r0 4da: be 01 movw r22, r28 4dc: 6f 5f subi r22, 0xFF ; 255 4de: 7f 4f sbci r23, 0xFF ; 255 4e0: c8 01 movw r24, r16 4e2: 09 95 icall if (res < 0) 4e4: 97 ff sbrs r25, 7 4e6: 07 c0 rjmp .+14 ; 0x4f6 <_ZL14SendInterfacesv+0x5c> #endif return interfaces; 4e8: 89 81 ldd r24, Y+1 ; 0x01 } 4ea: 0f 90 pop r0 4ec: df 91 pop r29 4ee: cf 91 pop r28 4f0: 1f 91 pop r17 4f2: 0f 91 pop r16 4f4: 08 95 ret int PluggableUSB_::getInterface(uint8_t* interfaceCount) { int sent = 0; PluggableUSBModule* node; for (node = rootNode; node; node = node->next) { 4f6: f8 01 movw r30, r16 4f8: 00 85 ldd r16, Z+8 ; 0x08 4fa: 11 85 ldd r17, Z+9 ; 0x09 4fc: e5 cf rjmp .-54 ; 0x4c8 <_ZL14SendInterfacesv+0x2e> 000004fe <_ZL4RecvPVhh>: UEINTX = ~(1< *data++ = UEDATX; 502: 20 91 f1 00 lds r18, 0x00F1 ; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1> 506: fc 01 movw r30, r24 508: 20 83 st Z, r18 50a: 01 96 adiw r24, 0x01 ; 1 50c: f8 cf rjmp .-16 ; 0x4fe <_ZL4RecvPVhh> RXLED1; // light the RX LED 50e: 28 98 cbi 0x05, 0 ; 5 RxLEDPulse = TX_RX_LED_PULSE_MS; 510: 84 e6 ldi r24, 0x64 ; 100 512: 80 93 93 01 sts 0x0193, r24 ; 0x800193 516: 08 95 ret 00000518 : return m; } unsigned long micros() { unsigned long m; uint8_t oldSREG = SREG, t; 518: 3f b7 in r19, 0x3f ; 63 cli(); 51a: f8 94 cli m = timer0_overflow_count; 51c: 80 91 2b 01 lds r24, 0x012B ; 0x80012b 520: 90 91 2c 01 lds r25, 0x012C ; 0x80012c 524: a0 91 2d 01 lds r26, 0x012D ; 0x80012d 528: b0 91 2e 01 lds r27, 0x012E ; 0x80012e #if defined(TCNT0) t = TCNT0; 52c: 26 b5 in r18, 0x26 ; 38 #else #error TIMER 0 not defined #endif #ifdef TIFR0 if ((TIFR0 & _BV(TOV0)) && (t < 255)) 52e: a8 9b sbis 0x15, 0 ; 21 530: 05 c0 rjmp .+10 ; 0x53c 532: 2f 3f cpi r18, 0xFF ; 255 534: 19 f0 breq .+6 ; 0x53c m++; 536: 01 96 adiw r24, 0x01 ; 1 538: a1 1d adc r26, r1 53a: b1 1d adc r27, r1 #else if ((TIFR & _BV(TOV0)) && (t < 255)) m++; #endif SREG = oldSREG; 53c: 3f bf out 0x3f, r19 ; 63 return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond()); 53e: ba 2f mov r27, r26 540: a9 2f mov r26, r25 542: 98 2f mov r25, r24 544: 88 27 eor r24, r24 546: 82 0f add r24, r18 548: 91 1d adc r25, r1 54a: a1 1d adc r26, r1 54c: b1 1d adc r27, r1 54e: bc 01 movw r22, r24 550: cd 01 movw r24, r26 552: 42 e0 ldi r20, 0x02 ; 2 554: 66 0f add r22, r22 556: 77 1f adc r23, r23 558: 88 1f adc r24, r24 55a: 99 1f adc r25, r25 55c: 4a 95 dec r20 55e: d1 f7 brne .-12 ; 0x554 } 560: 08 95 ret 00000562 : void delay(unsigned long ms) 562: cf 92 push r12 564: df 92 push r13 566: ef 92 push r14 568: ff 92 push r15 { uint32_t start = micros(); 56a: 0e 94 8c 02 call 0x518 ; 0x518 56e: 6b 01 movw r12, r22 570: 7c 01 movw r14, r24 while (ms > 0) { yield(); while ( ms > 0 && (micros() - start) >= 1000) { 572: 0e 94 8c 02 call 0x518 ; 0x518 576: dc 01 movw r26, r24 578: cb 01 movw r24, r22 57a: 8c 19 sub r24, r12 57c: 9d 09 sbc r25, r13 57e: ae 09 sbc r26, r14 580: bf 09 sbc r27, r15 582: 88 3e cpi r24, 0xE8 ; 232 584: 93 40 sbci r25, 0x03 ; 3 586: a1 05 cpc r26, r1 588: b1 05 cpc r27, r1 58a: 98 f3 brcs .-26 ; 0x572 ms--; start += 1000; } } } 58c: ff 90 pop r15 58e: ef 90 pop r14 590: df 90 pop r13 592: cf 90 pop r12 594: 08 95 ret 00000596 <_ZN7Serial_5writeEPKhj>: { return write(&c, 1); } size_t Serial_::write(const uint8_t *buffer, size_t size) { 596: 8f 92 push r8 598: 9f 92 push r9 59a: af 92 push r10 59c: bf 92 push r11 59e: cf 92 push r12 5a0: df 92 push r13 5a2: ef 92 push r14 5a4: ff 92 push r15 5a6: 0f 93 push r16 5a8: 1f 93 push r17 5aa: cf 93 push r28 5ac: df 93 push r29 5ae: 6c 01 movw r12, r24 5b0: 5b 01 movw r10, r22 5b2: 7a 01 movw r14, r20 the connection is closed are lost - just like with a UART. */ // TODO - ZE - check behavior on different OSes and test what happens if an // open connection isn't broken cleanly (cable is yanked out, host dies // or locks up, or host virtual serial port hangs) if (_usbLineInfo.lineState > 0) { 5b4: 80 91 0b 01 lds r24, 0x010B ; 0x80010b <_ZL12_usbLineInfo+0x7> 5b8: 88 23 and r24, r24 5ba: 09 f4 brne .+2 ; 0x5be <_ZN7Serial_5writeEPKhj+0x28> 5bc: 56 c0 rjmp .+172 ; 0x66a <_ZN7Serial_5writeEPKhj+0xd4> } // Blocking Send of data to an endpoint int USB_Send(u8 ep, const void* d, int len) { if (!_usbConfiguration) 5be: 80 91 94 01 lds r24, 0x0194 ; 0x800194 <_usbConfiguration> 5c2: 88 23 and r24, r24 5c4: 09 f4 brne .+2 ; 0x5c8 <_ZN7Serial_5writeEPKhj+0x32> 5c6: 51 c0 rjmp .+162 ; 0x66a <_ZN7Serial_5writeEPKhj+0xd4> return -1; if (_usbSuspendState & (1< 5cc: 80 ff sbrs r24, 0 5ce: 05 c0 rjmp .+10 ; 0x5da <_ZN7Serial_5writeEPKhj+0x44> //send a remote wakeup UDCON |= (1 << RMWKUP); 5d0: 80 91 e0 00 lds r24, 0x00E0 ; 0x8000e0 <__TEXT_REGION_LENGTH__+0x7e00e0> 5d4: 82 60 ori r24, 0x02 ; 2 5d6: 80 93 e0 00 sts 0x00E0, r24 ; 0x8000e0 <__TEXT_REGION_LENGTH__+0x7e00e0> Send8(*data++); } if (sendZlp) { ReleaseTX(); sendZlp = false; 5da: e7 01 movw r28, r14 5dc: 10 e0 ldi r17, 0x00 ; 0 5de: 0a ef ldi r16, 0xFA ; 250 UEDATX = d; } static inline void SetEP(u8 ep) { UENUM = ep; 5e0: 83 e0 ldi r24, 0x03 ; 3 5e2: 88 2e mov r8, r24 UEINTX = 0x6B; // FIFOCON=0 NAKINI=1 RWAL=1 NAKOUTI=0 RXSTPI=1 RXOUTI=0 STALLEDI=1 TXINI=1 } static inline void ReleaseTX() { UEINTX = 0x3A; // FIFOCON=0 NAKINI=0 RWAL=1 NAKOUTI=1 RXSTPI=1 RXOUTI=0 STALLEDI=1 TXINI=0 5e4: 9a e3 ldi r25, 0x3A ; 58 5e6: 99 2e mov r9, r25 int r = len; const u8* data = (const u8*)d; u8 timeout = 250; // 250ms timeout on send? TODO bool sendZlp = false; while (len || sendZlp) 5e8: 20 97 sbiw r28, 0x00 ; 0 5ea: b1 f1 breq .+108 ; 0x658 <_ZN7Serial_5writeEPKhj+0xc2> { u8 n = USB_SendSpace(ep); 5ec: 0e 94 e6 00 call 0x1cc ; 0x1cc <_Z13USB_SendSpaceh.constprop.4> if (n == 0) 5f0: 81 11 cpse r24, r1 5f2: 05 c0 rjmp .+10 ; 0x5fe <_ZN7Serial_5writeEPKhj+0x68> { if (!(--timeout)) 5f4: 01 50 subi r16, 0x01 ; 1 5f6: c9 f1 breq .+114 ; 0x66a <_ZN7Serial_5writeEPKhj+0xd4> return -1; delay(1); 5f8: 0e 94 b1 02 call 0x562 ; 0x562 5fc: f5 cf rjmp .-22 ; 0x5e8 <_ZN7Serial_5writeEPKhj+0x52> continue; } if (n > len) { 5fe: 28 2f mov r18, r24 600: 30 e0 ldi r19, 0x00 ; 0 602: c2 17 cp r28, r18 604: d3 07 cpc r29, r19 606: 0c f4 brge .+2 ; 0x60a <_ZN7Serial_5writeEPKhj+0x74> n = len; 608: 8c 2f mov r24, r28 #define USB_RECV_TIMEOUT class LockEP { u8 _sreg; public: LockEP(u8 ep) : _sreg(SREG) 60a: 4f b7 in r20, 0x3f ; 63 { cli(); 60c: f8 94 cli UEDATX = d; } static inline void SetEP(u8 ep) { UENUM = ep; 60e: 80 92 e9 00 sts 0x00E9, r8 ; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9> UECONX = (1< } { LockEP lock(ep); // Frame may have been released by the SOF interrupt handler if (!ReadWriteAllowed()) 616: 95 ff sbrs r25, 5 618: 1d c0 rjmp .+58 ; 0x654 <_ZN7Serial_5writeEPKhj+0xbe> continue; len -= n; 61a: 28 2f mov r18, r24 61c: 30 e0 ldi r19, 0x00 ; 0 61e: c2 1b sub r28, r18 620: d3 0b sbc r29, r19 622: f5 01 movw r30, r10 624: 98 2f mov r25, r24 while (n--) Send8(pgm_read_byte(data++)); } else { while (n--) 626: 91 50 subi r25, 0x01 ; 1 628: 20 f0 brcs .+8 ; 0x632 <_ZN7Serial_5writeEPKhj+0x9c> Send8(*data++); 62a: 81 91 ld r24, Z+ return UEDATX; } static inline void Send8(u8 d) { UEDATX = d; 62c: 80 93 f1 00 sts 0x00F1, r24 ; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1> 630: fa cf rjmp .-12 ; 0x626 <_ZN7Serial_5writeEPKhj+0x90> 632: a2 0e add r10, r18 634: b3 1e adc r11, r19 { while (n--) Send8(*data++); } if (sendZlp) { 636: 11 23 and r17, r17 638: 19 f0 breq .+6 ; 0x640 <_ZN7Serial_5writeEPKhj+0xaa> UEINTX = 0x6B; // FIFOCON=0 NAKINI=1 RWAL=1 NAKOUTI=0 RXSTPI=1 RXOUTI=0 STALLEDI=1 TXINI=1 } static inline void ReleaseTX() { UEINTX = 0x3A; // FIFOCON=0 NAKINI=0 RWAL=1 NAKOUTI=1 RXSTPI=1 RXOUTI=0 STALLEDI=1 TXINI=0 63a: 90 92 e8 00 sts 0x00E8, r9 ; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8> 63e: 09 c0 rjmp .+18 ; 0x652 <_ZN7Serial_5writeEPKhj+0xbc> UECONX = (1< } if (sendZlp) { ReleaseTX(); sendZlp = false; } else if (!ReadWriteAllowed()) { // ...release if buffer is full... 644: 85 fd sbrc r24, 5 646: 06 c0 rjmp .+12 ; 0x654 <_ZN7Serial_5writeEPKhj+0xbe> UEINTX = 0x6B; // FIFOCON=0 NAKINI=1 RWAL=1 NAKOUTI=0 RXSTPI=1 RXOUTI=0 STALLEDI=1 TXINI=1 } static inline void ReleaseTX() { UEINTX = 0x3A; // FIFOCON=0 NAKINI=0 RWAL=1 NAKOUTI=1 RXSTPI=1 RXOUTI=0 STALLEDI=1 TXINI=0 648: 90 92 e8 00 sts 0x00E8, r9 ; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8> if (sendZlp) { ReleaseTX(); sendZlp = false; } else if (!ReadWriteAllowed()) { // ...release if buffer is full... ReleaseTX(); if (len == 0) sendZlp = true; 64c: 11 e0 ldi r17, 0x01 ; 1 64e: 20 97 sbiw r28, 0x00 ; 0 650: 09 f0 breq .+2 ; 0x654 <_ZN7Serial_5writeEPKhj+0xbe> 652: 10 e0 ldi r17, 0x00 ; 0 cli(); SetEP(ep & 7); } ~LockEP() { SREG = _sreg; 654: 4f bf out 0x3f, r20 ; 63 656: c8 cf rjmp .-112 ; 0x5e8 <_ZN7Serial_5writeEPKhj+0x52> int r = len; const u8* data = (const u8*)d; u8 timeout = 250; // 250ms timeout on send? TODO bool sendZlp = false; while (len || sendZlp) 658: 11 11 cpse r17, r1 65a: c8 cf rjmp .-112 ; 0x5ec <_ZN7Serial_5writeEPKhj+0x56> // XXX: TRANSFER_RELEASE is never used can be removed? ReleaseTX(); } } } TXLED1; // light the TX LED 65c: 5d 98 cbi 0x0b, 5 ; 11 TxLEDPulse = TX_RX_LED_PULSE_MS; 65e: 84 e6 ldi r24, 0x64 ; 100 660: 80 93 35 01 sts 0x0135, r24 ; 0x800135 int r = USB_Send(CDC_TX,buffer,size); if (r > 0) { 664: 1e 14 cp r1, r14 666: 1f 04 cpc r1, r15 668: 44 f0 brlt .+16 ; 0x67a <_ZN7Serial_5writeEPKhj+0xe4> private: int write_error; size_t printNumber(unsigned long, uint8_t); size_t printFloat(double, uint8_t); protected: void setWriteError(int err = 1) { write_error = err; } 66a: 81 e0 ldi r24, 0x01 ; 1 66c: 90 e0 ldi r25, 0x00 ; 0 66e: f6 01 movw r30, r12 670: 93 83 std Z+3, r25 ; 0x03 672: 82 83 std Z+2, r24 ; 0x02 return r; } else { setWriteError(); return 0; 674: 80 e0 ldi r24, 0x00 ; 0 676: 90 e0 ldi r25, 0x00 ; 0 678: 01 c0 rjmp .+2 ; 0x67c <_ZN7Serial_5writeEPKhj+0xe6> // TODO - ZE - check behavior on different OSes and test what happens if an // open connection isn't broken cleanly (cable is yanked out, host dies // or locks up, or host virtual serial port hangs) if (_usbLineInfo.lineState > 0) { int r = USB_Send(CDC_TX,buffer,size); if (r > 0) { 67a: c7 01 movw r24, r14 return 0; } } setWriteError(); return 0; } 67c: df 91 pop r29 67e: cf 91 pop r28 680: 1f 91 pop r17 682: 0f 91 pop r16 684: ff 90 pop r15 686: ef 90 pop r14 688: df 90 pop r13 68a: cf 90 pop r12 68c: bf 90 pop r11 68e: af 90 pop r10 690: 9f 90 pop r9 692: 8f 90 pop r8 694: 08 95 ret 00000696 <__cxa_pure_virtual>: extern "C" void __cxa_deleted_virtual(void) __attribute__ ((__noreturn__)); void __cxa_pure_virtual(void) { // We might want to write some diagnostics to uart in this case //std::terminate(); abort(); 696: 0e 94 f7 06 call 0xdee ; 0xdee 0000069a <__vector_10>: #endif } // General interrupt ISR(USB_GEN_vect) { 69a: 1f 92 push r1 69c: 0f 92 push r0 69e: 0f b6 in r0, 0x3f ; 63 6a0: 0f 92 push r0 6a2: 11 24 eor r1, r1 6a4: 8f 93 push r24 6a6: 9f 93 push r25 u8 udint = UDINT; 6a8: 80 91 e1 00 lds r24, 0x00E1 ; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1> UDINT &= ~((1< 6b0: 93 7f andi r25, 0xF3 ; 243 6b2: 90 93 e1 00 sts 0x00E1, r25 ; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1> // End of Reset if (udint & (1< #define EP_SINGLE_16 0x12 static void InitEP(u8 index, u8 type, u8 size) { UENUM = index; 6ba: 10 92 e9 00 sts 0x00E9, r1 ; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9> UECONX = (1< UECFG0X = type; 6c4: 10 92 ec 00 sts 0x00EC, r1 ; 0x8000ec <__TEXT_REGION_LENGTH__+0x7e00ec> UECFG1X = size; 6c8: 92 e3 ldi r25, 0x32 ; 50 6ca: 90 93 ed 00 sts 0x00ED, r25 ; 0x8000ed <__TEXT_REGION_LENGTH__+0x7e00ed> // End of Reset if (udint & (1< UEIENX = 1 << RXSTPE; // Enable interrupts for ep0 6d2: 98 e0 ldi r25, 0x08 ; 8 6d4: 90 93 f0 00 sts 0x00F0, r25 ; 0x8000f0 <__TEXT_REGION_LENGTH__+0x7e00f0> } // Start of Frame - happens every millisecond so we use it for TX and RX LED one-shot timing, too if (udint & (1< UEDATX = d; } static inline void SetEP(u8 ep) { UENUM = ep; 6dc: 93 e0 ldi r25, 0x03 ; 3 6de: 90 93 e9 00 sts 0x00E9, r25 ; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9> } static inline u8 FifoByteCount() { return UEBCLX; 6e2: 90 91 f2 00 lds r25, 0x00F2 ; 0x8000f2 <__TEXT_REGION_LENGTH__+0x7e00f2> } void USB_Flush(u8 ep) { SetEP(ep); if (FifoByteCount()) 6e6: 99 23 and r25, r25 6e8: 19 f0 breq .+6 ; 0x6f0 <__vector_10+0x56> UEINTX = 0x6B; // FIFOCON=0 NAKINI=1 RWAL=1 NAKOUTI=0 RXSTPI=1 RXOUTI=0 STALLEDI=1 TXINI=1 } static inline void ReleaseTX() { UEINTX = 0x3A; // FIFOCON=0 NAKINI=0 RWAL=1 NAKOUTI=1 RXSTPI=1 RXOUTI=0 STALLEDI=1 TXINI=0 6ea: 9a e3 ldi r25, 0x3A ; 58 6ec: 90 93 e8 00 sts 0x00E8, r25 ; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8> if (udint & (1< 6f4: 99 23 and r25, r25 6f6: 39 f0 breq .+14 ; 0x706 <__vector_10+0x6c> 6f8: 90 91 35 01 lds r25, 0x0135 ; 0x800135 6fc: 91 50 subi r25, 0x01 ; 1 6fe: 90 93 35 01 sts 0x0135, r25 ; 0x800135 702: 99 23 and r25, r25 704: 89 f1 breq .+98 ; 0x768 <__vector_10+0xce> TXLED0; if (RxLEDPulse && !(--RxLEDPulse)) 706: 90 91 93 01 lds r25, 0x0193 ; 0x800193 70a: 99 23 and r25, r25 70c: 39 f0 breq .+14 ; 0x71c <__vector_10+0x82> 70e: 90 91 93 01 lds r25, 0x0193 ; 0x800193 712: 91 50 subi r25, 0x01 ; 1 714: 90 93 93 01 sts 0x0193, r25 ; 0x800193 718: 99 23 and r25, r25 71a: 41 f1 breq .+80 ; 0x76c <__vector_10+0xd2> } // the WAKEUPI interrupt is triggered as soon as there are non-idle patterns on the data // lines. Thus, the WAKEUPI interrupt can occur even if the controller is not in the "suspend" mode. // Therefore the we enable it only when USB is suspended if (udint & (1< { UDIEN = (UDIEN & ~(1< 724: 8e 7e andi r24, 0xEE ; 238 726: 81 60 ori r24, 0x01 ; 1 728: 80 93 e2 00 sts 0x00E2, r24 ; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2> //TODO // WAKEUPI shall be cleared by software (USB clock inputs must be enabled before). //USB_ClockEnable(); UDINT &= ~(1< 730: 8f 7e andi r24, 0xEF ; 239 732: 80 93 e1 00 sts 0x00E1, r24 ; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1> _usbSuspendState = (_usbSuspendState & ~(1< 73a: 8e 7e andi r24, 0xEE ; 238 73c: 80 61 ori r24, 0x10 ; 16 73e: 11 c0 rjmp .+34 ; 0x762 <__vector_10+0xc8> } else if (udint & (1< { UDIEN = (UDIEN & ~(1< 748: 8e 7e andi r24, 0xEE ; 238 74a: 80 61 ori r24, 0x10 ; 16 74c: 80 93 e2 00 sts 0x00E2, r24 ; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2> //TODO //USB_ClockDisable(); UDINT &= ~((1< 754: 8e 7e andi r24, 0xEE ; 238 756: 80 93 e1 00 sts 0x00E1, r24 ; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1> _usbSuspendState = (_usbSuspendState & ~(1< 75e: 8e 7e andi r24, 0xEE ; 238 760: 81 60 ori r24, 0x01 ; 1 762: 80 93 36 01 sts 0x0136, r24 ; 0x800136 <_usbSuspendState> 766: 04 c0 rjmp .+8 ; 0x770 <__vector_10+0xd6> { USB_Flush(CDC_TX); // Send a tx frame if found // check whether the one-shot period has elapsed. if so, turn off the LED if (TxLEDPulse && !(--TxLEDPulse)) TXLED0; 768: 5d 9a sbi 0x0b, 5 ; 11 76a: cd cf rjmp .-102 ; 0x706 <__vector_10+0x6c> if (RxLEDPulse && !(--RxLEDPulse)) RXLED0; 76c: 28 9a sbi 0x05, 0 ; 5 76e: d6 cf rjmp .-84 ; 0x71c <__vector_10+0x82> //USB_ClockDisable(); UDINT &= ~((1<: return true; } // Endpoint 0 interrupt ISR(USB_COM_vect) { 77e: 1f 92 push r1 780: 0f 92 push r0 782: 0f b6 in r0, 0x3f ; 63 784: 0f 92 push r0 786: 11 24 eor r1, r1 788: cf 92 push r12 78a: df 92 push r13 78c: ef 92 push r14 78e: ff 92 push r15 790: 0f 93 push r16 792: 1f 93 push r17 794: 2f 93 push r18 796: 3f 93 push r19 798: 4f 93 push r20 79a: 5f 93 push r21 79c: 6f 93 push r22 79e: 7f 93 push r23 7a0: 8f 93 push r24 7a2: 9f 93 push r25 7a4: af 93 push r26 7a6: bf 93 push r27 7a8: ef 93 push r30 7aa: ff 93 push r31 7ac: cf 93 push r28 7ae: df 93 push r29 7b0: cd b7 in r28, 0x3d ; 61 7b2: de b7 in r29, 0x3e ; 62 7b4: 6c 97 sbiw r28, 0x1c ; 28 7b6: de bf out 0x3e, r29 ; 62 7b8: cd bf out 0x3d, r28 ; 61 UEDATX = d; } static inline void SetEP(u8 ep) { UENUM = ep; 7ba: 10 92 e9 00 sts 0x00E9, r1 ; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9> return UEBCLX; } static inline u8 ReceivedSetupInt() { return UEINTX & (1< // Endpoint 0 interrupt ISR(USB_COM_vect) { SetEP(0); if (!ReceivedSetupInt()) 7c2: 83 ff sbrs r24, 3 7c4: ed c1 rjmp .+986 ; 0xba0 <__stack+0xa1> return; USBSetup setup; Recv((u8*)&setup,8); 7c6: 68 e0 ldi r22, 0x08 ; 8 7c8: ce 01 movw r24, r28 7ca: 45 96 adiw r24, 0x15 ; 21 7cc: 0e 94 7f 02 call 0x4fe ; 0x4fe <_ZL4RecvPVhh> return UEINTX & (1< USBSetup setup; Recv((u8*)&setup,8); ClearSetupInt(); u8 requestType = setup.bmRequestType; 7d6: 8d 89 ldd r24, Y+21 ; 0x15 if (requestType & REQUEST_DEVICETOHOST) 7d8: 87 ff sbrs r24, 7 7da: 05 c0 rjmp .+10 ; 0x7e6 <__vector_11+0x68> volatile u8 _usbCurrentStatus = 0; // meaning of bits see usb_20.pdf, Figure 9-4. Information Returned by a GetStatus() Request to a Device volatile u8 _usbSuspendState = 0; // copy of UDINT to check SUSPI and WAKEUPI bits static inline void WaitIN(void) { while (!(UEINTX & (1< 7e0: 90 ff sbrs r25, 0 7e2: fc cf rjmp .-8 ; 0x7dc <__vector_11+0x5e> 7e4: 03 c0 rjmp .+6 ; 0x7ec <__vector_11+0x6e> ; } static inline void ClearIN(void) { UEINTX = ~(1< WaitIN(); else ClearIN(); bool ok = true; if (REQUEST_STANDARD == (requestType & REQUEST_TYPE)) 7ec: 98 2f mov r25, r24 7ee: 90 76 andi r25, 0x60 ; 96 7f0: 09 f0 breq .+2 ; 0x7f4 <__vector_11+0x76> 7f2: c6 c0 rjmp .+396 ; 0x980 <__vector_11+0x202> { // Standard Requests u8 r = setup.bRequest; 7f4: 9e 89 ldd r25, Y+22 ; 0x16 u16 wValue = setup.wValueL | (setup.wValueH << 8); 7f6: 2f 89 ldd r18, Y+23 ; 0x17 7f8: 18 8d ldd r17, Y+24 ; 0x18 if (GET_STATUS == r) 7fa: 91 11 cpse r25, r1 7fc: 0c c0 rjmp .+24 ; 0x816 <__vector_11+0x98> { if (requestType == (REQUEST_DEVICETOHOST | REQUEST_STANDARD | REQUEST_DEVICE)) 7fe: 80 38 cpi r24, 0x80 ; 128 800: 29 f4 brne .+10 ; 0x80c <__vector_11+0x8e> { Send8(_usbCurrentStatus); 802: 80 91 34 01 lds r24, 0x0134 ; 0x800134 <_usbCurrentStatus> return UEDATX; } static inline void Send8(u8 d) { UEDATX = d; 806: 80 93 f1 00 sts 0x00F1, r24 ; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1> 80a: 02 c0 rjmp .+4 ; 0x810 <__vector_11+0x92> 80c: 10 92 f1 00 sts 0x00F1, r1 ; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1> 810: 10 92 f1 00 sts 0x00F1, r1 ; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1> 814: 48 c1 rjmp .+656 ; 0xaa6 <__vector_11+0x328> bool ok = true; if (REQUEST_STANDARD == (requestType & REQUEST_TYPE)) { // Standard Requests u8 r = setup.bRequest; u16 wValue = setup.wValueL | (setup.wValueH << 8); 816: 42 2f mov r20, r18 818: 50 e0 ldi r21, 0x00 ; 0 81a: 51 2b or r21, r17 // see "Figure 9-6. Information Returned by a GetStatus() Request to an Endpoint" in usb_20.pdf for more information Send8(0); Send8(0); } } else if (CLEAR_FEATURE == r) 81c: 91 30 cpi r25, 0x01 ; 1 81e: 51 f4 brne .+20 ; 0x834 <__vector_11+0xb6> { if((requestType == (REQUEST_HOSTTODEVICE | REQUEST_STANDARD | REQUEST_DEVICE)) 820: 81 11 cpse r24, r1 822: 41 c1 rjmp .+642 ; 0xaa6 <__vector_11+0x328> && (wValue == DEVICE_REMOTE_WAKEUP)) 824: 41 30 cpi r20, 0x01 ; 1 826: 51 05 cpc r21, r1 828: 09 f0 breq .+2 ; 0x82c <__vector_11+0xae> 82a: 3d c1 rjmp .+634 ; 0xaa6 <__vector_11+0x328> { _usbCurrentStatus &= ~FEATURE_REMOTE_WAKEUP_ENABLED; 82c: 80 91 34 01 lds r24, 0x0134 ; 0x800134 <_usbCurrentStatus> 830: 8d 7f andi r24, 0xFD ; 253 832: 0b c0 rjmp .+22 ; 0x84a <__vector_11+0xcc> } } else if (SET_FEATURE == r) 834: 93 30 cpi r25, 0x03 ; 3 836: 61 f4 brne .+24 ; 0x850 <__vector_11+0xd2> { if((requestType == (REQUEST_HOSTTODEVICE | REQUEST_STANDARD | REQUEST_DEVICE)) 838: 81 11 cpse r24, r1 83a: 35 c1 rjmp .+618 ; 0xaa6 <__vector_11+0x328> && (wValue == DEVICE_REMOTE_WAKEUP)) 83c: 41 30 cpi r20, 0x01 ; 1 83e: 51 05 cpc r21, r1 840: 09 f0 breq .+2 ; 0x844 <__vector_11+0xc6> 842: 31 c1 rjmp .+610 ; 0xaa6 <__vector_11+0x328> { _usbCurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED; 844: 80 91 34 01 lds r24, 0x0134 ; 0x800134 <_usbCurrentStatus> 848: 82 60 ori r24, 0x02 ; 2 84a: 80 93 34 01 sts 0x0134, r24 ; 0x800134 <_usbCurrentStatus> 84e: 2b c1 rjmp .+598 ; 0xaa6 <__vector_11+0x328> } } else if (SET_ADDRESS == r) 850: 95 30 cpi r25, 0x05 ; 5 852: 41 f4 brne .+16 ; 0x864 <__vector_11+0xe6> volatile u8 _usbCurrentStatus = 0; // meaning of bits see usb_20.pdf, Figure 9-4. Information Returned by a GetStatus() Request to a Device volatile u8 _usbSuspendState = 0; // copy of UDINT to check SUSPI and WAKEUPI bits static inline void WaitIN(void) { while (!(UEINTX & (1< 858: 80 ff sbrs r24, 0 85a: fc cf rjmp .-8 ; 0x854 <__vector_11+0xd6> } } else if (SET_ADDRESS == r) { WaitIN(); UDADDR = setup.wValueL | (1< 862: 21 c1 rjmp .+578 ; 0xaa6 <__vector_11+0x328> } else if (GET_DESCRIPTOR == r) 864: 96 30 cpi r25, 0x06 ; 6 866: 09 f0 breq .+2 ; 0x86a <__vector_11+0xec> 868: 5f c0 rjmp .+190 ; 0x928 <__vector_11+0x1aa> 86a: eb 8c ldd r14, Y+27 ; 0x1b 86c: fc 8c ldd r15, Y+28 ; 0x1c UEDATX = d; } static inline void SetEP(u8 ep) { UENUM = ep; 86e: 10 92 e9 00 sts 0x00E9, r1 ; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9> static int _cmark; static int _cend; void InitControl(int end) { SetEP(0); _cmark = 0; 872: 10 92 32 01 sts 0x0132, r1 ; 0x800132 <_ZL6_cmark+0x1> 876: 10 92 31 01 sts 0x0131, r1 ; 0x800131 <_ZL6_cmark> static bool SendDescriptor(USBSetup& setup) { int ret; u8 t = setup.wValueH; if (USB_CONFIGURATION_DESCRIPTOR_TYPE == t) 87a: 12 30 cpi r17, 0x02 ; 2 87c: 91 f5 brne .+100 ; 0x8e2 <__vector_11+0x164> static int _cend; void InitControl(int end) { SetEP(0); _cmark = 0; _cend = end; 87e: 10 92 30 01 sts 0x0130, r1 ; 0x800130 <_ZL5_cend+0x1> 882: 10 92 2f 01 sts 0x012F, r1 ; 0x80012f <_ZL5_cend> static bool SendConfiguration(int maxlen) { // Count and measure interfaces InitControl(0); u8 interfaces = SendInterfaces(); 886: 0e 94 4d 02 call 0x49a ; 0x49a <_ZL14SendInterfacesv> ConfigDescriptor config = D_CONFIG(_cmark + sizeof(ConfigDescriptor),interfaces); 88a: 99 e0 ldi r25, 0x09 ; 9 88c: be 01 movw r22, r28 88e: 6f 5f subi r22, 0xFF ; 255 890: 7f 4f sbci r23, 0xFF ; 255 892: db 01 movw r26, r22 894: e9 2f mov r30, r25 896: 1d 92 st X+, r1 898: ea 95 dec r30 89a: e9 f7 brne .-6 ; 0x896 <__vector_11+0x118> 89c: 99 83 std Y+1, r25 ; 0x01 89e: 1a 83 std Y+2, r17 ; 0x02 8a0: 91 e0 ldi r25, 0x01 ; 1 8a2: 9e 83 std Y+6, r25 ; 0x06 8a4: 90 ea ldi r25, 0xA0 ; 160 8a6: 98 87 std Y+8, r25 ; 0x08 8a8: 9a ef ldi r25, 0xFA ; 250 8aa: 99 87 std Y+9, r25 ; 0x09 8ac: 20 91 31 01 lds r18, 0x0131 ; 0x800131 <_ZL6_cmark> 8b0: 30 91 32 01 lds r19, 0x0132 ; 0x800132 <_ZL6_cmark+0x1> 8b4: 27 5f subi r18, 0xF7 ; 247 8b6: 3f 4f sbci r19, 0xFF ; 255 8b8: 3c 83 std Y+4, r19 ; 0x04 8ba: 2b 83 std Y+3, r18 ; 0x03 8bc: 8d 83 std Y+5, r24 ; 0x05 UEDATX = d; } static inline void SetEP(u8 ep) { UENUM = ep; 8be: 10 92 e9 00 sts 0x00E9, r1 ; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9> static int _cmark; static int _cend; void InitControl(int end) { SetEP(0); _cmark = 0; 8c2: 10 92 32 01 sts 0x0132, r1 ; 0x800132 <_ZL6_cmark+0x1> 8c6: 10 92 31 01 sts 0x0131, r1 ; 0x800131 <_ZL6_cmark> _cend = end; 8ca: f0 92 30 01 sts 0x0130, r15 ; 0x800130 <_ZL5_cend+0x1> 8ce: e0 92 2f 01 sts 0x012F, r14 ; 0x80012f <_ZL5_cend> u8 interfaces = SendInterfaces(); ConfigDescriptor config = D_CONFIG(_cmark + sizeof(ConfigDescriptor),interfaces); // Now send them InitControl(maxlen); USB_SendControl(0,&config,sizeof(ConfigDescriptor)); 8d2: 49 e0 ldi r20, 0x09 ; 9 8d4: 50 e0 ldi r21, 0x00 ; 0 8d6: 80 e0 ldi r24, 0x00 ; 0 8d8: 0e 94 26 02 call 0x44c ; 0x44c <_Z15USB_SendControlhPKvi> SendInterfaces(); 8dc: 0e 94 4d 02 call 0x49a ; 0x49a <_ZL14SendInterfacesv> 8e0: e2 c0 rjmp .+452 ; 0xaa6 <__vector_11+0x328> static int _cend; void InitControl(int end) { SetEP(0); _cmark = 0; _cend = end; 8e2: f0 92 30 01 sts 0x0130, r15 ; 0x800130 <_ZL5_cend+0x1> 8e6: e0 92 2f 01 sts 0x012F, r14 ; 0x80012f <_ZL5_cend> if (USB_CONFIGURATION_DESCRIPTOR_TYPE == t) return SendConfiguration(setup.wLength); InitControl(setup.wLength); #ifdef PLUGGABLE_USB_ENABLED ret = PluggableUSB().getDescriptor(setup); 8ea: 0e 94 22 01 call 0x244 ; 0x244 <_Z12PluggableUSBv> } int PluggableUSB_::getDescriptor(USBSetup& setup) { PluggableUSBModule* node; for (node = rootNode; node; node = node->next) { 8ee: dc 01 movw r26, r24 8f0: 12 96 adiw r26, 0x02 ; 2 8f2: ed 90 ld r14, X+ 8f4: fc 90 ld r15, X 8f6: 13 97 sbiw r26, 0x03 ; 3 8f8: e1 14 cp r14, r1 8fa: f1 04 cpc r15, r1 8fc: 09 f4 brne .+2 ; 0x900 <__vector_11+0x182> 8fe: c0 c0 rjmp .+384 ; 0xa80 <__vector_11+0x302> int ret = node->getDescriptor(setup); 900: d7 01 movw r26, r14 902: ed 91 ld r30, X+ 904: fc 91 ld r31, X 906: 04 80 ldd r0, Z+4 ; 0x04 908: f5 81 ldd r31, Z+5 ; 0x05 90a: e0 2d mov r30, r0 90c: be 01 movw r22, r28 90e: 6b 5e subi r22, 0xEB ; 235 910: 7f 4f sbci r23, 0xFF ; 255 912: c7 01 movw r24, r14 914: 09 95 icall // ret!=0 -> request has been processed if (ret) 916: 00 97 sbiw r24, 0x00 ; 0 918: 19 f0 breq .+6 ; 0x920 <__vector_11+0x1a2> if (ret != 0) { return (ret > 0 ? true : false); 91a: 0c f0 brlt .+2 ; 0x91e <__vector_11+0x1a0> 91c: c4 c0 rjmp .+392 ; 0xaa6 <__vector_11+0x328> 91e: c7 c0 rjmp .+398 ; 0xaae <__vector_11+0x330> } int PluggableUSB_::getDescriptor(USBSetup& setup) { PluggableUSBModule* node; for (node = rootNode; node; node = node->next) { 920: f7 01 movw r30, r14 922: e0 84 ldd r14, Z+8 ; 0x08 924: f1 84 ldd r15, Z+9 ; 0x09 926: e8 cf rjmp .-48 ; 0x8f8 <__vector_11+0x17a> } else if (GET_DESCRIPTOR == r) { ok = SendDescriptor(setup); } else if (SET_DESCRIPTOR == r) 928: 97 30 cpi r25, 0x07 ; 7 92a: 09 f4 brne .+2 ; 0x92e <__vector_11+0x1b0> 92c: c0 c0 rjmp .+384 ; 0xaae <__vector_11+0x330> { ok = false; } else if (GET_CONFIGURATION == r) 92e: 98 30 cpi r25, 0x08 ; 8 930: 21 f4 brne .+8 ; 0x93a <__vector_11+0x1bc> return UEDATX; } static inline void Send8(u8 d) { UEDATX = d; 932: 81 e0 ldi r24, 0x01 ; 1 934: 80 93 f1 00 sts 0x00F1, r24 ; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1> 938: b6 c0 rjmp .+364 ; 0xaa6 <__vector_11+0x328> } else if (GET_CONFIGURATION == r) { Send8(1); } else if (SET_CONFIGURATION == r) 93a: 99 30 cpi r25, 0x09 ; 9 93c: 09 f0 breq .+2 ; 0x940 <__vector_11+0x1c2> 93e: b3 c0 rjmp .+358 ; 0xaa6 <__vector_11+0x328> { if (REQUEST_DEVICE == (requestType & REQUEST_RECIPIENT)) 940: 83 70 andi r24, 0x03 ; 3 942: 09 f0 breq .+2 ; 0x946 <__vector_11+0x1c8> 944: b4 c0 rjmp .+360 ; 0xaae <__vector_11+0x330> 946: ed e0 ldi r30, 0x0D ; 13 948: f1 e0 ldi r31, 0x01 ; 1 94a: 81 e0 ldi r24, 0x01 ; 1 void InitEndpoints() { for (u8 i = 1; i < sizeof(_initEndpoints) && _initEndpoints[i] != 0; i++) { UENUM = i; UECONX = (1< { UENUM = i; 956: 80 93 e9 00 sts 0x00E9, r24 ; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9> UECONX = (1< UECFG0X = _initEndpoints[i]; 95e: 91 91 ld r25, Z+ 960: 90 93 ec 00 sts 0x00EC, r25 ; 0x8000ec <__TEXT_REGION_LENGTH__+0x7e00ec> #if USB_EP_SIZE == 16 UECFG1X = EP_SINGLE_16; #elif USB_EP_SIZE == 64 UECFG1X = EP_DOUBLE_64; 964: 30 93 ed 00 sts 0x00ED, r19 ; 0x8000ed <__TEXT_REGION_LENGTH__+0x7e00ed> } static void InitEndpoints() { for (u8 i = 1; i < sizeof(_initEndpoints) && _initEndpoints[i] != 0; i++) 968: 8f 5f subi r24, 0xFF ; 255 96a: 87 30 cpi r24, 0x07 ; 7 96c: 89 f7 brne .-30 ; 0x950 <__vector_11+0x1d2> UECFG1X = EP_DOUBLE_64; #else #error Unsupported value for USB_EP_SIZE #endif } UERST = 0x7E; // And reset them 96e: 8e e7 ldi r24, 0x7E ; 126 970: 80 93 ea 00 sts 0x00EA, r24 ; 0x8000ea <__TEXT_REGION_LENGTH__+0x7e00ea> UERST = 0; 974: 10 92 ea 00 sts 0x00EA, r1 ; 0x8000ea <__TEXT_REGION_LENGTH__+0x7e00ea> else if (SET_CONFIGURATION == r) { if (REQUEST_DEVICE == (requestType & REQUEST_RECIPIENT)) { InitEndpoints(); _usbConfiguration = setup.wValueL; 978: 8f 89 ldd r24, Y+23 ; 0x17 97a: 80 93 94 01 sts 0x0194, r24 ; 0x800194 <_usbConfiguration> 97e: 93 c0 rjmp .+294 ; 0xaa6 <__vector_11+0x328> { } } else { InitControl(setup.wLength); // Max length of transfer 980: 8b 8d ldd r24, Y+27 ; 0x1b 982: 9c 8d ldd r25, Y+28 ; 0x1c UEDATX = d; } static inline void SetEP(u8 ep) { UENUM = ep; 984: 10 92 e9 00 sts 0x00E9, r1 ; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9> static int _cmark; static int _cend; void InitControl(int end) { SetEP(0); _cmark = 0; 988: 10 92 32 01 sts 0x0132, r1 ; 0x800132 <_ZL6_cmark+0x1> 98c: 10 92 31 01 sts 0x0131, r1 ; 0x800131 <_ZL6_cmark> _cend = end; 990: 90 93 30 01 sts 0x0130, r25 ; 0x800130 <_ZL5_cend+0x1> 994: 80 93 2f 01 sts 0x012F, r24 ; 0x80012f <_ZL5_cend> static bool ClassInterfaceRequest(USBSetup& setup) { u8 i = setup.wIndex; if (CDC_ACM_INTERFACE == i) 998: 89 8d ldd r24, Y+25 ; 0x19 99a: 81 11 cpse r24, r1 99c: 56 c0 rjmp .+172 ; 0xa4a <__vector_11+0x2cc> return USB_SendControl(TRANSFER_PGM,&_cdcInterface,sizeof(_cdcInterface)); } bool CDC_Setup(USBSetup& setup) { u8 r = setup.bRequest; 99e: 8e 89 ldd r24, Y+22 ; 0x16 u8 requestType = setup.bmRequestType; 9a0: 9d 89 ldd r25, Y+21 ; 0x15 if (REQUEST_DEVICETOHOST_CLASS_INTERFACE == requestType) 9a2: 91 3a cpi r25, 0xA1 ; 161 9a4: 59 f4 brne .+22 ; 0x9bc <__vector_11+0x23e> { if (CDC_GET_LINE_CODING == r) 9a6: 81 32 cpi r24, 0x21 ; 33 9a8: 09 f0 breq .+2 ; 0x9ac <__vector_11+0x22e> 9aa: 81 c0 rjmp .+258 ; 0xaae <__vector_11+0x330> { USB_SendControl(0,(void*)&_usbLineInfo,7); 9ac: 47 e0 ldi r20, 0x07 ; 7 9ae: 50 e0 ldi r21, 0x00 ; 0 9b0: 64 e0 ldi r22, 0x04 ; 4 9b2: 71 e0 ldi r23, 0x01 ; 1 9b4: 80 e0 ldi r24, 0x00 ; 0 9b6: 0e 94 26 02 call 0x44c ; 0x44c <_Z15USB_SendControlhPKvi> 9ba: 75 c0 rjmp .+234 ; 0xaa6 <__vector_11+0x328> return true; } } if (REQUEST_HOSTTODEVICE_CLASS_INTERFACE == requestType) 9bc: 91 32 cpi r25, 0x21 ; 33 9be: 09 f0 breq .+2 ; 0x9c2 <__vector_11+0x244> 9c0: 76 c0 rjmp .+236 ; 0xaae <__vector_11+0x330> { if (CDC_SEND_BREAK == r) 9c2: 83 32 cpi r24, 0x23 ; 35 9c4: 89 f4 brne .+34 ; 0x9e8 <__vector_11+0x26a> { breakValue = ((uint16_t)setup.wValueH << 8) | setup.wValueL; 9c6: 88 8d ldd r24, Y+24 ; 0x18 9c8: 90 e0 ldi r25, 0x00 ; 0 9ca: 98 2f mov r25, r24 9cc: 88 27 eor r24, r24 9ce: 2f 89 ldd r18, Y+23 ; 0x17 9d0: 82 2b or r24, r18 9d2: a0 e0 ldi r26, 0x00 ; 0 9d4: b0 e0 ldi r27, 0x00 ; 0 9d6: 80 93 00 01 sts 0x0100, r24 ; 0x800100 <__data_start> 9da: 90 93 01 01 sts 0x0101, r25 ; 0x800101 <__data_start+0x1> 9de: a0 93 02 01 sts 0x0102, r26 ; 0x800102 <__data_start+0x2> 9e2: b0 93 03 01 sts 0x0103, r27 ; 0x800103 <__data_start+0x3> 9e6: 5f c0 rjmp .+190 ; 0xaa6 <__vector_11+0x328> } if (CDC_SET_LINE_CODING == r) 9e8: 80 32 cpi r24, 0x20 ; 32 9ea: 69 f4 brne .+26 ; 0xa06 <__vector_11+0x288> UEINTX = ~(1< 9f0: 82 ff sbrs r24, 2 9f2: fc cf rjmp .-8 ; 0x9ec <__vector_11+0x26e> recvLength = 64; } // Write data to fit to the end (not the beginning) of the array WaitOUT(); Recv((u8*)d + len - length, recvLength); 9f4: 67 e0 ldi r22, 0x07 ; 7 9f6: 84 e0 ldi r24, 0x04 ; 4 9f8: 91 e0 ldi r25, 0x01 ; 1 9fa: 0e 94 7f 02 call 0x4fe ; 0x4fe <_ZL4RecvPVhh> return (UEINTX & (1< a04: 06 c0 rjmp .+12 ; 0xa12 <__vector_11+0x294> { USB_RecvControl((void*)&_usbLineInfo,7); } if (CDC_SET_CONTROL_LINE_STATE == r) a06: 82 32 cpi r24, 0x22 ; 34 a08: 09 f0 breq .+2 ; 0xa0c <__vector_11+0x28e> a0a: 4d c0 rjmp .+154 ; 0xaa6 <__vector_11+0x328> { _usbLineInfo.lineState = setup.wValueL; a0c: 8f 89 ldd r24, Y+23 ; 0x17 a0e: 80 93 0b 01 sts 0x010B, r24 ; 0x80010b <_ZL12_usbLineInfo+0x7> // This is used to keep compatible with the old leonardo bootloaders. // You are still able to set the magic key position manually to RAMEND-1 to save a few bytes for this check. #if MAGIC_KEY_POS != (RAMEND-1) // For future boards save the key in the inproblematic RAMEND // Which is reserved for the main() return value (which will never return) if (_updatedLUFAbootloader) { a12: 80 91 33 01 lds r24, 0x0133 ; 0x800133 <_updatedLUFAbootloader> a16: 88 23 and r24, r24 a18: 19 f0 breq .+6 ; 0xa20 <__vector_11+0x2a2> // horray, we got a new bootloader! magic_key_pos = (RAMEND-1); a1a: ee ef ldi r30, 0xFE ; 254 a1c: fa e0 ldi r31, 0x0A ; 10 a1e: 02 c0 rjmp .+4 ; 0xa24 <__vector_11+0x2a6> // auto-reset into the bootloader is triggered when the port, already // open at 1200 bps, is closed. this is the signal to start the watchdog // with a relatively long period so it can finish housekeeping tasks // like servicing endpoints before the sketch ends uint16_t magic_key_pos = MAGIC_KEY_POS; a20: e0 e0 ldi r30, 0x00 ; 0 a22: f8 e0 ldi r31, 0x08 ; 8 magic_key_pos = (RAMEND-1); } #endif // We check DTR state to determine if host port is open (bit 0 of lineState). if (1200 == _usbLineInfo.dwDTERate && (_usbLineInfo.lineState & 0x01) == 0) a24: 80 91 04 01 lds r24, 0x0104 ; 0x800104 <_ZL12_usbLineInfo> a28: 90 91 05 01 lds r25, 0x0105 ; 0x800105 <_ZL12_usbLineInfo+0x1> a2c: a0 91 06 01 lds r26, 0x0106 ; 0x800106 <_ZL12_usbLineInfo+0x2> a30: b0 91 07 01 lds r27, 0x0107 ; 0x800107 <_ZL12_usbLineInfo+0x3> a34: 80 3b cpi r24, 0xB0 ; 176 a36: 94 40 sbci r25, 0x04 ; 4 a38: a1 05 cpc r26, r1 a3a: b1 05 cpc r27, r1 a3c: 09 f0 breq .+2 ; 0xa40 <__vector_11+0x2c2> a3e: 7b c0 rjmp .+246 ; 0xb36 <__stack+0x37> a40: 80 91 0b 01 lds r24, 0x010B ; 0x80010b <_ZL12_usbLineInfo+0x7> a44: 80 ff sbrs r24, 0 a46: 93 c0 rjmp .+294 ; 0xb6e <__stack+0x6f> a48: 76 c0 rjmp .+236 ; 0xb36 <__stack+0x37> if (CDC_ACM_INTERFACE == i) return CDC_Setup(setup); #ifdef PLUGGABLE_USB_ENABLED return PluggableUSB().setup(setup); a4a: 0e 94 22 01 call 0x244 ; 0x244 <_Z12PluggableUSBv> } bool PluggableUSB_::setup(USBSetup& setup) { PluggableUSBModule* node; for (node = rootNode; node; node = node->next) { a4e: dc 01 movw r26, r24 a50: 12 96 adiw r26, 0x02 ; 2 a52: 0d 91 ld r16, X+ a54: 1c 91 ld r17, X a56: 13 97 sbiw r26, 0x03 ; 3 a58: 01 15 cp r16, r1 a5a: 11 05 cpc r17, r1 a5c: 41 f1 breq .+80 ; 0xaae <__vector_11+0x330> if (node->setup(setup)) { a5e: d8 01 movw r26, r16 a60: ed 91 ld r30, X+ a62: fc 91 ld r31, X a64: 01 90 ld r0, Z+ a66: f0 81 ld r31, Z a68: e0 2d mov r30, r0 a6a: be 01 movw r22, r28 a6c: 6b 5e subi r22, 0xEB ; 235 a6e: 7f 4f sbci r23, 0xFF ; 255 a70: c8 01 movw r24, r16 a72: 09 95 icall a74: 81 11 cpse r24, r1 a76: 17 c0 rjmp .+46 ; 0xaa6 <__vector_11+0x328> } bool PluggableUSB_::setup(USBSetup& setup) { PluggableUSBModule* node; for (node = rootNode; node; node = node->next) { a78: f8 01 movw r30, r16 a7a: 00 85 ldd r16, Z+8 ; 0x08 a7c: 11 85 ldd r17, Z+9 ; 0x09 a7e: ec cf rjmp .-40 ; 0xa58 <__vector_11+0x2da> return (ret > 0 ? true : false); } #endif const u8* desc_addr = 0; if (USB_DEVICE_DESCRIPTOR_TYPE == t) a80: 11 30 cpi r17, 0x01 ; 1 a82: 09 f4 brne .+2 ; 0xa86 <__vector_11+0x308> a84: 4e c0 rjmp .+156 ; 0xb22 <__stack+0x23> { desc_addr = (const u8*)&USB_DeviceDescriptorIAD; } else if (USB_STRING_DESCRIPTOR_TYPE == t) a86: 13 30 cpi r17, 0x03 ; 3 a88: 91 f4 brne .+36 ; 0xaae <__vector_11+0x330> { if (setup.wValueL == 0) { a8a: 8f 89 ldd r24, Y+23 ; 0x17 a8c: 88 23 and r24, r24 a8e: 09 f4 brne .+2 ; 0xa92 <__vector_11+0x314> a90: 45 c0 rjmp .+138 ; 0xb1c <__stack+0x1d> desc_addr = (const u8*)&STRING_LANGUAGE; } else if (setup.wValueL == IPRODUCT) { a92: 82 30 cpi r24, 0x02 ; 2 a94: 81 f4 brne .+32 ; 0xab6 <__vector_11+0x338> return USB_SendStringDescriptor(STRING_PRODUCT, strlen(USB_PRODUCT), TRANSFER_PGM); a96: 40 e8 ldi r20, 0x80 ; 128 a98: 60 e1 ldi r22, 0x10 ; 16 a9a: 80 e1 ldi r24, 0x10 ; 16 a9c: 91 e0 ldi r25, 0x01 ; 1 } else if (setup.wValueL == IMANUFACTURER) { return USB_SendStringDescriptor(STRING_MANUFACTURER, strlen(USB_MANUFACTURER), TRANSFER_PGM); a9e: 0e 94 e9 01 call 0x3d2 ; 0x3d2 <_ZL24USB_SendStringDescriptorPKhhh> { InitControl(setup.wLength); // Max length of transfer ok = ClassInterfaceRequest(setup); } if (ok) aa2: 88 23 and r24, r24 aa4: 21 f0 breq .+8 ; 0xaae <__vector_11+0x330> ; } static inline void ClearIN(void) { UEINTX = ~(1< aac: 79 c0 rjmp .+242 ; 0xba0 <__stack+0xa1> UEINTX = ~((1< ab4: 75 c0 rjmp .+234 ; 0xba0 <__stack+0xa1> desc_addr = (const u8*)&STRING_LANGUAGE; } else if (setup.wValueL == IPRODUCT) { return USB_SendStringDescriptor(STRING_PRODUCT, strlen(USB_PRODUCT), TRANSFER_PGM); } else if (setup.wValueL == IMANUFACTURER) { ab6: 81 30 cpi r24, 0x01 ; 1 ab8: 29 f4 brne .+10 ; 0xac4 <__vector_11+0x346> return USB_SendStringDescriptor(STRING_MANUFACTURER, strlen(USB_MANUFACTURER), TRANSFER_PGM); aba: 40 e8 ldi r20, 0x80 ; 128 abc: 6b e0 ldi r22, 0x0B ; 11 abe: 84 e0 ldi r24, 0x04 ; 4 ac0: 91 e0 ldi r25, 0x01 ; 1 ac2: ed cf rjmp .-38 ; 0xa9e <__vector_11+0x320> } else if (setup.wValueL == ISERIAL) { ac4: 83 30 cpi r24, 0x03 ; 3 ac6: 99 f7 brne .-26 ; 0xaae <__vector_11+0x330> #ifdef PLUGGABLE_USB_ENABLED char name[ISERIAL_MAX_LEN]; PluggableUSB().getShortName(name); ac8: 0e 94 22 01 call 0x244 ; 0x244 <_Z12PluggableUSBv> } void PluggableUSB_::getShortName(char *iSerialNum) { PluggableUSBModule* node; for (node = rootNode; node; node = node->next) { acc: dc 01 movw r26, r24 ace: 12 96 adiw r26, 0x02 ; 2 ad0: ed 90 ld r14, X+ ad2: fc 90 ld r15, X ad4: 13 97 sbiw r26, 0x03 ; 3 ad6: 8e 01 movw r16, r28 ad8: 0f 5f subi r16, 0xFF ; 255 ada: 1f 4f sbci r17, 0xFF ; 255 adc: 68 01 movw r12, r16 ade: e1 14 cp r14, r1 ae0: f1 04 cpc r15, r1 ae2: 79 f0 breq .+30 ; 0xb02 <__stack+0x3> iSerialNum += node->getShortName(iSerialNum); ae4: d7 01 movw r26, r14 ae6: ed 91 ld r30, X+ ae8: fc 91 ld r31, X aea: 06 80 ldd r0, Z+6 ; 0x06 aec: f7 81 ldd r31, Z+7 ; 0x07 aee: e0 2d mov r30, r0 af0: b8 01 movw r22, r16 af2: c7 01 movw r24, r14 af4: 09 95 icall af6: 08 0f add r16, r24 af8: 11 1d adc r17, r1 } void PluggableUSB_::getShortName(char *iSerialNum) { PluggableUSBModule* node; for (node = rootNode; node; node = node->next) { afa: f7 01 movw r30, r14 afc: e0 84 ldd r14, Z+8 ; 0x08 afe: f1 84 ldd r15, Z+9 ; 0x09 b00: ee cf rjmp .-36 ; 0xade <__vector_11+0x360> iSerialNum += node->getShortName(iSerialNum); } *iSerialNum = 0; b02: d8 01 movw r26, r16 b04: 1c 92 st X, r1 return USB_SendStringDescriptor((uint8_t*)name, strlen(name), 0); b06: f6 01 movw r30, r12 b08: 01 90 ld r0, Z+ b0a: 00 20 and r0, r0 b0c: e9 f7 brne .-6 ; 0xb08 <__stack+0x9> b0e: 31 97 sbiw r30, 0x01 ; 1 b10: bf 01 movw r22, r30 b12: 6c 19 sub r22, r12 b14: 7d 09 sbc r23, r13 b16: 40 e0 ldi r20, 0x00 ; 0 b18: c6 01 movw r24, r12 b1a: c1 cf rjmp .-126 ; 0xa9e <__vector_11+0x320> desc_addr = (const u8*)&USB_DeviceDescriptorIAD; } else if (USB_STRING_DESCRIPTOR_TYPE == t) { if (setup.wValueL == 0) { desc_addr = (const u8*)&STRING_LANGUAGE; b1c: 6e ee ldi r22, 0xEE ; 238 b1e: 70 e0 ldi r23, 0x00 ; 0 b20: 02 c0 rjmp .+4 ; 0xb26 <__stack+0x27> #endif const u8* desc_addr = 0; if (USB_DEVICE_DESCRIPTOR_TYPE == t) { desc_addr = (const u8*)&USB_DeviceDescriptorIAD; b22: 62 ef ldi r22, 0xF2 ; 242 b24: 70 e0 ldi r23, 0x00 ; 0 } else return false; } if (desc_addr == 0) b26: 61 15 cp r22, r1 b28: 71 05 cpc r23, r1 b2a: 09 f2 breq .-126 ; 0xaae <__vector_11+0x330> return false; u8 desc_length = pgm_read_byte(desc_addr); b2c: fb 01 movw r30, r22 b2e: 44 91 lpm r20, Z USB_SendControl(TRANSFER_PGM,desc_addr,desc_length); b30: 50 e0 ldi r21, 0x00 ; 0 b32: 80 e8 ldi r24, 0x80 ; 128 b34: 40 cf rjmp .-384 ; 0x9b6 <__vector_11+0x238> "out __SREG__,__tmp_reg__" "\n\t" : [TEMPREG] "=d" (temp_reg) : [WDTREG] "n" (_SFR_MEM_ADDR(_WD_CONTROL_REG)), [WDCE_WDE] "n" ((uint8_t)(_BV(_WD_CHANGE_BIT) | _BV(WDE))) : "r0" ); b36: 0f b6 in r0, 0x3f ; 63 b38: f8 94 cli b3a: a8 95 wdr b3c: 80 91 60 00 lds r24, 0x0060 ; 0x800060 <__TEXT_REGION_LENGTH__+0x7e0060> b40: 88 61 ori r24, 0x18 ; 24 b42: 80 93 60 00 sts 0x0060, r24 ; 0x800060 <__TEXT_REGION_LENGTH__+0x7e0060> b46: 10 92 60 00 sts 0x0060, r1 ; 0x800060 <__TEXT_REGION_LENGTH__+0x7e0060> b4a: 0f be out 0x3f, r0 ; 63 // twiggle more than once before stabilizing. // To avoid spurious resets we set the watchdog to 250ms and eventually // cancel if DTR goes back high. wdt_disable(); wdt_reset(); b4c: a8 95 wdr #if MAGIC_KEY_POS != (RAMEND-1) // Restore backed up (old bootloader) magic key data if (magic_key_pos != (RAMEND-1)) { b4e: ee 3f cpi r30, 0xFE ; 254 b50: 2a e0 ldi r18, 0x0A ; 10 b52: f2 07 cpc r31, r18 b54: 39 f0 breq .+14 ; 0xb64 <__stack+0x65> *(uint16_t *)magic_key_pos = *(uint16_t *)(RAMEND-1); b56: 80 91 fe 0a lds r24, 0x0AFE ; 0x800afe <__bss_end+0x969> b5a: 90 91 ff 0a lds r25, 0x0AFF ; 0x800aff <__bss_end+0x96a> b5e: 91 83 std Z+1, r25 ; 0x01 b60: 80 83 st Z, r24 b62: a1 cf rjmp .-190 ; 0xaa6 <__vector_11+0x328> } else #endif { // Clean up RAMEND key *(uint16_t *)magic_key_pos = 0x0000; b64: 10 92 ff 0a sts 0x0AFF, r1 ; 0x800aff <__bss_end+0x96a> b68: 10 92 fe 0a sts 0x0AFE, r1 ; 0x800afe <__bss_end+0x969> b6c: 9c cf rjmp .-200 ; 0xaa6 <__vector_11+0x328> if (1200 == _usbLineInfo.dwDTERate && (_usbLineInfo.lineState & 0x01) == 0) { #if MAGIC_KEY_POS != (RAMEND-1) // Backup ram value if its not a newer bootloader. // This should avoid memory corruption at least a bit, not fully if (magic_key_pos != (RAMEND-1)) { b6e: ee 3f cpi r30, 0xFE ; 254 b70: 8a e0 ldi r24, 0x0A ; 10 b72: f8 07 cpc r31, r24 b74: 31 f0 breq .+12 ; 0xb82 <__stack+0x83> *(uint16_t *)(RAMEND-1) = *(uint16_t *)magic_key_pos; b76: 80 81 ld r24, Z b78: 91 81 ldd r25, Z+1 ; 0x01 b7a: 90 93 ff 0a sts 0x0AFF, r25 ; 0x800aff <__bss_end+0x96a> b7e: 80 93 fe 0a sts 0x0AFE, r24 ; 0x800afe <__bss_end+0x969> } #endif // Store boot key *(uint16_t *)magic_key_pos = MAGIC_KEY; b82: 87 e7 ldi r24, 0x77 ; 119 b84: 97 e7 ldi r25, 0x77 ; 119 b86: 91 83 std Z+1, r25 ; 0x01 b88: 80 83 st Z, r24 : "n" (_SFR_MEM_ADDR(_WD_CONTROL_REG)), "r" ((uint8_t)(_BV(_WD_CHANGE_BIT) | _BV(WDE))), "r" ((uint8_t) ((value & 0x08 ? _WD_PS3_MASK : 0x00) | _BV(WDE) | (value & 0x07)) ) : "r0" ); b8a: 9b e0 ldi r25, 0x0B ; 11 b8c: 88 e1 ldi r24, 0x18 ; 24 b8e: 0f b6 in r0, 0x3f ; 63 b90: f8 94 cli b92: a8 95 wdr b94: 80 93 60 00 sts 0x0060, r24 ; 0x800060 <__TEXT_REGION_LENGTH__+0x7e0060> b98: 0f be out 0x3f, r0 ; 63 b9a: 90 93 60 00 sts 0x0060, r25 ; 0x800060 <__TEXT_REGION_LENGTH__+0x7e0060> b9e: 83 cf rjmp .-250 ; 0xaa6 <__vector_11+0x328> ClearIN(); else { Stall(); } } ba0: 6c 96 adiw r28, 0x1c ; 28 ba2: 0f b6 in r0, 0x3f ; 63 ba4: f8 94 cli ba6: de bf out 0x3e, r29 ; 62 ba8: 0f be out 0x3f, r0 ; 63 baa: cd bf out 0x3d, r28 ; 61 bac: df 91 pop r29 bae: cf 91 pop r28 bb0: ff 91 pop r31 bb2: ef 91 pop r30 bb4: bf 91 pop r27 bb6: af 91 pop r26 bb8: 9f 91 pop r25 bba: 8f 91 pop r24 bbc: 7f 91 pop r23 bbe: 6f 91 pop r22 bc0: 5f 91 pop r21 bc2: 4f 91 pop r20 bc4: 3f 91 pop r19 bc6: 2f 91 pop r18 bc8: 1f 91 pop r17 bca: 0f 91 pop r16 bcc: ff 90 pop r15 bce: ef 90 pop r14 bd0: df 90 pop r13 bd2: cf 90 pop r12 bd4: 0f 90 pop r0 bd6: 0f be out 0x3f, r0 ; 63 bd8: 0f 90 pop r0 bda: 1f 90 pop r1 bdc: 18 95 reti 00000bde <__vector_23>: #if defined(__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__) ISR(TIM0_OVF_vect) #else ISR(TIMER0_OVF_vect) #endif { bde: 1f 92 push r1 be0: 0f 92 push r0 be2: 0f b6 in r0, 0x3f ; 63 be4: 0f 92 push r0 be6: 11 24 eor r1, r1 be8: 2f 93 push r18 bea: 3f 93 push r19 bec: 8f 93 push r24 bee: 9f 93 push r25 bf0: af 93 push r26 bf2: bf 93 push r27 // copy these to local variables so they can be stored in registers // (volatile variables must be read from memory on every access) unsigned long m = timer0_millis; bf4: 80 91 27 01 lds r24, 0x0127 ; 0x800127 bf8: 90 91 28 01 lds r25, 0x0128 ; 0x800128 bfc: a0 91 29 01 lds r26, 0x0129 ; 0x800129 c00: b0 91 2a 01 lds r27, 0x012A ; 0x80012a unsigned char f = timer0_fract; c04: 30 91 26 01 lds r19, 0x0126 ; 0x800126 <__data_end> m += MILLIS_INC; f += FRACT_INC; c08: 23 e0 ldi r18, 0x03 ; 3 c0a: 23 0f add r18, r19 if (f >= FRACT_MAX) { c0c: 2d 37 cpi r18, 0x7D ; 125 c0e: 20 f4 brcc .+8 ; 0xc18 <__vector_23+0x3a> // copy these to local variables so they can be stored in registers // (volatile variables must be read from memory on every access) unsigned long m = timer0_millis; unsigned char f = timer0_fract; m += MILLIS_INC; c10: 01 96 adiw r24, 0x01 ; 1 c12: a1 1d adc r26, r1 c14: b1 1d adc r27, r1 c16: 05 c0 rjmp .+10 ; 0xc22 <__vector_23+0x44> f += FRACT_INC; if (f >= FRACT_MAX) { f -= FRACT_MAX; c18: 26 e8 ldi r18, 0x86 ; 134 c1a: 23 0f add r18, r19 m += 1; c1c: 02 96 adiw r24, 0x02 ; 2 c1e: a1 1d adc r26, r1 c20: b1 1d adc r27, r1 } timer0_fract = f; c22: 20 93 26 01 sts 0x0126, r18 ; 0x800126 <__data_end> timer0_millis = m; c26: 80 93 27 01 sts 0x0127, r24 ; 0x800127 c2a: 90 93 28 01 sts 0x0128, r25 ; 0x800128 c2e: a0 93 29 01 sts 0x0129, r26 ; 0x800129 c32: b0 93 2a 01 sts 0x012A, r27 ; 0x80012a timer0_overflow_count++; c36: 80 91 2b 01 lds r24, 0x012B ; 0x80012b c3a: 90 91 2c 01 lds r25, 0x012C ; 0x80012c c3e: a0 91 2d 01 lds r26, 0x012D ; 0x80012d c42: b0 91 2e 01 lds r27, 0x012E ; 0x80012e c46: 01 96 adiw r24, 0x01 ; 1 c48: a1 1d adc r26, r1 c4a: b1 1d adc r27, r1 c4c: 80 93 2b 01 sts 0x012B, r24 ; 0x80012b c50: 90 93 2c 01 sts 0x012C, r25 ; 0x80012c c54: a0 93 2d 01 sts 0x012D, r26 ; 0x80012d c58: b0 93 2e 01 sts 0x012E, r27 ; 0x80012e } c5c: bf 91 pop r27 c5e: af 91 pop r26 c60: 9f 91 pop r25 c62: 8f 91 pop r24 c64: 3f 91 pop r19 c66: 2f 91 pop r18 c68: 0f 90 pop r0 c6a: 0f be out 0x3f, r0 ; 63 c6c: 0f 90 pop r0 c6e: 1f 90 pop r1 c70: 18 95 reti 00000c72 <_GLOBAL__sub_I__updatedLUFAbootloader>: public: Print() : write_error(0) {} c72: e7 e3 ldi r30, 0x37 ; 55 c74: f1 e0 ldi r31, 0x01 ; 1 c76: 13 82 std Z+3, r1 ; 0x03 c78: 12 82 std Z+2, r1 ; 0x02 public: virtual int available() = 0; virtual int read() = 0; virtual int peek() = 0; Stream() {_timeout=1000;} c7a: 88 ee ldi r24, 0xE8 ; 232 c7c: 93 e0 ldi r25, 0x03 ; 3 c7e: a0 e0 ldi r26, 0x00 ; 0 c80: b0 e0 ldi r27, 0x00 ; 0 c82: 84 83 std Z+4, r24 ; 0x04 c84: 95 83 std Z+5, r25 ; 0x05 c86: a6 83 std Z+6, r26 ; 0x06 c88: b7 83 std Z+7, r27 ; 0x07 class Serial_ : public Stream { private: int peek_buffer; public: Serial_() { peek_buffer = -1; }; c8a: 87 e1 ldi r24, 0x17 ; 23 c8c: 91 e0 ldi r25, 0x01 ; 1 c8e: 91 83 std Z+1, r25 ; 0x01 c90: 80 83 st Z, r24 c92: 8f ef ldi r24, 0xFF ; 255 c94: 9f ef ldi r25, 0xFF ; 255 c96: 95 87 std Z+13, r25 ; 0x0d c98: 84 87 std Z+12, r24 ; 0x0c c9a: 08 95 ret 00000c9c
: void init() { // this needs to be called before setup() or some functions won't // work there sei(); c9c: 78 94 sei // on the ATmega168, timer 0 is also used for fast hardware pwm // (using phase-correct PWM would mean that timer 0 overflowed half as often // resulting in different millis() behavior on the ATmega8 and ATmega168) #if defined(TCCR0A) && defined(WGM01) sbi(TCCR0A, WGM01); c9e: 84 b5 in r24, 0x24 ; 36 ca0: 82 60 ori r24, 0x02 ; 2 ca2: 84 bd out 0x24, r24 ; 36 sbi(TCCR0A, WGM00); ca4: 84 b5 in r24, 0x24 ; 36 ca6: 81 60 ori r24, 0x01 ; 1 ca8: 84 bd out 0x24, r24 ; 36 // this combination is for the standard atmega8 sbi(TCCR0, CS01); sbi(TCCR0, CS00); #elif defined(TCCR0B) && defined(CS01) && defined(CS00) // this combination is for the standard 168/328/1280/2560 sbi(TCCR0B, CS01); caa: 85 b5 in r24, 0x25 ; 37 cac: 82 60 ori r24, 0x02 ; 2 cae: 85 bd out 0x25, r24 ; 37 sbi(TCCR0B, CS00); cb0: 85 b5 in r24, 0x25 ; 37 cb2: 81 60 ori r24, 0x01 ; 1 cb4: 85 bd out 0x25, r24 ; 37 // enable timer 0 overflow interrupt #if defined(TIMSK) && defined(TOIE0) sbi(TIMSK, TOIE0); #elif defined(TIMSK0) && defined(TOIE0) sbi(TIMSK0, TOIE0); cb6: 80 91 6e 00 lds r24, 0x006E ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e> cba: 81 60 ori r24, 0x01 ; 1 cbc: 80 93 6e 00 sts 0x006E, r24 ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e> // this is better for motors as it ensures an even waveform // note, however, that fast pwm mode can achieve a frequency of up // 8 MHz (with a 16 MHz clock) at 50% duty cycle #if defined(TCCR1B) && defined(CS11) && defined(CS10) TCCR1B = 0; cc0: 10 92 81 00 sts 0x0081, r1 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> // set timer 1 prescale factor to 64 sbi(TCCR1B, CS11); cc4: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> cc8: 82 60 ori r24, 0x02 ; 2 cca: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> #if F_CPU >= 8000000L sbi(TCCR1B, CS10); cce: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> cd2: 81 60 ori r24, 0x01 ; 1 cd4: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> sbi(TCCR1, CS10); #endif #endif // put timer 1 in 8-bit phase correct pwm mode #if defined(TCCR1A) && defined(WGM10) sbi(TCCR1A, WGM10); cd8: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> cdc: 81 60 ori r24, 0x01 ; 1 cde: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> //#else // Timer 2 not finished (may not be present on this CPU) #endif #if defined(TCCR3B) && defined(CS31) && defined(WGM30) sbi(TCCR3B, CS31); // set timer 3 prescale factor to 64 ce2: 80 91 91 00 lds r24, 0x0091 ; 0x800091 <__TEXT_REGION_LENGTH__+0x7e0091> ce6: 82 60 ori r24, 0x02 ; 2 ce8: 80 93 91 00 sts 0x0091, r24 ; 0x800091 <__TEXT_REGION_LENGTH__+0x7e0091> sbi(TCCR3B, CS30); cec: 80 91 91 00 lds r24, 0x0091 ; 0x800091 <__TEXT_REGION_LENGTH__+0x7e0091> cf0: 81 60 ori r24, 0x01 ; 1 cf2: 80 93 91 00 sts 0x0091, r24 ; 0x800091 <__TEXT_REGION_LENGTH__+0x7e0091> sbi(TCCR3A, WGM30); // put timer 3 in 8-bit phase correct pwm mode cf6: 80 91 90 00 lds r24, 0x0090 ; 0x800090 <__TEXT_REGION_LENGTH__+0x7e0090> cfa: 81 60 ori r24, 0x01 ; 1 cfc: 80 93 90 00 sts 0x0090, r24 ; 0x800090 <__TEXT_REGION_LENGTH__+0x7e0090> #endif #if defined(TCCR4A) && defined(TCCR4B) && defined(TCCR4D) /* beginning of timer4 block for 32U4 and similar */ sbi(TCCR4B, CS42); // set timer4 prescale factor to 64 d00: 80 91 c1 00 lds r24, 0x00C1 ; 0x8000c1 <__TEXT_REGION_LENGTH__+0x7e00c1> d04: 84 60 ori r24, 0x04 ; 4 d06: 80 93 c1 00 sts 0x00C1, r24 ; 0x8000c1 <__TEXT_REGION_LENGTH__+0x7e00c1> sbi(TCCR4B, CS41); d0a: 80 91 c1 00 lds r24, 0x00C1 ; 0x8000c1 <__TEXT_REGION_LENGTH__+0x7e00c1> d0e: 82 60 ori r24, 0x02 ; 2 d10: 80 93 c1 00 sts 0x00C1, r24 ; 0x8000c1 <__TEXT_REGION_LENGTH__+0x7e00c1> sbi(TCCR4B, CS40); d14: 80 91 c1 00 lds r24, 0x00C1 ; 0x8000c1 <__TEXT_REGION_LENGTH__+0x7e00c1> d18: 81 60 ori r24, 0x01 ; 1 d1a: 80 93 c1 00 sts 0x00C1, r24 ; 0x8000c1 <__TEXT_REGION_LENGTH__+0x7e00c1> sbi(TCCR4D, WGM40); // put timer 4 in phase- and frequency-correct PWM mode d1e: 80 91 c3 00 lds r24, 0x00C3 ; 0x8000c3 <__TEXT_REGION_LENGTH__+0x7e00c3> d22: 81 60 ori r24, 0x01 ; 1 d24: 80 93 c3 00 sts 0x00C3, r24 ; 0x8000c3 <__TEXT_REGION_LENGTH__+0x7e00c3> sbi(TCCR4A, PWM4A); // enable PWM mode for comparator OCR4A d28: 80 91 c0 00 lds r24, 0x00C0 ; 0x8000c0 <__TEXT_REGION_LENGTH__+0x7e00c0> d2c: 82 60 ori r24, 0x02 ; 2 d2e: 80 93 c0 00 sts 0x00C0, r24 ; 0x8000c0 <__TEXT_REGION_LENGTH__+0x7e00c0> sbi(TCCR4C, PWM4D); // enable PWM mode for comparator OCR4D d32: 80 91 c2 00 lds r24, 0x00C2 ; 0x8000c2 <__TEXT_REGION_LENGTH__+0x7e00c2> d36: 81 60 ori r24, 0x01 ; 1 d38: 80 93 c2 00 sts 0x00C2, r24 ; 0x8000c2 <__TEXT_REGION_LENGTH__+0x7e00c2> #endif #if defined(ADCSRA) // set a2d prescaler so we are inside the desired 50-200 KHz range. #if F_CPU >= 16000000 // 16 MHz / 128 = 125 KHz sbi(ADCSRA, ADPS2); d3c: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> d40: 84 60 ori r24, 0x04 ; 4 d42: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> sbi(ADCSRA, ADPS1); d46: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> d4a: 82 60 ori r24, 0x02 ; 2 d4c: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> sbi(ADCSRA, ADPS0); d50: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> d54: 81 60 ori r24, 0x01 ; 1 d56: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> cbi(ADCSRA, ADPS2); cbi(ADCSRA, ADPS1); sbi(ADCSRA, ADPS0); #endif // enable a2d conversions sbi(ADCSRA, ADEN); d5a: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> d5e: 80 68 ori r24, 0x80 ; 128 d60: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> { } void USBDevice_::attach() { _usbConfiguration = 0; d64: 10 92 94 01 sts 0x0194, r1 ; 0x800194 <_usbConfiguration> _usbCurrentStatus = 0; d68: 10 92 34 01 sts 0x0134, r1 ; 0x800134 <_usbCurrentStatus> _usbSuspendState = 0; d6c: 10 92 36 01 sts 0x0136, r1 ; 0x800136 <_usbSuspendState> } static inline void USB_ClockEnable() { #if defined(UHWCON) UHWCON |= (1< d74: 81 60 ori r24, 0x01 ; 1 d76: 80 93 d7 00 sts 0x00D7, r24 ; 0x8000d7 <__TEXT_REGION_LENGTH__+0x7e00d7> #endif USBCON = (1< // ATmega32U4 #if defined(PINDIV) #if F_CPU == 16000000UL PLLCSR |= (1< } // Some tests on specific versions of macosx (10.7.3), reported some // strange behaviors when the board is reset using the serial // port touch at 1200 bps. This delay fixes this behavior. delay(1); d92: 0e 94 b1 02 call 0x562 ; 0x562 #if defined(OTGPADE) USBCON = (USBCON & ~(1< d9a: 8f 7c andi r24, 0xCF ; 207 d9c: 80 61 ori r24, 0x10 ; 16 d9e: 80 93 d8 00 sts 0x00D8, r24 ; 0x8000d8 <__TEXT_REGION_LENGTH__+0x7e00d8> USBCON &= ~(1 << FRZCLK); // start USB clock #endif #if defined(RSTCPU) #if defined(LSM) UDCON &= ~((1< da6: 80 7f andi r24, 0xF0 ; 240 da8: 80 93 e0 00 sts 0x00E0, r24 ; 0x8000e0 <__TEXT_REGION_LENGTH__+0x7e00e0> _usbConfiguration = 0; _usbCurrentStatus = 0; _usbSuspendState = 0; USB_ClockEnable(); UDINT &= ~((1< db0: 8e 7e andi r24, 0xEE ; 238 db2: 80 93 e1 00 sts 0x00E1, r24 ; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1> UDIEN = (1< TX_RX_LED_INIT; dbc: 55 9a sbi 0x0a, 5 ; 10 dbe: 20 9a sbi 0x04, 0 ; 4 #if MAGIC_KEY_POS != (RAMEND-1) if (pgm_read_word(FLASHEND - 1) == NEW_LUFA_SIGNATURE) { dc0: ee ef ldi r30, 0xFE ; 254 dc2: ff e7 ldi r31, 0x7F ; 127 dc4: 85 91 lpm r24, Z+ dc6: 94 91 lpm r25, Z dc8: 8b 3f cpi r24, 0xFB ; 251 dca: 9c 4d sbci r25, 0xDC ; 220 dcc: 19 f4 brne .+6 ; 0xdd4 _updatedLUFAbootloader = true; dce: 81 e0 ldi r24, 0x01 ; 1 dd0: 80 93 33 01 sts 0x0133, r24 ; 0x800133 <_updatedLUFAbootloader> setup(); for (;;) { loop(); if (serialEventRun) serialEventRun(); dd4: c0 e0 ldi r28, 0x00 ; 0 dd6: d0 e0 ldi r29, 0x00 ; 0 dd8: 20 97 sbiw r28, 0x00 ; 0 dda: f1 f3 breq .-4 ; 0xdd8 ddc: 0e 94 00 00 call 0 ; 0x0 <__vectors> de0: fb cf rjmp .-10 ; 0xdd8 00000de2 <__tablejump2__>: de2: ee 0f add r30, r30 de4: ff 1f adc r31, r31 de6: 05 90 lpm r0, Z+ de8: f4 91 lpm r31, Z dea: e0 2d mov r30, r0 dec: 09 94 ijmp 00000dee : dee: 81 e0 ldi r24, 0x01 ; 1 df0: 90 e0 ldi r25, 0x00 ; 0 df2: f8 94 cli df4: 0c 94 fc 06 jmp 0xdf8 ; 0xdf8 <_exit> 00000df8 <_exit>: df8: f8 94 cli 00000dfa <__stop_program>: dfa: ff cf rjmp .-2 ; 0xdfa <__stop_program>