diff options
Diffstat (limited to 'firmware/VirtualSerial.lss')
| -rw-r--r-- | firmware/VirtualSerial.lss | 3526 |
1 files changed, 3526 insertions, 0 deletions
diff --git a/firmware/VirtualSerial.lss b/firmware/VirtualSerial.lss new file mode 100644 index 0000000..c2bb1c1 --- /dev/null +++ b/firmware/VirtualSerial.lss @@ -0,0 +1,3526 @@ + +VirtualSerial.elf: file format elf32-avr + +Sections: +Idx Name Size VMA LMA File off Algn + 0 .data 000000d8 00800100 00000ece 00000f62 2**0 + CONTENTS, ALLOC, LOAD, DATA + 1 .text 00000ece 00000000 00000000 00000094 2**1 + CONTENTS, ALLOC, LOAD, READONLY, CODE + 2 .bss 0000003e 008001d8 008001d8 0000103a 2**0 + ALLOC + 3 .stab 00001080 00000000 00000000 0000103c 2**2 + CONTENTS, READONLY, DEBUGGING + 4 .stabstr 000009a6 00000000 00000000 000020bc 2**0 + CONTENTS, READONLY, DEBUGGING + 5 .debug_aranges 00000438 00000000 00000000 00002a62 2**0 + CONTENTS, READONLY, DEBUGGING + 6 .debug_pubnames 00000b8d 00000000 00000000 00002e9a 2**0 + CONTENTS, READONLY, DEBUGGING + 7 .debug_info 00006c93 00000000 00000000 00003a27 2**0 + CONTENTS, READONLY, DEBUGGING + 8 .debug_abbrev 00001dd1 00000000 00000000 0000a6ba 2**0 + CONTENTS, READONLY, DEBUGGING + 9 .debug_line 00005218 00000000 00000000 0000c48b 2**0 + CONTENTS, READONLY, DEBUGGING + 10 .debug_frame 00000650 00000000 00000000 000116a4 2**2 + CONTENTS, READONLY, DEBUGGING + 11 .debug_str 00002b5d 00000000 00000000 00011cf4 2**0 + CONTENTS, READONLY, DEBUGGING + 12 .debug_loc 00002be2 00000000 00000000 00014851 2**0 + CONTENTS, READONLY, DEBUGGING + 13 .debug_ranges 00000458 00000000 00000000 00017433 2**0 + CONTENTS, READONLY, DEBUGGING + +Disassembly of section .text: + +00000000 <__vectors>: + USB_Init(); +} + +/** Checks for changes in the position of the board joystick, sending strings to the host upon each change. */ +void CheckPinStatus(void) +{ + 0: 81 c0 rjmp .+258 ; 0x104 <__ctors_end> + + return Endpoint_IsConfigured(); +} + +void Endpoint_ClearEndpoints(void) +{ + 2: 00 00 nop + #if defined(USB_CAN_BE_BOTH) + USB_CurrentMode = USB_MODE_None; + #endif + + USB_IsInitialized = false; +} + 4: 9a c0 rjmp .+308 ; 0x13a <__bad_interrupt> +uint8_t TEMPLATE_FUNC_NAME (const void* Buffer, + uint16_t Length) +{ + 6: 00 00 nop + + return ENDPOINT_READYWAIT_NoError; +} + +uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) +{ + 8: 98 c0 rjmp .+304 ; 0x13a <__bad_interrupt> + a: 00 00 nop + c: 96 c0 rjmp .+300 ; 0x13a <__bad_interrupt> + e: 00 00 nop + 10: 94 c0 rjmp .+296 ; 0x13a <__bad_interrupt> + 12: 00 00 nop + 14: 92 c0 rjmp .+292 ; 0x13a <__bad_interrupt> + 16: 00 00 nop + 18: 90 c0 rjmp .+288 ; 0x13a <__bad_interrupt> + 1a: 00 00 nop + 1c: 8e c0 rjmp .+284 ; 0x13a <__bad_interrupt> + 1e: 00 00 nop + 20: 8c c0 rjmp .+280 ; 0x13a <__bad_interrupt> + 22: 00 00 nop + 24: 8a c0 rjmp .+276 ; 0x13a <__bad_interrupt> + 26: 00 00 nop + 28: 88 c0 rjmp .+272 ; 0x13a <__bad_interrupt> + 2a: 00 00 nop + 2c: 80 c2 rjmp .+1280 ; 0x52e <__vector_11> + 2e: 00 00 nop + 30: 84 c0 rjmp .+264 ; 0x13a <__bad_interrupt> + 32: 00 00 nop + 34: 82 c0 rjmp .+260 ; 0x13a <__bad_interrupt> + 36: 00 00 nop + 38: 80 c0 rjmp .+256 ; 0x13a <__bad_interrupt> + 3a: 00 00 nop + 3c: 93 c0 rjmp .+294 ; 0x164 <__vector_15> + 3e: 00 00 nop + 40: 7c c0 rjmp .+248 ; 0x13a <__bad_interrupt> + 42: 00 00 nop + 44: 7a c0 rjmp .+244 ; 0x13a <__bad_interrupt> + 46: 00 00 nop + 48: 78 c0 rjmp .+240 ; 0x13a <__bad_interrupt> + 4a: 00 00 nop + 4c: 76 c0 rjmp .+236 ; 0x13a <__bad_interrupt> + 4e: 00 00 nop + 50: 74 c0 rjmp .+232 ; 0x13a <__bad_interrupt> + 52: 00 00 nop + 54: 72 c0 rjmp .+228 ; 0x13a <__bad_interrupt> + 56: 00 00 nop + 58: 70 c0 rjmp .+224 ; 0x13a <__bad_interrupt> + 5a: 00 00 nop + 5c: 6e c0 rjmp .+220 ; 0x13a <__bad_interrupt> + 5e: 00 00 nop + 60: 6c c0 rjmp .+216 ; 0x13a <__bad_interrupt> + 62: 00 00 nop + 64: 6a c0 rjmp .+212 ; 0x13a <__bad_interrupt> + 66: 00 00 nop + 68: 68 c0 rjmp .+208 ; 0x13a <__bad_interrupt> + 6a: 00 00 nop + 6c: 66 c0 rjmp .+204 ; 0x13a <__bad_interrupt> + 6e: 00 00 nop + 70: 64 c0 rjmp .+200 ; 0x13a <__bad_interrupt> + 72: 00 00 nop + +00000074 <DeviceDescriptor>: + 74: 12 01 10 01 02 00 00 08 eb 03 6f 20 01 00 01 02 ..........o .... + 84: 00 01 .. + +00000086 <ConfigurationDescriptor>: + 86: 09 02 3e 00 02 01 00 c0 32 09 04 00 00 01 02 02 ..>.....2....... + 96: 01 00 05 24 00 10 01 04 24 02 06 05 24 06 00 01 ...$....$...$... + a6: 07 05 82 03 08 00 ff 09 04 01 00 02 0a 00 00 00 ................ + b6: 07 05 04 02 10 00 01 07 05 83 02 10 00 01 .............. + +000000c4 <LanguageString>: + c4: 04 03 09 04 .... + +000000c8 <ManufacturerString>: + c8: 18 03 50 00 49 00 4e 00 47 00 20 00 4c 00 61 00 ..P.I.N.G. .L.a. + d8: 62 00 73 00 00 00 b.s... + +000000de <ProductString>: + de: 26 03 46 00 72 00 69 00 64 00 67 00 65 00 20 00 &.F.r.i.d.g.e. . + ee: 43 00 6f 00 6e 00 74 00 72 00 6f 00 6c 00 6c 00 C.o.n.t.r.o.l.l. + fe: 65 00 72 00 00 00 e.r... + +00000104 <__ctors_end>: + 104: 11 24 eor r1, r1 + 106: 1f be out 0x3f, r1 ; 63 + 108: cf ef ldi r28, 0xFF ; 255 + 10a: d2 e0 ldi r29, 0x02 ; 2 + 10c: de bf out 0x3e, r29 ; 62 + 10e: cd bf out 0x3d, r28 ; 61 + +00000110 <__do_copy_data>: + 110: 11 e0 ldi r17, 0x01 ; 1 + 112: a0 e0 ldi r26, 0x00 ; 0 + 114: b1 e0 ldi r27, 0x01 ; 1 + 116: ee ec ldi r30, 0xCE ; 206 + 118: fe e0 ldi r31, 0x0E ; 14 + 11a: 02 c0 rjmp .+4 ; 0x120 <.do_copy_data_start> + +0000011c <.do_copy_data_loop>: + 11c: 05 90 lpm r0, Z+ + 11e: 0d 92 st X+, r0 + +00000120 <.do_copy_data_start>: + 120: a8 3d cpi r26, 0xD8 ; 216 + 122: b1 07 cpc r27, r17 + 124: d9 f7 brne .-10 ; 0x11c <.do_copy_data_loop> + +00000126 <__do_clear_bss>: + 126: 12 e0 ldi r17, 0x02 ; 2 + 128: a8 ed ldi r26, 0xD8 ; 216 + 12a: b1 e0 ldi r27, 0x01 ; 1 + 12c: 01 c0 rjmp .+2 ; 0x130 <.do_clear_bss_start> + +0000012e <.do_clear_bss_loop>: + 12e: 1d 92 st X+, r1 + +00000130 <.do_clear_bss_start>: + 130: a6 31 cpi r26, 0x16 ; 22 + 132: b1 07 cpc r27, r17 + 134: e1 f7 brne .-8 ; 0x12e <.do_clear_bss_loop> + 136: eb d0 rcall .+470 ; 0x30e <main> + 138: c8 c6 rjmp .+3472 ; 0xeca <_exit> + +0000013a <__bad_interrupt>: + 13a: 62 cf rjmp .-316 ; 0x0 <__vectors> + +0000013c <lock_timer_setup>: + +static volatile uint8_t lock_timer_ticks; + +void lock_timer_setup(void) +{ + OCR1A = 128; + 13c: e0 e8 ldi r30, 0x80 ; 128 + 13e: f0 e0 ldi r31, 0x00 ; 0 + 140: f0 93 89 00 sts 0x0089, r31 + 144: e0 93 88 00 sts 0x0088, r30 + + // CTC mode + TCCR1A = (1 << WGM12); + 148: 88 e0 ldi r24, 0x08 ; 8 + 14a: 80 83 st Z, r24 + + // Prescaler + TCCR1B = (1 << CS12); + 14c: 84 e0 ldi r24, 0x04 ; 4 + 14e: 80 93 81 00 sts 0x0081, r24 + + // Enable interrupt + TIMSK1 = (1 << OCIE1A); + 152: 82 e0 ldi r24, 0x02 ; 2 + 154: 80 93 6f 00 sts 0x006F, r24 +} + 158: 08 95 ret + +0000015a <lock_timer_reset>: + +void lock_timer_reset(void) +{ + lock_timer_ticks = 0; + 15a: 10 92 08 02 sts 0x0208, r1 +} + 15e: 08 95 ret + +00000160 <EVENT_USB_Device_Connect>: + +/** Event handler for the library USB Connection event. */ +void EVENT_USB_Device_Connect(void) +{ +// LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING); +} + 160: 08 95 ret + +00000162 <EVENT_USB_Device_Disconnect>: + +/** Event handler for the library USB Disconnection event. */ +void EVENT_USB_Device_Disconnect(void) +{ +// LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY); +} + 162: 08 95 ret + +00000164 <__vector_15>: +{ + CDC_Device_ProcessControlRequest(&VirtualSerial_CDC_Interface); +} + +ISR(TIMER1_COMPA_vect) +{ + 164: 1f 92 push r1 + 166: 0f 92 push r0 + 168: 0f b6 in r0, 0x3f ; 63 + 16a: 0f 92 push r0 + 16c: 11 24 eor r1, r1 + 16e: 8f 93 push r24 + if(PINB & (1 << PB5)) + 170: 1d 99 sbic 0x03, 5 ; 3 + PORTB |= 1 << PB4; + 172: 2c 9a sbi 0x05, 4 ; 5 + + if(lock_timer_ticks == 0xff) + 174: 80 91 08 02 lds r24, 0x0208 + 178: 8f 3f cpi r24, 0xFF ; 255 + 17a: 61 f0 breq .+24 ; 0x194 <__vector_15+0x30> + return; + + if(lock_timer_ticks < 30) + 17c: 80 91 08 02 lds r24, 0x0208 + 180: 8e 31 cpi r24, 0x1E ; 30 + 182: 20 f4 brcc .+8 ; 0x18c <__vector_15+0x28> + { + ++lock_timer_ticks; + 184: 80 91 08 02 lds r24, 0x0208 + 188: 8f 5f subi r24, 0xFF ; 255 + 18a: 02 c0 rjmp .+4 ; 0x190 <__vector_15+0x2c> + return; + } + + PORTB |= 1 << PB4; + 18c: 2c 9a sbi 0x05, 4 ; 5 + lock_timer_ticks = 0xff; + 18e: 8f ef ldi r24, 0xFF ; 255 + 190: 80 93 08 02 sts 0x0208, r24 +} + 194: 8f 91 pop r24 + 196: 0f 90 pop r0 + 198: 0f be out 0x3f, r0 ; 63 + 19a: 0f 90 pop r0 + 19c: 1f 90 pop r1 + 19e: 18 95 reti + +000001a0 <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); + 1a0: 80 ec ldi r24, 0xC0 ; 192 + 1a2: 91 e0 ldi r25, 0x01 ; 1 +} + 1a4: ad c5 rjmp .+2906 ; 0xd00 <CDC_Device_ProcessControlRequest> + +000001a6 <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); + 1a6: 80 ec ldi r24, 0xC0 ; 192 + 1a8: 91 e0 ldi r25, 0x01 ; 1 + +// LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR); +} + 1aa: 61 c5 rjmp .+2754 ; 0xc6e <CDC_Device_ConfigureEndpoints> + +000001ac <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); + 1ac: 84 b7 in r24, 0x34 ; 52 + 1ae: 87 7f andi r24, 0xF7 ; 247 + 1b0: 84 bf out 0x34, r24 ; 52 + + /* Enable the watchdog timer. */ + wdt_enable(WDTO_1S); + 1b2: 2e e0 ldi r18, 0x0E ; 14 + 1b4: 88 e1 ldi r24, 0x18 ; 24 + 1b6: 90 e0 ldi r25, 0x00 ; 0 + 1b8: 0f b6 in r0, 0x3f ; 63 + 1ba: f8 94 cli + 1bc: a8 95 wdr + 1be: 80 93 60 00 sts 0x0060, r24 + 1c2: 0f be out 0x3f, r0 ; 63 + 1c4: 20 93 60 00 sts 0x0060, r18 +The type of x is clock_div_t. +*/ +void clock_prescale_set(clock_div_t __x) +{ + uint8_t __tmp = _BV(CLKPCE); + __asm__ __volatile__ ( + 1c8: 90 e0 ldi r25, 0x00 ; 0 + 1ca: 80 e8 ldi r24, 0x80 ; 128 + 1cc: 0f b6 in r0, 0x3f ; 63 + 1ce: f8 94 cli + 1d0: 80 93 61 00 sts 0x0061, r24 + 1d4: 90 93 61 00 sts 0x0061, r25 + 1d8: 0f be out 0x3f, r0 ; 63 + /* Disable clock division */ + clock_prescale_set(clock_div_1); + + /* Hardware Initialization */ + USB_Init(); +} + 1da: 9a c1 rjmp .+820 ; 0x510 <USB_Init> + +000001dc <handle_command>: + + for (;;); +} + +void handle_command(const char *buf) +{ + 1dc: cf 93 push r28 + 1de: df 93 push r29 + 1e0: ec 01 movw r28, r24 + if (strcmp("cola", buf) == 0) + 1e2: 8d e1 ldi r24, 0x1D ; 29 + 1e4: 91 e0 ldi r25, 0x01 ; 1 + 1e6: be 01 movw r22, r28 + 1e8: f8 d5 rcall .+3056 ; 0xdda <strcmp> + 1ea: 00 97 sbiw r24, 0x00 ; 0 + 1ec: 39 f4 brne .+14 ; 0x1fc <handle_command+0x20> + { + PORTB ^= 1 << PB5; + 1ee: 85 b1 in r24, 0x05 ; 5 + 1f0: 90 e2 ldi r25, 0x20 ; 32 + 1f2: 89 27 eor r24, r25 + 1f4: 85 b9 out 0x05, r24 ; 5 + fputs("mmm! LED toggeled\r\n", &USBSerialStream); + 1f6: 82 e2 ldi r24, 0x22 ; 34 + 1f8: 91 e0 ldi r25, 0x01 ; 1 + 1fa: 4e c0 rjmp .+156 ; 0x298 <handle_command+0xbc> + } + + else if (strcmp("reboot", buf) == 0 || strcmp("reset", buf) == 0) + 1fc: 86 e3 ldi r24, 0x36 ; 54 + 1fe: 91 e0 ldi r25, 0x01 ; 1 + 200: be 01 movw r22, r28 + 202: eb d5 rcall .+3030 ; 0xdda <strcmp> + 204: 00 97 sbiw r24, 0x00 ; 0 + 206: 31 f0 breq .+12 ; 0x214 <handle_command+0x38> + 208: 8d e3 ldi r24, 0x3D ; 61 + 20a: 91 e0 ldi r25, 0x01 ; 1 + 20c: be 01 movw r22, r28 + 20e: e5 d5 rcall .+3018 ; 0xdda <strcmp> + 210: 00 97 sbiw r24, 0x00 ; 0 + 212: 51 f4 brne .+20 ; 0x228 <handle_command+0x4c> + { + fputs("Rebooting!\r\n", &USBSerialStream); + 214: 80 e1 ldi r24, 0x10 ; 16 + 216: 91 e0 ldi r25, 0x01 ; 1 + 218: 6a ef ldi r22, 0xFA ; 250 + 21a: 71 e0 ldi r23, 0x01 ; 1 + 21c: 13 d6 rcall .+3110 ; 0xe44 <fputs> + running = false; + 21e: 10 92 d7 01 sts 0x01D7, r1 + 222: 10 92 d6 01 sts 0x01D6, r1 + 226: 3b c0 rjmp .+118 ; 0x29e <handle_command+0xc2> + } + + else if (strcmp("toggle", buf) == 0) + 228: 83 e4 ldi r24, 0x43 ; 67 + 22a: 91 e0 ldi r25, 0x01 ; 1 + 22c: be 01 movw r22, r28 + 22e: d5 d5 rcall .+2986 ; 0xdda <strcmp> + 230: 00 97 sbiw r24, 0x00 ; 0 + 232: 51 f4 brne .+20 ; 0x248 <handle_command+0x6c> + { + fputs("Toggling Magnet Lock\r\n", &USBSerialStream); + 234: 8a e4 ldi r24, 0x4A ; 74 + 236: 91 e0 ldi r25, 0x01 ; 1 + 238: 6a ef ldi r22, 0xFA ; 250 + 23a: 71 e0 ldi r23, 0x01 ; 1 + 23c: 03 d6 rcall .+3078 ; 0xe44 <fputs> + PORTB ^= 1 << PB4; + 23e: 85 b1 in r24, 0x05 ; 5 + 240: 90 e1 ldi r25, 0x10 ; 16 + 242: 89 27 eor r24, r25 + 244: 85 b9 out 0x05, r24 ; 5 + 246: 2b c0 rjmp .+86 ; 0x29e <handle_command+0xc2> + } + + else if (strcmp("lock", buf) == 0) + 248: 81 e6 ldi r24, 0x61 ; 97 + 24a: 91 e0 ldi r25, 0x01 ; 1 + 24c: be 01 movw r22, r28 + 24e: c5 d5 rcall .+2954 ; 0xdda <strcmp> + 250: 00 97 sbiw r24, 0x00 ; 0 + 252: 39 f4 brne .+14 ; 0x262 <handle_command+0x86> + { + fputs("status: locked\n", &USBSerialStream); + 254: 86 e6 ldi r24, 0x66 ; 102 + 256: 91 e0 ldi r25, 0x01 ; 1 + 258: 6a ef ldi r22, 0xFA ; 250 + 25a: 71 e0 ldi r23, 0x01 ; 1 + 25c: f3 d5 rcall .+3046 ; 0xe44 <fputs> + PORTB |= 1 << PB4; + 25e: 2c 9a sbi 0x05, 4 ; 5 + 260: 1e c0 rjmp .+60 ; 0x29e <handle_command+0xc2> + } + + else if (strcmp("unlock", buf) == 0) + 262: 86 e7 ldi r24, 0x76 ; 118 + 264: 91 e0 ldi r25, 0x01 ; 1 + 266: be 01 movw r22, r28 + 268: b8 d5 rcall .+2928 ; 0xdda <strcmp> + 26a: 00 97 sbiw r24, 0x00 ; 0 + 26c: 41 f4 brne .+16 ; 0x27e <handle_command+0xa2> + { + fputs("status: unlocked\n", &USBSerialStream); + 26e: 8d e7 ldi r24, 0x7D ; 125 + 270: 91 e0 ldi r25, 0x01 ; 1 + 272: 6a ef ldi r22, 0xFA ; 250 + 274: 71 e0 ldi r23, 0x01 ; 1 + 276: e6 d5 rcall .+3020 ; 0xe44 <fputs> + PORTB &= ~(1 << PB4); + 278: 2c 98 cbi 0x05, 4 ; 5 + lock_timer_reset(); + 27a: 6f df rcall .-290 ; 0x15a <lock_timer_reset> + 27c: 10 c0 rjmp .+32 ; 0x29e <handle_command+0xc2> + } + + else if (strcmp("doorstatus", buf) == 0) + 27e: 8f e8 ldi r24, 0x8F ; 143 + 280: 91 e0 ldi r25, 0x01 ; 1 + 282: be 01 movw r22, r28 + 284: aa d5 rcall .+2900 ; 0xdda <strcmp> + 286: 00 97 sbiw r24, 0x00 ; 0 + 288: 51 f4 brne .+20 ; 0x29e <handle_command+0xc2> + { + if (PINB & (1 << PB5)) + 28a: 1d 9b sbis 0x03, 5 ; 3 + 28c: 03 c0 rjmp .+6 ; 0x294 <handle_command+0xb8> + fputs("doorstatus: open\n", &USBSerialStream); + 28e: 8a e9 ldi r24, 0x9A ; 154 + 290: 91 e0 ldi r25, 0x01 ; 1 + 292: 02 c0 rjmp .+4 ; 0x298 <handle_command+0xbc> + else + fputs("doorstatus: closed\n", &USBSerialStream); + 294: 8c ea ldi r24, 0xAC ; 172 + 296: 91 e0 ldi r25, 0x01 ; 1 + 298: 6a ef ldi r22, 0xFA ; 250 + 29a: 71 e0 ldi r23, 0x01 ; 1 + 29c: d3 d5 rcall .+2982 ; 0xe44 <fputs> + } +} + 29e: df 91 pop r29 + 2a0: cf 91 pop r28 + 2a2: 08 95 ret + +000002a4 <CheckACMStatus>: + +void CheckACMStatus() +{ + 2a4: cf 93 push r28 + 2a6: df 93 push r29 + 2a8: 28 c0 rjmp .+80 ; 0x2fa <CheckACMStatus+0x56> + static uint8_t len = 0; + + int c; + while((c = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface)) > 0) + { + putc(c, &USBSerialStream); + 2aa: ce 01 movw r24, r28 + 2ac: 6a ef ldi r22, 0xFA ; 250 + 2ae: 71 e0 ldi r23, 0x01 ; 1 + 2b0: 9d d5 rcall .+2874 ; 0xdec <fputc> + + if (c == '\r') + 2b2: cd 30 cpi r28, 0x0D ; 13 + 2b4: d1 05 cpc r29, r1 + 2b6: 99 f4 brne .+38 ; 0x2de <CheckACMStatus+0x3a> + { + putc('\n', &USBSerialStream); + 2b8: 8a e0 ldi r24, 0x0A ; 10 + 2ba: 90 e0 ldi r25, 0x00 ; 0 + 2bc: 6a ef ldi r22, 0xFA ; 250 + 2be: 71 e0 ldi r23, 0x01 ; 1 + 2c0: 95 d5 rcall .+2858 ; 0xdec <fputc> + buf[len++] = '\0'; + 2c2: 80 91 d9 01 lds r24, 0x01D9 + 2c6: e8 2f mov r30, r24 + 2c8: f0 e0 ldi r31, 0x00 ; 0 + 2ca: e6 52 subi r30, 0x26 ; 38 + 2cc: fe 4f sbci r31, 0xFE ; 254 + 2ce: 10 82 st Z, r1 + 2d0: 8f 5f subi r24, 0xFF ; 255 + 2d2: 80 93 d9 01 sts 0x01D9, r24 + handle_command(buf); + 2d6: 8a ed ldi r24, 0xDA ; 218 + 2d8: 91 e0 ldi r25, 0x01 ; 1 + 2da: 80 df rcall .-256 ; 0x1dc <handle_command> + 2dc: 0c c0 rjmp .+24 ; 0x2f6 <CheckACMStatus+0x52> + len = 0; + continue; + } + + buf[len++] = c; + 2de: 80 91 d9 01 lds r24, 0x01D9 + 2e2: e8 2f mov r30, r24 + 2e4: f0 e0 ldi r31, 0x00 ; 0 + 2e6: e6 52 subi r30, 0x26 ; 38 + 2e8: fe 4f sbci r31, 0xFE ; 254 + 2ea: c0 83 st Z, r28 + 2ec: 8f 5f subi r24, 0xFF ; 255 + 2ee: 80 93 d9 01 sts 0x01D9, r24 + + if (len == sizeof(buf)) + 2f2: 80 32 cpi r24, 0x20 ; 32 + 2f4: 11 f4 brne .+4 ; 0x2fa <CheckACMStatus+0x56> + { + len = 0; + 2f6: 10 92 d9 01 sts 0x01D9, r1 +{ + static char buf[32]; + static uint8_t len = 0; + + int c; + while((c = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface)) > 0) + 2fa: 80 ec ldi r24, 0xC0 ; 192 + 2fc: 91 e0 ldi r25, 0x01 ; 1 + 2fe: fc d3 rcall .+2040 ; 0xaf8 <CDC_Device_ReceiveByte> + 300: ec 01 movw r28, r24 + 302: 18 16 cp r1, r24 + 304: 19 06 cpc r1, r25 + 306: 8c f2 brlt .-94 ; 0x2aa <CheckACMStatus+0x6> + { + len = 0; + continue; + } + } +} + 308: df 91 pop r29 + 30a: cf 91 pop r28 + 30c: 08 95 ret + +0000030e <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) +{ + 30e: cf 93 push r28 + 310: df 93 push r29 + DDRB = 1 << PB0 | 1 << PB4 | 0 << PB5; + 312: 81 e1 ldi r24, 0x11 ; 17 + 314: 84 b9 out 0x04, r24 ; 4 + PORTB = 0 << PB0; + 316: 15 b8 out 0x05, r1 ; 5 + + SetupHardware(); + 318: 49 df rcall .-366 ; 0x1ac <SetupHardware> + + lock_timer_setup(); + 31a: 10 df rcall .-480 ; 0x13c <lock_timer_setup> + + /* Create a regular character stream for the interface so that it can be used with the stdio.h functions */ + CDC_Device_CreateStream(&VirtualSerial_CDC_Interface, &USBSerialStream); + 31c: 80 ec ldi r24, 0xC0 ; 192 + 31e: 91 e0 ldi r25, 0x01 ; 1 + 320: 6a ef ldi r22, 0xFA ; 250 + 322: 71 e0 ldi r23, 0x01 ; 1 + 324: 16 d4 rcall .+2092 ; 0xb52 <CDC_Device_CreateStream> + +// LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY); + sei(); + 326: 78 94 sei + milliseconds can be achieved. + */ +void +_delay_loop_2(uint16_t __count) +{ + __asm__ volatile ( + 328: c0 e9 ldi r28, 0x90 ; 144 + 32a: d1 e0 ldi r29, 0x01 ; 1 + 32c: 0d c0 rjmp .+26 ; 0x348 <main+0x3a> + + while(running) + { + wdt_reset(); + 32e: a8 95 wdr + 330: 84 ec ldi r24, 0xC4 ; 196 + 332: 99 e0 ldi r25, 0x09 ; 9 + 334: fe 01 movw r30, r28 + 336: 31 97 sbiw r30, 0x01 ; 1 + 338: f1 f7 brne .-4 ; 0x336 <main+0x28> + __ticks = (uint16_t) (__ms * 10.0); + while(__ticks) + { + // wait 1/10 ms + _delay_loop_2(((F_CPU) / 4e3) / 10); + __ticks --; + 33a: 01 97 sbiw r24, 0x01 ; 1 + __ticks = 1; + else if (__tmp > 65535) + { + // __ticks = requested delay in 1/10 ms + __ticks = (uint16_t) (__ms * 10.0); + while(__ticks) + 33c: d9 f7 brne .-10 ; 0x334 <main+0x26> + _delay_ms(250); +// PORTB ^= 1 << PB0; // Toggle external LED + +// CheckPinStatus(); + + CheckACMStatus(); + 33e: b2 df rcall .-156 ; 0x2a4 <CheckACMStatus> + + CDC_Device_USBTask(&VirtualSerial_CDC_Interface); + 340: 80 ec ldi r24, 0xC0 ; 192 + 342: 91 e0 ldi r25, 0x01 ; 1 + 344: 50 d4 rcall .+2208 ; 0xbe6 <CDC_Device_USBTask> + USB_USBTask(); + 346: c4 d3 rcall .+1928 ; 0xad0 <USB_USBTask> + CDC_Device_CreateStream(&VirtualSerial_CDC_Interface, &USBSerialStream); + +// LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY); + sei(); + + while(running) + 348: 80 91 d6 01 lds r24, 0x01D6 + 34c: 90 91 d7 01 lds r25, 0x01D7 + 350: 89 2b or r24, r25 + 352: 69 f7 brne .-38 ; 0x32e <main+0x20> + * enumerating the device once attached until \ref USB_Attach() is called. + */ + static inline void USB_Detach(void) ATTR_ALWAYS_INLINE; + static inline void USB_Detach(void) + { + UDCON |= (1 << DETACH); + 354: 80 91 e0 00 lds r24, 0x00E0 + 358: 81 60 ori r24, 0x01 ; 1 + 35a: 80 93 e0 00 sts 0x00E0, r24 + } + + USB_Detach(); + + /* Enable the watchdog and force a timeout to reset the AVR */ + wdt_enable(WDTO_250MS); + 35e: 2c e0 ldi r18, 0x0C ; 12 + 360: 88 e1 ldi r24, 0x18 ; 24 + 362: 90 e0 ldi r25, 0x00 ; 0 + 364: 0f b6 in r0, 0x3f ; 63 + 366: f8 94 cli + 368: a8 95 wdr + 36a: 80 93 60 00 sts 0x0060, r24 + 36e: 0f be out 0x3f, r0 ; 63 + 370: 20 93 60 00 sts 0x0060, r18 + 374: ff cf rjmp .-2 ; 0x374 <main+0x66> + +00000376 <CALLBACK_USB_GetDescriptor>: + * USB host. + */ +uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue, + const uint8_t wIndex, + const void** const DescriptorAddress) +{ + 376: da 01 movw r26, r20 + const uint8_t DescriptorNumber = (wValue & 0xFF); + + const void* Address = NULL; + uint16_t Size = NO_DESCRIPTOR; + + switch (DescriptorType) + 378: 92 30 cpi r25, 0x02 ; 2 + 37a: 49 f0 breq .+18 ; 0x38e <CALLBACK_USB_GetDescriptor+0x18> + 37c: 93 30 cpi r25, 0x03 ; 3 + 37e: 61 f0 breq .+24 ; 0x398 <CALLBACK_USB_GetDescriptor+0x22> + 380: 91 30 cpi r25, 0x01 ; 1 + 382: f9 f4 brne .+62 ; 0x3c2 <CALLBACK_USB_GetDescriptor+0x4c> + 384: e4 e7 ldi r30, 0x74 ; 116 + 386: f0 e0 ldi r31, 0x00 ; 0 + 388: 22 e1 ldi r18, 0x12 ; 18 + 38a: 30 e0 ldi r19, 0x00 ; 0 + 38c: 1e c0 rjmp .+60 ; 0x3ca <CALLBACK_USB_GetDescriptor+0x54> + 38e: e6 e8 ldi r30, 0x86 ; 134 + 390: f0 e0 ldi r31, 0x00 ; 0 + 392: 2e e3 ldi r18, 0x3E ; 62 + 394: 30 e0 ldi r19, 0x00 ; 0 + 396: 19 c0 rjmp .+50 ; 0x3ca <CALLBACK_USB_GetDescriptor+0x54> + case DTYPE_Configuration: + Address = &ConfigurationDescriptor; + Size = sizeof(USB_Descriptor_Configuration_t); + break; + case DTYPE_String: + switch (DescriptorNumber) + 398: 81 30 cpi r24, 0x01 ; 1 + 39a: 49 f0 breq .+18 ; 0x3ae <CALLBACK_USB_GetDescriptor+0x38> + 39c: 81 30 cpi r24, 0x01 ; 1 + 39e: 18 f0 brcs .+6 ; 0x3a6 <CALLBACK_USB_GetDescriptor+0x30> + 3a0: 82 30 cpi r24, 0x02 ; 2 + 3a2: 79 f4 brne .+30 ; 0x3c2 <CALLBACK_USB_GetDescriptor+0x4c> + 3a4: 08 c0 rjmp .+16 ; 0x3b6 <CALLBACK_USB_GetDescriptor+0x40> + { + case 0x00: + Address = &LanguageString; + Size = pgm_read_byte(&LanguageString.Header.Size); + 3a6: e4 ec ldi r30, 0xC4 ; 196 + 3a8: f0 e0 ldi r31, 0x00 ; 0 + 3aa: 84 91 lpm r24, Z+ + 3ac: 07 c0 rjmp .+14 ; 0x3bc <CALLBACK_USB_GetDescriptor+0x46> + break; + case 0x01: + Address = &ManufacturerString; + Size = pgm_read_byte(&ManufacturerString.Header.Size); + 3ae: e8 ec ldi r30, 0xC8 ; 200 + 3b0: f0 e0 ldi r31, 0x00 ; 0 + 3b2: 84 91 lpm r24, Z+ + 3b4: 03 c0 rjmp .+6 ; 0x3bc <CALLBACK_USB_GetDescriptor+0x46> + break; + case 0x02: + Address = &ProductString; + Size = pgm_read_byte(&ProductString.Header.Size); + 3b6: ee ed ldi r30, 0xDE ; 222 + 3b8: f0 e0 ldi r31, 0x00 ; 0 + 3ba: 84 91 lpm r24, Z+ + 3bc: 28 2f mov r18, r24 + 3be: 30 e0 ldi r19, 0x00 ; 0 + 3c0: 04 c0 rjmp .+8 ; 0x3ca <CALLBACK_USB_GetDescriptor+0x54> + 3c2: e0 e0 ldi r30, 0x00 ; 0 + 3c4: f0 e0 ldi r31, 0x00 ; 0 + 3c6: 20 e0 ldi r18, 0x00 ; 0 + 3c8: 30 e0 ldi r19, 0x00 ; 0 + } + + break; + } + + *DescriptorAddress = Address; + 3ca: ed 93 st X+, r30 + 3cc: fc 93 st X, r31 + return Size; +} + 3ce: c9 01 movw r24, r18 + 3d0: 08 95 ret + +000003d2 <Endpoint_ConfigureEndpoint_Prv>: + */ + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) ATTR_ALWAYS_INLINE; + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) + { + #if !defined(CONTROL_ONLY_DEVICE) + UENUM = EndpointNumber; + 3d2: 80 93 e9 00 sts 0x00E9, r24 + * \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); + 3d6: 80 91 eb 00 lds r24, 0x00EB + 3da: 81 60 ori r24, 0x01 ; 1 + 3dc: 80 93 eb 00 sts 0x00EB, r24 + const uint8_t UECFG1XData) +{ + Endpoint_SelectEndpoint(Number); + Endpoint_EnableEndpoint(); + + UECFG1X = 0; + 3e0: 10 92 ed 00 sts 0x00ED, r1 + UECFG0X = UECFG0XData; + 3e4: 60 93 ec 00 sts 0x00EC, r22 + UECFG1X = UECFG1XData; + 3e8: 40 93 ed 00 sts 0x00ED, r20 + * \return Boolean true if the currently selected endpoint has been configured, 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); + 3ec: 80 91 ee 00 lds r24, 0x00EE + + return Endpoint_IsConfigured(); +} + 3f0: 88 1f adc r24, r24 + 3f2: 88 27 eor r24, r24 + 3f4: 88 1f adc r24, r24 + 3f6: 08 95 ret + +000003f8 <Endpoint_ClearStatusStage>: + } +} + +void Endpoint_ClearStatusStage(void) +{ + if (USB_ControlRequest.bmRequestType & REQDIR_DEVICETOHOST) + 3f8: 80 91 0e 02 lds r24, 0x020E + 3fc: 88 23 and r24, r24 + 3fe: 9c f4 brge .+38 ; 0x426 <Endpoint_ClearStatusStage+0x2e> + 400: 04 c0 rjmp .+8 ; 0x40a <Endpoint_ClearStatusStage+0x12> + { + while (!(Endpoint_IsOUTReceived())) + { + if (USB_DeviceState == DEVICE_STATE_Unattached) + 402: 80 91 0d 02 lds r24, 0x020D + 406: 88 23 and r24, r24 + 408: b9 f0 breq .+46 ; 0x438 <Endpoint_ClearStatusStage+0x40> + * \return Boolean true if current endpoint is has received an OUT packet, 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); + 40a: 80 91 e8 00 lds r24, 0x00E8 + +void Endpoint_ClearStatusStage(void) +{ + if (USB_ControlRequest.bmRequestType & REQDIR_DEVICETOHOST) + { + while (!(Endpoint_IsOUTReceived())) + 40e: 82 ff sbrs r24, 2 + 410: f8 cf rjmp .-16 ; 0x402 <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)); + 412: 80 91 e8 00 lds r24, 0x00E8 + 416: 8b 77 andi r24, 0x7B ; 123 + 418: 80 93 e8 00 sts 0x00E8, r24 + 41c: 08 95 ret + } + else + { + while (!(Endpoint_IsINReady())) + { + if (USB_DeviceState == DEVICE_STATE_Unattached) + 41e: 80 91 0d 02 lds r24, 0x020D + 422: 88 23 and r24, r24 + 424: 49 f0 breq .+18 ; 0x438 <Endpoint_ClearStatusStage+0x40> + * \return Boolean true if the current endpoint is ready for an IN packet, 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); + 426: 80 91 e8 00 lds r24, 0x00E8 + + Endpoint_ClearOUT(); + } + else + { + while (!(Endpoint_IsINReady())) + 42a: 80 ff sbrs r24, 0 + 42c: f8 cf rjmp .-16 ; 0x41e <Endpoint_ClearStatusStage+0x26> + */ + 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)); + 42e: 80 91 e8 00 lds r24, 0x00E8 + 432: 8e 77 andi r24, 0x7E ; 126 + 434: 80 93 e8 00 sts 0x00E8, r24 + 438: 08 95 ret + +0000043a <Endpoint_WaitUntilReady>: + /** Returns the current USB frame number, when in device mode. Every millisecond the USB bus is active (i.e. enumerated to a host) + * the frame number is incremented by one. + */ + static inline uint16_t USB_Device_GetFrameNumber(void) + { + return UDFNUM; + 43a: 40 91 e4 00 lds r20, 0x00E4 + 43e: 50 91 e5 00 lds r21, 0x00E5 + 442: 24 e6 ldi r18, 0x64 ; 100 + * \return The currently selected endpoint's direction, as a 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 & ENDPOINT_DIR_IN); + 444: 80 91 ec 00 lds r24, 0x00EC + + uint16_t PreviousFrameNumber = USB_Device_GetFrameNumber(); + + for (;;) + { + if (Endpoint_GetEndpointDirection() == ENDPOINT_DIR_IN) + 448: 80 ff sbrs r24, 0 + 44a: 05 c0 rjmp .+10 ; 0x456 <Endpoint_WaitUntilReady+0x1c> + * \return Boolean true if the current endpoint is ready for an IN packet, 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); + 44c: 80 91 e8 00 lds r24, 0x00E8 + { + if (Endpoint_IsINReady()) + 450: 80 ff sbrs r24, 0 + 452: 05 c0 rjmp .+10 ; 0x45e <Endpoint_WaitUntilReady+0x24> + 454: 22 c0 rjmp .+68 ; 0x49a <Endpoint_WaitUntilReady+0x60> + * \return Boolean true if current endpoint is has received an OUT packet, 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); + 456: 80 91 e8 00 lds r24, 0x00E8 + return ENDPOINT_READYWAIT_NoError; + } + else + { + if (Endpoint_IsOUTReceived()) + 45a: 82 fd sbrc r24, 2 + 45c: 1e c0 rjmp .+60 ; 0x49a <Endpoint_WaitUntilReady+0x60> + return ENDPOINT_READYWAIT_NoError; + } + + uint8_t USB_DeviceState_LCL = USB_DeviceState; + 45e: 80 91 0d 02 lds r24, 0x020D + + if (USB_DeviceState_LCL == DEVICE_STATE_Unattached) + 462: 88 23 and r24, r24 + 464: 11 f4 brne .+4 ; 0x46a <Endpoint_WaitUntilReady+0x30> + 466: 82 e0 ldi r24, 0x02 ; 2 + 468: 08 95 ret + return ENDPOINT_READYWAIT_DeviceDisconnected; + else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended) + 46a: 85 30 cpi r24, 0x05 ; 5 + 46c: 11 f4 brne .+4 ; 0x472 <Endpoint_WaitUntilReady+0x38> + 46e: 83 e0 ldi r24, 0x03 ; 3 + 470: 08 95 ret + * \return Boolean true if the currently selected endpoint is stalled, 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); + 472: 80 91 eb 00 lds r24, 0x00EB + return ENDPOINT_READYWAIT_BusSuspended; + else if (Endpoint_IsStalled()) + 476: 85 ff sbrs r24, 5 + 478: 02 c0 rjmp .+4 ; 0x47e <Endpoint_WaitUntilReady+0x44> + 47a: 81 e0 ldi r24, 0x01 ; 1 + 47c: 08 95 ret + 47e: 80 91 e4 00 lds r24, 0x00E4 + 482: 90 91 e5 00 lds r25, 0x00E5 + return ENDPOINT_READYWAIT_EndpointStalled; + + uint16_t CurrentFrameNumber = USB_Device_GetFrameNumber(); + + if (CurrentFrameNumber != PreviousFrameNumber) + 486: 84 17 cp r24, r20 + 488: 95 07 cpc r25, r21 + 48a: e1 f2 breq .-72 ; 0x444 <Endpoint_WaitUntilReady+0xa> + { + PreviousFrameNumber = CurrentFrameNumber; + + if (!(TimeoutMSRem--)) + 48c: 22 23 and r18, r18 + 48e: 11 f4 brne .+4 ; 0x494 <Endpoint_WaitUntilReady+0x5a> + 490: 84 e0 ldi r24, 0x04 ; 4 + 492: 08 95 ret + 494: 21 50 subi r18, 0x01 ; 1 + 496: ac 01 movw r20, r24 + 498: d5 cf rjmp .-86 ; 0x444 <Endpoint_WaitUntilReady+0xa> + 49a: 80 e0 ldi r24, 0x00 ; 0 + return ENDPOINT_READYWAIT_Timeout; + } + } +} + 49c: 08 95 ret + +0000049e <USB_ResetInterface>: +{ + #if defined(USB_CAN_BE_BOTH) + bool UIDModeSelectEnabled = ((UHWCON & (1 << UIDE)) != 0); + #endif + + USB_INT_DisableAllInterrupts(); + 49e: 41 d0 rcall .+130 ; 0x522 <USB_INT_DisableAllInterrupts> + USB_INT_ClearAllInterrupts(); + 4a0: 43 d0 rcall .+134 ; 0x528 <USB_INT_ClearAllInterrupts> + } + + static inline void USB_Controller_Reset(void) ATTR_ALWAYS_INLINE; + static inline void USB_Controller_Reset(void) + { + const uint8_t Temp = USBCON; + 4a2: 80 91 d8 00 lds r24, 0x00D8 + + USBCON = (Temp & ~(1 << USBE)); + 4a6: 98 2f mov r25, r24 + 4a8: 9f 77 andi r25, 0x7F ; 127 + 4aa: 90 93 d8 00 sts 0x00D8, r25 + USBCON = (Temp | (1 << USBE)); + 4ae: 80 68 ori r24, 0x80 ; 128 + 4b0: 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; + 4b4: 84 e0 ldi r24, 0x04 ; 4 + 4b6: 89 bd out 0x29, r24 ; 41 + PLLCSR |= (1 << PLLE); + 4b8: 89 b5 in r24, 0x29 ; 41 + 4ba: 82 60 ori r24, 0x02 ; 2 + 4bc: 89 bd out 0x29, r24 ; 41 + #if defined(USB_SERIES_4_AVR) + PLLFRQ = ((1 << PLLUSB) | (1 << PDIV3) | (1 << PDIV1)); + #endif + + USB_PLL_On(); + while (!(USB_PLL_IsReady())); + 4be: 09 b4 in r0, 0x29 ; 41 + 4c0: 00 fe sbrs r0, 0 + 4c2: fd cf rjmp .-6 ; 0x4be <USB_ResetInterface+0x20> + } + + static inline void USB_CLK_Unfreeze(void) ATTR_ALWAYS_INLINE; + static inline void USB_CLK_Unfreeze(void) + { + USBCON &= ~(1 << FRZCLK); + 4c4: 80 91 d8 00 lds r24, 0x00D8 + 4c8: 8f 7d andi r24, 0xDF ; 223 + 4ca: 80 93 d8 00 sts 0x00D8, r24 +} + +#if defined(USB_CAN_BE_DEVICE) +static void USB_Init_Device(void) +{ + USB_DeviceState = DEVICE_STATE_Unattached; + 4ce: 10 92 0d 02 sts 0x020D, r1 + USB_ConfigurationNumber = 0; + 4d2: 10 92 0b 02 sts 0x020B, r1 + + #if !defined(NO_DEVICE_REMOTE_WAKEUP) + USB_RemoteWakeupEnabled = false; + 4d6: 10 92 0a 02 sts 0x020A, r1 + #endif + + #if !defined(NO_DEVICE_SELF_POWER) + USB_CurrentlySelfPowered = false; + 4da: 10 92 09 02 sts 0x0209, r1 + const uint8_t Type, + const uint8_t Direction, + const uint16_t Size, + const uint8_t Banks) + { + return Endpoint_ConfigureEndpoint_Prv(Number, (((Type) << EPTYPE0) | (Direction)), + 4de: 80 e0 ldi r24, 0x00 ; 0 + 4e0: 60 e0 ldi r22, 0x00 ; 0 + 4e2: 42 e0 ldi r20, 0x02 ; 2 + 4e4: 76 df rcall .-276 ; 0x3d2 <Endpoint_ConfigureEndpoint_Prv> + + Endpoint_ConfigureEndpoint(ENDPOINT_CONTROLEP, EP_TYPE_CONTROL, + ENDPOINT_DIR_OUT, USB_ControlEndpointSize, + ENDPOINT_BANK_SINGLE); + + USB_INT_Clear(USB_INT_SUSPI); + 4e6: 80 91 e1 00 lds r24, 0x00E1 + 4ea: 8e 7f andi r24, 0xFE ; 254 + 4ec: 80 93 e1 00 sts 0x00E1, r24 + USB_INT_Enable(USB_INT_SUSPI); + 4f0: 80 91 e2 00 lds r24, 0x00E2 + 4f4: 81 60 ori r24, 0x01 ; 1 + 4f6: 80 93 e2 00 sts 0x00E2, r24 + USB_INT_Enable(USB_INT_EORSTI); + 4fa: 80 91 e2 00 lds r24, 0x00E2 + 4fe: 88 60 ori r24, 0x08 ; 8 + 500: 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); + 504: 80 91 e0 00 lds r24, 0x00E0 + 508: 8e 7f andi r24, 0xFE ; 254 + 50a: 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 +} + 50e: 08 95 ret + +00000510 <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); + 510: e3 e6 ldi r30, 0x63 ; 99 + 512: f0 e0 ldi r31, 0x00 ; 0 + 514: 80 81 ld r24, Z + 516: 8e 7f andi r24, 0xFE ; 254 + 518: 80 83 st Z, r24 + { + USB_CurrentMode = Mode; + } + #endif + + USB_IsInitialized = true; + 51a: 81 e0 ldi r24, 0x01 ; 1 + 51c: 80 93 0c 02 sts 0x020C, r24 + + USB_ResetInterface(); +} + 520: be cf rjmp .-132 ; 0x49e <USB_ResetInterface> + +00000522 <USB_INT_DisableAllInterrupts>: + #if defined(USB_CAN_BE_HOST) + UHIEN = 0; + #endif + + #if defined(USB_CAN_BE_DEVICE) + UDIEN = 0; + 522: 10 92 e2 00 sts 0x00E2, r1 + #endif +} + 526: 08 95 ret + +00000528 <USB_INT_ClearAllInterrupts>: + #if defined(USB_CAN_BE_HOST) + UHINT = 0; + #endif + + #if defined(USB_CAN_BE_DEVICE) + UDINT = 0; + 528: 10 92 e1 00 sts 0x00E1, r1 + #endif +} + 52c: 08 95 ret + +0000052e <__vector_11>: + +ISR(USB_GEN_vect, ISR_BLOCK) +{ + 52e: 1f 92 push r1 + 530: 0f 92 push r0 + 532: 0f b6 in r0, 0x3f ; 63 + 534: 0f 92 push r0 + 536: 11 24 eor r1, r1 + 538: 2f 93 push r18 + 53a: 3f 93 push r19 + 53c: 4f 93 push r20 + 53e: 5f 93 push r21 + 540: 6f 93 push r22 + 542: 7f 93 push r23 + 544: 8f 93 push r24 + 546: 9f 93 push r25 + 548: af 93 push r26 + 54a: bf 93 push r27 + 54c: ef 93 push r30 + 54e: ff 93 push r31 + EVENT_USB_Device_Disconnect(); + } + } + #endif + + if (USB_INT_HasOccurred(USB_INT_SUSPI) && USB_INT_IsEnabled(USB_INT_SUSPI)) + 550: 80 91 e1 00 lds r24, 0x00E1 + 554: 80 ff sbrs r24, 0 + 556: 1c c0 rjmp .+56 ; 0x590 <__vector_11+0x62> + 558: 80 91 e2 00 lds r24, 0x00E2 + 55c: 80 ff sbrs r24, 0 + 55e: 18 c0 rjmp .+48 ; 0x590 <__vector_11+0x62> + { + USB_INT_Clear(USB_INT_SUSPI); + 560: 80 91 e1 00 lds r24, 0x00E1 + 564: 8e 7f andi r24, 0xFE ; 254 + 566: 80 93 e1 00 sts 0x00E1, r24 + + USB_INT_Disable(USB_INT_SUSPI); + 56a: 80 91 e2 00 lds r24, 0x00E2 + 56e: 8e 7f andi r24, 0xFE ; 254 + 570: 80 93 e2 00 sts 0x00E2, r24 + USB_INT_Enable(USB_INT_WAKEUPI); + 574: 80 91 e2 00 lds r24, 0x00E2 + 578: 80 61 ori r24, 0x10 ; 16 + 57a: 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); + 57e: 80 91 d8 00 lds r24, 0x00D8 + 582: 80 62 ori r24, 0x20 ; 32 + 584: 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; + 588: 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; + 58a: 10 92 0d 02 sts 0x020D, r1 + EVENT_USB_Device_Disconnect(); + 58e: e9 dd rcall .-1070 ; 0x162 <EVENT_USB_Device_Disconnect> + USB_DeviceState = DEVICE_STATE_Suspended; + EVENT_USB_Device_Suspend(); + #endif + } + + if (USB_INT_HasOccurred(USB_INT_WAKEUPI) && USB_INT_IsEnabled(USB_INT_WAKEUPI)) + 590: 80 91 e1 00 lds r24, 0x00E1 + 594: 84 ff sbrs r24, 4 + 596: 2e c0 rjmp .+92 ; 0x5f4 <__vector_11+0xc6> + 598: 80 91 e2 00 lds r24, 0x00E2 + 59c: 84 ff sbrs r24, 4 + 59e: 2a c0 rjmp .+84 ; 0x5f4 <__vector_11+0xc6> + + /* Inline Functions: */ + static inline void USB_PLL_On(void) ATTR_ALWAYS_INLINE; + static inline void USB_PLL_On(void) + { + PLLCSR = USB_PLL_PSC; + 5a0: 84 e0 ldi r24, 0x04 ; 4 + 5a2: 89 bd out 0x29, r24 ; 41 + PLLCSR |= (1 << PLLE); + 5a4: 89 b5 in r24, 0x29 ; 41 + 5a6: 82 60 ori r24, 0x02 ; 2 + 5a8: 89 bd out 0x29, r24 ; 41 + { + if (!(USB_Options & USB_OPT_MANUAL_PLL)) + { + USB_PLL_On(); + while (!(USB_PLL_IsReady())); + 5aa: 09 b4 in r0, 0x29 ; 41 + 5ac: 00 fe sbrs r0, 0 + 5ae: fd cf rjmp .-6 ; 0x5aa <__vector_11+0x7c> + } + + static inline void USB_CLK_Unfreeze(void) ATTR_ALWAYS_INLINE; + static inline void USB_CLK_Unfreeze(void) + { + USBCON &= ~(1 << FRZCLK); + 5b0: 80 91 d8 00 lds r24, 0x00D8 + 5b4: 8f 7d andi r24, 0xDF ; 223 + 5b6: 80 93 d8 00 sts 0x00D8, r24 + } + + USB_CLK_Unfreeze(); + + USB_INT_Clear(USB_INT_WAKEUPI); + 5ba: 80 91 e1 00 lds r24, 0x00E1 + 5be: 8f 7e andi r24, 0xEF ; 239 + 5c0: 80 93 e1 00 sts 0x00E1, r24 + + USB_INT_Disable(USB_INT_WAKEUPI); + 5c4: 80 91 e2 00 lds r24, 0x00E2 + 5c8: 8f 7e andi r24, 0xEF ; 239 + 5ca: 80 93 e2 00 sts 0x00E2, r24 + USB_INT_Enable(USB_INT_SUSPI); + 5ce: 80 91 e2 00 lds r24, 0x00E2 + 5d2: 81 60 ori r24, 0x01 ; 1 + 5d4: 80 93 e2 00 sts 0x00E2, r24 + + if (USB_ConfigurationNumber) + 5d8: 80 91 0b 02 lds r24, 0x020B + 5dc: 88 23 and r24, r24 + 5de: 31 f4 brne .+12 ; 0x5ec <__vector_11+0xbe> + } + + static inline bool USB_Device_IsAddressSet(void) ATTR_ALWAYS_INLINE; + static inline bool USB_Device_IsAddressSet(void) + { + return (UDADDR & (1 << ADDEN)); + 5e0: 80 91 e3 00 lds r24, 0x00E3 + USB_DeviceState = DEVICE_STATE_Configured; + else + USB_DeviceState = (USB_Device_IsAddressSet()) ? DEVICE_STATE_Configured : DEVICE_STATE_Powered; + 5e4: 87 fd sbrc r24, 7 + 5e6: 02 c0 rjmp .+4 ; 0x5ec <__vector_11+0xbe> + 5e8: 81 e0 ldi r24, 0x01 ; 1 + 5ea: 01 c0 rjmp .+2 ; 0x5ee <__vector_11+0xc0> + 5ec: 84 e0 ldi r24, 0x04 ; 4 + 5ee: 80 93 0d 02 sts 0x020D, r24 + + #if defined(USB_SERIES_2_AVR) && !defined(NO_LIMITED_CONTROLLER_CONNECT) + EVENT_USB_Device_Connect(); + 5f2: b6 dd rcall .-1172 ; 0x160 <EVENT_USB_Device_Connect> + #else + EVENT_USB_Device_WakeUp(); + #endif + } + + if (USB_INT_HasOccurred(USB_INT_EORSTI) && USB_INT_IsEnabled(USB_INT_EORSTI)) + 5f4: 80 91 e1 00 lds r24, 0x00E1 + 5f8: 83 ff sbrs r24, 3 + 5fa: 22 c0 rjmp .+68 ; 0x640 <__vector_11+0x112> + 5fc: 80 91 e2 00 lds r24, 0x00E2 + 600: 83 ff sbrs r24, 3 + 602: 1e c0 rjmp .+60 ; 0x640 <__vector_11+0x112> + { + USB_INT_Clear(USB_INT_EORSTI); + 604: 80 91 e1 00 lds r24, 0x00E1 + 608: 87 7f andi r24, 0xF7 ; 247 + 60a: 80 93 e1 00 sts 0x00E1, r24 + + USB_DeviceState = DEVICE_STATE_Default; + 60e: 82 e0 ldi r24, 0x02 ; 2 + 610: 80 93 0d 02 sts 0x020D, r24 + USB_ConfigurationNumber = 0; + 614: 10 92 0b 02 sts 0x020B, r1 + + USB_INT_Clear(USB_INT_SUSPI); + 618: 80 91 e1 00 lds r24, 0x00E1 + 61c: 8e 7f andi r24, 0xFE ; 254 + 61e: 80 93 e1 00 sts 0x00E1, r24 + USB_INT_Disable(USB_INT_SUSPI); + 622: 80 91 e2 00 lds r24, 0x00E2 + 626: 8e 7f andi r24, 0xFE ; 254 + 628: 80 93 e2 00 sts 0x00E2, r24 + USB_INT_Enable(USB_INT_WAKEUPI); + 62c: 80 91 e2 00 lds r24, 0x00E2 + 630: 80 61 ori r24, 0x10 ; 16 + 632: 80 93 e2 00 sts 0x00E2, r24 + 636: 80 e0 ldi r24, 0x00 ; 0 + 638: 60 e0 ldi r22, 0x00 ; 0 + 63a: 42 e0 ldi r20, 0x02 ; 2 + 63c: ca de rcall .-620 ; 0x3d2 <Endpoint_ConfigureEndpoint_Prv> + + #if defined(INTERRUPT_CONTROL_ENDPOINT) + USB_INT_Enable(USB_INT_RXSTPI); + #endif + + EVENT_USB_Device_Reset(); + 63e: 4b d1 rcall .+662 ; 0x8d6 <USB_Event_Stub> + } + + #if !defined(NO_SOF_EVENTS) + if (USB_INT_HasOccurred(USB_INT_SOFI) && USB_INT_IsEnabled(USB_INT_SOFI)) + 640: 80 91 e1 00 lds r24, 0x00E1 + 644: 82 ff sbrs r24, 2 + 646: 0a c0 rjmp .+20 ; 0x65c <__vector_11+0x12e> + 648: 80 91 e2 00 lds r24, 0x00E2 + 64c: 82 ff sbrs r24, 2 + 64e: 06 c0 rjmp .+12 ; 0x65c <__vector_11+0x12e> + { + USB_INT_Clear(USB_INT_SOFI); + 650: 80 91 e1 00 lds r24, 0x00E1 + 654: 8b 7f andi r24, 0xFB ; 251 + 656: 80 93 e1 00 sts 0x00E1, r24 + + EVENT_USB_Device_StartOfFrame(); + 65a: 3d d1 rcall .+634 ; 0x8d6 <USB_Event_Stub> + USB_ResetInterface(); + + EVENT_USB_UIDChange(); + } + #endif +} + 65c: ff 91 pop r31 + 65e: ef 91 pop r30 + 660: bf 91 pop r27 + 662: af 91 pop r26 + 664: 9f 91 pop r25 + 666: 8f 91 pop r24 + 668: 7f 91 pop r23 + 66a: 6f 91 pop r22 + 66c: 5f 91 pop r21 + 66e: 4f 91 pop r20 + 670: 3f 91 pop r19 + 672: 2f 91 pop r18 + 674: 0f 90 pop r0 + 676: 0f be out 0x3f, r0 ; 63 + 678: 0f 90 pop r0 + 67a: 1f 90 pop r1 + 67c: 18 95 reti + +0000067e <USB_Device_ProcessControlRequest>: +#if !defined(NO_DEVICE_REMOTE_WAKEUP) +bool USB_RemoteWakeupEnabled; +#endif + +void USB_Device_ProcessControlRequest(void) +{ + 67e: 0f 93 push r16 + 680: 1f 93 push r17 + 682: df 93 push r29 + 684: cf 93 push r28 + 686: 00 d0 rcall .+0 ; 0x688 <USB_Device_ProcessControlRequest+0xa> + 688: cd b7 in r28, 0x3d ; 61 + 68a: de b7 in r29, 0x3e ; 62 + 68c: ee e0 ldi r30, 0x0E ; 14 + 68e: f2 e0 ldi r31, 0x02 ; 2 + * \return Next byte in the currently selected endpoint's FIFO buffer. + */ + static inline uint8_t Endpoint_Read_Byte(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; + static inline uint8_t Endpoint_Read_Byte(void) + { + return UEDATX; + 690: 80 91 f1 00 lds r24, 0x00F1 + uint8_t* RequestHeader = (uint8_t*)&USB_ControlRequest; + + for (uint8_t RequestHeaderByte = 0; RequestHeaderByte < sizeof(USB_Request_Header_t); RequestHeaderByte++) + *(RequestHeader++) = Endpoint_Read_Byte(); + 694: 81 93 st Z+, r24 + +void USB_Device_ProcessControlRequest(void) +{ + uint8_t* RequestHeader = (uint8_t*)&USB_ControlRequest; + + for (uint8_t RequestHeaderByte = 0; RequestHeaderByte < sizeof(USB_Request_Header_t); RequestHeaderByte++) + 696: 82 e0 ldi r24, 0x02 ; 2 + 698: e6 31 cpi r30, 0x16 ; 22 + 69a: f8 07 cpc r31, r24 + 69c: c9 f7 brne .-14 ; 0x690 <USB_Device_ProcessControlRequest+0x12> + *(RequestHeader++) = Endpoint_Read_Byte(); + + EVENT_USB_Device_ControlRequest(); + 69e: 80 dd rcall .-1280 ; 0x1a0 <EVENT_USB_Device_ControlRequest> + * \return Boolean true if the selected endpoint has received a SETUP packet, 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); + 6a0: 80 91 e8 00 lds r24, 0x00E8 + + if (Endpoint_IsSETUPReceived()) + 6a4: 83 ff sbrs r24, 3 + 6a6: 02 c1 rjmp .+516 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> + { + uint8_t bmRequestType = USB_ControlRequest.bmRequestType; + 6a8: 80 91 0e 02 lds r24, 0x020E + + switch (USB_ControlRequest.bRequest) + 6ac: 30 91 0f 02 lds r19, 0x020F + 6b0: 35 30 cpi r19, 0x05 ; 5 + 6b2: 09 f4 brne .+2 ; 0x6b6 <USB_Device_ProcessControlRequest+0x38> + 6b4: 87 c0 rjmp .+270 ; 0x7c4 <USB_Device_ProcessControlRequest+0x146> + 6b6: 36 30 cpi r19, 0x06 ; 6 + 6b8: 40 f4 brcc .+16 ; 0x6ca <USB_Device_ProcessControlRequest+0x4c> + 6ba: 31 30 cpi r19, 0x01 ; 1 + 6bc: c9 f1 breq .+114 ; 0x730 <USB_Device_ProcessControlRequest+0xb2> + 6be: 31 30 cpi r19, 0x01 ; 1 + 6c0: 70 f0 brcs .+28 ; 0x6de <USB_Device_ProcessControlRequest+0x60> + 6c2: 33 30 cpi r19, 0x03 ; 3 + 6c4: 09 f0 breq .+2 ; 0x6c8 <USB_Device_ProcessControlRequest+0x4a> + 6c6: f2 c0 rjmp .+484 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> + 6c8: 33 c0 rjmp .+102 ; 0x730 <USB_Device_ProcessControlRequest+0xb2> + 6ca: 38 30 cpi r19, 0x08 ; 8 + 6cc: 09 f4 brne .+2 ; 0x6d0 <USB_Device_ProcessControlRequest+0x52> + 6ce: c0 c0 rjmp .+384 ; 0x850 <USB_Device_ProcessControlRequest+0x1d2> + 6d0: 39 30 cpi r19, 0x09 ; 9 + 6d2: 09 f4 brne .+2 ; 0x6d6 <USB_Device_ProcessControlRequest+0x58> + 6d4: cf c0 rjmp .+414 ; 0x874 <USB_Device_ProcessControlRequest+0x1f6> + 6d6: 36 30 cpi r19, 0x06 ; 6 + 6d8: 09 f0 breq .+2 ; 0x6dc <USB_Device_ProcessControlRequest+0x5e> + 6da: e8 c0 rjmp .+464 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> + 6dc: 99 c0 rjmp .+306 ; 0x810 <USB_Device_ProcessControlRequest+0x192> + { + case REQ_GetStatus: + if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) || + 6de: 80 38 cpi r24, 0x80 ; 128 + 6e0: 21 f0 breq .+8 ; 0x6ea <USB_Device_ProcessControlRequest+0x6c> + 6e2: 82 38 cpi r24, 0x82 ; 130 + 6e4: 09 f0 breq .+2 ; 0x6e8 <USB_Device_ProcessControlRequest+0x6a> + 6e6: e2 c0 rjmp .+452 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> + 6e8: 08 c0 rjmp .+16 ; 0x6fa <USB_Device_ProcessControlRequest+0x7c> + 6ea: 90 91 09 02 lds r25, 0x0209 + if (USB_CurrentlySelfPowered) + CurrentStatus |= FEATURE_SELFPOWERED_ENABLED; + #endif + + #if !defined(NO_DEVICE_REMOTE_WAKEUP) + if (USB_RemoteWakeupEnabled) + 6ee: 80 91 0a 02 lds r24, 0x020A + 6f2: 88 23 and r24, r24 + 6f4: 99 f0 breq .+38 ; 0x71c <USB_Device_ProcessControlRequest+0x9e> + CurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED; + 6f6: 92 60 ori r25, 0x02 ; 2 + 6f8: 11 c0 rjmp .+34 ; 0x71c <USB_Device_ProcessControlRequest+0x9e> + #endif + break; + #endif + #if !defined(CONTROL_ONLY_DEVICE) + case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT): + Endpoint_SelectEndpoint((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK); + 6fa: 80 91 12 02 lds r24, 0x0212 + 6fe: 87 70 andi r24, 0x07 ; 7 + */ + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) ATTR_ALWAYS_INLINE; + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) + { + #if !defined(CONTROL_ONLY_DEVICE) + UENUM = EndpointNumber; + 700: 80 93 e9 00 sts 0x00E9, r24 + * \return Boolean true if the currently selected endpoint is stalled, 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); + 704: 80 91 eb 00 lds r24, 0x00EB + + CurrentStatus = Endpoint_IsStalled(); + 708: 90 e0 ldi r25, 0x00 ; 0 + 70a: 25 e0 ldi r18, 0x05 ; 5 + 70c: 96 95 lsr r25 + 70e: 87 95 ror r24 + 710: 2a 95 dec r18 + 712: e1 f7 brne .-8 ; 0x70c <USB_Device_ProcessControlRequest+0x8e> + 714: 98 2f mov r25, r24 + 716: 91 70 andi r25, 0x01 ; 1 + */ + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) ATTR_ALWAYS_INLINE; + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) + { + #if !defined(CONTROL_ONLY_DEVICE) + UENUM = EndpointNumber; + 718: 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); + 71c: 80 91 e8 00 lds r24, 0x00E8 + 720: 87 7f andi r24, 0xF7 ; 247 + 722: 80 93 e8 00 sts 0x00E8, r24 + * \param[in] Word Next word to write to the currently selected endpoint's FIFO buffer. + */ + static inline void Endpoint_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE; + static inline void Endpoint_Write_Word_LE(const uint16_t Word) + { + UEDATX = (Word & 0xFF); + 726: 90 93 f1 00 sts 0x00F1, r25 + UEDATX = (Word >> 8); + 72a: 10 92 f1 00 sts 0x00F1, r1 + 72e: 9b c0 rjmp .+310 ; 0x866 <USB_Device_ProcessControlRequest+0x1e8> + } + + break; + case REQ_ClearFeature: + case REQ_SetFeature: + if ((bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE)) || + 730: 88 23 and r24, r24 + 732: 19 f0 breq .+6 ; 0x73a <USB_Device_ProcessControlRequest+0xbc> + 734: 82 30 cpi r24, 0x02 ; 2 + 736: 09 f0 breq .+2 ; 0x73a <USB_Device_ProcessControlRequest+0xbc> + 738: b9 c0 rjmp .+370 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> + Endpoint_ClearStatusStage(); +} + +static void USB_Device_ClearSetFeature(void) +{ + switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT) + 73a: 90 e0 ldi r25, 0x00 ; 0 + 73c: 8f 71 andi r24, 0x1F ; 31 + 73e: 90 70 andi r25, 0x00 ; 0 + 740: 00 97 sbiw r24, 0x00 ; 0 + 742: 21 f0 breq .+8 ; 0x74c <USB_Device_ProcessControlRequest+0xce> + 744: 02 97 sbiw r24, 0x02 ; 2 + 746: 09 f0 breq .+2 ; 0x74a <USB_Device_ProcessControlRequest+0xcc> + 748: b1 c0 rjmp .+354 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> + 74a: 0c c0 rjmp .+24 ; 0x764 <USB_Device_ProcessControlRequest+0xe6> + { + #if !defined(NO_DEVICE_REMOTE_WAKEUP) + case REQREC_DEVICE: + if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_DeviceRemoteWakeup) + 74c: 80 91 10 02 lds r24, 0x0210 + 750: 81 30 cpi r24, 0x01 ; 1 + 752: 09 f0 breq .+2 ; 0x756 <USB_Device_ProcessControlRequest+0xd8> + 754: ab c0 rjmp .+342 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> + USB_RemoteWakeupEnabled = (USB_ControlRequest.bRequest == REQ_SetFeature); + 756: 10 92 0a 02 sts 0x020A, r1 + 75a: 33 30 cpi r19, 0x03 ; 3 + 75c: 69 f5 brne .+90 ; 0x7b8 <USB_Device_ProcessControlRequest+0x13a> + 75e: 80 93 0a 02 sts 0x020A, r24 + 762: 2a c0 rjmp .+84 ; 0x7b8 <USB_Device_ProcessControlRequest+0x13a> + + break; + #endif + #if !defined(CONTROL_ONLY_DEVICE) + case REQREC_ENDPOINT: + if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_EndpointHalt) + 764: 80 91 10 02 lds r24, 0x0210 + 768: 88 23 and r24, r24 + 76a: 31 f5 brne .+76 ; 0x7b8 <USB_Device_ProcessControlRequest+0x13a> + { + uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK); + 76c: 20 91 12 02 lds r18, 0x0212 + 770: 27 70 andi r18, 0x07 ; 7 + + if (EndpointIndex == ENDPOINT_CONTROLEP) + 772: 09 f4 brne .+2 ; 0x776 <USB_Device_ProcessControlRequest+0xf8> + 774: 9b c0 rjmp .+310 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> + */ + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) ATTR_ALWAYS_INLINE; + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) + { + #if !defined(CONTROL_ONLY_DEVICE) + UENUM = EndpointNumber; + 776: 20 93 e9 00 sts 0x00E9, r18 + * \return Boolean True if the currently selected endpoint is enabled, 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); + 77a: 80 91 eb 00 lds r24, 0x00EB + return; + + Endpoint_SelectEndpoint(EndpointIndex); + + if (Endpoint_IsEnabled()) + 77e: 80 ff sbrs r24, 0 + 780: 1b c0 rjmp .+54 ; 0x7b8 <USB_Device_ProcessControlRequest+0x13a> + { + if (USB_ControlRequest.bRequest == REQ_SetFeature) + 782: 33 30 cpi r19, 0x03 ; 3 + 784: 21 f4 brne .+8 ; 0x78e <USB_Device_ProcessControlRequest+0x110> + * \ingroup Group_EndpointPacketManagement + */ + static inline void Endpoint_StallTransaction(void) ATTR_ALWAYS_INLINE; + static inline void Endpoint_StallTransaction(void) + { + UECONX |= (1 << STALLRQ); + 786: 80 91 eb 00 lds r24, 0x00EB + 78a: 80 62 ori r24, 0x20 ; 32 + 78c: 13 c0 rjmp .+38 ; 0x7b4 <USB_Device_ProcessControlRequest+0x136> + * \ingroup Group_EndpointPacketManagement + */ + static inline void Endpoint_ClearStall(void) ATTR_ALWAYS_INLINE; + static inline void Endpoint_ClearStall(void) + { + UECONX |= (1 << STALLRQC); + 78e: 80 91 eb 00 lds r24, 0x00EB + 792: 80 61 ori r24, 0x10 ; 16 + 794: 80 93 eb 00 sts 0x00EB, r24 + * \param[in] EndpointNumber Endpoint number whose FIFO buffers are to be reset. + */ + static inline void Endpoint_ResetFIFO(const uint8_t EndpointNumber) ATTR_ALWAYS_INLINE; + static inline void Endpoint_ResetFIFO(const uint8_t EndpointNumber) + { + UERST = (1 << EndpointNumber); + 798: 81 e0 ldi r24, 0x01 ; 1 + 79a: 90 e0 ldi r25, 0x00 ; 0 + 79c: 02 c0 rjmp .+4 ; 0x7a2 <USB_Device_ProcessControlRequest+0x124> + 79e: 88 0f add r24, r24 + 7a0: 99 1f adc r25, r25 + 7a2: 2a 95 dec r18 + 7a4: e2 f7 brpl .-8 ; 0x79e <USB_Device_ProcessControlRequest+0x120> + 7a6: 80 93 ea 00 sts 0x00EA, r24 + UERST = 0; + 7aa: 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); + 7ae: 80 91 eb 00 lds r24, 0x00EB + 7b2: 88 60 ori r24, 0x08 ; 8 + 7b4: 80 93 eb 00 sts 0x00EB, r24 + */ + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) ATTR_ALWAYS_INLINE; + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) + { + #if !defined(CONTROL_ONLY_DEVICE) + UENUM = EndpointNumber; + 7b8: 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); + 7bc: 80 91 e8 00 lds r24, 0x00E8 + 7c0: 87 7f andi r24, 0xF7 ; 247 + 7c2: 54 c0 rjmp .+168 ; 0x86c <USB_Device_ProcessControlRequest+0x1ee> + USB_Device_ClearSetFeature(); + } + + break; + case REQ_SetAddress: + if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE)) + 7c4: 88 23 and r24, r24 + 7c6: 09 f0 breq .+2 ; 0x7ca <USB_Device_ProcessControlRequest+0x14c> + 7c8: 71 c0 rjmp .+226 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> + } +} + +static void USB_Device_SetAddress(void) +{ + uint8_t DeviceAddress = (USB_ControlRequest.wValue & 0x7F); + 7ca: 10 91 10 02 lds r17, 0x0210 + 7ce: 1f 77 andi r17, 0x7F ; 127 + + ATOMIC_BLOCK(ATOMIC_RESTORESTATE) + 7d0: 0f b7 in r16, 0x3f ; 63 + return 1; +} + +static __inline__ uint8_t __iCliRetVal(void) +{ + cli(); + 7d2: f8 94 cli + 7d4: 80 91 e8 00 lds r24, 0x00E8 + 7d8: 87 7f andi r24, 0xF7 ; 247 + 7da: 80 93 e8 00 sts 0x00E8, r24 + { + Endpoint_ClearSETUP(); + + Endpoint_ClearStatusStage(); + 7de: 0c de rcall .-1000 ; 0x3f8 <Endpoint_ClearStatusStage> + * \return Boolean true if the current endpoint is ready for an IN packet, 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); + 7e0: 80 91 e8 00 lds r24, 0x00E8 + + while (!(Endpoint_IsINReady())); + 7e4: 80 ff sbrs r24, 0 + 7e6: fc cf rjmp .-8 ; 0x7e0 <USB_Device_ProcessControlRequest+0x162> + + USB_DeviceState = (DeviceAddress) ? DEVICE_STATE_Addressed : DEVICE_STATE_Default; + 7e8: 11 23 and r17, r17 + 7ea: 11 f4 brne .+4 ; 0x7f0 <USB_Device_ProcessControlRequest+0x172> + 7ec: 82 e0 ldi r24, 0x02 ; 2 + 7ee: 01 c0 rjmp .+2 ; 0x7f2 <USB_Device_ProcessControlRequest+0x174> + 7f0: 83 e0 ldi r24, 0x03 ; 3 + 7f2: 80 93 0d 02 sts 0x020D, r24 + #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)); + 7f6: 80 91 e3 00 lds r24, 0x00E3 + 7fa: 80 78 andi r24, 0x80 ; 128 + 7fc: 18 2b or r17, r24 + 7fe: 10 93 e3 00 sts 0x00E3, r17 + UDADDR |= (1 << ADDEN); + 802: 80 91 e3 00 lds r24, 0x00E3 + 806: 80 68 ori r24, 0x80 ; 128 + 808: 80 93 e3 00 sts 0x00E3, r24 + (void)__s; +} + +static __inline__ void __iRestore(const uint8_t *__s) +{ + SREG = *__s; + 80c: 0f bf out 0x3f, r16 ; 63 + __asm__ volatile ("" ::: "memory"); + 80e: 4e c0 rjmp .+156 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> + if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE)) + USB_Device_SetAddress(); + + break; + case REQ_GetDescriptor: + if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) || + 810: 80 58 subi r24, 0x80 ; 128 + 812: 82 30 cpi r24, 0x02 ; 2 + 814: 08 f0 brcs .+2 ; 0x818 <USB_Device_ProcessControlRequest+0x19a> + 816: 4a c0 rjmp .+148 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> + USB_Device_GetInternalSerialDescriptor(); + return; + } + #endif + + if ((DescriptorSize = CALLBACK_USB_GetDescriptor(USB_ControlRequest.wValue, USB_ControlRequest.wIndex, + 818: 80 91 10 02 lds r24, 0x0210 + 81c: 90 91 11 02 lds r25, 0x0211 + 820: 60 91 12 02 lds r22, 0x0212 + 824: ae 01 movw r20, r28 + 826: 4f 5f subi r20, 0xFF ; 255 + 828: 5f 4f sbci r21, 0xFF ; 255 + 82a: a5 dd rcall .-1206 ; 0x376 <CALLBACK_USB_GetDescriptor> + 82c: bc 01 movw r22, r24 + 82e: 00 97 sbiw r24, 0x00 ; 0 + 830: 09 f4 brne .+2 ; 0x834 <USB_Device_ProcessControlRequest+0x1b6> + 832: 3c c0 rjmp .+120 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> + * \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); + 834: 80 91 e8 00 lds r24, 0x00E8 + 838: 87 7f andi r24, 0xF7 ; 247 + 83a: 80 93 e8 00 sts 0x00E8, r24 + #if defined(USE_RAM_DESCRIPTORS) + 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); + 83e: 89 81 ldd r24, Y+1 ; 0x01 + 840: 9a 81 ldd r25, Y+2 ; 0x02 + 842: a8 d0 rcall .+336 ; 0x994 <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)); + 844: 80 91 e8 00 lds r24, 0x00E8 + 848: 8b 77 andi r24, 0x7B ; 123 + 84a: 80 93 e8 00 sts 0x00E8, r24 + 84e: 2e c0 rjmp .+92 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> + USB_Device_GetDescriptor(); + } + + break; + case REQ_GetConfiguration: + if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) + 850: 80 38 cpi r24, 0x80 ; 128 + 852: 61 f5 brne .+88 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> + * \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); + 854: 80 91 e8 00 lds r24, 0x00E8 + 858: 87 7f andi r24, 0xF7 ; 247 + 85a: 80 93 e8 00 sts 0x00E8, r24 + +static void USB_Device_GetConfiguration(void) +{ + Endpoint_ClearSETUP(); + + Endpoint_Write_Byte(USB_ConfigurationNumber); + 85e: 80 91 0b 02 lds r24, 0x020B + * \param[in] Byte Next byte to write into the the currently selected endpoint's FIFO buffer. + */ + static inline void Endpoint_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE; + static inline void Endpoint_Write_Byte(const uint8_t Byte) + { + UEDATX = Byte; + 862: 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)); + 866: 80 91 e8 00 lds r24, 0x00E8 + 86a: 8e 77 andi r24, 0x7E ; 126 + 86c: 80 93 e8 00 sts 0x00E8, r24 + Endpoint_ClearIN(); + + Endpoint_ClearStatusStage(); + 870: c3 dd rcall .-1146 ; 0x3f8 <Endpoint_ClearStatusStage> + 872: 1c c0 rjmp .+56 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> + if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) + USB_Device_GetConfiguration(); + + break; + case REQ_SetConfiguration: + if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE)) + 874: 88 23 and r24, r24 + 876: d1 f4 brne .+52 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> +} + +static void USB_Device_SetConfiguration(void) +{ + #if defined(FIXED_NUM_CONFIGURATIONS) + if ((uint8_t)USB_ControlRequest.wValue > FIXED_NUM_CONFIGURATIONS) + 878: 90 91 10 02 lds r25, 0x0210 + 87c: 92 30 cpi r25, 0x02 ; 2 + 87e: b0 f4 brcc .+44 ; 0x8ac <USB_Device_ProcessControlRequest+0x22e> + * \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); + 880: 80 91 e8 00 lds r24, 0x00E8 + 884: 87 7f andi r24, 0xF7 ; 247 + 886: 80 93 e8 00 sts 0x00E8, r24 + } + #endif + + Endpoint_ClearSETUP(); + + USB_ConfigurationNumber = (uint8_t)USB_ControlRequest.wValue; + 88a: 90 93 0b 02 sts 0x020B, r25 + + Endpoint_ClearStatusStage(); + 88e: b4 dd rcall .-1176 ; 0x3f8 <Endpoint_ClearStatusStage> + + if (USB_ConfigurationNumber) + 890: 80 91 0b 02 lds r24, 0x020B + 894: 88 23 and r24, r24 + 896: 31 f4 brne .+12 ; 0x8a4 <USB_Device_ProcessControlRequest+0x226> + } + + static inline bool USB_Device_IsAddressSet(void) ATTR_ALWAYS_INLINE; + static inline bool USB_Device_IsAddressSet(void) + { + return (UDADDR & (1 << ADDEN)); + 898: 80 91 e3 00 lds r24, 0x00E3 + USB_DeviceState = DEVICE_STATE_Configured; + else + USB_DeviceState = (USB_Device_IsAddressSet()) ? DEVICE_STATE_Configured : DEVICE_STATE_Powered; + 89c: 87 fd sbrc r24, 7 + 89e: 02 c0 rjmp .+4 ; 0x8a4 <USB_Device_ProcessControlRequest+0x226> + 8a0: 81 e0 ldi r24, 0x01 ; 1 + 8a2: 01 c0 rjmp .+2 ; 0x8a6 <USB_Device_ProcessControlRequest+0x228> + 8a4: 84 e0 ldi r24, 0x04 ; 4 + 8a6: 80 93 0d 02 sts 0x020D, r24 + + EVENT_USB_Device_ConfigurationChanged(); + 8aa: 7d dc rcall .-1798 ; 0x1a6 <EVENT_USB_Device_ConfigurationChanged> + * \return Boolean true if the selected endpoint has received a SETUP packet, 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); + 8ac: 80 91 e8 00 lds r24, 0x00E8 + + break; + } + } + + if (Endpoint_IsSETUPReceived()) + 8b0: 83 ff sbrs r24, 3 + 8b2: 0a c0 rjmp .+20 ; 0x8c8 <USB_Device_ProcessControlRequest+0x24a> + * \ingroup Group_EndpointPacketManagement + */ + static inline void Endpoint_StallTransaction(void) ATTR_ALWAYS_INLINE; + static inline void Endpoint_StallTransaction(void) + { + UECONX |= (1 << STALLRQ); + 8b4: 80 91 eb 00 lds r24, 0x00EB + 8b8: 80 62 ori r24, 0x20 ; 32 + 8ba: 80 93 eb 00 sts 0x00EB, r24 + * \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); + 8be: 80 91 e8 00 lds r24, 0x00E8 + 8c2: 87 7f andi r24, 0xF7 ; 247 + 8c4: 80 93 e8 00 sts 0x00E8, r24 + { + Endpoint_StallTransaction(); + Endpoint_ClearSETUP(); + } +} + 8c8: 0f 90 pop r0 + 8ca: 0f 90 pop r0 + 8cc: cf 91 pop r28 + 8ce: df 91 pop r29 + 8d0: 1f 91 pop r17 + 8d2: 0f 91 pop r16 + 8d4: 08 95 ret + +000008d6 <USB_Event_Stub>: +#include "Events.h" + +void USB_Event_Stub(void) +{ + +} + 8d6: 08 95 ret + +000008d8 <Endpoint_Write_Control_Stream_LE>: + 8d8: 9c 01 movw r18, r24 + uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length)); + bool LastPacketFull = false; + + if (Length > USB_ControlRequest.wLength) + 8da: 40 91 14 02 lds r20, 0x0214 + 8de: 50 91 15 02 lds r21, 0x0215 + 8e2: 46 17 cp r20, r22 + 8e4: 57 07 cpc r21, r23 + 8e6: 18 f4 brcc .+6 ; 0x8ee <Endpoint_Write_Control_Stream_LE+0x16> +uint8_t TEMPLATE_FUNC_NAME (const void* Buffer, + uint16_t Length) +{ + uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length)); + 8e8: f9 01 movw r30, r18 + 8ea: 90 e0 ldi r25, 0x00 ; 0 + 8ec: 3d c0 rjmp .+122 ; 0x968 <Endpoint_Write_Control_Stream_LE+0x90> + bool LastPacketFull = false; + + if (Length > USB_ControlRequest.wLength) + Length = USB_ControlRequest.wLength; + else if (!(Length)) + 8ee: 61 15 cp r22, r1 + 8f0: 71 05 cpc r23, r1 + 8f2: 11 f0 breq .+4 ; 0x8f8 <Endpoint_Write_Control_Stream_LE+0x20> + 8f4: ab 01 movw r20, r22 + 8f6: f8 cf rjmp .-16 ; 0x8e8 <Endpoint_Write_Control_Stream_LE+0x10> + */ + 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)); + 8f8: 80 91 e8 00 lds r24, 0x00E8 + 8fc: 8e 77 andi r24, 0x7E ; 126 + 8fe: 80 93 e8 00 sts 0x00E8, r24 + 902: 40 e0 ldi r20, 0x00 ; 0 + 904: 50 e0 ldi r21, 0x00 ; 0 + 906: f0 cf rjmp .-32 ; 0x8e8 <Endpoint_Write_Control_Stream_LE+0x10> + Endpoint_ClearIN(); + + while (Length || LastPacketFull) + { + uint8_t USB_DeviceState_LCL = USB_DeviceState; + 908: 80 91 0d 02 lds r24, 0x020D + + if (USB_DeviceState_LCL == DEVICE_STATE_Unattached) + 90c: 88 23 and r24, r24 + 90e: f1 f1 breq .+124 ; 0x98c <Endpoint_Write_Control_Stream_LE+0xb4> + return ENDPOINT_RWCSTREAM_DeviceDisconnected; + else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended) + 910: 85 30 cpi r24, 0x05 ; 5 + 912: f1 f1 breq .+124 ; 0x990 <Endpoint_Write_Control_Stream_LE+0xb8> + * \return Boolean true if the selected endpoint has received a SETUP packet, 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); + 914: 80 91 e8 00 lds r24, 0x00E8 + return ENDPOINT_RWCSTREAM_BusSuspended; + else if (Endpoint_IsSETUPReceived()) + 918: 83 ff sbrs r24, 3 + 91a: 02 c0 rjmp .+4 ; 0x920 <Endpoint_Write_Control_Stream_LE+0x48> + 91c: 81 e0 ldi r24, 0x01 ; 1 + 91e: 08 95 ret + * \return Boolean true if current endpoint is has received an OUT packet, 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); + 920: 80 91 e8 00 lds r24, 0x00E8 + return ENDPOINT_RWCSTREAM_HostAborted; + else if (Endpoint_IsOUTReceived()) + 924: 82 fd sbrc r24, 2 + 926: 2c c0 rjmp .+88 ; 0x980 <Endpoint_Write_Control_Stream_LE+0xa8> + * \return Boolean true if the current endpoint is ready for an IN packet, 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); + 928: 80 91 e8 00 lds r24, 0x00E8 + break; + + if (Endpoint_IsINReady()) + 92c: 80 ff sbrs r24, 0 + 92e: 1c c0 rjmp .+56 ; 0x968 <Endpoint_Write_Control_Stream_LE+0x90> + #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; + 930: 80 91 f2 00 lds r24, 0x00F2 + 934: 28 2f mov r18, r24 + 936: 30 e0 ldi r19, 0x00 ; 0 + 938: 07 c0 rjmp .+14 ; 0x948 <Endpoint_Write_Control_Stream_LE+0x70> + { + uint16_t BytesInEndpoint = Endpoint_BytesInEndpoint(); + + while (Length && (BytesInEndpoint < USB_ControlEndpointSize)) + { + TEMPLATE_TRANSFER_BYTE(DataStream); + 93a: 81 91 ld r24, Z+ + * \param[in] Byte Next byte to write into the the currently selected endpoint's FIFO buffer. + */ + static inline void Endpoint_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE; + static inline void Endpoint_Write_Byte(const uint8_t Byte) + { + UEDATX = Byte; + 93c: 80 93 f1 00 sts 0x00F1, r24 + Length--; + 940: 41 50 subi r20, 0x01 ; 1 + 942: 50 40 sbci r21, 0x00 ; 0 + BytesInEndpoint++; + 944: 2f 5f subi r18, 0xFF ; 255 + 946: 3f 4f sbci r19, 0xFF ; 255 + + if (Endpoint_IsINReady()) + { + uint16_t BytesInEndpoint = Endpoint_BytesInEndpoint(); + + while (Length && (BytesInEndpoint < USB_ControlEndpointSize)) + 948: 41 15 cp r20, r1 + 94a: 51 05 cpc r21, r1 + 94c: 19 f0 breq .+6 ; 0x954 <Endpoint_Write_Control_Stream_LE+0x7c> + 94e: 28 30 cpi r18, 0x08 ; 8 + 950: 31 05 cpc r19, r1 + 952: 98 f3 brcs .-26 ; 0x93a <Endpoint_Write_Control_Stream_LE+0x62> + TEMPLATE_TRANSFER_BYTE(DataStream); + Length--; + BytesInEndpoint++; + } + + LastPacketFull = (BytesInEndpoint == USB_ControlEndpointSize); + 954: 90 e0 ldi r25, 0x00 ; 0 + 956: 28 30 cpi r18, 0x08 ; 8 + 958: 31 05 cpc r19, r1 + 95a: 09 f4 brne .+2 ; 0x95e <Endpoint_Write_Control_Stream_LE+0x86> + 95c: 91 e0 ldi r25, 0x01 ; 1 + */ + 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)); + 95e: 80 91 e8 00 lds r24, 0x00E8 + 962: 8e 77 andi r24, 0x7E ; 126 + 964: 80 93 e8 00 sts 0x00E8, r24 + if (Length > USB_ControlRequest.wLength) + Length = USB_ControlRequest.wLength; + else if (!(Length)) + Endpoint_ClearIN(); + + while (Length || LastPacketFull) + 968: 41 15 cp r20, r1 + 96a: 51 05 cpc r21, r1 + 96c: 69 f6 brne .-102 ; 0x908 <Endpoint_Write_Control_Stream_LE+0x30> + 96e: 99 23 and r25, r25 + 970: 59 f6 brne .-106 ; 0x908 <Endpoint_Write_Control_Stream_LE+0x30> + 972: 06 c0 rjmp .+12 ; 0x980 <Endpoint_Write_Control_Stream_LE+0xa8> + } + } + + while (!(Endpoint_IsOUTReceived())) + { + uint8_t USB_DeviceState_LCL = USB_DeviceState; + 974: 80 91 0d 02 lds r24, 0x020D + + if (USB_DeviceState_LCL == DEVICE_STATE_Unattached) + 978: 88 23 and r24, r24 + 97a: 41 f0 breq .+16 ; 0x98c <Endpoint_Write_Control_Stream_LE+0xb4> + return ENDPOINT_RWCSTREAM_DeviceDisconnected; + else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended) + 97c: 85 30 cpi r24, 0x05 ; 5 + 97e: 41 f0 breq .+16 ; 0x990 <Endpoint_Write_Control_Stream_LE+0xb8> + * \return Boolean true if current endpoint is has received an OUT packet, 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); + 980: 80 91 e8 00 lds r24, 0x00E8 + LastPacketFull = (BytesInEndpoint == USB_ControlEndpointSize); + Endpoint_ClearIN(); + } + } + + while (!(Endpoint_IsOUTReceived())) + 984: 82 ff sbrs r24, 2 + 986: f6 cf rjmp .-20 ; 0x974 <Endpoint_Write_Control_Stream_LE+0x9c> + 988: 80 e0 ldi r24, 0x00 ; 0 + 98a: 08 95 ret + 98c: 82 e0 ldi r24, 0x02 ; 2 + 98e: 08 95 ret + 990: 83 e0 ldi r24, 0x03 ; 3 + else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended) + return ENDPOINT_RWCSTREAM_BusSuspended; + } + + return ENDPOINT_RWCSTREAM_NoError; +} + 992: 08 95 ret + +00000994 <Endpoint_Write_Control_PStream_LE>: +uint8_t TEMPLATE_FUNC_NAME (const void* Buffer, + uint16_t Length) +{ + 994: 9c 01 movw r18, r24 + uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length)); + bool LastPacketFull = false; + + if (Length > USB_ControlRequest.wLength) + 996: 40 91 14 02 lds r20, 0x0214 + 99a: 50 91 15 02 lds r21, 0x0215 + 99e: 46 17 cp r20, r22 + 9a0: 57 07 cpc r21, r23 + 9a2: 10 f4 brcc .+4 ; 0x9a8 <Endpoint_Write_Control_PStream_LE+0x14> +uint8_t TEMPLATE_FUNC_NAME (const void* Buffer, + uint16_t Length) +{ + uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length)); + 9a4: 60 e0 ldi r22, 0x00 ; 0 + 9a6: 3f c0 rjmp .+126 ; 0xa26 <Endpoint_Write_Control_PStream_LE+0x92> + bool LastPacketFull = false; + + if (Length > USB_ControlRequest.wLength) + Length = USB_ControlRequest.wLength; + else if (!(Length)) + 9a8: 61 15 cp r22, r1 + 9aa: 71 05 cpc r23, r1 + 9ac: 11 f0 breq .+4 ; 0x9b2 <Endpoint_Write_Control_PStream_LE+0x1e> + 9ae: ab 01 movw r20, r22 + 9b0: f9 cf rjmp .-14 ; 0x9a4 <Endpoint_Write_Control_PStream_LE+0x10> + */ + 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)); + 9b2: 80 91 e8 00 lds r24, 0x00E8 + 9b6: 8e 77 andi r24, 0x7E ; 126 + 9b8: 80 93 e8 00 sts 0x00E8, r24 + 9bc: 40 e0 ldi r20, 0x00 ; 0 + 9be: 50 e0 ldi r21, 0x00 ; 0 + 9c0: f1 cf rjmp .-30 ; 0x9a4 <Endpoint_Write_Control_PStream_LE+0x10> + Endpoint_ClearIN(); + + while (Length || LastPacketFull) + { + uint8_t USB_DeviceState_LCL = USB_DeviceState; + 9c2: 80 91 0d 02 lds r24, 0x020D + + if (USB_DeviceState_LCL == DEVICE_STATE_Unattached) + 9c6: 88 23 and r24, r24 + 9c8: 09 f4 brne .+2 ; 0x9cc <Endpoint_Write_Control_PStream_LE+0x38> + 9ca: 3f c0 rjmp .+126 ; 0xa4a <Endpoint_Write_Control_PStream_LE+0xb6> + return ENDPOINT_RWCSTREAM_DeviceDisconnected; + else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended) + 9cc: 85 30 cpi r24, 0x05 ; 5 + 9ce: 09 f4 brne .+2 ; 0x9d2 <Endpoint_Write_Control_PStream_LE+0x3e> + 9d0: 3e c0 rjmp .+124 ; 0xa4e <Endpoint_Write_Control_PStream_LE+0xba> + * \return Boolean true if the selected endpoint has received a SETUP packet, 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); + 9d2: 80 91 e8 00 lds r24, 0x00E8 + return ENDPOINT_RWCSTREAM_BusSuspended; + else if (Endpoint_IsSETUPReceived()) + 9d6: 83 ff sbrs r24, 3 + 9d8: 02 c0 rjmp .+4 ; 0x9de <Endpoint_Write_Control_PStream_LE+0x4a> + 9da: 81 e0 ldi r24, 0x01 ; 1 + 9dc: 08 95 ret + * \return Boolean true if current endpoint is has received an OUT packet, 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); + 9de: 80 91 e8 00 lds r24, 0x00E8 + return ENDPOINT_RWCSTREAM_HostAborted; + else if (Endpoint_IsOUTReceived()) + 9e2: 82 fd sbrc r24, 2 + 9e4: 2c c0 rjmp .+88 ; 0xa3e <Endpoint_Write_Control_PStream_LE+0xaa> + * \return Boolean true if the current endpoint is ready for an IN packet, 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); + 9e6: 80 91 e8 00 lds r24, 0x00E8 + break; + + if (Endpoint_IsINReady()) + 9ea: 80 ff sbrs r24, 0 + 9ec: 1c c0 rjmp .+56 ; 0xa26 <Endpoint_Write_Control_PStream_LE+0x92> + #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; + 9ee: 80 91 f2 00 lds r24, 0x00F2 + 9f2: 90 e0 ldi r25, 0x00 ; 0 + 9f4: 09 c0 rjmp .+18 ; 0xa08 <Endpoint_Write_Control_PStream_LE+0x74> + { + uint16_t BytesInEndpoint = Endpoint_BytesInEndpoint(); + + while (Length && (BytesInEndpoint < USB_ControlEndpointSize)) + 9f6: f9 01 movw r30, r18 + { + TEMPLATE_TRANSFER_BYTE(DataStream); + 9f8: 2f 5f subi r18, 0xFF ; 255 + 9fa: 3f 4f sbci r19, 0xFF ; 255 + 9fc: e4 91 lpm r30, Z+ + * \param[in] Byte Next byte to write into the the currently selected endpoint's FIFO buffer. + */ + static inline void Endpoint_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE; + static inline void Endpoint_Write_Byte(const uint8_t Byte) + { + UEDATX = Byte; + 9fe: e0 93 f1 00 sts 0x00F1, r30 + Length--; + a02: 41 50 subi r20, 0x01 ; 1 + a04: 50 40 sbci r21, 0x00 ; 0 + BytesInEndpoint++; + a06: 01 96 adiw r24, 0x01 ; 1 + + if (Endpoint_IsINReady()) + { + uint16_t BytesInEndpoint = Endpoint_BytesInEndpoint(); + + while (Length && (BytesInEndpoint < USB_ControlEndpointSize)) + a08: 41 15 cp r20, r1 + a0a: 51 05 cpc r21, r1 + a0c: 19 f0 breq .+6 ; 0xa14 <Endpoint_Write_Control_PStream_LE+0x80> + a0e: 88 30 cpi r24, 0x08 ; 8 + a10: 91 05 cpc r25, r1 + a12: 88 f3 brcs .-30 ; 0x9f6 <Endpoint_Write_Control_PStream_LE+0x62> + TEMPLATE_TRANSFER_BYTE(DataStream); + Length--; + BytesInEndpoint++; + } + + LastPacketFull = (BytesInEndpoint == USB_ControlEndpointSize); + a14: 60 e0 ldi r22, 0x00 ; 0 + a16: 08 97 sbiw r24, 0x08 ; 8 + a18: 09 f4 brne .+2 ; 0xa1c <Endpoint_Write_Control_PStream_LE+0x88> + a1a: 61 e0 ldi r22, 0x01 ; 1 + */ + 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)); + a1c: 80 91 e8 00 lds r24, 0x00E8 + a20: 8e 77 andi r24, 0x7E ; 126 + a22: 80 93 e8 00 sts 0x00E8, r24 + if (Length > USB_ControlRequest.wLength) + Length = USB_ControlRequest.wLength; + else if (!(Length)) + Endpoint_ClearIN(); + + while (Length || LastPacketFull) + a26: 41 15 cp r20, r1 + a28: 51 05 cpc r21, r1 + a2a: 59 f6 brne .-106 ; 0x9c2 <Endpoint_Write_Control_PStream_LE+0x2e> + a2c: 66 23 and r22, r22 + a2e: 49 f6 brne .-110 ; 0x9c2 <Endpoint_Write_Control_PStream_LE+0x2e> + a30: 06 c0 rjmp .+12 ; 0xa3e <Endpoint_Write_Control_PStream_LE+0xaa> + } + } + + while (!(Endpoint_IsOUTReceived())) + { + uint8_t USB_DeviceState_LCL = USB_DeviceState; + a32: 80 91 0d 02 lds r24, 0x020D + + if (USB_DeviceState_LCL == DEVICE_STATE_Unattached) + a36: 88 23 and r24, r24 + a38: 41 f0 breq .+16 ; 0xa4a <Endpoint_Write_Control_PStream_LE+0xb6> + return ENDPOINT_RWCSTREAM_DeviceDisconnected; + else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended) + a3a: 85 30 cpi r24, 0x05 ; 5 + a3c: 41 f0 breq .+16 ; 0xa4e <Endpoint_Write_Control_PStream_LE+0xba> + * \return Boolean true if current endpoint is has received an OUT packet, 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); + a3e: 80 91 e8 00 lds r24, 0x00E8 + LastPacketFull = (BytesInEndpoint == USB_ControlEndpointSize); + Endpoint_ClearIN(); + } + } + + while (!(Endpoint_IsOUTReceived())) + a42: 82 ff sbrs r24, 2 + a44: f6 cf rjmp .-20 ; 0xa32 <Endpoint_Write_Control_PStream_LE+0x9e> + a46: 80 e0 ldi r24, 0x00 ; 0 + a48: 08 95 ret + a4a: 82 e0 ldi r24, 0x02 ; 2 + a4c: 08 95 ret + a4e: 83 e0 ldi r24, 0x03 ; 3 + else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended) + return ENDPOINT_RWCSTREAM_BusSuspended; + } + + return ENDPOINT_RWCSTREAM_NoError; +} + a50: 08 95 ret + +00000a52 <Endpoint_Read_Control_Stream_LE>: +uint8_t TEMPLATE_FUNC_NAME (void* Buffer, + uint16_t Length) +{ + a52: 9c 01 movw r18, r24 + uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length)); + + if (!(Length)) + a54: 61 15 cp r22, r1 + a56: 71 05 cpc r23, r1 + a58: 29 f4 brne .+10 ; 0xa64 <Endpoint_Read_Control_Stream_LE+0x12> + */ + 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)); + a5a: 80 91 e8 00 lds r24, 0x00E8 + a5e: 8b 77 andi r24, 0x7B ; 123 + a60: 80 93 e8 00 sts 0x00E8, r24 +uint8_t TEMPLATE_FUNC_NAME (void* Buffer, + uint16_t Length) +{ + uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length)); + a64: f9 01 movw r30, r18 + a66: 20 c0 rjmp .+64 ; 0xaa8 <Endpoint_Read_Control_Stream_LE+0x56> + if (!(Length)) + Endpoint_ClearOUT(); + + while (Length) + { + uint8_t USB_DeviceState_LCL = USB_DeviceState; + a68: 80 91 0d 02 lds r24, 0x020D + + if (USB_DeviceState_LCL == DEVICE_STATE_Unattached) + a6c: 88 23 and r24, r24 + a6e: 61 f1 breq .+88 ; 0xac8 <Endpoint_Read_Control_Stream_LE+0x76> + return ENDPOINT_RWCSTREAM_DeviceDisconnected; + else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended) + a70: 85 30 cpi r24, 0x05 ; 5 + a72: 61 f1 breq .+88 ; 0xacc <Endpoint_Read_Control_Stream_LE+0x7a> + * \return Boolean true if the selected endpoint has received a SETUP packet, 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); + a74: 80 91 e8 00 lds r24, 0x00E8 + return ENDPOINT_RWCSTREAM_BusSuspended; + else if (Endpoint_IsSETUPReceived()) + a78: 83 ff sbrs r24, 3 + a7a: 02 c0 rjmp .+4 ; 0xa80 <Endpoint_Read_Control_Stream_LE+0x2e> + a7c: 81 e0 ldi r24, 0x01 ; 1 + a7e: 08 95 ret + * \return Boolean true if current endpoint is has received an OUT packet, 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); + a80: 80 91 e8 00 lds r24, 0x00E8 + return ENDPOINT_RWCSTREAM_HostAborted; + + if (Endpoint_IsOUTReceived()) + a84: 82 ff sbrs r24, 2 + a86: f0 cf rjmp .-32 ; 0xa68 <Endpoint_Read_Control_Stream_LE+0x16> + a88: 06 c0 rjmp .+12 ; 0xa96 <Endpoint_Read_Control_Stream_LE+0x44> + * \return Next byte in the currently selected endpoint's FIFO buffer. + */ + static inline uint8_t Endpoint_Read_Byte(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; + static inline uint8_t Endpoint_Read_Byte(void) + { + return UEDATX; + a8a: 80 91 f1 00 lds r24, 0x00F1 + { + while (Length && Endpoint_BytesInEndpoint()) + { + TEMPLATE_TRANSFER_BYTE(DataStream); + a8e: 81 93 st Z+, r24 + Length--; + a90: 61 50 subi r22, 0x01 ; 1 + a92: 70 40 sbci r23, 0x00 ; 0 + else if (Endpoint_IsSETUPReceived()) + return ENDPOINT_RWCSTREAM_HostAborted; + + if (Endpoint_IsOUTReceived()) + { + while (Length && Endpoint_BytesInEndpoint()) + a94: 21 f0 breq .+8 ; 0xa9e <Endpoint_Read_Control_Stream_LE+0x4c> + #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; + a96: 80 91 f2 00 lds r24, 0x00F2 + a9a: 88 23 and r24, r24 + a9c: b1 f7 brne .-20 ; 0xa8a <Endpoint_Read_Control_Stream_LE+0x38> + */ + 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)); + a9e: 80 91 e8 00 lds r24, 0x00E8 + aa2: 8b 77 andi r24, 0x7B ; 123 + aa4: 80 93 e8 00 sts 0x00E8, r24 + uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length)); + + if (!(Length)) + Endpoint_ClearOUT(); + + while (Length) + aa8: 61 15 cp r22, r1 + aaa: 71 05 cpc r23, r1 + aac: e9 f6 brne .-70 ; 0xa68 <Endpoint_Read_Control_Stream_LE+0x16> + aae: 06 c0 rjmp .+12 ; 0xabc <Endpoint_Read_Control_Stream_LE+0x6a> + } + } + + while (!(Endpoint_IsINReady())) + { + uint8_t USB_DeviceState_LCL = USB_DeviceState; + ab0: 80 91 0d 02 lds r24, 0x020D + + if (USB_DeviceState_LCL == DEVICE_STATE_Unattached) + ab4: 88 23 and r24, r24 + ab6: 41 f0 breq .+16 ; 0xac8 <Endpoint_Read_Control_Stream_LE+0x76> + return ENDPOINT_RWCSTREAM_DeviceDisconnected; + else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended) + ab8: 85 30 cpi r24, 0x05 ; 5 + aba: 41 f0 breq .+16 ; 0xacc <Endpoint_Read_Control_Stream_LE+0x7a> + * \return Boolean true if the current endpoint is ready for an IN packet, 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); + abc: 80 91 e8 00 lds r24, 0x00E8 + + Endpoint_ClearOUT(); + } + } + + while (!(Endpoint_IsINReady())) + ac0: 80 ff sbrs r24, 0 + ac2: f6 cf rjmp .-20 ; 0xab0 <Endpoint_Read_Control_Stream_LE+0x5e> + ac4: 80 e0 ldi r24, 0x00 ; 0 + ac6: 08 95 ret + ac8: 82 e0 ldi r24, 0x02 ; 2 + aca: 08 95 ret + acc: 83 e0 ldi r24, 0x03 ; 3 + else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended) + return ENDPOINT_RWCSTREAM_BusSuspended; + } + + return ENDPOINT_RWCSTREAM_NoError; +} + ace: 08 95 ret + +00000ad0 <USB_USBTask>: +#if defined(USB_CAN_BE_DEVICE) && !defined(DEVICE_STATE_AS_GPIOR) +volatile uint8_t USB_DeviceState; +#endif + +void USB_USBTask(void) +{ + ad0: 1f 93 push r17 +} + +#if defined(USB_CAN_BE_DEVICE) +static void USB_DeviceTask(void) +{ + if (USB_DeviceState != DEVICE_STATE_Unattached) + ad2: 80 91 0d 02 lds r24, 0x020D + ad6: 88 23 and r24, r24 + ad8: 61 f0 breq .+24 ; 0xaf2 <USB_USBTask+0x22> + */ + 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); + ada: 10 91 e9 00 lds r17, 0x00E9 + */ + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) ATTR_ALWAYS_INLINE; + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) + { + #if !defined(CONTROL_ONLY_DEVICE) + UENUM = EndpointNumber; + ade: 10 92 e9 00 sts 0x00E9, r1 + * \return Boolean true if the selected endpoint has received a SETUP packet, 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); + ae2: 80 91 e8 00 lds r24, 0x00E8 + { + uint8_t PrevEndpoint = Endpoint_GetCurrentEndpoint(); + + Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP); + + if (Endpoint_IsSETUPReceived()) + ae6: 83 ff sbrs r24, 3 + ae8: 01 c0 rjmp .+2 ; 0xaec <USB_USBTask+0x1c> + USB_Device_ProcessControlRequest(); + aea: c9 dd rcall .-1134 ; 0x67e <USB_Device_ProcessControlRequest> + */ + 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); + aec: 17 70 andi r17, 0x07 ; 7 + */ + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) ATTR_ALWAYS_INLINE; + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) + { + #if !defined(CONTROL_ONLY_DEVICE) + UENUM = EndpointNumber; + aee: 10 93 e9 00 sts 0x00E9, r17 + if (USB_CurrentMode == USB_MODE_Device) + USB_DeviceTask(); + else if (USB_CurrentMode == USB_MODE_Host) + USB_HostTask(); + #endif +} + af2: 1f 91 pop r17 + af4: 08 95 ret + +00000af6 <CDC_Device_Event_Stub>: +#include "CDC.h" + +void CDC_Device_Event_Stub(void) +{ + +} + af6: 08 95 ret + +00000af8 <CDC_Device_ReceiveByte>: + return 0; + } +} + +int16_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) +{ + af8: fc 01 movw r30, r24 + if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS)) + afa: 80 91 0d 02 lds r24, 0x020D + afe: 84 30 cpi r24, 0x04 ; 4 + b00: 21 f5 brne .+72 ; 0xb4a <CDC_Device_ReceiveByte+0x52> + b02: 87 85 ldd r24, Z+15 ; 0x0f + b04: 90 89 ldd r25, Z+16 ; 0x10 + b06: a1 89 ldd r26, Z+17 ; 0x11 + b08: b2 89 ldd r27, Z+18 ; 0x12 + b0a: 00 97 sbiw r24, 0x00 ; 0 + b0c: a1 05 cpc r26, r1 + b0e: b1 05 cpc r27, r1 + b10: e1 f0 breq .+56 ; 0xb4a <CDC_Device_ReceiveByte+0x52> + return -1; + + int16_t ReceivedByte = -1; + + Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber); + b12: 85 81 ldd r24, Z+5 ; 0x05 + */ + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) ATTR_ALWAYS_INLINE; + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) + { + #if !defined(CONTROL_ONLY_DEVICE) + UENUM = EndpointNumber; + b14: 80 93 e9 00 sts 0x00E9, r24 + * \return Boolean true if current endpoint is has received an OUT packet, 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); + b18: 80 91 e8 00 lds r24, 0x00E8 + + if (Endpoint_IsOUTReceived()) + b1c: 82 ff sbrs r24, 2 + b1e: 15 c0 rjmp .+42 ; 0xb4a <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; + b20: 80 91 f2 00 lds r24, 0x00F2 + { + if (Endpoint_BytesInEndpoint()) + b24: 88 23 and r24, r24 + b26: 19 f4 brne .+6 ; 0xb2e <CDC_Device_ReceiveByte+0x36> + b28: 2f ef ldi r18, 0xFF ; 255 + b2a: 3f ef ldi r19, 0xFF ; 255 + b2c: 04 c0 rjmp .+8 ; 0xb36 <CDC_Device_ReceiveByte+0x3e> + * \return Next byte in the currently selected endpoint's FIFO buffer. + */ + static inline uint8_t Endpoint_Read_Byte(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; + static inline uint8_t Endpoint_Read_Byte(void) + { + return UEDATX; + b2e: 80 91 f1 00 lds r24, 0x00F1 + ReceivedByte = Endpoint_Read_Byte(); + b32: 28 2f mov r18, r24 + b34: 30 e0 ldi r19, 0x00 ; 0 + #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; + b36: 80 91 f2 00 lds r24, 0x00F2 + + if (!(Endpoint_BytesInEndpoint())) + b3a: 88 23 and r24, r24 + b3c: 41 f4 brne .+16 ; 0xb4e <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)); + b3e: 80 91 e8 00 lds r24, 0x00E8 + b42: 8b 77 andi r24, 0x7B ; 123 + b44: 80 93 e8 00 sts 0x00E8, r24 + b48: 02 c0 rjmp .+4 ; 0xb4e <CDC_Device_ReceiveByte+0x56> + b4a: 2f ef ldi r18, 0xFF ; 255 + b4c: 3f ef ldi r19, 0xFF ; 255 + Endpoint_ClearOUT(); + } + + return ReceivedByte; +} + b4e: c9 01 movw r24, r18 + b50: 08 95 ret + +00000b52 <CDC_Device_CreateStream>: + Endpoint_ClearIN(); +} + +void CDC_Device_CreateStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, + FILE* const Stream) +{ + b52: fb 01 movw r30, r22 + *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar, _FDEV_SETUP_RW); + b54: 2e e0 ldi r18, 0x0E ; 14 + b56: db 01 movw r26, r22 + b58: 1d 92 st X+, r1 + b5a: 2a 95 dec r18 + b5c: e9 f7 brne .-6 ; 0xb58 <CDC_Device_CreateStream+0x6> + b5e: 23 e0 ldi r18, 0x03 ; 3 + b60: 23 83 std Z+3, r18 ; 0x03 + b62: 28 e2 ldi r18, 0x28 ; 40 + b64: 36 e0 ldi r19, 0x06 ; 6 + b66: 31 87 std Z+9, r19 ; 0x09 + b68: 20 87 std Z+8, r18 ; 0x08 + b6a: 2c eb ldi r18, 0xBC ; 188 + b6c: 35 e0 ldi r19, 0x05 ; 5 + b6e: 33 87 std Z+11, r19 ; 0x0b + b70: 22 87 std Z+10, r18 ; 0x0a + fdev_set_udata(Stream, CDCInterfaceInfo); + b72: 95 87 std Z+13, r25 ; 0x0d + b74: 84 87 std Z+12, r24 ; 0x0c +} + b76: 08 95 ret + +00000b78 <CDC_Device_getchar>: + return CDC_Device_SendByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : 0; +} + +static int CDC_Device_getchar(FILE* Stream) +{ + int16_t ReceivedByte = CDC_Device_ReceiveByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream)); + b78: fc 01 movw r30, r24 + b7a: 84 85 ldd r24, Z+12 ; 0x0c + b7c: 95 85 ldd r25, Z+13 ; 0x0d + b7e: bc df rcall .-136 ; 0xaf8 <CDC_Device_ReceiveByte> + b80: 9c 01 movw r18, r24 + + if (ReceivedByte < 0) + b82: 97 ff sbrs r25, 7 + b84: 02 c0 rjmp .+4 ; 0xb8a <CDC_Device_getchar+0x12> + b86: 2e ef ldi r18, 0xFE ; 254 + b88: 3f ef ldi r19, 0xFF ; 255 + return _FDEV_EOF; + + return ReceivedByte; +} + b8a: c9 01 movw r24, r18 + b8c: 08 95 ret + +00000b8e <CDC_Device_Flush>: + Endpoint_Write_Byte(Data); + return ENDPOINT_READYWAIT_NoError; +} + +uint8_t CDC_Device_Flush(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) +{ + b8e: fc 01 movw r30, r24 + if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS)) + b90: 80 91 0d 02 lds r24, 0x020D + b94: 84 30 cpi r24, 0x04 ; 4 + b96: 11 f5 brne .+68 ; 0xbdc <CDC_Device_Flush+0x4e> + b98: 87 85 ldd r24, Z+15 ; 0x0f + b9a: 90 89 ldd r25, Z+16 ; 0x10 + b9c: a1 89 ldd r26, Z+17 ; 0x11 + b9e: b2 89 ldd r27, Z+18 ; 0x12 + ba0: 00 97 sbiw r24, 0x00 ; 0 + ba2: a1 05 cpc r26, r1 + ba4: b1 05 cpc r27, r1 + ba6: d1 f0 breq .+52 ; 0xbdc <CDC_Device_Flush+0x4e> + return ENDPOINT_RWSTREAM_DeviceDisconnected; + + uint8_t ErrorCode; + + Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber); + ba8: 81 81 ldd r24, Z+1 ; 0x01 + */ + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) ATTR_ALWAYS_INLINE; + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) + { + #if !defined(CONTROL_ONLY_DEVICE) + UENUM = EndpointNumber; + baa: 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; + bae: 80 91 f2 00 lds r24, 0x00F2 + + if (!(Endpoint_BytesInEndpoint())) + bb2: 88 23 and r24, r24 + bb4: a9 f0 breq .+42 ; 0xbe0 <CDC_Device_Flush+0x52> + * \return Boolean true if the currently selected endpoint may be read from or written to, depending 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); + bb6: 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)); + bba: 80 91 e8 00 lds r24, 0x00E8 + bbe: 8e 77 andi r24, 0x7E ; 126 + bc0: 80 93 e8 00 sts 0x00E8, r24 + + bool BankFull = !(Endpoint_IsReadWriteAllowed()); + + Endpoint_ClearIN(); + + if (BankFull) + bc4: 95 fd sbrc r25, 5 + bc6: 0c c0 rjmp .+24 ; 0xbe0 <CDC_Device_Flush+0x52> + { + if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError) + bc8: 38 dc rcall .-1936 ; 0x43a <Endpoint_WaitUntilReady> + bca: 98 2f mov r25, r24 + bcc: 88 23 and r24, r24 + bce: 49 f4 brne .+18 ; 0xbe2 <CDC_Device_Flush+0x54> + bd0: 80 91 e8 00 lds r24, 0x00E8 + bd4: 8e 77 andi r24, 0x7E ; 126 + bd6: 80 93 e8 00 sts 0x00E8, r24 + bda: 03 c0 rjmp .+6 ; 0xbe2 <CDC_Device_Flush+0x54> + bdc: 92 e0 ldi r25, 0x02 ; 2 + bde: 01 c0 rjmp .+2 ; 0xbe2 <CDC_Device_Flush+0x54> + be0: 90 e0 ldi r25, 0x00 ; 0 + + Endpoint_ClearIN(); + } + + return ENDPOINT_READYWAIT_NoError; +} + be2: 89 2f mov r24, r25 + be4: 08 95 ret + +00000be6 <CDC_Device_USBTask>: + + return true; +} + +void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) +{ + be6: fc 01 movw r30, r24 + if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS)) + be8: 80 91 0d 02 lds r24, 0x020D + bec: 84 30 cpi r24, 0x04 ; 4 + bee: 51 f4 brne .+20 ; 0xc04 <CDC_Device_USBTask+0x1e> + bf0: 87 85 ldd r24, Z+15 ; 0x0f + bf2: 90 89 ldd r25, Z+16 ; 0x10 + bf4: a1 89 ldd r26, Z+17 ; 0x11 + bf6: b2 89 ldd r27, Z+18 ; 0x12 + bf8: 00 97 sbiw r24, 0x00 ; 0 + bfa: a1 05 cpc r26, r1 + bfc: b1 05 cpc r27, r1 + bfe: 11 f0 breq .+4 ; 0xc04 <CDC_Device_USBTask+0x1e> + return; + + #if !defined(NO_CLASS_DRIVER_AUTOFLUSH) + CDC_Device_Flush(CDCInterfaceInfo); + c00: cf 01 movw r24, r30 + c02: c5 cf rjmp .-118 ; 0xb8e <CDC_Device_Flush> + c04: 08 95 ret + +00000c06 <CDC_Device_SendByte>: + return Endpoint_Write_Stream_LE(Data, Length, NO_STREAM_CALLBACK); +} + +uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, + const uint8_t Data) +{ + c06: 1f 93 push r17 + c08: fc 01 movw r30, r24 + c0a: 16 2f mov r17, r22 + if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS)) + c0c: 80 91 0d 02 lds r24, 0x020D + c10: 84 30 cpi r24, 0x04 ; 4 + c12: d9 f4 brne .+54 ; 0xc4a <CDC_Device_SendByte+0x44> + c14: 87 85 ldd r24, Z+15 ; 0x0f + c16: 90 89 ldd r25, Z+16 ; 0x10 + c18: a1 89 ldd r26, Z+17 ; 0x11 + c1a: b2 89 ldd r27, Z+18 ; 0x12 + c1c: 00 97 sbiw r24, 0x00 ; 0 + c1e: a1 05 cpc r26, r1 + c20: b1 05 cpc r27, r1 + c22: 99 f0 breq .+38 ; 0xc4a <CDC_Device_SendByte+0x44> + return ENDPOINT_RWSTREAM_DeviceDisconnected; + + Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber); + c24: 81 81 ldd r24, Z+1 ; 0x01 + */ + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) ATTR_ALWAYS_INLINE; + static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) + { + #if !defined(CONTROL_ONLY_DEVICE) + UENUM = EndpointNumber; + c26: 80 93 e9 00 sts 0x00E9, r24 + * \return Boolean true if the currently selected endpoint may be read from or written to, depending 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); + c2a: 80 91 e8 00 lds r24, 0x00E8 + + if (!(Endpoint_IsReadWriteAllowed())) + c2e: 85 fd sbrc r24, 5 + c30: 08 c0 rjmp .+16 ; 0xc42 <CDC_Device_SendByte+0x3c> + */ + 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)); + c32: 80 91 e8 00 lds r24, 0x00E8 + c36: 8e 77 andi r24, 0x7E ; 126 + c38: 80 93 e8 00 sts 0x00E8, r24 + { + Endpoint_ClearIN(); + + uint8_t ErrorCode; + + if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError) + c3c: fe db rcall .-2052 ; 0x43a <Endpoint_WaitUntilReady> + c3e: 88 23 and r24, r24 + c40: 29 f4 brne .+10 ; 0xc4c <CDC_Device_SendByte+0x46> + * \param[in] Byte Next byte to write into the the currently selected endpoint's FIFO buffer. + */ + static inline void Endpoint_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE; + static inline void Endpoint_Write_Byte(const uint8_t Byte) + { + UEDATX = Byte; + c42: 10 93 f1 00 sts 0x00F1, r17 + c46: 80 e0 ldi r24, 0x00 ; 0 + c48: 01 c0 rjmp .+2 ; 0xc4c <CDC_Device_SendByte+0x46> + return ErrorCode; + } + + Endpoint_Write_Byte(Data); + return ENDPOINT_READYWAIT_NoError; + c4a: 82 e0 ldi r24, 0x02 ; 2 +} + c4c: 1f 91 pop r17 + c4e: 08 95 ret + +00000c50 <CDC_Device_putchar>: + fdev_set_udata(Stream, CDCInterfaceInfo); +} + +static int CDC_Device_putchar(char c, + FILE* Stream) +{ + c50: 28 2f mov r18, r24 + c52: fb 01 movw r30, r22 + return CDC_Device_SendByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : 0; + c54: 84 85 ldd r24, Z+12 ; 0x0c + c56: 95 85 ldd r25, Z+13 ; 0x0d + c58: 62 2f mov r22, r18 + c5a: d5 df rcall .-86 ; 0xc06 <CDC_Device_SendByte> + c5c: 88 23 and r24, r24 + c5e: 19 f4 brne .+6 ; 0xc66 <CDC_Device_putchar+0x16> + c60: 20 e0 ldi r18, 0x00 ; 0 + c62: 30 e0 ldi r19, 0x00 ; 0 + c64: 02 c0 rjmp .+4 ; 0xc6a <CDC_Device_putchar+0x1a> + c66: 2f ef ldi r18, 0xFF ; 255 + c68: 3f ef ldi r19, 0xFF ; 255 +} + c6a: c9 01 movw r24, r18 + c6c: 08 95 ret + +00000c6e <CDC_Device_ConfigureEndpoints>: + break; + } +} + +bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) +{ + c6e: 1f 93 push r17 + c70: cf 93 push r28 + c72: df 93 push r29 + c74: ec 01 movw r28, r24 + memset(&CDCInterfaceInfo->State, 0x00, sizeof(CDCInterfaceInfo->State)); + c76: 0d 96 adiw r24, 0x0d ; 13 + c78: fc 01 movw r30, r24 + c7a: 89 e0 ldi r24, 0x09 ; 9 + c7c: df 01 movw r26, r30 + c7e: 1d 92 st X+, r1 + c80: 8a 95 dec r24 + c82: e9 f7 brne .-6 ; 0xc7e <CDC_Device_ConfigureEndpoints+0x10> + c84: 11 e0 ldi r17, 0x01 ; 1 + uint16_t Size; + uint8_t Type; + uint8_t Direction; + bool DoubleBanked; + + if (EndpointNum == CDCInterfaceInfo->Config.DataINEndpointNumber) + c86: 89 81 ldd r24, Y+1 ; 0x01 + c88: 18 17 cp r17, r24 + c8a: 29 f4 brne .+10 ; 0xc96 <CDC_Device_ConfigureEndpoints+0x28> + { + Size = CDCInterfaceInfo->Config.DataINEndpointSize; + c8c: ea 81 ldd r30, Y+2 ; 0x02 + c8e: fb 81 ldd r31, Y+3 ; 0x03 + Direction = ENDPOINT_DIR_IN; + Type = EP_TYPE_BULK; + DoubleBanked = CDCInterfaceInfo->Config.DataINEndpointDoubleBank; + c90: 8c 81 ldd r24, Y+4 ; 0x04 + c92: 62 e0 ldi r22, 0x02 ; 2 + c94: 10 c0 rjmp .+32 ; 0xcb6 <CDC_Device_ConfigureEndpoints+0x48> + } + else if (EndpointNum == CDCInterfaceInfo->Config.DataOUTEndpointNumber) + c96: 8d 81 ldd r24, Y+5 ; 0x05 + c98: 18 17 cp r17, r24 + c9a: 31 f4 brne .+12 ; 0xca8 <CDC_Device_ConfigureEndpoints+0x3a> + { + Size = CDCInterfaceInfo->Config.DataOUTEndpointSize; + c9c: ee 81 ldd r30, Y+6 ; 0x06 + c9e: ff 81 ldd r31, Y+7 ; 0x07 + Direction = ENDPOINT_DIR_OUT; + Type = EP_TYPE_BULK; + DoubleBanked = CDCInterfaceInfo->Config.DataOUTEndpointDoubleBank; + ca0: 88 85 ldd r24, Y+8 ; 0x08 + ca2: 62 e0 ldi r22, 0x02 ; 2 + ca4: 30 e0 ldi r19, 0x00 ; 0 + ca6: 08 c0 rjmp .+16 ; 0xcb8 <CDC_Device_ConfigureEndpoints+0x4a> + } + else if (EndpointNum == CDCInterfaceInfo->Config.NotificationEndpointNumber) + ca8: 89 85 ldd r24, Y+9 ; 0x09 + caa: 18 17 cp r17, r24 + cac: 09 f5 brne .+66 ; 0xcf0 <CDC_Device_ConfigureEndpoints+0x82> + { + Size = CDCInterfaceInfo->Config.NotificationEndpointSize; + cae: ea 85 ldd r30, Y+10 ; 0x0a + cb0: fb 85 ldd r31, Y+11 ; 0x0b + Direction = ENDPOINT_DIR_IN; + Type = EP_TYPE_INTERRUPT; + DoubleBanked = CDCInterfaceInfo->Config.NotificationEndpointDoubleBank; + cb2: 8c 85 ldd r24, Y+12 ; 0x0c + cb4: 63 e0 ldi r22, 0x03 ; 3 + cb6: 31 e0 ldi r19, 0x01 ; 1 + else + { + continue; + } + + if (!(Endpoint_ConfigureEndpoint(EndpointNum, Type, Direction, Size, + cb8: 88 23 and r24, r24 + cba: 11 f4 brne .+4 ; 0xcc0 <CDC_Device_ConfigureEndpoints+0x52> + cbc: 40 e0 ldi r20, 0x00 ; 0 + cbe: 01 c0 rjmp .+2 ; 0xcc2 <CDC_Device_ConfigureEndpoints+0x54> + cc0: 44 e0 ldi r20, 0x04 ; 4 + cc2: 20 e0 ldi r18, 0x00 ; 0 + cc4: 88 e0 ldi r24, 0x08 ; 8 + cc6: 90 e0 ldi r25, 0x00 ; 0 + cc8: 03 c0 rjmp .+6 ; 0xcd0 <CDC_Device_ConfigureEndpoints+0x62> + uint8_t MaskVal = 0; + uint16_t CheckBytes = 8; + + while (CheckBytes < Bytes) + { + MaskVal++; + cca: 2f 5f subi r18, 0xFF ; 255 + CheckBytes <<= 1; + ccc: 88 0f add r24, r24 + cce: 99 1f adc r25, r25 + static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes) + { + uint8_t MaskVal = 0; + uint16_t CheckBytes = 8; + + while (CheckBytes < Bytes) + cd0: 8e 17 cp r24, r30 + cd2: 9f 07 cpc r25, r31 + cd4: d0 f3 brcs .-12 ; 0xcca <CDC_Device_ConfigureEndpoints+0x5c> + const uint8_t Type, + const uint8_t Direction, + const uint16_t Size, + const uint8_t Banks) + { + return Endpoint_ConfigureEndpoint_Prv(Number, (((Type) << EPTYPE0) | (Direction)), + cd6: 62 95 swap r22 + cd8: 66 0f add r22, r22 + cda: 66 0f add r22, r22 + cdc: 60 7c andi r22, 0xC0 ; 192 + cde: 63 2b or r22, r19 + ce0: 42 60 ori r20, 0x02 ; 2 + ce2: 22 95 swap r18 + ce4: 20 7f andi r18, 0xF0 ; 240 + ce6: 42 2b or r20, r18 + ce8: 81 2f mov r24, r17 + cea: 73 db rcall .-2330 ; 0x3d2 <Endpoint_ConfigureEndpoint_Prv> + cec: 88 23 and r24, r24 + cee: 21 f0 breq .+8 ; 0xcf8 <CDC_Device_ConfigureEndpoints+0x8a> + +bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) +{ + memset(&CDCInterfaceInfo->State, 0x00, sizeof(CDCInterfaceInfo->State)); + + for (uint8_t EndpointNum = 1; EndpointNum < ENDPOINT_TOTAL_ENDPOINTS; EndpointNum++) + cf0: 1f 5f subi r17, 0xFF ; 255 + cf2: 15 30 cpi r17, 0x05 ; 5 + cf4: 41 f6 brne .-112 ; 0xc86 <CDC_Device_ConfigureEndpoints+0x18> + cf6: 81 e0 ldi r24, 0x01 ; 1 + return false; + } + } + + return true; +} + cf8: df 91 pop r29 + cfa: cf 91 pop r28 + cfc: 1f 91 pop r17 + cfe: 08 95 ret + +00000d00 <CDC_Device_ProcessControlRequest>: +{ + +} + +void CDC_Device_ProcessControlRequest(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) +{ + d00: cf 93 push r28 + d02: df 93 push r29 + d04: ec 01 movw r28, r24 + * \return Boolean true if the selected endpoint has received a SETUP packet, 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); + d06: 80 91 e8 00 lds r24, 0x00E8 + if (!(Endpoint_IsSETUPReceived())) + d0a: 83 ff sbrs r24, 3 + d0c: 63 c0 rjmp .+198 ; 0xdd4 <CDC_Device_ProcessControlRequest+0xd4> + return; + + if (USB_ControlRequest.wIndex != CDCInterfaceInfo->Config.ControlInterfaceNumber) + d0e: 88 81 ld r24, Y + d10: 90 e0 ldi r25, 0x00 ; 0 + d12: 20 91 12 02 lds r18, 0x0212 + d16: 30 91 13 02 lds r19, 0x0213 + d1a: 28 17 cp r18, r24 + d1c: 39 07 cpc r19, r25 + d1e: 09 f0 breq .+2 ; 0xd22 <CDC_Device_ProcessControlRequest+0x22> + d20: 59 c0 rjmp .+178 ; 0xdd4 <CDC_Device_ProcessControlRequest+0xd4> + return; + + switch (USB_ControlRequest.bRequest) + d22: 80 91 0f 02 lds r24, 0x020F + d26: 81 32 cpi r24, 0x21 ; 33 + d28: 61 f0 breq .+24 ; 0xd42 <CDC_Device_ProcessControlRequest+0x42> + d2a: 82 32 cpi r24, 0x22 ; 34 + d2c: 20 f4 brcc .+8 ; 0xd36 <CDC_Device_ProcessControlRequest+0x36> + d2e: 80 32 cpi r24, 0x20 ; 32 + d30: 09 f0 breq .+2 ; 0xd34 <CDC_Device_ProcessControlRequest+0x34> + d32: 50 c0 rjmp .+160 ; 0xdd4 <CDC_Device_ProcessControlRequest+0xd4> + d34: 1b c0 rjmp .+54 ; 0xd6c <CDC_Device_ProcessControlRequest+0x6c> + d36: 82 32 cpi r24, 0x22 ; 34 + d38: 79 f1 breq .+94 ; 0xd98 <CDC_Device_ProcessControlRequest+0x98> + d3a: 83 32 cpi r24, 0x23 ; 35 + d3c: 09 f0 breq .+2 ; 0xd40 <CDC_Device_ProcessControlRequest+0x40> + d3e: 4a c0 rjmp .+148 ; 0xdd4 <CDC_Device_ProcessControlRequest+0xd4> + d40: 3b c0 rjmp .+118 ; 0xdb8 <CDC_Device_ProcessControlRequest+0xb8> + { + case CDC_REQ_GetLineEncoding: + if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE)) + d42: 80 91 0e 02 lds r24, 0x020E + d46: 81 3a cpi r24, 0xA1 ; 161 + d48: 09 f0 breq .+2 ; 0xd4c <CDC_Device_ProcessControlRequest+0x4c> + d4a: 44 c0 rjmp .+136 ; 0xdd4 <CDC_Device_ProcessControlRequest+0xd4> + * \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); + d4c: 80 91 e8 00 lds r24, 0x00E8 + d50: 87 7f andi r24, 0xF7 ; 247 + d52: 80 93 e8 00 sts 0x00E8, r24 + { + Endpoint_ClearSETUP(); + Endpoint_Write_Control_Stream_LE(&CDCInterfaceInfo->State.LineEncoding, sizeof(CDCInterfaceInfo->State.LineEncoding)); + d56: ce 01 movw r24, r28 + d58: 0f 96 adiw r24, 0x0f ; 15 + d5a: 67 e0 ldi r22, 0x07 ; 7 + d5c: 70 e0 ldi r23, 0x00 ; 0 + d5e: bc dd rcall .-1160 ; 0x8d8 <Endpoint_Write_Control_Stream_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)); + d60: 80 91 e8 00 lds r24, 0x00E8 + d64: 8b 77 andi r24, 0x7B ; 123 + d66: 80 93 e8 00 sts 0x00E8, r24 + d6a: 34 c0 rjmp .+104 ; 0xdd4 <CDC_Device_ProcessControlRequest+0xd4> + Endpoint_ClearOUT(); + } + + break; + case CDC_REQ_SetLineEncoding: + if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE)) + d6c: 80 91 0e 02 lds r24, 0x020E + d70: 81 32 cpi r24, 0x21 ; 33 + d72: 81 f5 brne .+96 ; 0xdd4 <CDC_Device_ProcessControlRequest+0xd4> + * \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); + d74: 80 91 e8 00 lds r24, 0x00E8 + d78: 87 7f andi r24, 0xF7 ; 247 + d7a: 80 93 e8 00 sts 0x00E8, r24 + { + Endpoint_ClearSETUP(); + Endpoint_Read_Control_Stream_LE(&CDCInterfaceInfo->State.LineEncoding, sizeof(CDCInterfaceInfo->State.LineEncoding)); + d7e: ce 01 movw r24, r28 + d80: 0f 96 adiw r24, 0x0f ; 15 + d82: 67 e0 ldi r22, 0x07 ; 7 + d84: 70 e0 ldi r23, 0x00 ; 0 + d86: 65 de rcall .-822 ; 0xa52 <Endpoint_Read_Control_Stream_LE> + */ + 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)); + d88: 80 91 e8 00 lds r24, 0x00E8 + d8c: 8e 77 andi r24, 0x7E ; 126 + d8e: 80 93 e8 00 sts 0x00E8, r24 + Endpoint_ClearIN(); + + EVENT_CDC_Device_LineEncodingChanged(CDCInterfaceInfo); + d92: ce 01 movw r24, r28 + d94: b0 de rcall .-672 ; 0xaf6 <CDC_Device_Event_Stub> + d96: 1e c0 rjmp .+60 ; 0xdd4 <CDC_Device_ProcessControlRequest+0xd4> + } + + break; + case CDC_REQ_SetControlLineState: + if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE)) + d98: 80 91 0e 02 lds r24, 0x020E + d9c: 81 32 cpi r24, 0x21 ; 33 + d9e: d1 f4 brne .+52 ; 0xdd4 <CDC_Device_ProcessControlRequest+0xd4> + * \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); + da0: 80 91 e8 00 lds r24, 0x00E8 + da4: 87 7f andi r24, 0xF7 ; 247 + da6: 80 93 e8 00 sts 0x00E8, r24 + { + Endpoint_ClearSETUP(); + Endpoint_ClearStatusStage(); + daa: 26 db rcall .-2484 ; 0x3f8 <Endpoint_ClearStatusStage> + + CDCInterfaceInfo->State.ControlLineStates.HostToDevice = USB_ControlRequest.wValue; + dac: 80 91 10 02 lds r24, 0x0210 + db0: 8d 87 std Y+13, r24 ; 0x0d + + EVENT_CDC_Device_ControLineStateChanged(CDCInterfaceInfo); + db2: ce 01 movw r24, r28 + db4: a0 de rcall .-704 ; 0xaf6 <CDC_Device_Event_Stub> + db6: 0e c0 rjmp .+28 ; 0xdd4 <CDC_Device_ProcessControlRequest+0xd4> + } + + break; + case CDC_REQ_SendBreak: + if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE)) + db8: 80 91 0e 02 lds r24, 0x020E + dbc: 81 32 cpi r24, 0x21 ; 33 + dbe: 51 f4 brne .+20 ; 0xdd4 <CDC_Device_ProcessControlRequest+0xd4> + dc0: 80 91 e8 00 lds r24, 0x00E8 + dc4: 87 7f andi r24, 0xF7 ; 247 + dc6: 80 93 e8 00 sts 0x00E8, r24 + { + Endpoint_ClearSETUP(); + Endpoint_ClearStatusStage(); + dca: 16 db rcall .-2516 ; 0x3f8 <Endpoint_ClearStatusStage> + + EVENT_CDC_Device_BreakSent(CDCInterfaceInfo, (uint8_t)USB_ControlRequest.wValue); + dcc: ce 01 movw r24, r28 + dce: 60 91 10 02 lds r22, 0x0210 + dd2: 91 de rcall .-734 ; 0xaf6 <CDC_Device_Event_Stub> + } + + break; + } +} + dd4: df 91 pop r29 + dd6: cf 91 pop r28 + dd8: 08 95 ret + +00000dda <strcmp>: + dda: fb 01 movw r30, r22 + ddc: dc 01 movw r26, r24 + dde: 8d 91 ld r24, X+ + de0: 01 90 ld r0, Z+ + de2: 80 19 sub r24, r0 + de4: 01 10 cpse r0, r1 + de6: d9 f3 breq .-10 ; 0xdde <strcmp+0x4> + de8: 99 0b sbc r25, r25 + dea: 08 95 ret + +00000dec <fputc>: + dec: 0f 93 push r16 + dee: 1f 93 push r17 + df0: cf 93 push r28 + df2: df 93 push r29 + df4: 8c 01 movw r16, r24 + df6: eb 01 movw r28, r22 + df8: 8b 81 ldd r24, Y+3 ; 0x03 + dfa: 81 ff sbrs r24, 1 + dfc: 1b c0 rjmp .+54 ; 0xe34 <fputc+0x48> + dfe: 82 ff sbrs r24, 2 + e00: 0d c0 rjmp .+26 ; 0xe1c <fputc+0x30> + e02: 2e 81 ldd r18, Y+6 ; 0x06 + e04: 3f 81 ldd r19, Y+7 ; 0x07 + e06: 8c 81 ldd r24, Y+4 ; 0x04 + e08: 9d 81 ldd r25, Y+5 ; 0x05 + e0a: 28 17 cp r18, r24 + e0c: 39 07 cpc r19, r25 + e0e: 64 f4 brge .+24 ; 0xe28 <fputc+0x3c> + e10: e8 81 ld r30, Y + e12: f9 81 ldd r31, Y+1 ; 0x01 + e14: 01 93 st Z+, r16 + e16: f9 83 std Y+1, r31 ; 0x01 + e18: e8 83 st Y, r30 + e1a: 06 c0 rjmp .+12 ; 0xe28 <fputc+0x3c> + e1c: e8 85 ldd r30, Y+8 ; 0x08 + e1e: f9 85 ldd r31, Y+9 ; 0x09 + e20: 80 2f mov r24, r16 + e22: 09 95 icall + e24: 89 2b or r24, r25 + e26: 31 f4 brne .+12 ; 0xe34 <fputc+0x48> + e28: 8e 81 ldd r24, Y+6 ; 0x06 + e2a: 9f 81 ldd r25, Y+7 ; 0x07 + e2c: 01 96 adiw r24, 0x01 ; 1 + e2e: 9f 83 std Y+7, r25 ; 0x07 + e30: 8e 83 std Y+6, r24 ; 0x06 + e32: 02 c0 rjmp .+4 ; 0xe38 <fputc+0x4c> + e34: 0f ef ldi r16, 0xFF ; 255 + e36: 1f ef ldi r17, 0xFF ; 255 + e38: c8 01 movw r24, r16 + e3a: df 91 pop r29 + e3c: cf 91 pop r28 + e3e: 1f 91 pop r17 + e40: 0f 91 pop r16 + e42: 08 95 ret + +00000e44 <fputs>: + e44: ef 92 push r14 + e46: ff 92 push r15 + e48: 0f 93 push r16 + e4a: 1f 93 push r17 + e4c: cf 93 push r28 + e4e: df 93 push r29 + e50: 7c 01 movw r14, r24 + e52: 8b 01 movw r16, r22 + e54: db 01 movw r26, r22 + e56: 13 96 adiw r26, 0x03 ; 3 + e58: 8c 91 ld r24, X + e5a: 81 fd sbrc r24, 1 + e5c: 03 c0 rjmp .+6 ; 0xe64 <fputs+0x20> + e5e: cf ef ldi r28, 0xFF ; 255 + e60: df ef ldi r29, 0xFF ; 255 + e62: 13 c0 rjmp .+38 ; 0xe8a <fputs+0x46> + e64: c0 e0 ldi r28, 0x00 ; 0 + e66: d0 e0 ldi r29, 0x00 ; 0 + e68: 0b c0 rjmp .+22 ; 0xe80 <fputs+0x3c> + e6a: d8 01 movw r26, r16 + e6c: 18 96 adiw r26, 0x08 ; 8 + e6e: ed 91 ld r30, X+ + e70: fc 91 ld r31, X + e72: 19 97 sbiw r26, 0x09 ; 9 + e74: b8 01 movw r22, r16 + e76: 09 95 icall + e78: 89 2b or r24, r25 + e7a: 11 f0 breq .+4 ; 0xe80 <fputs+0x3c> + e7c: cf ef ldi r28, 0xFF ; 255 + e7e: df ef ldi r29, 0xFF ; 255 + e80: f7 01 movw r30, r14 + e82: 81 91 ld r24, Z+ + e84: 7f 01 movw r14, r30 + e86: 88 23 and r24, r24 + e88: 81 f7 brne .-32 ; 0xe6a <fputs+0x26> + e8a: ce 01 movw r24, r28 + e8c: cd b7 in r28, 0x3d ; 61 + e8e: de b7 in r29, 0x3e ; 62 + e90: e6 e0 ldi r30, 0x06 ; 6 + e92: 0c c0 rjmp .+24 ; 0xeac <__epilogue_restores__+0x18> + +00000e94 <__epilogue_restores__>: + e94: 2a 88 ldd r2, Y+18 ; 0x12 + e96: 39 88 ldd r3, Y+17 ; 0x11 + e98: 48 88 ldd r4, Y+16 ; 0x10 + e9a: 5f 84 ldd r5, Y+15 ; 0x0f + e9c: 6e 84 ldd r6, Y+14 ; 0x0e + e9e: 7d 84 ldd r7, Y+13 ; 0x0d + ea0: 8c 84 ldd r8, Y+12 ; 0x0c + ea2: 9b 84 ldd r9, Y+11 ; 0x0b + ea4: aa 84 ldd r10, Y+10 ; 0x0a + ea6: b9 84 ldd r11, Y+9 ; 0x09 + ea8: c8 84 ldd r12, Y+8 ; 0x08 + eaa: df 80 ldd r13, Y+7 ; 0x07 + eac: ee 80 ldd r14, Y+6 ; 0x06 + eae: fd 80 ldd r15, Y+5 ; 0x05 + eb0: 0c 81 ldd r16, Y+4 ; 0x04 + eb2: 1b 81 ldd r17, Y+3 ; 0x03 + eb4: aa 81 ldd r26, Y+2 ; 0x02 + eb6: b9 81 ldd r27, Y+1 ; 0x01 + eb8: ce 0f add r28, r30 + eba: d1 1d adc r29, r1 + ebc: 0f b6 in r0, 0x3f ; 63 + ebe: f8 94 cli + ec0: de bf out 0x3e, r29 ; 62 + ec2: 0f be out 0x3f, r0 ; 63 + ec4: cd bf out 0x3d, r28 ; 61 + ec6: ed 01 movw r28, r26 + ec8: 08 95 ret + +00000eca <_exit>: + eca: f8 94 cli + +00000ecc <__stop_program>: + ecc: ff cf rjmp .-2 ; 0xecc <__stop_program> |