AudioInputHost.elf: file format elf32-avr Sections: Idx Name Size VMA LMA File off Algn 0 .data 0000001c 00800100 000018fa 0000198e 2**0 CONTENTS, ALLOC, LOAD, DATA 1 .text 000018fa 00000000 00000000 00000094 2**1 CONTENTS, ALLOC, LOAD, READONLY, CODE 2 .bss 00000024 0080011c 0080011c 000019aa 2**0 ALLOC 3 .stab 00000e28 00000000 00000000 000019ac 2**2 CONTENTS, READONLY, DEBUGGING 4 .stabstr 0000026b 00000000 00000000 000027d4 2**0 CONTENTS, READONLY, DEBUGGING 5 .debug_aranges 000003b0 00000000 00000000 00002a3f 2**0 CONTENTS, READONLY, DEBUGGING 6 .debug_pubnames 0000089a 00000000 00000000 00002def 2**0 CONTENTS, READONLY, DEBUGGING 7 .debug_info 000056c7 00000000 00000000 00003689 2**0 CONTENTS, READONLY, DEBUGGING 8 .debug_abbrev 00001b65 00000000 00000000 00008d50 2**0 CONTENTS, READONLY, DEBUGGING 9 .debug_line 000053bf 00000000 00000000 0000a8b5 2**0 CONTENTS, READONLY, DEBUGGING 10 .debug_frame 00000540 00000000 00000000 0000fc74 2**2 CONTENTS, READONLY, DEBUGGING 11 .debug_str 000026bf 00000000 00000000 000101b4 2**0 CONTENTS, READONLY, DEBUGGING 12 .debug_loc 00003422 00000000 00000000 00012873 2**0 CONTENTS, READONLY, DEBUGGING 13 .debug_pubtypes 00000a86 00000000 00000000 00015c95 2**0 CONTENTS, READONLY, DEBUGGING 14 .debug_ranges 00000490 00000000 00000000 0001671b 2**0 CONTENTS, READONLY, DEBUGGING Disassembly of section .text: 00000000 <__vectors>: 0: 51 c1 rjmp .+674 ; 0x2a4 <__ctors_end> 2: 00 00 nop 4: 6d c1 rjmp .+730 ; 0x2e0 <__bad_interrupt> 6: 00 00 nop 8: 6b c1 rjmp .+726 ; 0x2e0 <__bad_interrupt> a: 00 00 nop c: 69 c1 rjmp .+722 ; 0x2e0 <__bad_interrupt> e: 00 00 nop 10: 67 c1 rjmp .+718 ; 0x2e0 <__bad_interrupt> 12: 00 00 nop 14: 65 c1 rjmp .+714 ; 0x2e0 <__bad_interrupt> 16: 00 00 nop 18: 63 c1 rjmp .+710 ; 0x2e0 <__bad_interrupt> 1a: 00 00 nop 1c: 61 c1 rjmp .+706 ; 0x2e0 <__bad_interrupt> 1e: 00 00 nop 20: 5f c1 rjmp .+702 ; 0x2e0 <__bad_interrupt> 22: 00 00 nop 24: 5d c1 rjmp .+698 ; 0x2e0 <__bad_interrupt> 26: 00 00 nop 28: d5 c6 rjmp .+3498 ; 0xdd4 <__vector_10> 2a: 00 00 nop 2c: 59 c1 rjmp .+690 ; 0x2e0 <__bad_interrupt> 2e: 00 00 nop 30: 57 c1 rjmp .+686 ; 0x2e0 <__bad_interrupt> 32: 00 00 nop 34: 55 c1 rjmp .+682 ; 0x2e0 <__bad_interrupt> 36: 00 00 nop 38: 53 c1 rjmp .+678 ; 0x2e0 <__bad_interrupt> 3a: 00 00 nop 3c: 51 c1 rjmp .+674 ; 0x2e0 <__bad_interrupt> 3e: 00 00 nop 40: 4f c1 rjmp .+670 ; 0x2e0 <__bad_interrupt> 42: 00 00 nop 44: 4d c1 rjmp .+666 ; 0x2e0 <__bad_interrupt> 46: 00 00 nop 48: 4b c1 rjmp .+662 ; 0x2e0 <__bad_interrupt> 4a: 00 00 nop 4c: 49 c1 rjmp .+658 ; 0x2e0 <__bad_interrupt> 4e: 00 00 nop 50: 47 c1 rjmp .+654 ; 0x2e0 <__bad_interrupt> 52: 00 00 nop 54: 8b c2 rjmp .+1302 ; 0x56c <__vector_21> 56: 00 00 nop 58: 43 c1 rjmp .+646 ; 0x2e0 <__bad_interrupt> 5a: 00 00 nop 5c: 41 c1 rjmp .+642 ; 0x2e0 <__bad_interrupt> 5e: 00 00 nop 60: 3f c1 rjmp .+638 ; 0x2e0 <__bad_interrupt> 62: 00 00 nop 64: 3d c1 rjmp .+634 ; 0x2e0 <__bad_interrupt> 66: 00 00 nop 68: 3b c1 rjmp .+630 ; 0x2e0 <__bad_interrupt> 6a: 00 00 nop 6c: 39 c1 rjmp .+626 ; 0x2e0 <__bad_interrupt> 6e: 00 00 nop 70: 37 c1 rjmp .+622 ; 0x2e0 <__bad_interrupt> 72: 00 00 nop 74: 35 c1 rjmp .+618 ; 0x2e0 <__bad_interrupt> 76: 00 00 nop 78: 33 c1 rjmp .+614 ; 0x2e0 <__bad_interrupt> 7a: 00 00 nop 7c: 31 c1 rjmp .+610 ; 0x2e0 <__bad_interrupt> 7e: 00 00 nop 80: 2f c1 rjmp .+606 ; 0x2e0 <__bad_interrupt> 82: 00 00 nop 84: 2d c1 rjmp .+602 ; 0x2e0 <__bad_interrupt> 86: 00 00 nop 88: 2b c1 rjmp .+598 ; 0x2e0 <__bad_interrupt> 8a: 00 00 nop 8c: 29 c1 rjmp .+594 ; 0x2e0 <__bad_interrupt> 8e: 00 00 nop 90: 27 c1 rjmp .+590 ; 0x2e0 <__bad_interrupt> 92: 00 00 nop 94: 25 c1 rjmp .+586 ; 0x2e0 <__bad_interrupt> 96: 00 00 nop 00000098 <__c.3939>: 98: 4d 69 63 72 6f 70 68 6f 6e 65 20 45 6e 75 6d 65 Microphone Enume a8: 72 61 74 65 64 2e 0d 0a 00 rated.... 000000b1 <__c.3935>: b1: 1b 5b 33 31 6d 43 6f 75 6c 64 20 6e 6f 74 20 73 .[31mCould not s c1: 65 74 20 61 6c 74 65 72 6e 61 74 69 76 65 20 73 et alternative s d1: 74 72 65 61 6d 69 6e 67 20 69 6e 74 65 72 66 61 treaming interfa e1: 63 65 20 73 65 74 74 69 6e 67 2e 0d 0a 20 2d 2d ce setting... -- f1: 20 45 72 72 6f 72 20 43 6f 64 65 3a 20 25 64 0d Error Code: %d. 101: 0a 1b 5b 33 37 6d 00 ..[37m. 00000108 <__c.3933>: 108: 1b 5b 33 31 6d 43 6f 6e 74 72 6f 6c 20 45 72 72 .[31mControl Err 118: 6f 72 20 28 53 65 74 20 43 6f 6e 66 69 67 75 72 or (Set Configur 128: 61 74 69 6f 6e 29 2e 0d 0a 20 2d 2d 20 45 72 72 ation)... -- Err 138: 6f 72 20 43 6f 64 65 3a 20 25 64 0d 0a 1b 5b 33 or Code: %d...[3 148: 37 6d 00 7m. 0000014b <__c.3930>: 14b: 20 2d 2d 20 45 72 72 6f 72 20 43 6f 64 65 3a 20 -- Error Code: 15b: 25 64 0d 0a 1b 5b 33 37 6d 00 %d...[37m. 00000165 <__c.3928>: 165: 1b 5b 33 31 6d 49 6e 76 61 6c 69 64 20 44 65 76 .[31mInvalid Dev 175: 69 63 65 2e 0d 0a 00 ice.... 0000017c <__c.3926>: 17c: 1b 5b 33 31 6d 43 6f 6e 74 72 6f 6c 20 45 72 72 .[31mControl Err 18c: 6f 72 20 28 47 65 74 20 43 6f 6e 66 69 67 75 72 or (Get Configur 19c: 61 74 69 6f 6e 29 2e 0d 0a 00 ation).... 000001a6 <__c.3924>: 1a6: 47 65 74 74 69 6e 67 20 43 6f 6e 66 69 67 20 44 Getting Config D 1b6: 61 74 61 2e 0d 0a 00 ata.... 000001bd <__c.3917>: 1bd: 1b 5b 33 31 6d 44 65 76 20 45 6e 75 6d 20 45 72 .[31mDev Enum Er 1cd: 72 6f 72 0d 0a 20 2d 2d 20 45 72 72 6f 72 20 43 ror.. -- Error C 1dd: 6f 64 65 20 25 64 0d 0a 20 2d 2d 20 53 75 62 20 ode %d.. -- Sub 1ed: 45 72 72 6f 72 20 43 6f 64 65 20 25 64 0d 0a 20 Error Code %d.. 1fd: 2d 2d 20 49 6e 20 53 74 61 74 65 20 25 64 0d 0a -- In State %d.. 20d: 1b 5b 33 37 6d 00 .[37m. 00000213 <__c.3910>: 213: 1b 5b 33 31 6d 48 6f 73 74 20 4d 6f 64 65 20 45 .[31mHost Mode E 223: 72 72 6f 72 0d 0a 20 2d 2d 20 45 72 72 6f 72 20 rror.. -- Error 233: 43 6f 64 65 20 25 64 0d 0a 1b 5b 33 37 6d 00 Code %d...[37m. 00000242 <__c.3902>: 242: 1b 5b 33 32 6d 44 65 76 69 63 65 20 55 6e 61 74 .[32mDevice Unat 252: 74 61 63 68 65 64 2e 0d 0a 1b 5b 33 37 6d 00 tached....[37m. 00000261 <__c.3897>: 261: 1b 5b 33 32 6d 44 65 76 69 63 65 20 41 74 74 61 .[32mDevice Atta 271: 63 68 65 64 2e 0d 0a 1b 5b 33 37 6d 00 ched....[37m. 0000027e <__c.3888>: 27e: 1b 5b 33 36 6d 41 75 64 69 6f 20 48 6f 73 74 20 .[36mAudio Host 28e: 44 65 6d 6f 20 72 75 6e 6e 69 6e 67 2e 0d 0a 1b Demo running.... 29e: 5b 33 37 6d 00 00 [37m.. 000002a4 <__ctors_end>: 2a4: 11 24 eor r1, r1 2a6: 1f be out 0x3f, r1 ; 63 2a8: cf ef ldi r28, 0xFF ; 255 2aa: d0 e2 ldi r29, 0x20 ; 32 2ac: de bf out 0x3e, r29 ; 62 2ae: cd bf out 0x3d, r28 ; 61 000002b0 <__do_copy_data>: 2b0: 11 e0 ldi r17, 0x01 ; 1 2b2: a0 e0 ldi r26, 0x00 ; 0 2b4: b1 e0 ldi r27, 0x01 ; 1 2b6: ea ef ldi r30, 0xFA ; 250 2b8: f8 e1 ldi r31, 0x18 ; 24 2ba: 00 e0 ldi r16, 0x00 ; 0 2bc: 0b bf out 0x3b, r16 ; 59 2be: 02 c0 rjmp .+4 ; 0x2c4 <__do_copy_data+0x14> 2c0: 07 90 elpm r0, Z+ 2c2: 0d 92 st X+, r0 2c4: ac 31 cpi r26, 0x1C ; 28 2c6: b1 07 cpc r27, r17 2c8: d9 f7 brne .-10 ; 0x2c0 <__do_copy_data+0x10> 000002ca <__do_clear_bss>: 2ca: 11 e0 ldi r17, 0x01 ; 1 2cc: ac e1 ldi r26, 0x1C ; 28 2ce: b1 e0 ldi r27, 0x01 ; 1 2d0: 01 c0 rjmp .+2 ; 0x2d4 <.do_clear_bss_start> 000002d2 <.do_clear_bss_loop>: 2d2: 1d 92 st X+, r1 000002d4 <.do_clear_bss_start>: 2d4: a0 34 cpi r26, 0x40 ; 64 2d6: b1 07 cpc r27, r17 2d8: e1 f7 brne .-8 ; 0x2d2 <.do_clear_bss_loop> 2da: 3e d1 rcall .+636 ; 0x558
2dc: 0c 94 7b 0c jmp 0x18f6 ; 0x18f6 <_exit> 000002e0 <__bad_interrupt>: 2e0: 8f ce rjmp .-738 ; 0x0 <__vectors> 000002e2 : PORTD &= ~LEDMask; } static inline void LEDs_SetAllLEDs(const uint8_t LEDMask) { PORTD = ((PORTD & ~LEDS_ALL_LEDS) | LEDMask); 2e2: 9b b1 in r25, 0x0b ; 11 2e4: 9f 70 andi r25, 0x0F ; 15 2e6: 98 2b or r25, r24 2e8: 9b b9 out 0x0b, r25 ; 11 } 2ea: 08 95 ret 000002ec : /** 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); 2ec: 84 b7 in r24, 0x34 ; 52 2ee: 87 7f andi r24, 0xF7 ; 247 2f0: 84 bf out 0x34, r24 ; 52 wdt_disable(); 2f2: 28 e1 ldi r18, 0x18 ; 24 2f4: 0f b6 in r0, 0x3f ; 63 2f6: f8 94 cli 2f8: 20 93 60 00 sts 0x0060, r18 2fc: 10 92 60 00 sts 0x0060, r1 300: 0f be out 0x3f, r0 ; 63 The type of x is clock_div_t. */ void clock_prescale_set(clock_div_t __x) { uint8_t __tmp = _BV(CLKPCE); __asm__ __volatile__ ( 302: 90 e0 ldi r25, 0x00 ; 0 304: 80 e8 ldi r24, 0x80 ; 128 306: 0f b6 in r0, 0x3f ; 63 308: f8 94 cli 30a: 80 93 61 00 sts 0x0061, r24 30e: 90 93 61 00 sts 0x0061, r25 312: 0f be out 0x3f, r0 ; 63 * \param[in] DoubleSpeed Enables double speed mode when set, halving the sample time to double the baud rate. */ static inline void Serial_Init(const uint32_t BaudRate, const bool DoubleSpeed) { UBRR1 = (DoubleSpeed ? SERIAL_2X_UBBRVAL(BaudRate) : SERIAL_UBBRVAL(BaudRate)); 314: 83 e3 ldi r24, 0x33 ; 51 316: 90 e0 ldi r25, 0x00 ; 0 318: 90 93 cd 00 sts 0x00CD, r25 31c: 80 93 cc 00 sts 0x00CC, r24 UCSR1C = ((1 << UCSZ11) | (1 << UCSZ10)); 320: 86 e0 ldi r24, 0x06 ; 6 322: 80 93 ca 00 sts 0x00CA, r24 UCSR1A = (DoubleSpeed ? (1 << U2X1) : 0); 326: 10 92 c8 00 sts 0x00C8, r1 UCSR1B = ((1 << TXEN1) | (1 << RXEN1)); 32a: 20 93 c9 00 sts 0x00C9, r18 DDRD |= (1 << 3); 32e: 53 9a sbi 0x0a, 3 ; 10 PORTD |= (1 << 2); 330: 5a 9a sbi 0x0b, 2 ; 11 /* Inline Functions: */ #if !defined(__DOXYGEN__) static inline void LEDs_Init(void) { DDRD |= LEDS_ALL_LEDS; 332: 8a b1 in r24, 0x0a ; 10 334: 80 6f ori r24, 0xF0 ; 240 336: 8a b9 out 0x0a, r24 ; 10 PORTD &= ~LEDS_ALL_LEDS; 338: 8b b1 in r24, 0x0b ; 11 33a: 8f 70 andi r24, 0x0F ; 15 33c: 8b b9 out 0x0b, r24 ; 11 clock_prescale_set(clock_div_1); /* Hardware Initialization */ Serial_Init(9600, false); LEDs_Init(); USB_Init(); 33e: 34 d5 rcall .+2664 ; 0xda8 static inline void Serial_CreateStream(FILE* Stream) { if (!(Stream)) { Stream = &USARTSerialStream; stdin = Stream; 340: ec e2 ldi r30, 0x2C ; 44 342: f1 e0 ldi r31, 0x01 ; 1 344: f0 93 3b 01 sts 0x013B, r31 348: e0 93 3a 01 sts 0x013A, r30 stdout = Stream; 34c: f0 93 3d 01 sts 0x013D, r31 350: e0 93 3c 01 sts 0x013C, r30 } *Stream = (FILE)FDEV_SETUP_STREAM(Serial_putchar, Serial_getchar, _FDEV_SETUP_RW); 354: 8e e0 ldi r24, 0x0E ; 14 356: df 01 movw r26, r30 358: 1d 92 st X+, r1 35a: 8a 95 dec r24 35c: e9 f7 brne .-6 ; 0x358 35e: 83 e0 ldi r24, 0x03 ; 3 360: 80 93 2f 01 sts 0x012F, r24 364: 85 e6 ldi r24, 0x65 ; 101 366: 99 e0 ldi r25, 0x09 ; 9 368: 90 93 35 01 sts 0x0135, r25 36c: 80 93 34 01 sts 0x0134, r24 370: 8e e6 ldi r24, 0x6E ; 110 372: 99 e0 ldi r25, 0x09 ; 9 374: 90 93 37 01 sts 0x0137, r25 378: 80 93 36 01 sts 0x0136, r24 /* Create a stdio stream for the serial port for stdin and stdout */ Serial_CreateStream(NULL); } 37c: 08 95 ret 0000037e : /** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and * starts the library USB task to begin the enumeration and USB management process. */ void EVENT_USB_Host_DeviceAttached(void) { puts_P(PSTR(ESC_FG_GREEN "Device Attached.\r\n" ESC_FG_WHITE)); 37e: 81 e6 ldi r24, 0x61 ; 97 380: 92 e0 ldi r25, 0x02 ; 2 382: de d7 rcall .+4028 ; 0x1340 LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING); 384: 80 ea ldi r24, 0xA0 ; 160 } 386: ad cf rjmp .-166 ; 0x2e2 00000388 : /** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and * stops the library USB task management process. */ void EVENT_USB_Host_DeviceUnattached(void) { puts_P(PSTR(ESC_FG_GREEN "Device Unattached.\r\n" ESC_FG_WHITE)); 388: 82 e4 ldi r24, 0x42 ; 66 38a: 92 e0 ldi r25, 0x02 ; 2 38c: d9 d7 rcall .+4018 ; 0x1340 LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY); 38e: 80 e1 ldi r24, 0x10 ; 16 } 390: a8 cf rjmp .-176 ; 0x2e2 00000392 : /** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully * enumerated by the host and is now ready to be used by the application. */ void EVENT_USB_Host_DeviceEnumerationComplete(void) { LEDs_SetAllLEDs(LEDMASK_USB_READY); 392: 80 e6 ldi r24, 0x60 ; 96 } 394: a6 cf rjmp .-180 ; 0x2e2 00000396 : /** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */ void EVENT_USB_Host_HostError(const uint8_t ErrorCode) { 396: df 93 push r29 398: cf 93 push r28 39a: 0f 92 push r0 39c: cd b7 in r28, 0x3d ; 61 39e: de b7 in r29, 0x3e ; 62 USB_Disable(); 3a0: 89 83 std Y+1, r24 ; 0x01 3a2: 9c d4 rcall .+2360 ; 0xcdc printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n" 3a4: 00 d0 rcall .+0 ; 0x3a6 3a6: 00 d0 rcall .+0 ; 0x3a8 3a8: ed b7 in r30, 0x3d ; 61 3aa: fe b7 in r31, 0x3e ; 62 3ac: 31 96 adiw r30, 0x01 ; 1 3ae: 23 e1 ldi r18, 0x13 ; 19 3b0: 32 e0 ldi r19, 0x02 ; 2 3b2: ad b7 in r26, 0x3d ; 61 3b4: be b7 in r27, 0x3e ; 62 3b6: 12 96 adiw r26, 0x02 ; 2 3b8: 3c 93 st X, r19 3ba: 2e 93 st -X, r18 3bc: 11 97 sbiw r26, 0x01 ; 1 3be: 89 81 ldd r24, Y+1 ; 0x01 3c0: 82 83 std Z+2, r24 ; 0x02 3c2: 13 82 std Z+3, r1 ; 0x03 3c4: 9e d7 rcall .+3900 ; 0x1302 " -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode); LEDs_SetAllLEDs(LEDMASK_USB_ERROR); 3c6: 0f 90 pop r0 3c8: 0f 90 pop r0 3ca: 0f 90 pop r0 3cc: 0f 90 pop r0 3ce: 80 e9 ldi r24, 0x90 ; 144 3d0: 88 df rcall .-240 ; 0x2e2 3d2: ff cf rjmp .-2 ; 0x3d2 000003d4 : * enumerating an attached USB device. */ void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode) { printf_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n" 3d4: 90 91 2b 01 lds r25, 0x012B 3d8: 2d b7 in r18, 0x3d ; 61 3da: 3e b7 in r19, 0x3e ; 62 3dc: 28 50 subi r18, 0x08 ; 8 3de: 30 40 sbci r19, 0x00 ; 0 3e0: 0f b6 in r0, 0x3f ; 63 3e2: f8 94 cli 3e4: 3e bf out 0x3e, r19 ; 62 3e6: 0f be out 0x3f, r0 ; 63 3e8: 2d bf out 0x3d, r18 ; 61 3ea: ed b7 in r30, 0x3d ; 61 3ec: fe b7 in r31, 0x3e ; 62 3ee: 31 96 adiw r30, 0x01 ; 1 3f0: 2d eb ldi r18, 0xBD ; 189 3f2: 31 e0 ldi r19, 0x01 ; 1 3f4: ad b7 in r26, 0x3d ; 61 3f6: be b7 in r27, 0x3e ; 62 3f8: 12 96 adiw r26, 0x02 ; 2 3fa: 3c 93 st X, r19 3fc: 2e 93 st -X, r18 3fe: 11 97 sbiw r26, 0x01 ; 1 400: 82 83 std Z+2, r24 ; 0x02 402: 13 82 std Z+3, r1 ; 0x03 404: 64 83 std Z+4, r22 ; 0x04 406: 15 82 std Z+5, r1 ; 0x05 408: 96 83 std Z+6, r25 ; 0x06 40a: 17 82 std Z+7, r1 ; 0x07 40c: 7a d7 rcall .+3828 ; 0x1302 " -- Error Code %d\r\n" " -- Sub Error Code %d\r\n" " -- In State %d\r\n" ESC_FG_WHITE), ErrorCode, SubErrorCode, USB_HostState); LEDs_SetAllLEDs(LEDMASK_USB_ERROR); 40e: 2d b7 in r18, 0x3d ; 61 410: 3e b7 in r19, 0x3e ; 62 412: 28 5f subi r18, 0xF8 ; 248 414: 3f 4f sbci r19, 0xFF ; 255 416: 0f b6 in r0, 0x3f ; 63 418: f8 94 cli 41a: 3e bf out 0x3e, r19 ; 62 41c: 0f be out 0x3f, r0 ; 63 41e: 2d bf out 0x3d, r18 ; 61 420: 80 e9 ldi r24, 0x90 ; 144 } 422: 5f cf rjmp .-322 ; 0x2e2 00000424 : void Audio_Task(void) { 424: 1f 93 push r17 426: df 93 push r29 428: cf 93 push r28 42a: 00 d0 rcall .+0 ; 0x42c 42c: 0f 92 push r0 42e: cd b7 in r28, 0x3d ; 61 430: de b7 in r29, 0x3e ; 62 uint8_t ErrorCode; switch (USB_HostState) 432: 80 91 2b 01 lds r24, 0x012B 436: 8b 30 cpi r24, 0x0B ; 11 438: 09 f0 breq .+2 ; 0x43c 43a: 87 c0 rjmp .+270 ; 0x54a { case HOST_STATE_Addressed: puts_P(PSTR("Getting Config Data.\r\n")); 43c: 86 ea ldi r24, 0xA6 ; 166 43e: 91 e0 ldi r25, 0x01 ; 1 440: 7f d7 rcall .+3838 ; 0x1340 /* Get and process the configuration descriptor data */ if ((ErrorCode = ProcessConfigurationDescriptor()) != SuccessfulConfigRead) 442: 30 d1 rcall .+608 ; 0x6a4 444: 18 2f mov r17, r24 446: 88 23 and r24, r24 448: e9 f0 breq .+58 ; 0x484 { if (ErrorCode == ControlError) 44a: 81 30 cpi r24, 0x01 ; 1 44c: 19 f4 brne .+6 ; 0x454 puts_P(PSTR(ESC_FG_RED "Control Error (Get Configuration).\r\n")); 44e: 8c e7 ldi r24, 0x7C ; 124 450: 91 e0 ldi r25, 0x01 ; 1 452: 02 c0 rjmp .+4 ; 0x458 else puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n")); 454: 85 e6 ldi r24, 0x65 ; 101 456: 91 e0 ldi r25, 0x01 ; 1 458: 73 d7 rcall .+3814 ; 0x1340 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode); 45a: 00 d0 rcall .+0 ; 0x45c 45c: 00 d0 rcall .+0 ; 0x45e 45e: ed b7 in r30, 0x3d ; 61 460: fe b7 in r31, 0x3e ; 62 462: 31 96 adiw r30, 0x01 ; 1 464: 2b e4 ldi r18, 0x4B ; 75 466: 31 e0 ldi r19, 0x01 ; 1 468: ad b7 in r26, 0x3d ; 61 46a: be b7 in r27, 0x3e ; 62 46c: 12 96 adiw r26, 0x02 ; 2 46e: 3c 93 st X, r19 470: 2e 93 st -X, r18 472: 11 97 sbiw r26, 0x01 ; 1 474: 12 83 std Z+2, r17 ; 0x02 476: 13 82 std Z+3, r1 ; 0x03 478: 44 d7 rcall .+3720 ; 0x1302 /* Indicate error status */ LEDs_SetAllLEDs(LEDMASK_USB_ERROR); 47a: 0f 90 pop r0 47c: 0f 90 pop r0 47e: 0f 90 pop r0 480: 0f 90 pop r0 482: 4a c0 rjmp .+148 ; 0x518 USB_HostState = HOST_STATE_WaitForDeviceRemoval; break; } /* Set the device configuration to the first configuration (rarely do devices use multiple configurations) */ if ((ErrorCode = USB_Host_SetDeviceConfiguration(1)) != HOST_SENDCONTROL_Successful) 484: 81 e0 ldi r24, 0x01 ; 1 486: 82 d3 rcall .+1796 ; 0xb8c 488: 88 23 and r24, r24 48a: 41 f0 breq .+16 ; 0x49c { printf_P(PSTR(ESC_FG_RED "Control Error (Set Configuration).\r\n" 48c: 00 d0 rcall .+0 ; 0x48e 48e: 00 d0 rcall .+0 ; 0x490 490: ed b7 in r30, 0x3d ; 61 492: fe b7 in r31, 0x3e ; 62 494: 31 96 adiw r30, 0x01 ; 1 496: 28 e0 ldi r18, 0x08 ; 8 498: 31 e0 ldi r19, 0x01 ; 1 49a: 0e c0 rjmp .+28 ; 0x4b8 /* Wait until USB device disconnected */ USB_HostState = HOST_STATE_WaitForDeviceRemoval; break; } if ((ErrorCode = USB_Host_SetInterfaceAltSetting(StreamingInterfaceIndex, 49c: 80 91 1c 01 lds r24, 0x011C 4a0: 60 91 1d 01 lds r22, 0x011D 4a4: 89 d3 rcall .+1810 ; 0xbb8 4a6: 88 23 and r24, r24 4a8: 79 f0 breq .+30 ; 0x4c8 StreamingInterfaceAltSetting)) != HOST_SENDCONTROL_Successful) { printf_P(PSTR(ESC_FG_RED "Could not set alternative streaming interface setting.\r\n" 4aa: 00 d0 rcall .+0 ; 0x4ac 4ac: 00 d0 rcall .+0 ; 0x4ae 4ae: ed b7 in r30, 0x3d ; 61 4b0: fe b7 in r31, 0x3e ; 62 4b2: 31 96 adiw r30, 0x01 ; 1 4b4: 21 eb ldi r18, 0xB1 ; 177 4b6: 30 e0 ldi r19, 0x00 ; 0 4b8: ad b7 in r26, 0x3d ; 61 4ba: be b7 in r27, 0x3e ; 62 4bc: 12 96 adiw r26, 0x02 ; 2 4be: 3c 93 st X, r19 4c0: 2e 93 st -X, r18 4c2: 11 97 sbiw r26, 0x01 ; 1 4c4: 82 83 std Z+2, r24 ; 0x02 4c6: d7 cf rjmp .-82 ; 0x476 /* Wait until USB device disconnected */ USB_HostState = HOST_STATE_WaitForDeviceRemoval; break; } USB_ControlRequest = (USB_Request_Header_t) 4c8: 20 91 1e 01 lds r18, 0x011E 4cc: 82 e2 ldi r24, 0x22 ; 34 4ce: 80 93 23 01 sts 0x0123, r24 4d2: 81 e0 ldi r24, 0x01 ; 1 4d4: 80 93 24 01 sts 0x0124, r24 4d8: 80 e0 ldi r24, 0x00 ; 0 4da: 91 e0 ldi r25, 0x01 ; 1 4dc: 90 93 26 01 sts 0x0126, r25 4e0: 80 93 25 01 sts 0x0125, r24 4e4: 20 93 27 01 sts 0x0127, r18 4e8: 10 92 28 01 sts 0x0128, r1 4ec: 83 e0 ldi r24, 0x03 ; 3 4ee: 90 e0 ldi r25, 0x00 ; 0 4f0: 90 93 2a 01 sts 0x012A, r25 4f4: 80 93 29 01 sts 0x0129, r24 .wValue = 0x0100, .wIndex = StreamingEndpointAddress, .wLength = sizeof(USB_Audio_SampleFreq_t), }; USB_Audio_SampleFreq_t SampleRate = AUDIO_SAMPLE_FREQ(48000); 4f8: de 01 movw r26, r28 4fa: 11 96 adiw r26, 0x01 ; 1 4fc: e0 e0 ldi r30, 0x00 ; 0 4fe: f1 e0 ldi r31, 0x01 ; 1 500: 83 e0 ldi r24, 0x03 ; 3 502: 01 90 ld r0, Z+ 504: 0d 92 st X+, r0 506: 81 50 subi r24, 0x01 ; 1 508: e1 f7 brne .-8 ; 0x502 * \param[in] PipeNumber Index of the pipe to select. */ static inline void Pipe_SelectPipe(const uint8_t PipeNumber) ATTR_ALWAYS_INLINE; static inline void Pipe_SelectPipe(const uint8_t PipeNumber) { UPNUM = PipeNumber; 50a: 10 92 a7 00 sts 0x00A7, r1 /* Select the control pipe for the request transfer */ Pipe_SelectPipe(PIPE_CONTROLPIPE); /* Set the sample rate on the streaming interface endpoint */ if ((ErrorCode = USB_Host_SendControlRequest(&SampleRate)) != HOST_SENDCONTROL_Successful) 50e: ce 01 movw r24, r28 510: 01 96 adiw r24, 0x01 ; 1 512: b7 d5 rcall .+2926 ; 0x1082 514: 88 23 and r24, r24 516: 29 f0 breq .+10 ; 0x522 { /* Indicate error status */ LEDs_SetAllLEDs(LEDMASK_USB_ERROR); 518: 80 e9 ldi r24, 0x90 ; 144 51a: e3 de rcall .-570 ; 0x2e2 /* Wait until USB device disconnected */ USB_HostState = HOST_STATE_WaitForDeviceRemoval; 51c: 10 92 2b 01 sts 0x012B, r1 break; 520: 14 c0 rjmp .+40 ; 0x54a } /* Sample reload timer initialization */ TIMSK0 = (1 << OCIE0A); 522: 82 e0 ldi r24, 0x02 ; 2 524: 80 93 6e 00 sts 0x006E, r24 OCR0A = ((F_CPU / 8 / 8000) - 1); 528: 9c e7 ldi r25, 0x7C ; 124 52a: 97 bd out 0x27, r25 ; 39 TCCR0A = (1 << WGM01); // CTC mode 52c: 84 bd out 0x24, r24 ; 36 TCCR0B = (1 << CS01); // Fcpu/8 speed 52e: 85 bd out 0x25, r24 ; 37 /* Set speaker as output */ DDRC |= (1 << 6); 530: 3e 9a sbi 0x07, 6 ; 7 /* PWM speaker timer initialization */ TCCR3A = ((1 << WGM30) | (1 << COM3A1) | (1 << COM3A0) 532: 81 ef ldi r24, 0xF1 ; 241 534: 80 93 90 00 sts 0x0090, r24 | (1 << COM3B1) | (1 << COM3B0)); // Set on match, clear on TOP TCCR3B = ((1 << WGM32) | (1 << CS30)); // Fast 8-Bit PWM, F_CPU speed 538: 89 e0 ldi r24, 0x09 ; 9 53a: 80 93 91 00 sts 0x0091, r24 puts_P(PSTR("Microphone Enumerated.\r\n")); 53e: 88 e9 ldi r24, 0x98 ; 152 540: 90 e0 ldi r25, 0x00 ; 0 542: fe d6 rcall .+3580 ; 0x1340 USB_HostState = HOST_STATE_Configured; 544: 8c e0 ldi r24, 0x0C ; 12 546: 80 93 2b 01 sts 0x012B, r24 break; case HOST_STATE_Configured: break; } } 54a: 0f 90 pop r0 54c: 0f 90 pop r0 54e: 0f 90 pop r0 550: cf 91 pop r28 552: df 91 pop r29 554: 1f 91 pop r17 556: 08 95 ret 00000558
: /** Main program entry point. This routine configures the hardware required by the application, then * enters a loop to run the application tasks in sequence. */ int main(void) { SetupHardware(); 558: c9 de rcall .-622 ; 0x2ec puts_P(PSTR(ESC_FG_CYAN "Audio Host Demo running.\r\n" ESC_FG_WHITE)); 55a: 8e e7 ldi r24, 0x7E ; 126 55c: 92 e0 ldi r25, 0x02 ; 2 55e: f0 d6 rcall .+3552 ; 0x1340 LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY); 560: 80 e1 ldi r24, 0x10 ; 16 562: bf de rcall .-642 ; 0x2e2 sei(); 564: 78 94 sei for (;;) { Audio_Task(); 566: 5e df rcall .-324 ; 0x424 USB_USBTask(); 568: a2 d6 rcall .+3396 ; 0x12ae 56a: fd cf rjmp .-6 ; 0x566 0000056c <__vector_21>: } } /** ISR to handle the reloading of the PWM timer with the next sample. */ ISR(TIMER0_COMPA_vect, ISR_BLOCK) { 56c: 1f 92 push r1 56e: 0f 92 push r0 570: 0f b6 in r0, 0x3f ; 63 572: 0f 92 push r0 574: 0b b6 in r0, 0x3b ; 59 576: 0f 92 push r0 578: 11 24 eor r1, r1 57a: 1f 93 push r17 57c: 2f 93 push r18 57e: 3f 93 push r19 580: 4f 93 push r20 582: 5f 93 push r21 584: 6f 93 push r22 586: 7f 93 push r23 588: 8f 93 push r24 58a: 9f 93 push r25 58c: af 93 push r26 58e: bf 93 push r27 590: ef 93 push r30 592: ff 93 push r31 * \return Index of the currently selected pipe. */ static inline uint8_t Pipe_GetCurrentPipe(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline uint8_t Pipe_GetCurrentPipe(void) { return (UPNUM & PIPE_PIPENUM_MASK); 594: 10 91 a7 00 lds r17, 0x00A7 598: 17 70 andi r17, 0x07 ; 7 * \param[in] PipeNumber Index of the pipe to select. */ static inline void Pipe_SelectPipe(const uint8_t PipeNumber) ATTR_ALWAYS_INLINE; static inline void Pipe_SelectPipe(const uint8_t PipeNumber) { UPNUM = PipeNumber; 59a: 81 e0 ldi r24, 0x01 ; 1 59c: 80 93 a7 00 sts 0x00A7, r24 /** Unfreezes the selected pipe, allowing it to communicate with an attached device. */ static inline void Pipe_Unfreeze(void) ATTR_ALWAYS_INLINE; static inline void Pipe_Unfreeze(void) { UPCONX &= ~(1 << PFREEZE); 5a0: 80 91 a9 00 lds r24, 0x00A9 5a4: 8f 7b andi r24, 0xBF ; 191 5a6: 80 93 a9 00 sts 0x00A9, r24 * \return Boolean \c true if the current pipe has received an IN packet, \c false otherwise. */ static inline bool Pipe_IsINReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline bool Pipe_IsINReceived(void) { return ((UPINTX & (1 << RXINI)) ? true : false); 5aa: 80 91 a6 00 lds r24, 0x00A6 Pipe_SelectPipe(AUDIO_DATA_IN_PIPE); Pipe_Unfreeze(); /* Check if the current pipe can be read from (contains a packet) and the device is sending data */ if (Pipe_IsINReceived()) 5ae: 80 ff sbrs r24, 0 5b0: 2b c0 rjmp .+86 ; 0x608 <__vector_21+0x9c> { uint16_t Value; uint8_t Bytes[2]; } Data; Data.Bytes[0] = UPDATX; 5b2: 80 91 af 00 lds r24, 0x00AF Data.Bytes[1] = UPDATX; 5b6: 40 91 af 00 lds r20, 0x00AF * on its direction. */ static inline bool Pipe_IsReadWriteAllowed(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline bool Pipe_IsReadWriteAllowed(void) { return ((UPINTX & (1 << RWAL)) ? true : false); 5ba: 80 91 a6 00 lds r24, 0x00A6 { /* Retrieve the signed 16-bit audio sample, convert to 8-bit */ int8_t Sample_8Bit = (Pipe_Read_16_LE() >> 8); /* Check to see if the bank is now empty */ if (!(Pipe_IsReadWriteAllowed())) 5be: 85 fd sbrc r24, 5 5c0: 05 c0 rjmp .+10 ; 0x5cc <__vector_21+0x60> * \ingroup Group_PipePacketManagement_AVR8 */ static inline void Pipe_ClearIN(void) ATTR_ALWAYS_INLINE; static inline void Pipe_ClearIN(void) { UPINTX &= ~((1 << RXINI) | (1 << FIFOCON)); 5c2: 80 91 a6 00 lds r24, 0x00A6 5c6: 8e 77 andi r24, 0x7E ; 126 5c8: 80 93 a6 00 sts 0x00A6, r24 /* Acknowledge the packet, clear the bank ready for the next packet */ Pipe_ClearIN(); } /* Load the sample into the PWM timer channel */ OCR3A = (Sample_8Bit ^ (1 << 7)); 5cc: 84 2f mov r24, r20 5ce: 99 27 eor r25, r25 5d0: 87 fd sbrc r24, 7 5d2: 90 95 com r25 5d4: 20 e8 ldi r18, 0x80 ; 128 5d6: 30 e0 ldi r19, 0x00 ; 0 5d8: 82 27 eor r24, r18 5da: 93 27 eor r25, r19 5dc: 90 93 99 00 sts 0x0099, r25 5e0: 80 93 98 00 sts 0x0098, r24 uint8_t LEDMask = LEDS_NO_LEDS; /* Turn on LEDs as the sample amplitude increases */ if (Sample_8Bit > 16) 5e4: 41 31 cpi r20, 0x11 ; 17 5e6: 44 f4 brge .+16 ; 0x5f8 <__vector_21+0x8c> LEDMask = (LEDS_LED1 | LEDS_LED2 | LEDS_LED3 | LEDS_LED4); else if (Sample_8Bit > 8) 5e8: 49 30 cpi r20, 0x09 ; 9 5ea: 44 f4 brge .+16 ; 0x5fc <__vector_21+0x90> LEDMask = (LEDS_LED1 | LEDS_LED2 | LEDS_LED3); else if (Sample_8Bit > 4) 5ec: 45 30 cpi r20, 0x05 ; 5 5ee: 44 f4 brge .+16 ; 0x600 <__vector_21+0x94> LEDMask = (LEDS_LED1 | LEDS_LED2); else if (Sample_8Bit > 2) 5f0: 43 30 cpi r20, 0x03 ; 3 5f2: 44 f4 brge .+16 ; 0x604 <__vector_21+0x98> } /* Load the sample into the PWM timer channel */ OCR3A = (Sample_8Bit ^ (1 << 7)); uint8_t LEDMask = LEDS_NO_LEDS; 5f4: 80 e0 ldi r24, 0x00 ; 0 5f6: 07 c0 rjmp .+14 ; 0x606 <__vector_21+0x9a> /* Turn on LEDs as the sample amplitude increases */ if (Sample_8Bit > 16) LEDMask = (LEDS_LED1 | LEDS_LED2 | LEDS_LED3 | LEDS_LED4); 5f8: 80 ef ldi r24, 0xF0 ; 240 5fa: 05 c0 rjmp .+10 ; 0x606 <__vector_21+0x9a> else if (Sample_8Bit > 8) LEDMask = (LEDS_LED1 | LEDS_LED2 | LEDS_LED3); 5fc: 80 eb ldi r24, 0xB0 ; 176 5fe: 03 c0 rjmp .+6 ; 0x606 <__vector_21+0x9a> else if (Sample_8Bit > 4) LEDMask = (LEDS_LED1 | LEDS_LED2); 600: 80 e3 ldi r24, 0x30 ; 48 602: 01 c0 rjmp .+2 ; 0x606 <__vector_21+0x9a> else if (Sample_8Bit > 2) LEDMask = (LEDS_LED1); 604: 80 e1 ldi r24, 0x10 ; 16 LEDs_SetAllLEDs(LEDMask); 606: 6d de rcall .-806 ; 0x2e2 /** Freezes the selected pipe, preventing it from communicating with an attached device. */ static inline void Pipe_Freeze(void) ATTR_ALWAYS_INLINE; static inline void Pipe_Freeze(void) { UPCONX |= (1 << PFREEZE); 608: 80 91 a9 00 lds r24, 0x00A9 60c: 80 64 ori r24, 0x40 ; 64 60e: 80 93 a9 00 sts 0x00A9, r24 * \param[in] PipeNumber Index of the pipe to select. */ static inline void Pipe_SelectPipe(const uint8_t PipeNumber) ATTR_ALWAYS_INLINE; static inline void Pipe_SelectPipe(const uint8_t PipeNumber) { UPNUM = PipeNumber; 612: 10 93 a7 00 sts 0x00A7, r17 } Pipe_Freeze(); Pipe_SelectPipe(PrevPipe); } 616: ff 91 pop r31 618: ef 91 pop r30 61a: bf 91 pop r27 61c: af 91 pop r26 61e: 9f 91 pop r25 620: 8f 91 pop r24 622: 7f 91 pop r23 624: 6f 91 pop r22 626: 5f 91 pop r21 628: 4f 91 pop r20 62a: 3f 91 pop r19 62c: 2f 91 pop r18 62e: 1f 91 pop r17 630: 0f 90 pop r0 632: 0b be out 0x3b, r0 ; 59 634: 0f 90 pop r0 636: 0f be out 0x3f, r0 ; 63 638: 0f 90 pop r0 63a: 1f 90 pop r1 63c: 18 95 reti 0000063e : /* Valid data found, return success */ return SuccessfulConfigRead; } uint8_t DComp_NextAudioControlInterface(void* CurrentDescriptor) { 63e: fc 01 movw r30, r24 USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t); if (Header->Type == DTYPE_Interface) 640: 81 81 ldd r24, Z+1 ; 0x01 642: 84 30 cpi r24, 0x04 ; 4 644: 49 f4 brne .+18 ; 0x658 { USB_Descriptor_Interface_t* Interface = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Interface_t); if ((Interface->Class == AUDIO_CSCP_AudioClass) && 646: 85 81 ldd r24, Z+5 ; 0x05 648: 81 30 cpi r24, 0x01 ; 1 64a: 31 f4 brne .+12 ; 0x658 64c: 86 81 ldd r24, Z+6 ; 0x06 64e: 81 30 cpi r24, 0x01 ; 1 650: 19 f4 brne .+6 ; 0x658 (Interface->SubClass == AUDIO_CSCP_ControlSubclass) && 652: 87 81 ldd r24, Z+7 ; 0x07 654: 88 23 and r24, r24 656: 11 f0 breq .+4 ; 0x65c { return DESCRIPTOR_SEARCH_Found; } } return DESCRIPTOR_SEARCH_NotFound; 658: 82 e0 ldi r24, 0x02 ; 2 65a: 08 95 ret if ((Interface->Class == AUDIO_CSCP_AudioClass) && (Interface->SubClass == AUDIO_CSCP_ControlSubclass) && (Interface->Protocol == AUDIO_CSCP_ControlProtocol)) { return DESCRIPTOR_SEARCH_Found; 65c: 80 e0 ldi r24, 0x00 ; 0 } } return DESCRIPTOR_SEARCH_NotFound; } 65e: 08 95 ret 00000660 : uint8_t DComp_NextAudioStreamInterface(void* CurrentDescriptor) { 660: fc 01 movw r30, r24 USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t); if (Header->Type == DTYPE_Interface) 662: 81 81 ldd r24, Z+1 ; 0x01 664: 84 30 cpi r24, 0x04 ; 4 666: 49 f4 brne .+18 ; 0x67a { USB_Descriptor_Interface_t* Interface = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Interface_t); if ((Interface->Class == AUDIO_CSCP_AudioClass) && 668: 85 81 ldd r24, Z+5 ; 0x05 66a: 81 30 cpi r24, 0x01 ; 1 66c: 31 f4 brne .+12 ; 0x67a 66e: 86 81 ldd r24, Z+6 ; 0x06 670: 82 30 cpi r24, 0x02 ; 2 672: 19 f4 brne .+6 ; 0x67a (Interface->SubClass == AUDIO_CSCP_AudioStreamingSubclass) && 674: 87 81 ldd r24, Z+7 ; 0x07 676: 88 23 and r24, r24 678: 11 f0 breq .+4 ; 0x67e { return DESCRIPTOR_SEARCH_Found; } } return DESCRIPTOR_SEARCH_NotFound; 67a: 82 e0 ldi r24, 0x02 ; 2 67c: 08 95 ret if ((Interface->Class == AUDIO_CSCP_AudioClass) && (Interface->SubClass == AUDIO_CSCP_AudioStreamingSubclass) && (Interface->Protocol == AUDIO_CSCP_StreamingProtocol)) { return DESCRIPTOR_SEARCH_Found; 67e: 80 e0 ldi r24, 0x00 ; 0 } } return DESCRIPTOR_SEARCH_NotFound; } 680: 08 95 ret 00000682 : uint8_t DComp_NextAudioInterfaceDataEndpoint(void* CurrentDescriptor) { 682: fc 01 movw r30, r24 USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t); if (Header->Type == DTYPE_Endpoint) 684: 81 81 ldd r24, Z+1 ; 0x01 686: 85 30 cpi r24, 0x05 ; 5 688: 29 f4 brne .+10 ; 0x694 { USB_Descriptor_Endpoint_t* Endpoint = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Endpoint_t); if ((Endpoint->Attributes & EP_TYPE_MASK) == EP_TYPE_ISOCHRONOUS) 68a: 83 81 ldd r24, Z+3 ; 0x03 68c: 83 70 andi r24, 0x03 ; 3 68e: 81 30 cpi r24, 0x01 ; 1 690: 19 f4 brne .+6 ; 0x698 692: 04 c0 rjmp .+8 ; 0x69c return DESCRIPTOR_SEARCH_Found; } else if (Header->Type == DTYPE_Interface) 694: 84 30 cpi r24, 0x04 ; 4 696: 21 f0 breq .+8 ; 0x6a0 { return DESCRIPTOR_SEARCH_Fail; } return DESCRIPTOR_SEARCH_NotFound; 698: 82 e0 ldi r24, 0x02 ; 2 69a: 08 95 ret if (Header->Type == DTYPE_Endpoint) { USB_Descriptor_Endpoint_t* Endpoint = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Endpoint_t); if ((Endpoint->Attributes & EP_TYPE_MASK) == EP_TYPE_ISOCHRONOUS) return DESCRIPTOR_SEARCH_Found; 69c: 80 e0 ldi r24, 0x00 ; 0 69e: 08 95 ret } else if (Header->Type == DTYPE_Interface) { return DESCRIPTOR_SEARCH_Fail; 6a0: 81 e0 ldi r24, 0x01 ; 1 } return DESCRIPTOR_SEARCH_NotFound; } 6a2: 08 95 ret 000006a4 : uint8_t StreamingInterfaceIndex = 0; uint8_t StreamingInterfaceAltSetting = 0; uint8_t StreamingEndpointAddress = 0; uint8_t ProcessConfigurationDescriptor(void) { 6a4: af 92 push r10 6a6: bf 92 push r11 6a8: cf 92 push r12 6aa: df 92 push r13 6ac: ef 92 push r14 6ae: ff 92 push r15 6b0: 0f 93 push r16 6b2: 1f 93 push r17 6b4: df 93 push r29 6b6: cf 93 push r28 6b8: cd b7 in r28, 0x3d ; 61 6ba: de b7 in r29, 0x3e ; 62 6bc: c4 50 subi r28, 0x04 ; 4 6be: d2 40 sbci r29, 0x02 ; 2 6c0: 0f b6 in r0, 0x3f ; 63 6c2: f8 94 cli 6c4: de bf out 0x3e, r29 ; 62 6c6: 0f be out 0x3f, r0 ; 63 6c8: cd bf out 0x3d, r28 ; 61 uint8_t ConfigDescriptorData[512]; void* CurrConfigLocation = ConfigDescriptorData; 6ca: ae 01 movw r20, r28 6cc: 4b 5f subi r20, 0xFB ; 251 6ce: 5f 4f sbci r21, 0xFF ; 255 6d0: 5a 83 std Y+2, r21 ; 0x02 6d2: 49 83 std Y+1, r20 ; 0x01 USB_Descriptor_Interface_t* AudioControlInterface = NULL; USB_Descriptor_Interface_t* AudioStreamingInterface = NULL; USB_Descriptor_Endpoint_t* DataINEndpoint = NULL; /* Retrieve the entire configuration descriptor into the allocated buffer */ switch (USB_Host_GetDeviceConfigDescriptor(1, &CurrConfigBytesRem, ConfigDescriptorData, sizeof(ConfigDescriptorData))) 6d4: 23 e0 ldi r18, 0x03 ; 3 6d6: e2 2e mov r14, r18 6d8: f1 2c mov r15, r1 6da: ec 0e add r14, r28 6dc: fd 1e adc r15, r29 6de: 81 e0 ldi r24, 0x01 ; 1 6e0: b7 01 movw r22, r14 6e2: 20 e0 ldi r18, 0x00 ; 0 6e4: 32 e0 ldi r19, 0x02 ; 2 6e6: 09 d4 rcall .+2066 ; 0xefa 6e8: 85 30 cpi r24, 0x05 ; 5 6ea: 09 f4 brne .+2 ; 0x6ee 6ec: 5c c0 rjmp .+184 ; 0x7a6 6ee: 86 30 cpi r24, 0x06 ; 6 6f0: 61 f0 breq .+24 ; 0x70a 6f2: 88 23 and r24, r24 6f4: 61 f4 brne .+24 ; 0x70e 6f6: 00 e0 ldi r16, 0x00 ; 0 6f8: 10 e0 ldi r17, 0x00 ; 0 6fa: cc 24 eor r12, r12 6fc: dd 24 eor r13, r13 6fe: 57 01 movw r10, r14 700: 7e 01 movw r14, r28 702: 08 94 sec 704: e1 1c adc r14, r1 706: f1 1c adc r15, r1 708: 07 c0 rjmp .+14 ; 0x718 { case HOST_GETCONFIG_Successful: break; case HOST_GETCONFIG_InvalidData: return InvalidConfigDataReturned; 70a: 83 e0 ldi r24, 0x03 ; 3 70c: 4f c0 rjmp .+158 ; 0x7ac case HOST_GETCONFIG_BuffOverflow: return DescriptorTooLarge; default: return ControlError; 70e: 81 e0 ldi r24, 0x01 ; 1 710: 4d c0 rjmp .+154 ; 0x7ac USB_Descriptor_Interface_t* AudioControlInterface = NULL; USB_Descriptor_Interface_t* AudioStreamingInterface = NULL; USB_Descriptor_Endpoint_t* DataINEndpoint = NULL; /* Retrieve the entire configuration descriptor into the allocated buffer */ switch (USB_Host_GetDeviceConfigDescriptor(1, &CurrConfigBytesRem, ConfigDescriptorData, sizeof(ConfigDescriptorData))) 712: 9c 01 movw r18, r24 714: 03 2f mov r16, r19 716: 18 2f mov r17, r24 return ControlError; } while (!(DataINEndpoint)) { if (!(AudioControlInterface) || 718: c1 14 cp r12, r1 71a: d1 04 cpc r13, r1 71c: 41 f0 breq .+16 ; 0x72e USB_GetNextDescriptorComp(&CurrConfigBytesRem, &CurrConfigLocation, 71e: c5 01 movw r24, r10 720: b7 01 movw r22, r14 722: 41 e4 ldi r20, 0x41 ; 65 724: 53 e0 ldi r21, 0x03 ; 3 726: 40 d4 rcall .+2176 ; 0xfa8 return ControlError; } while (!(DataINEndpoint)) { if (!(AudioControlInterface) || 728: 88 23 and r24, r24 72a: 51 f4 brne .+20 ; 0x740 72c: 1c c0 rjmp .+56 ; 0x766 USB_GetNextDescriptorComp(&CurrConfigBytesRem, &CurrConfigLocation, DComp_NextAudioInterfaceDataEndpoint) != DESCRIPTOR_SEARCH_COMP_Found) { if (!(AudioControlInterface)) { if (USB_GetNextDescriptorComp(&CurrConfigBytesRem, &CurrConfigLocation, 72e: c5 01 movw r24, r10 730: b7 01 movw r22, r14 732: 4f e1 ldi r20, 0x1F ; 31 734: 53 e0 ldi r21, 0x03 ; 3 736: 38 d4 rcall .+2160 ; 0xfa8 738: 88 23 and r24, r24 73a: b9 f5 brne .+110 ; 0x7aa /* Descriptor not found, error out */ return NoCompatibleInterfaceFound; } /* Save the interface in case we need to refer back to it later */ AudioControlInterface = DESCRIPTOR_PCAST(CurrConfigLocation, USB_Descriptor_Interface_t); 73c: c9 80 ldd r12, Y+1 ; 0x01 73e: da 80 ldd r13, Y+2 ; 0x02 } if (USB_GetNextDescriptorComp(&CurrConfigBytesRem, &CurrConfigLocation, 740: c5 01 movw r24, r10 742: b7 01 movw r22, r14 744: 40 e3 ldi r20, 0x30 ; 48 746: 53 e0 ldi r21, 0x03 ; 3 748: 2f d4 rcall .+2142 ; 0xfa8 74a: 88 23 and r24, r24 74c: 49 f0 breq .+18 ; 0x760 DComp_NextAudioStreamInterface) != DESCRIPTOR_SEARCH_COMP_Found) { if (USB_GetNextDescriptorComp(&CurrConfigBytesRem, &CurrConfigLocation, 74e: c5 01 movw r24, r10 750: b7 01 movw r22, r14 752: 4f e1 ldi r20, 0x1F ; 31 754: 53 e0 ldi r21, 0x03 ; 3 756: 28 d4 rcall .+2128 ; 0xfa8 758: 88 23 and r24, r24 75a: 39 f5 brne .+78 ; 0x7aa /* Descriptor not found, error out */ return NoCompatibleInterfaceFound; } /* Save the interface in case we need to refer back to it later */ AudioControlInterface = DESCRIPTOR_PCAST(CurrConfigLocation, USB_Descriptor_Interface_t); 75c: c9 80 ldd r12, Y+1 ; 0x01 75e: da 80 ldd r13, Y+2 ; 0x02 } /* Save the interface in case we need to refer back to it later */ AudioStreamingInterface = DESCRIPTOR_PCAST(CurrConfigLocation, USB_Descriptor_Interface_t); 760: 09 81 ldd r16, Y+1 ; 0x01 762: 1a 81 ldd r17, Y+2 ; 0x02 /* Skip the remainder of the loop as we have not found an endpoint yet */ continue; 764: 35 c0 rjmp .+106 ; 0x7d0 } /* Retrieve the endpoint address from the endpoint descriptor */ USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(CurrConfigLocation, USB_Descriptor_Endpoint_t); 766: e9 81 ldd r30, Y+1 ; 0x01 768: fa 81 ldd r31, Y+2 ; 0x02 /* If the endpoint is a IN type endpoint */ if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN) 76a: 82 81 ldd r24, Z+2 ; 0x02 76c: 87 ff sbrs r24, 7 76e: 30 c0 rjmp .+96 ; 0x7d0 770: 90 2f mov r25, r16 772: 81 2f mov r24, r17 return DescriptorTooLarge; default: return ControlError; } while (!(DataINEndpoint)) 774: 30 97 sbiw r30, 0x00 ; 0 776: 69 f2 breq .-102 ; 0x712 /* If the endpoint is a IN type endpoint */ if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN) DataINEndpoint = EndpointData; } StreamingInterfaceIndex = AudioStreamingInterface->InterfaceNumber; 778: d8 01 movw r26, r16 77a: 12 96 adiw r26, 0x02 ; 2 77c: 8c 91 ld r24, X 77e: 12 97 sbiw r26, 0x02 ; 2 780: 80 93 1c 01 sts 0x011C, r24 StreamingInterfaceAltSetting = AudioStreamingInterface->AlternateSetting; 784: 13 96 adiw r26, 0x03 ; 3 786: 8c 91 ld r24, X 788: 80 93 1d 01 sts 0x011D, r24 StreamingEndpointAddress = DataINEndpoint->EndpointAddress; 78c: 22 81 ldd r18, Z+2 ; 0x02 78e: 20 93 1e 01 sts 0x011E, r18 /* Configure the HID data IN pipe */ Pipe_ConfigurePipe(AUDIO_DATA_IN_PIPE, EP_TYPE_ISOCHRONOUS, PIPE_TOKEN_IN, 792: 04 81 ldd r16, Z+4 ; 0x04 794: 15 81 ldd r17, Z+5 ; 0x05 796: 81 e0 ldi r24, 0x01 ; 1 798: 61 e0 ldi r22, 0x01 ; 1 79a: 40 e1 ldi r20, 0x10 ; 16 79c: 94 e0 ldi r25, 0x04 ; 4 79e: e9 2e mov r14, r25 7a0: 22 d2 rcall .+1092 ; 0xbe6 DataINEndpoint->EndpointAddress, DataINEndpoint->EndpointSize, PIPE_BANK_DOUBLE); /* Valid data found, return success */ return SuccessfulConfigRead; 7a2: 80 e0 ldi r24, 0x00 ; 0 7a4: 03 c0 rjmp .+6 ; 0x7ac case HOST_GETCONFIG_Successful: break; case HOST_GETCONFIG_InvalidData: return InvalidConfigDataReturned; case HOST_GETCONFIG_BuffOverflow: return DescriptorTooLarge; 7a6: 82 e0 ldi r24, 0x02 ; 2 7a8: 01 c0 rjmp .+2 ; 0x7ac { if (USB_GetNextDescriptorComp(&CurrConfigBytesRem, &CurrConfigLocation, DComp_NextAudioControlInterface) != DESCRIPTOR_SEARCH_COMP_Found) { /* Descriptor not found, error out */ return NoCompatibleInterfaceFound; 7aa: 84 e0 ldi r24, 0x04 ; 4 Pipe_ConfigurePipe(AUDIO_DATA_IN_PIPE, EP_TYPE_ISOCHRONOUS, PIPE_TOKEN_IN, DataINEndpoint->EndpointAddress, DataINEndpoint->EndpointSize, PIPE_BANK_DOUBLE); /* Valid data found, return success */ return SuccessfulConfigRead; } 7ac: cc 5f subi r28, 0xFC ; 252 7ae: dd 4f sbci r29, 0xFD ; 253 7b0: 0f b6 in r0, 0x3f ; 63 7b2: f8 94 cli 7b4: de bf out 0x3e, r29 ; 62 7b6: 0f be out 0x3f, r0 ; 63 7b8: cd bf out 0x3d, r28 ; 61 7ba: cf 91 pop r28 7bc: df 91 pop r29 7be: 1f 91 pop r17 7c0: 0f 91 pop r16 7c2: ff 90 pop r15 7c4: ef 90 pop r14 7c6: df 90 pop r13 7c8: cf 90 pop r12 7ca: bf 90 pop r11 7cc: af 90 pop r10 7ce: 08 95 ret USB_Descriptor_Interface_t* AudioControlInterface = NULL; USB_Descriptor_Interface_t* AudioStreamingInterface = NULL; USB_Descriptor_Endpoint_t* DataINEndpoint = NULL; /* Retrieve the entire configuration descriptor into the allocated buffer */ switch (USB_Host_GetDeviceConfigDescriptor(1, &CurrConfigBytesRem, ConfigDescriptorData, sizeof(ConfigDescriptorData))) 7d0: 90 2f mov r25, r16 7d2: 81 2f mov r24, r17 7d4: 9e cf rjmp .-196 ; 0x712 000007d6 : * \return Boolean \c true if the bus is currently suspended, \c false otherwise. */ static inline bool USB_Host_IsBusSuspended(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline bool USB_Host_IsBusSuspended(void) { return ((UHCON & (1 << SOFEN)) ? false : true); 7d6: 80 91 9e 00 lds r24, 0x009E 7da: 90 e0 ldi r25, 0x00 ; 0 7dc: 81 70 andi r24, 0x01 ; 1 7de: 90 70 andi r25, 0x00 ; 0 break; case USB_INT_DCONNI: UHIEN &= ~(1 << DCONNE); break; case USB_INT_DDISCI: UHIEN &= ~(1 << DDISCE); 7e0: 20 91 a0 00 lds r18, 0x00A0 7e4: 2d 7f andi r18, 0xFD ; 253 7e6: 20 93 a0 00 sts 0x00A0, r18 * woken up automatically and the bus resumed after the reset has been correctly issued. */ static inline void USB_Host_ResetBus(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_ResetBus(void) { UHCON |= (1 << RESET); 7ea: 20 91 9e 00 lds r18, 0x009E 7ee: 22 60 ori r18, 0x02 ; 2 7f0: 20 93 9e 00 sts 0x009E, r18 * \return Boolean \c true if no bus reset is currently being sent, \c false otherwise. */ static inline bool USB_Host_IsBusResetComplete(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline bool USB_Host_IsBusResetComplete(void) { return ((UHCON & (1 << RESET)) ? false : true); 7f4: 20 91 9e 00 lds r18, 0x009E bool BusSuspended = USB_Host_IsBusSuspended(); USB_INT_Disable(USB_INT_DDISCI); USB_Host_ResetBus(); while (!(USB_Host_IsBusResetComplete())); 7f8: 21 fd sbrc r18, 1 7fa: fc cf rjmp .-8 ; 0x7f4 * host and attached device may occur. */ static inline void USB_Host_ResumeBus(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_ResumeBus(void) { UHCON |= (1 << SOFEN); 7fc: 20 91 9e 00 lds r18, 0x009E 800: 21 60 ori r18, 0x01 ; 1 802: 20 93 9e 00 sts 0x009E, r18 case USB_INT_RXSTPI: return (UEIENX & (1 << RXSTPE)); #endif #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: return (UHIEN & (1 << HSOFE)); 806: 20 91 a0 00 lds r18, 0x00A0 80a: 30 e0 ldi r19, 0x00 ; 0 80c: 20 72 andi r18, 0x20 ; 32 80e: 30 70 andi r19, 0x00 ; 0 UEIENX &= ~(1 << RXSTPE); break; #endif #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: UHIEN &= ~(1 << HSOFE); 810: 40 91 a0 00 lds r20, 0x00A0 814: 4f 7d andi r20, 0xDF ; 223 816: 40 93 a0 00 sts 0x00A0, r20 UEINTX &= ~(1 << RXSTPI); break; #endif #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: UHINT &= ~(1 << HSOFI); 81a: 40 91 9f 00 lds r20, 0x009F 81e: 4f 7d andi r20, 0xDF ; 223 820: 40 93 9f 00 sts 0x009F, r20 824: 4a e0 ldi r20, 0x0A ; 10 case USB_INT_RXSTPI: return (UEINTX & (1 << RXSTPI)); #endif #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: return (UHINT & (1 << HSOFI)); 826: 50 91 9f 00 lds r21, 0x009F /* Workaround for powerless-pull-up devices. After a USB bus reset, all disconnection interrupts are suppressed while a USB frame is looked for - if it is found within 10ms, the device is still present. */ if (USB_INT_HasOccurred(USB_INT_HSOFI)) 82a: 55 ff sbrs r21, 5 82c: 0b c0 rjmp .+22 ; 0x844 UEINTX &= ~(1 << RXSTPI); break; #endif #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: UHINT &= ~(1 << HSOFI); 82e: 40 91 9f 00 lds r20, 0x009F 832: 4f 7d andi r20, 0xDF ; 223 834: 40 93 9f 00 sts 0x009F, r20 break; case USB_INT_DCONNI: UHINT &= ~(1 << DCONNI); break; case USB_INT_DDISCI: UHINT &= ~(1 << DDISCI); 838: 40 91 9f 00 lds r20, 0x009F 83c: 4d 7f andi r20, 0xFD ; 253 83e: 40 93 9f 00 sts 0x009F, r20 842: 08 c0 rjmp .+16 ; 0x854 #else //round up by default __ticks_dc = (uint32_t)(ceil(fabs(__tmp))); #endif __builtin_avr_delay_cycles(__ticks_dc); 844: ef ec ldi r30, 0xCF ; 207 846: f7 e0 ldi r31, 0x07 ; 7 848: 31 97 sbiw r30, 0x01 ; 1 84a: f1 f7 brne .-4 ; 0x848 84c: 00 c0 rjmp .+0 ; 0x84e 84e: 00 00 nop 850: 41 50 subi r20, 0x01 ; 1 bool HSOFIEnabled = USB_INT_IsEnabled(USB_INT_HSOFI); USB_INT_Disable(USB_INT_HSOFI); USB_INT_Clear(USB_INT_HSOFI); for (uint8_t MSRem = 10; MSRem != 0; MSRem--) 852: 49 f7 brne .-46 ; 0x826 } Delay_MS(1); } if (HSOFIEnabled) 854: 21 15 cp r18, r1 856: 31 05 cpc r19, r1 858: 29 f0 breq .+10 ; 0x864 UEIENX |= (1 << RXSTPE); break; #endif #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: UHIEN |= (1 << HSOFE); 85a: 20 91 a0 00 lds r18, 0x00A0 85e: 20 62 ori r18, 0x20 ; 32 860: 20 93 a0 00 sts 0x00A0, r18 USB_INT_Enable(USB_INT_HSOFI); if (BusSuspended) 864: 00 97 sbiw r24, 0x00 ; 0 866: 29 f4 brne .+10 ; 0x872 * messages to the device. */ static inline void USB_Host_SuspendBus(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_SuspendBus(void) { UHCON &= ~(1 << SOFEN); 868: 80 91 9e 00 lds r24, 0x009E 86c: 8e 7f andi r24, 0xFE ; 254 86e: 80 93 9e 00 sts 0x009E, r24 break; case USB_INT_DCONNI: UHIEN |= (1 << DCONNE); break; case USB_INT_DDISCI: UHIEN |= (1 << DDISCE); 872: 80 91 a0 00 lds r24, 0x00A0 876: 82 60 ori r24, 0x02 ; 2 878: 80 93 a0 00 sts 0x00A0, r24 USB_Host_SuspendBus(); USB_INT_Enable(USB_INT_DDISCI); } 87c: 08 95 ret 0000087e : * \return Boolean \c true if the bus is currently suspended, \c false otherwise. */ static inline bool USB_Host_IsBusSuspended(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline bool USB_Host_IsBusSuspended(void) { return ((UHCON & (1 << SOFEN)) ? false : true); 87e: 40 91 9e 00 lds r20, 0x009E 882: 50 e0 ldi r21, 0x00 ; 0 884: 41 70 andi r20, 0x01 ; 1 886: 50 70 andi r21, 0x00 ; 0 case USB_INT_RXSTPI: return (UEIENX & (1 << RXSTPE)); #endif #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: return (UHIEN & (1 << HSOFE)); 888: 20 91 a0 00 lds r18, 0x00A0 88c: 30 e0 ldi r19, 0x00 ; 0 88e: 20 72 andi r18, 0x20 ; 32 890: 30 70 andi r19, 0x00 ; 0 UEIENX &= ~(1 << RXSTPE); break; #endif #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: UHIEN &= ~(1 << HSOFE); 892: 90 91 a0 00 lds r25, 0x00A0 896: 9f 7d andi r25, 0xDF ; 223 898: 90 93 a0 00 sts 0x00A0, r25 UEINTX &= ~(1 << RXSTPI); break; #endif #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: UHINT &= ~(1 << HSOFI); 89c: 90 91 9f 00 lds r25, 0x009F 8a0: 9f 7d andi r25, 0xDF ; 223 8a2: 90 93 9f 00 sts 0x009F, r25 * host and attached device may occur. */ static inline void USB_Host_ResumeBus(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_ResumeBus(void) { UHCON |= (1 << SOFEN); 8a6: 90 91 9e 00 lds r25, 0x009E 8aa: 91 60 ori r25, 0x01 ; 1 8ac: 90 93 9e 00 sts 0x009E, r25 USB_INT_Disable(USB_INT_HSOFI); USB_INT_Clear(USB_INT_HSOFI); USB_Host_ResumeBus(); while (MS) 8b0: 26 c0 rjmp .+76 ; 0x8fe case USB_INT_RXSTPI: return (UEINTX & (1 << RXSTPI)); #endif #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: return (UHINT & (1 << HSOFI)); 8b2: 90 91 9f 00 lds r25, 0x009F { if (USB_INT_HasOccurred(USB_INT_HSOFI)) 8b6: 95 ff sbrs r25, 5 8b8: 06 c0 rjmp .+12 ; 0x8c6 UEINTX &= ~(1 << RXSTPI); break; #endif #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: UHINT &= ~(1 << HSOFI); 8ba: 90 91 9f 00 lds r25, 0x009F 8be: 9f 7d andi r25, 0xDF ; 223 8c0: 90 93 9f 00 sts 0x009F, r25 { USB_INT_Clear(USB_INT_HSOFI); MS--; 8c4: 81 50 subi r24, 0x01 ; 1 } if ((USB_HostState == HOST_STATE_Unattached) || (USB_CurrentMode != USB_MODE_Host)) 8c6: 90 91 2b 01 lds r25, 0x012B 8ca: 92 30 cpi r25, 0x02 ; 2 8cc: d9 f0 breq .+54 ; 0x904 * \return Boolean \c true if an error has occurred on the selected pipe, \c false otherwise. */ static inline bool Pipe_IsError(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline bool Pipe_IsError(void) { return ((UPINTX & (1 << PERRI)) ? true : false); 8ce: 90 91 a6 00 lds r25, 0x00A6 ErrorCode = HOST_WAITERROR_DeviceDisconnect; break; } if (Pipe_IsError() == true) 8d2: 94 ff sbrs r25, 4 8d4: 09 c0 rjmp .+18 ; 0x8e8 /** Clears the error flags for the currently selected pipe. */ static inline void Pipe_ClearError(void) ATTR_ALWAYS_INLINE; static inline void Pipe_ClearError(void) { UPERRX = 0; 8d6: 10 92 f5 00 sts 0x00F5, r1 UPINTX &= ~(1 << PERRI); 8da: 80 91 a6 00 lds r24, 0x00A6 8de: 8f 7e andi r24, 0xEF ; 239 8e0: 80 93 a6 00 sts 0x00A6, r24 { Pipe_ClearError(); ErrorCode = HOST_WAITERROR_PipeError; 8e4: 82 e0 ldi r24, 0x02 ; 2 break; 8e6: 0f c0 rjmp .+30 ; 0x906 * \return Boolean \c true if the current pipe has been stalled by the attached device, \c false otherwise. */ static inline bool Pipe_IsStalled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline bool Pipe_IsStalled(void) { return ((UPINTX & (1 << RXSTALLI)) ? true : false); 8e8: 90 91 a6 00 lds r25, 0x00A6 } if (Pipe_IsStalled() == true) 8ec: 91 ff sbrs r25, 1 8ee: 07 c0 rjmp .+14 ; 0x8fe * \ingroup Group_PipePacketManagement_AVR8 */ static inline void Pipe_ClearStall(void) ATTR_ALWAYS_INLINE; static inline void Pipe_ClearStall(void) { UPINTX &= ~(1 << RXSTALLI); 8f0: 80 91 a6 00 lds r24, 0x00A6 8f4: 8d 7f andi r24, 0xFD ; 253 8f6: 80 93 a6 00 sts 0x00A6, r24 { Pipe_ClearStall(); ErrorCode = HOST_WAITERROR_SetupStalled; 8fa: 83 e0 ldi r24, 0x03 ; 3 break; 8fc: 04 c0 rjmp .+8 ; 0x906 USB_INT_Disable(USB_INT_HSOFI); USB_INT_Clear(USB_INT_HSOFI); USB_Host_ResumeBus(); while (MS) 8fe: 88 23 and r24, r24 900: c1 f6 brne .-80 ; 0x8b2 902: 01 c0 rjmp .+2 ; 0x906 MS--; } if ((USB_HostState == HOST_STATE_Unattached) || (USB_CurrentMode != USB_MODE_Host)) { ErrorCode = HOST_WAITERROR_DeviceDisconnect; 904: 81 e0 ldi r24, 0x01 ; 1 break; } } if (BusSuspended) 906: 41 15 cp r20, r1 908: 51 05 cpc r21, r1 90a: 29 f4 brne .+10 ; 0x916 * messages to the device. */ static inline void USB_Host_SuspendBus(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_SuspendBus(void) { UHCON &= ~(1 << SOFEN); 90c: 90 91 9e 00 lds r25, 0x009E 910: 9e 7f andi r25, 0xFE ; 254 912: 90 93 9e 00 sts 0x009E, r25 USB_Host_SuspendBus(); if (HSOFIEnabled) 916: 21 15 cp r18, r1 918: 31 05 cpc r19, r1 91a: 29 f0 breq .+10 ; 0x926 UEIENX |= (1 << RXSTPE); break; #endif #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: UHIEN |= (1 << HSOFE); 91c: 90 91 a0 00 lds r25, 0x00A0 920: 90 62 ori r25, 0x20 ; 32 922: 90 93 a0 00 sts 0x00A0, r25 USB_INT_Enable(USB_INT_HSOFI); return ErrorCode; } 926: 08 95 ret 00000928 : #define __INCLUDE_FROM_HOST_C #include "../Host.h" void USB_Host_ProcessNextHostState(void) { 928: ef 92 push r14 92a: 0f 93 push r16 92c: 1f 93 push r17 92e: df 93 push r29 930: cf 93 push r28 932: cd b7 in r28, 0x3d ; 61 934: de b7 in r29, 0x3e ; 62 936: 28 97 sbiw r28, 0x08 ; 8 938: 0f b6 in r0, 0x3f ; 63 93a: f8 94 cli 93c: de bf out 0x3e, r29 ; 62 93e: 0f be out 0x3f, r0 ; 63 940: cd bf out 0x3d, r28 ; 61 uint8_t SubErrorCode = HOST_ENUMERROR_NoError; static uint16_t WaitMSRemaining; static uint8_t PostWaitState; switch (USB_HostState) 942: 80 91 2b 01 lds r24, 0x012B 946: 86 30 cpi r24, 0x06 ; 6 948: 09 f4 brne .+2 ; 0x94c 94a: 99 c0 rjmp .+306 ; 0xa7e 94c: 87 30 cpi r24, 0x07 ; 7 94e: 70 f4 brcc .+28 ; 0x96c 950: 83 30 cpi r24, 0x03 ; 3 952: c9 f1 breq .+114 ; 0x9c6 954: 84 30 cpi r24, 0x04 ; 4 956: 20 f4 brcc .+8 ; 0x960 958: 81 30 cpi r24, 0x01 ; 1 95a: 09 f0 breq .+2 ; 0x95e 95c: 0b c1 rjmp .+534 ; 0xb74 95e: 13 c0 rjmp .+38 ; 0x986 960: 84 30 cpi r24, 0x04 ; 4 962: c9 f1 breq .+114 ; 0x9d6 964: 85 30 cpi r24, 0x05 ; 5 966: 09 f0 breq .+2 ; 0x96a 968: 05 c1 rjmp .+522 ; 0xb74 96a: 60 c0 rjmp .+192 ; 0xa2c 96c: 88 30 cpi r24, 0x08 ; 8 96e: 09 f4 brne .+2 ; 0x972 970: a0 c0 rjmp .+320 ; 0xab2 972: 88 30 cpi r24, 0x08 ; 8 974: 08 f4 brcc .+2 ; 0x978 976: 8f c0 rjmp .+286 ; 0xa96 978: 89 30 cpi r24, 0x09 ; 9 97a: 09 f4 brne .+2 ; 0x97e 97c: b9 c0 rjmp .+370 ; 0xaf0 97e: 8a 30 cpi r24, 0x0A ; 10 980: 09 f0 breq .+2 ; 0x984 982: f8 c0 rjmp .+496 ; 0xb74 984: de c0 rjmp .+444 ; 0xb42 { case HOST_STATE_WaitForDevice: if (WaitMSRemaining) 986: 00 91 20 01 lds r16, 0x0120 98a: 10 91 21 01 lds r17, 0x0121 98e: 01 15 cp r16, r1 990: 11 05 cpc r17, r1 992: 09 f4 brne .+2 ; 0x996 994: ef c0 rjmp .+478 ; 0xb74 { if ((SubErrorCode = USB_Host_WaitMS(1)) != HOST_WAITERROR_Successful) 996: 81 e0 ldi r24, 0x01 ; 1 998: 72 df rcall .-284 ; 0x87e 99a: 68 2f mov r22, r24 99c: 88 23 and r24, r24 99e: 31 f0 breq .+12 ; 0x9ac { USB_HostState = PostWaitState; 9a0: 80 91 1f 01 lds r24, 0x011F 9a4: 80 93 2b 01 sts 0x012B, r24 ErrorCode = HOST_ENUMERROR_WaitStage; 9a8: 81 e0 ldi r24, 0x01 ; 1 break; 9aa: e0 c0 rjmp .+448 ; 0xb6c } if (!(--WaitMSRemaining)) 9ac: 01 50 subi r16, 0x01 ; 1 9ae: 10 40 sbci r17, 0x00 ; 0 9b0: 10 93 21 01 sts 0x0121, r17 9b4: 00 93 20 01 sts 0x0120, r16 9b8: 01 15 cp r16, r1 9ba: 11 05 cpc r17, r1 9bc: 09 f0 breq .+2 ; 0x9c0 9be: da c0 rjmp .+436 ; 0xb74 USB_HostState = PostWaitState; 9c0: 80 91 1f 01 lds r24, 0x011F 9c4: c3 c0 rjmp .+390 ; 0xb4c } break; case HOST_STATE_Powered: WaitMSRemaining = HOST_DEVICE_SETTLE_DELAY_MS; 9c6: 88 ee ldi r24, 0xE8 ; 232 9c8: 93 e0 ldi r25, 0x03 ; 3 9ca: 90 93 21 01 sts 0x0121, r25 9ce: 80 93 20 01 sts 0x0120, r24 USB_HostState = HOST_STATE_Powered_WaitForDeviceSettle; 9d2: 84 e0 ldi r24, 0x04 ; 4 9d4: bb c0 rjmp .+374 ; 0xb4c break; case HOST_STATE_Powered_WaitForDeviceSettle: if (WaitMSRemaining--) 9d6: 80 91 20 01 lds r24, 0x0120 9da: 90 91 21 01 lds r25, 0x0121 9de: 9c 01 movw r18, r24 9e0: 21 50 subi r18, 0x01 ; 1 9e2: 30 40 sbci r19, 0x00 ; 0 9e4: 30 93 21 01 sts 0x0121, r19 9e8: 20 93 20 01 sts 0x0120, r18 9ec: 00 97 sbiw r24, 0x00 ; 0 9ee: 39 f0 breq .+14 ; 0x9fe 9f0: 8f ec ldi r24, 0xCF ; 207 9f2: 97 e0 ldi r25, 0x07 ; 7 9f4: 01 97 sbiw r24, 0x01 ; 1 9f6: f1 f7 brne .-4 ; 0x9f4 9f8: 00 c0 rjmp .+0 ; 0x9fa 9fa: 00 00 nop 9fc: bb c0 rjmp .+374 ; 0xb74 } static inline void USB_Host_VBUS_Manual_Off(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_VBUS_Manual_Off(void) { PORTE &= ~(1 << 7); 9fe: 77 98 cbi 0x0e, 7 ; 14 #if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR) static inline void USB_OTGPAD_On(void) ATTR_ALWAYS_INLINE; static inline void USB_OTGPAD_On(void) { USBCON |= (1 << OTGPADE); a00: 80 91 d8 00 lds r24, 0x00D8 a04: 80 61 ori r24, 0x10 ; 16 a06: 80 93 d8 00 sts 0x00D8, r24 } static inline void USB_Host_VBUS_Auto_Enable(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_VBUS_Auto_Enable(void) { OTGCON &= ~(1 << VBUSHWC); a0a: 80 91 dd 00 lds r24, 0x00DD a0e: 8b 7f andi r24, 0xFB ; 251 a10: 80 93 dd 00 sts 0x00DD, r24 UHWCON |= (1 << UVCONE); a14: 80 91 d7 00 lds r24, 0x00D7 a18: 80 61 ori r24, 0x10 ; 16 a1a: 80 93 d7 00 sts 0x00D7, r24 } static inline void USB_Host_VBUS_Auto_On(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_VBUS_Auto_On(void) { OTGCON |= (1 << VBUSREQ); a1e: 80 91 dd 00 lds r24, 0x00DD a22: 82 60 ori r24, 0x02 ; 2 a24: 80 93 dd 00 sts 0x00DD, r24 USB_OTGPAD_On(); USB_Host_VBUS_Auto_Enable(); USB_Host_VBUS_Auto_On(); USB_HostState = HOST_STATE_Powered_WaitForConnect; a28: 85 e0 ldi r24, 0x05 ; 5 a2a: 90 c0 rjmp .+288 ; 0xb4c #endif #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: return (UHINT & (1 << HSOFI)); case USB_INT_DCONNI: return (UHINT & (1 << DCONNI)); a2c: 80 91 9f 00 lds r24, 0x009F } break; case HOST_STATE_Powered_WaitForConnect: if (USB_INT_HasOccurred(USB_INT_DCONNI)) a30: 80 ff sbrs r24, 0 a32: a0 c0 rjmp .+320 ; 0xb74 #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: UHINT &= ~(1 << HSOFI); break; case USB_INT_DCONNI: UHINT &= ~(1 << DCONNI); a34: 80 91 9f 00 lds r24, 0x009F a38: 8e 7f andi r24, 0xFE ; 254 a3a: 80 93 9f 00 sts 0x009F, r24 break; case USB_INT_DDISCI: UHINT &= ~(1 << DDISCI); a3e: 80 91 9f 00 lds r24, 0x009F a42: 8d 7f andi r24, 0xFD ; 253 a44: 80 93 9f 00 sts 0x009F, r24 break; case USB_INT_BCERRI: OTGINT &= ~(1 << BCERRI); break; case USB_INT_VBERRI: OTGINT &= ~(1 << VBERRI); a48: 80 91 df 00 lds r24, 0x00DF a4c: 8d 7f andi r24, 0xFD ; 253 a4e: 80 93 df 00 sts 0x00DF, r24 break; case USB_INT_BCERRI: OTGIEN |= (1 << BCERRE); break; case USB_INT_VBERRI: OTGIEN |= (1 << VBERRE); a52: 80 91 de 00 lds r24, 0x00DE a56: 82 60 ori r24, 0x02 ; 2 a58: 80 93 de 00 sts 0x00DE, r24 * host and attached device may occur. */ static inline void USB_Host_ResumeBus(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_ResumeBus(void) { UHCON |= (1 << SOFEN); a5c: 80 91 9e 00 lds r24, 0x009E a60: 81 60 ori r24, 0x01 ; 1 a62: 80 93 9e 00 sts 0x009E, r24 USB_INT_Clear(USB_INT_VBERRI); USB_INT_Enable(USB_INT_VBERRI); USB_Host_ResumeBus(); Pipe_ClearPipes(); a66: 26 d1 rcall .+588 ; 0xcb4 HOST_TASK_NONBLOCK_WAIT(100, HOST_STATE_Powered_DoReset); a68: 81 e0 ldi r24, 0x01 ; 1 a6a: 80 93 2b 01 sts 0x012B, r24 a6e: 84 e6 ldi r24, 0x64 ; 100 a70: 90 e0 ldi r25, 0x00 ; 0 a72: 90 93 21 01 sts 0x0121, r25 a76: 80 93 20 01 sts 0x0120, r24 a7a: 86 e0 ldi r24, 0x06 ; 6 a7c: 5f c0 rjmp .+190 ; 0xb3c } break; case HOST_STATE_Powered_DoReset: USB_Host_ResetDevice(); a7e: ab de rcall .-682 ; 0x7d6 HOST_TASK_NONBLOCK_WAIT(200, HOST_STATE_Powered_ConfigPipe); a80: 81 e0 ldi r24, 0x01 ; 1 a82: 80 93 2b 01 sts 0x012B, r24 a86: 88 ec ldi r24, 0xC8 ; 200 a88: 90 e0 ldi r25, 0x00 ; 0 a8a: 90 93 21 01 sts 0x0121, r25 a8e: 80 93 20 01 sts 0x0120, r24 a92: 87 e0 ldi r24, 0x07 ; 7 a94: 53 c0 rjmp .+166 ; 0xb3c break; case HOST_STATE_Powered_ConfigPipe: Pipe_ConfigurePipe(PIPE_CONTROLPIPE, EP_TYPE_CONTROL, a96: 80 e0 ldi r24, 0x00 ; 0 a98: 60 e0 ldi r22, 0x00 ; 0 a9a: 40 e0 ldi r20, 0x00 ; 0 a9c: 20 e0 ldi r18, 0x00 ; 0 a9e: 00 e4 ldi r16, 0x40 ; 64 aa0: 10 e0 ldi r17, 0x00 ; 0 aa2: ee 24 eor r14, r14 aa4: a0 d0 rcall .+320 ; 0xbe6 * \return Boolean \c true if the selected pipe is configured, \c false otherwise. */ static inline bool Pipe_IsConfigured(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline bool Pipe_IsConfigured(void) { return ((UPSTAX & (1 << CFGOK)) ? true : false); aa6: 80 91 ac 00 lds r24, 0x00AC PIPE_TOKEN_SETUP, ENDPOINT_CONTROLEP, PIPE_CONTROLPIPE_DEFAULT_SIZE, PIPE_BANK_SINGLE); if (!(Pipe_IsConfigured())) aaa: 87 ff sbrs r24, 7 aac: 5b c0 rjmp .+182 ; 0xb64 ErrorCode = HOST_ENUMERROR_PipeConfigError; SubErrorCode = 0; break; } USB_HostState = HOST_STATE_Default; aae: 88 e0 ldi r24, 0x08 ; 8 ab0: 4d c0 rjmp .+154 ; 0xb4c break; case HOST_STATE_Default: USB_ControlRequest = (USB_Request_Header_t) ab2: a3 e2 ldi r26, 0x23 ; 35 ab4: b1 e0 ldi r27, 0x01 ; 1 ab6: e3 e1 ldi r30, 0x13 ; 19 ab8: f1 e0 ldi r31, 0x01 ; 1 aba: 88 e0 ldi r24, 0x08 ; 8 abc: 01 90 ld r0, Z+ abe: 0d 92 st X+, r0 ac0: 81 50 subi r24, 0x01 ; 1 ac2: e1 f7 brne .-8 ; 0xabc .wLength = 8, }; uint8_t DataBuffer[8]; if ((SubErrorCode = USB_Host_SendControlRequest(DataBuffer)) != HOST_SENDCONTROL_Successful) ac4: ce 01 movw r24, r28 ac6: 01 96 adiw r24, 0x01 ; 1 ac8: dc d2 rcall .+1464 ; 0x1082 aca: 68 2f mov r22, r24 acc: 88 23 and r24, r24 ace: 09 f0 breq .+2 ; 0xad2 ad0: 4c c0 rjmp .+152 ; 0xb6a { ErrorCode = HOST_ENUMERROR_ControlError; break; } USB_ControlPipeSize = DataBuffer[offsetof(USB_Descriptor_Device_t, Endpoint0Size)]; ad2: 88 85 ldd r24, Y+8 ; 0x08 ad4: 80 93 1b 01 sts 0x011B, r24 USB_Host_ResetDevice(); ad8: 7e de rcall .-772 ; 0x7d6 HOST_TASK_NONBLOCK_WAIT(200, HOST_STATE_Default_PostReset); ada: 81 e0 ldi r24, 0x01 ; 1 adc: 80 93 2b 01 sts 0x012B, r24 ae0: 88 ec ldi r24, 0xC8 ; 200 ae2: 90 e0 ldi r25, 0x00 ; 0 ae4: 90 93 21 01 sts 0x0121, r25 ae8: 80 93 20 01 sts 0x0120, r24 aec: 89 e0 ldi r24, 0x09 ; 9 aee: 26 c0 rjmp .+76 ; 0xb3c break; case HOST_STATE_Default_PostReset: Pipe_ConfigurePipe(PIPE_CONTROLPIPE, EP_TYPE_CONTROL, af0: 00 91 1b 01 lds r16, 0x011B af4: 80 e0 ldi r24, 0x00 ; 0 af6: 60 e0 ldi r22, 0x00 ; 0 af8: 40 e0 ldi r20, 0x00 ; 0 afa: 20 e0 ldi r18, 0x00 ; 0 afc: 10 e0 ldi r17, 0x00 ; 0 afe: ee 24 eor r14, r14 b00: 72 d0 rcall .+228 ; 0xbe6 b02: 80 91 ac 00 lds r24, 0x00AC PIPE_TOKEN_SETUP, ENDPOINT_CONTROLEP, USB_ControlPipeSize, PIPE_BANK_SINGLE); if (!(Pipe_IsConfigured())) b06: 87 ff sbrs r24, 7 b08: 2d c0 rjmp .+90 ; 0xb64 ErrorCode = HOST_ENUMERROR_PipeConfigError; SubErrorCode = 0; break; } USB_ControlRequest = (USB_Request_Header_t) b0a: a3 e2 ldi r26, 0x23 ; 35 b0c: b1 e0 ldi r27, 0x01 ; 1 b0e: eb e0 ldi r30, 0x0B ; 11 b10: f1 e0 ldi r31, 0x01 ; 1 b12: 88 e0 ldi r24, 0x08 ; 8 b14: 01 90 ld r0, Z+ b16: 0d 92 st X+, r0 b18: 81 50 subi r24, 0x01 ; 1 b1a: e1 f7 brne .-8 ; 0xb14 .wValue = USB_HOST_DEVICEADDRESS, .wIndex = 0, .wLength = 0, }; if ((SubErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful) b1c: 80 e0 ldi r24, 0x00 ; 0 b1e: 90 e0 ldi r25, 0x00 ; 0 b20: b0 d2 rcall .+1376 ; 0x1082 b22: 68 2f mov r22, r24 b24: 88 23 and r24, r24 b26: 09 f5 brne .+66 ; 0xb6a { ErrorCode = HOST_ENUMERROR_ControlError; break; } HOST_TASK_NONBLOCK_WAIT(100, HOST_STATE_Default_PostAddressSet); b28: 81 e0 ldi r24, 0x01 ; 1 b2a: 80 93 2b 01 sts 0x012B, r24 b2e: 84 e6 ldi r24, 0x64 ; 100 b30: 90 e0 ldi r25, 0x00 ; 0 b32: 90 93 21 01 sts 0x0121, r25 b36: 80 93 20 01 sts 0x0120, r24 b3a: 8a e0 ldi r24, 0x0A ; 10 b3c: 80 93 1f 01 sts 0x011F, r24 break; b40: 19 c0 rjmp .+50 ; 0xb74 } static inline void USB_Host_SetDeviceAddress(const uint8_t Address) ATTR_ALWAYS_INLINE; static inline void USB_Host_SetDeviceAddress(const uint8_t Address) { UHADDR = (Address & 0x7F); b42: 81 e0 ldi r24, 0x01 ; 1 b44: 80 93 a1 00 sts 0x00A1, r24 case HOST_STATE_Default_PostAddressSet: USB_Host_SetDeviceAddress(USB_HOST_DEVICEADDRESS); EVENT_USB_Host_DeviceEnumerationComplete(); b48: 24 dc rcall .-1976 ; 0x392 USB_HostState = HOST_STATE_Addressed; b4a: 8b e0 ldi r24, 0x0B ; 11 b4c: 80 93 2b 01 sts 0x012B, r24 break; b50: 11 c0 rjmp .+34 ; 0xb74 } if ((ErrorCode != HOST_ENUMERROR_NoError) && (USB_HostState != HOST_STATE_Unattached)) { EVENT_USB_Host_DeviceEnumerationFailed(ErrorCode, SubErrorCode); b52: 40 dc rcall .-1920 ; 0x3d4 } static inline void USB_Host_VBUS_Auto_Off(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_VBUS_Auto_Off(void) { OTGCON |= (1 << VBUSRQC); b54: 80 91 dd 00 lds r24, 0x00DD b58: 81 60 ori r24, 0x01 ; 1 b5a: 80 93 dd 00 sts 0x00DD, r24 USB_Host_VBUS_Auto_Off(); EVENT_USB_Host_DeviceUnattached(); b5e: 14 dc rcall .-2008 ; 0x388 USB_ResetInterface(); b60: d5 d0 rcall .+426 ; 0xd0c b62: 08 c0 rjmp .+16 ; 0xb74 USB_ControlPipeSize, PIPE_BANK_SINGLE); if (!(Pipe_IsConfigured())) { ErrorCode = HOST_ENUMERROR_PipeConfigError; SubErrorCode = 0; b64: 60 e0 ldi r22, 0x00 ; 0 PIPE_TOKEN_SETUP, ENDPOINT_CONTROLEP, USB_ControlPipeSize, PIPE_BANK_SINGLE); if (!(Pipe_IsConfigured())) { ErrorCode = HOST_ENUMERROR_PipeConfigError; b66: 84 e0 ldi r24, 0x04 ; 4 b68: 01 c0 rjmp .+2 ; 0xb6c .wLength = 0, }; if ((SubErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful) { ErrorCode = HOST_ENUMERROR_ControlError; b6a: 83 e0 ldi r24, 0x03 ; 3 EVENT_USB_Host_DeviceEnumerationComplete(); USB_HostState = HOST_STATE_Addressed; break; } if ((ErrorCode != HOST_ENUMERROR_NoError) && (USB_HostState != HOST_STATE_Unattached)) b6c: 90 91 2b 01 lds r25, 0x012B b70: 92 30 cpi r25, 0x02 ; 2 b72: 79 f7 brne .-34 ; 0xb52 EVENT_USB_Host_DeviceUnattached(); USB_ResetInterface(); } } b74: 28 96 adiw r28, 0x08 ; 8 b76: 0f b6 in r0, 0x3f ; 63 b78: f8 94 cli b7a: de bf out 0x3e, r29 ; 62 b7c: 0f be out 0x3f, r0 ; 63 b7e: cd bf out 0x3d, r28 ; 61 b80: cf 91 pop r28 b82: df 91 pop r29 b84: 1f 91 pop r17 b86: 0f 91 pop r16 b88: ef 90 pop r14 b8a: 08 95 ret 00000b8c : USB_INT_Enable(USB_INT_DDISCI); } uint8_t USB_Host_SetDeviceConfiguration(const uint8_t ConfigNumber) { USB_ControlRequest = (USB_Request_Header_t) b8c: 10 92 23 01 sts 0x0123, r1 b90: 99 e0 ldi r25, 0x09 ; 9 b92: 90 93 24 01 sts 0x0124, r25 b96: 80 93 25 01 sts 0x0125, r24 b9a: 10 92 26 01 sts 0x0126, r1 b9e: 10 92 28 01 sts 0x0128, r1 ba2: 10 92 27 01 sts 0x0127, r1 ba6: 10 92 2a 01 sts 0x012A, r1 baa: 10 92 29 01 sts 0x0129, r1 * \param[in] PipeNumber Index of the pipe to select. */ static inline void Pipe_SelectPipe(const uint8_t PipeNumber) ATTR_ALWAYS_INLINE; static inline void Pipe_SelectPipe(const uint8_t PipeNumber) { UPNUM = PipeNumber; bae: 10 92 a7 00 sts 0x00A7, r1 .wLength = 0, }; Pipe_SelectPipe(PIPE_CONTROLPIPE); return USB_Host_SendControlRequest(NULL); bb2: 80 e0 ldi r24, 0x00 ; 0 bb4: 90 e0 ldi r25, 0x00 ; 0 } bb6: 65 c2 rjmp .+1226 ; 0x1082 00000bb8 : } uint8_t USB_Host_SetInterfaceAltSetting(const uint8_t InterfaceNum, const uint8_t AltSetting) { USB_ControlRequest = (USB_Request_Header_t) bb8: e3 e2 ldi r30, 0x23 ; 35 bba: f1 e0 ldi r31, 0x01 ; 1 bbc: 91 e0 ldi r25, 0x01 ; 1 bbe: 90 93 23 01 sts 0x0123, r25 bc2: 9b e0 ldi r25, 0x0B ; 11 bc4: 90 93 24 01 sts 0x0124, r25 bc8: 60 93 25 01 sts 0x0125, r22 bcc: 13 82 std Z+3, r1 ; 0x03 bce: 80 93 27 01 sts 0x0127, r24 bd2: 15 82 std Z+5, r1 ; 0x05 bd4: 10 92 2a 01 sts 0x012A, r1 bd8: 10 92 29 01 sts 0x0129, r1 bdc: 10 92 a7 00 sts 0x00A7, r1 .wLength = 0, }; Pipe_SelectPipe(PIPE_CONTROLPIPE); return USB_Host_SendControlRequest(NULL); be0: 80 e0 ldi r24, 0x00 ; 0 be2: 90 e0 ldi r25, 0x00 ; 0 } be4: 4e c2 rjmp .+1180 ; 0x1082 00000be6 : const uint8_t Type, const uint8_t Token, const uint8_t EndpointNumber, const uint16_t Size, const uint8_t Banks) { be6: ef 92 push r14 be8: 0f 93 push r16 bea: 1f 93 push r17 bec: 5e 2d mov r21, r14 Pipe_SelectPipe(PNum); if (PNum == Number) { UPCFG0XTemp = ((Type << EPTYPE0) | Token | ((EndpointNumber & PIPE_EPNUM_MASK) << PEPNUM0)); bee: 62 95 swap r22 bf0: 66 0f add r22, r22 bf2: 66 0f add r22, r22 bf4: 60 7c andi r22, 0xC0 ; 192 bf6: 64 2b or r22, r20 bf8: 2f 70 andi r18, 0x0F ; 15 bfa: 62 2b or r22, r18 Pipe_SetInfiniteINRequests(); return Pipe_IsConfigured(); #else for (uint8_t PNum = Number; PNum < PIPE_TOTAL_PIPES; PNum++) bfc: 98 2f mov r25, r24 Pipe_SelectPipe(PNum); if (PNum == Number) { UPCFG0XTemp = ((Type << EPTYPE0) | Token | ((EndpointNumber & PIPE_EPNUM_MASK) << PEPNUM0)); UPCFG1XTemp = ((1 << ALLOC) | Banks | Pipe_BytesToEPSizeMask(Size)); bfe: 52 60 ori r21, 0x02 ; 2 Pipe_SetInfiniteINRequests(); return Pipe_IsConfigured(); #else for (uint8_t PNum = Number; PNum < PIPE_TOTAL_PIPES; PNum++) c00: 4d c0 rjmp .+154 ; 0xc9c * \param[in] PipeNumber Index of the pipe to select. */ static inline void Pipe_SelectPipe(const uint8_t PipeNumber) ATTR_ALWAYS_INLINE; static inline void Pipe_SelectPipe(const uint8_t PipeNumber) { UPNUM = PipeNumber; c02: 90 93 a7 00 sts 0x00A7, r25 uint8_t UPINRQXTemp; uint8_t UPIENXTemp; Pipe_SelectPipe(PNum); if (PNum == Number) c06: 98 17 cp r25, r24 c08: b1 f4 brne .+44 ; 0xc36 c0a: 28 e0 ldi r18, 0x08 ; 8 c0c: 30 e0 ldi r19, 0x00 ; 0 c0e: 40 e0 ldi r20, 0x00 ; 0 c10: 03 c0 rjmp .+6 ; 0xc18 uint8_t MaskVal = 0; uint16_t CheckBytes = 8; while ((CheckBytes < Bytes) && (CheckBytes < PIPE_MAX_SIZE)) { MaskVal++; c12: 4f 5f subi r20, 0xFF ; 255 CheckBytes <<= 1; c14: 22 0f add r18, r18 c16: 33 1f adc r19, r19 static inline uint8_t Pipe_BytesToEPSizeMask(const uint16_t Bytes) { uint8_t MaskVal = 0; uint16_t CheckBytes = 8; while ((CheckBytes < Bytes) && (CheckBytes < PIPE_MAX_SIZE)) c18: 20 17 cp r18, r16 c1a: 31 07 cpc r19, r17 c1c: 10 f4 brcc .+4 ; 0xc22 c1e: 45 30 cpi r20, 0x05 ; 5 c20: c1 f7 brne .-16 ; 0xc12 { MaskVal++; CheckBytes <<= 1; } return (MaskVal << EPSIZE0); c22: 24 2f mov r18, r20 c24: 22 95 swap r18 c26: 20 7f andi r18, 0xF0 ; 240 { UPCFG0XTemp = ((Type << EPTYPE0) | Token | ((EndpointNumber & PIPE_EPNUM_MASK) << PEPNUM0)); UPCFG1XTemp = ((1 << ALLOC) | Banks | Pipe_BytesToEPSizeMask(Size)); c28: 25 2b or r18, r21 Pipe_SelectPipe(PNum); if (PNum == Number) { UPCFG0XTemp = ((Type << EPTYPE0) | Token | ((EndpointNumber & PIPE_EPNUM_MASK) << PEPNUM0)); c2a: a6 2f mov r26, r22 UPCFG1XTemp = ((1 << ALLOC) | Banks | Pipe_BytesToEPSizeMask(Size)); UPCFG2XTemp = 0; UPCONXTemp = ((1 << PEN) | (1 << INMODE)); UPINRQXTemp = 0; UPIENXTemp = 0; c2c: 40 e0 ldi r20, 0x00 ; 0 { UPCFG0XTemp = ((Type << EPTYPE0) | Token | ((EndpointNumber & PIPE_EPNUM_MASK) << PEPNUM0)); UPCFG1XTemp = ((1 << ALLOC) | Banks | Pipe_BytesToEPSizeMask(Size)); UPCFG2XTemp = 0; UPCONXTemp = ((1 << PEN) | (1 << INMODE)); UPINRQXTemp = 0; c2e: 70 e0 ldi r23, 0x00 ; 0 if (PNum == Number) { UPCFG0XTemp = ((Type << EPTYPE0) | Token | ((EndpointNumber & PIPE_EPNUM_MASK) << PEPNUM0)); UPCFG1XTemp = ((1 << ALLOC) | Banks | Pipe_BytesToEPSizeMask(Size)); UPCFG2XTemp = 0; UPCONXTemp = ((1 << PEN) | (1 << INMODE)); c30: e1 e2 ldi r30, 0x21 ; 33 if (PNum == Number) { UPCFG0XTemp = ((Type << EPTYPE0) | Token | ((EndpointNumber & PIPE_EPNUM_MASK) << PEPNUM0)); UPCFG1XTemp = ((1 << ALLOC) | Banks | Pipe_BytesToEPSizeMask(Size)); UPCFG2XTemp = 0; c32: f0 e0 ldi r31, 0x00 ; 0 c34: 0c c0 rjmp .+24 ; 0xc4e UPINRQXTemp = 0; UPIENXTemp = 0; } else { UPCFG0XTemp = UPCFG0X; c36: a0 91 aa 00 lds r26, 0x00AA UPCFG1XTemp = UPCFG1X; c3a: 20 91 ab 00 lds r18, 0x00AB UPCFG2XTemp = UPCFG2X; c3e: f0 91 ad 00 lds r31, 0x00AD UPCONXTemp = UPCONX; c42: e0 91 a9 00 lds r30, 0x00A9 UPINRQXTemp = UPINRQX; c46: 70 91 a5 00 lds r23, 0x00A5 UPIENXTemp = UPIENX; c4a: 40 91 ae 00 lds r20, 0x00AE /** Configures the currently selected pipe to allow for an unlimited number of IN requests. */ static inline void Pipe_SetInfiniteINRequests(void) ATTR_ALWAYS_INLINE; static inline void Pipe_SetInfiniteINRequests(void) { UPCONX |= (1 << INMODE); c4e: 30 91 a9 00 lds r19, 0x00A9 c52: 30 62 ori r19, 0x20 ; 32 c54: 30 93 a9 00 sts 0x00A9, r19 } Pipe_SetInfiniteINRequests(); if (!(UPCFG1XTemp & (1 << ALLOC))) c58: 21 ff sbrs r18, 1 c5a: 1f c0 rjmp .+62 ; 0xc9a * from an attached device. */ static inline void Pipe_DisablePipe(void) ATTR_ALWAYS_INLINE; static inline void Pipe_DisablePipe(void) { UPCONX &= ~(1 << PEN); c5c: 30 91 a9 00 lds r19, 0x00A9 c60: 3e 7f andi r19, 0xFE ; 254 c62: 30 93 a9 00 sts 0x00A9, r19 continue; Pipe_DisablePipe(); UPCFG1X &= (1 << ALLOC); c66: 30 91 ab 00 lds r19, 0x00AB c6a: 32 70 andi r19, 0x02 ; 2 c6c: 30 93 ab 00 sts 0x00AB, r19 * \pre The currently selected pipe must first be configured properly via \ref Pipe_ConfigurePipe(). */ static inline void Pipe_EnablePipe(void) ATTR_ALWAYS_INLINE; static inline void Pipe_EnablePipe(void) { UPCONX |= (1 << PEN); c70: 30 91 a9 00 lds r19, 0x00A9 c74: 31 60 ori r19, 0x01 ; 1 c76: 30 93 a9 00 sts 0x00A9, r19 Pipe_EnablePipe(); UPCFG0X = UPCFG0XTemp; c7a: a0 93 aa 00 sts 0x00AA, r26 UPCFG1X = UPCFG1XTemp; c7e: 20 93 ab 00 sts 0x00AB, r18 UPCFG2X = UPCFG2XTemp; c82: f0 93 ad 00 sts 0x00AD, r31 UPCONX = UPCONXTemp; c86: e0 93 a9 00 sts 0x00A9, r30 UPINRQX = UPINRQXTemp; c8a: 70 93 a5 00 sts 0x00A5, r23 UPIENX = UPIENXTemp; c8e: 40 93 ae 00 sts 0x00AE, r20 * \return Boolean \c true if the selected pipe is configured, \c false otherwise. */ static inline bool Pipe_IsConfigured(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline bool Pipe_IsConfigured(void) { return ((UPSTAX & (1 << CFGOK)) ? true : false); c92: 20 91 ac 00 lds r18, 0x00AC if (!(Pipe_IsConfigured())) c96: 27 ff sbrs r18, 7 c98: 08 c0 rjmp .+16 ; 0xcaa Pipe_SetInfiniteINRequests(); return Pipe_IsConfigured(); #else for (uint8_t PNum = Number; PNum < PIPE_TOTAL_PIPES; PNum++) c9a: 9f 5f subi r25, 0xFF ; 255 c9c: 97 30 cpi r25, 0x07 ; 7 c9e: 08 f4 brcc .+2 ; 0xca2 ca0: b0 cf rjmp .-160 ; 0xc02 * \param[in] PipeNumber Index of the pipe to select. */ static inline void Pipe_SelectPipe(const uint8_t PipeNumber) ATTR_ALWAYS_INLINE; static inline void Pipe_SelectPipe(const uint8_t PipeNumber) { UPNUM = PipeNumber; ca2: 80 93 a7 00 sts 0x00A7, r24 if (!(Pipe_IsConfigured())) return false; } Pipe_SelectPipe(Number); return true; ca6: 81 e0 ldi r24, 0x01 ; 1 ca8: 01 c0 rjmp .+2 ; 0xcac UPCONX = UPCONXTemp; UPINRQX = UPINRQXTemp; UPIENX = UPIENXTemp; if (!(Pipe_IsConfigured())) return false; caa: 80 e0 ldi r24, 0x00 ; 0 } Pipe_SelectPipe(Number); return true; #endif } cac: 1f 91 pop r17 cae: 0f 91 pop r16 cb0: ef 90 pop r14 cb2: 08 95 ret 00000cb4 : void Pipe_ClearPipes(void) { UPINT = 0; cb4: 10 92 f8 00 sts 0x00F8, r1 for (uint8_t PNum = 0; PNum < PIPE_TOTAL_PIPES; PNum++) cb8: 80 e0 ldi r24, 0x00 ; 0 cba: 80 93 a7 00 sts 0x00A7, r24 { Pipe_SelectPipe(PNum); UPIENX = 0; cbe: 10 92 ae 00 sts 0x00AE, r1 UPINTX = 0; cc2: 10 92 a6 00 sts 0x00A6, r1 UPCFG1X = 0; cc6: 10 92 ab 00 sts 0x00AB, r1 * from an attached device. */ static inline void Pipe_DisablePipe(void) ATTR_ALWAYS_INLINE; static inline void Pipe_DisablePipe(void) { UPCONX &= ~(1 << PEN); cca: 90 91 a9 00 lds r25, 0x00A9 cce: 9e 7f andi r25, 0xFE ; 254 cd0: 90 93 a9 00 sts 0x00A9, r25 void Pipe_ClearPipes(void) { UPINT = 0; for (uint8_t PNum = 0; PNum < PIPE_TOTAL_PIPES; PNum++) cd4: 8f 5f subi r24, 0xFF ; 255 cd6: 87 30 cpi r24, 0x07 ; 7 cd8: 81 f7 brne .-32 ; 0xcba UPIENX = 0; UPINTX = 0; UPCFG1X = 0; Pipe_DisablePipe(); } } cda: 08 95 ret 00000cdc : USB_ResetInterface(); } void USB_Disable(void) { USB_INT_DisableAllInterrupts(); cdc: 6e d0 rcall .+220 ; 0xdba USB_INT_ClearAllInterrupts(); cde: 75 d0 rcall .+234 ; 0xdca * 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); ce0: e0 ee ldi r30, 0xE0 ; 224 ce2: f0 e0 ldi r31, 0x00 ; 0 ce4: 80 81 ld r24, Z ce6: 81 60 ori r24, 0x01 ; 1 ce8: 80 83 st Z, r24 } static inline void USB_Controller_Disable(void) ATTR_ALWAYS_INLINE; static inline void USB_Controller_Disable(void) { USBCON &= ~(1 << USBE); cea: e8 ed ldi r30, 0xD8 ; 216 cec: f0 e0 ldi r31, 0x00 ; 0 cee: 80 81 ld r24, Z cf0: 8f 77 andi r24, 0x7F ; 127 cf2: 80 83 st Z, r24 } static inline void USB_PLL_Off(void) ATTR_ALWAYS_INLINE; static inline void USB_PLL_Off(void) { PLLCSR = 0; cf4: 19 bc out 0x29, r1 ; 41 static inline void USB_REG_Off(void) ATTR_ALWAYS_INLINE; static inline void USB_REG_Off(void) { #if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR) UHWCON &= ~(1 << UVREGE); cf6: a7 ed ldi r26, 0xD7 ; 215 cf8: b0 e0 ldi r27, 0x00 ; 0 cfa: 8c 91 ld r24, X cfc: 8e 7f andi r24, 0xFE ; 254 cfe: 8c 93 st X, r24 } static inline void USB_OTGPAD_Off(void) ATTR_ALWAYS_INLINE; static inline void USB_OTGPAD_Off(void) { USBCON &= ~(1 << OTGPADE); d00: 80 81 ld r24, Z d02: 8f 7e andi r24, 0xEF ; 239 d04: 80 83 st Z, r24 #if defined(USB_CAN_BE_BOTH) USB_CurrentMode = USB_MODE_None; #endif USB_IsInitialized = false; d06: 10 92 22 01 sts 0x0122, r1 } d0a: 08 95 ret 00000d0c : { #if defined(USB_CAN_BE_BOTH) bool UIDModeSelectEnabled = ((UHWCON & (1 << UIDE)) != 0); #endif USB_INT_DisableAllInterrupts(); d0c: 56 d0 rcall .+172 ; 0xdba USB_INT_ClearAllInterrupts(); d0e: 5d d0 rcall .+186 ; 0xdca } static inline void USB_Controller_Reset(void) ATTR_ALWAYS_INLINE; static inline void USB_Controller_Reset(void) { const uint8_t Temp = USBCON; d10: 80 91 d8 00 lds r24, 0x00D8 USBCON = (Temp & ~(1 << USBE)); d14: 98 2f mov r25, r24 d16: 9f 77 andi r25, 0x7F ; 127 d18: 90 93 d8 00 sts 0x00D8, r25 USBCON = (Temp | (1 << USBE)); d1c: 80 68 ori r24, 0x80 ; 128 d1e: 80 93 d8 00 sts 0x00D8, r24 } static inline void USB_CLK_Unfreeze(void) ATTR_ALWAYS_INLINE; static inline void USB_CLK_Unfreeze(void) { USBCON &= ~(1 << FRZCLK); d22: 80 91 d8 00 lds r24, 0x00D8 d26: 8f 7d andi r24, 0xDF ; 223 d28: 80 93 d8 00 sts 0x00D8, r24 #endif } else if (USB_CurrentMode == USB_MODE_Host) { #if defined(USB_CAN_BE_HOST) UHWCON &= ~(1 << UIMOD); d2c: 80 91 d7 00 lds r24, 0x00D7 d30: 8f 77 andi r24, 0x7F ; 127 d32: 80 93 d7 00 sts 0x00D7, r24 /* Inline Functions: */ static inline void USB_PLL_On(void) ATTR_ALWAYS_INLINE; static inline void USB_PLL_On(void) { PLLCSR = USB_PLL_PSC; d36: 8c e0 ldi r24, 0x0C ; 12 d38: 89 bd out 0x29, r24 ; 41 PLLCSR |= (1 << PLLE); d3a: 89 b5 in r24, 0x29 ; 41 d3c: 82 60 ori r24, 0x02 ; 2 d3e: 89 bd out 0x29, r24 ; 41 if (!(USB_Options & USB_OPT_MANUAL_PLL)) { #if defined(USB_CAN_BE_HOST) USB_PLL_On(); while (!(USB_PLL_IsReady())); d40: 09 b4 in r0, 0x29 ; 41 d42: 00 fe sbrs r0, 0 d44: fd cf rjmp .-6 ; 0xd40 #endif #if defined(USB_CAN_BE_HOST) static void USB_Init_Host(void) { USB_HostState = HOST_STATE_Unattached; d46: 82 e0 ldi r24, 0x02 ; 2 d48: 80 93 2b 01 sts 0x012B, r24 USB_ControlPipeSize = PIPE_CONTROLPIPE_DEFAULT_SIZE; d4c: 80 e4 ldi r24, 0x40 ; 64 d4e: 80 93 1b 01 sts 0x011B, r24 #if !defined(__DOXYGEN__) /* Macros: */ static inline void USB_Host_HostMode_On(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_HostMode_On(void) { USBCON |= (1 << HOST); d52: 80 91 d8 00 lds r24, 0x00D8 d56: 80 64 ori r24, 0x40 ; 64 d58: 80 93 d8 00 sts 0x00D8, r24 } static inline void USB_Host_VBUS_Auto_Off(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_VBUS_Auto_Off(void) { OTGCON |= (1 << VBUSRQC); d5c: 80 91 dd 00 lds r24, 0x00DD d60: 81 60 ori r24, 0x01 ; 1 d62: 80 93 dd 00 sts 0x00DD, r24 } static inline void USB_Host_VBUS_Manual_Enable(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_VBUS_Manual_Enable(void) { OTGCON |= (1 << VBUSHWC); d66: 80 91 dd 00 lds r24, 0x00DD d6a: 84 60 ori r24, 0x04 ; 4 d6c: 80 93 dd 00 sts 0x00DD, r24 UHWCON &= ~(1 << UVCONE); d70: 80 91 d7 00 lds r24, 0x00D7 d74: 8f 7e andi r24, 0xEF ; 239 d76: 80 93 d7 00 sts 0x00D7, r24 DDRE |= (1 << 7); d7a: 6f 9a sbi 0x0d, 7 ; 13 } static inline void USB_Host_VBUS_Manual_On(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_VBUS_Manual_On(void) { PORTE |= (1 << 7); d7c: 77 9a sbi 0x0e, 7 ; 14 break; case USB_INT_VBERRI: OTGIEN |= (1 << VBERRE); break; case USB_INT_SRPI: OTGIEN |= (1 << SRPE); d7e: 80 91 de 00 lds r24, 0x00DE d82: 81 60 ori r24, 0x01 ; 1 d84: 80 93 de 00 sts 0x00DE, r24 break; case USB_INT_RSTI: UHIEN |= (1 << RSTE); break; case USB_INT_BCERRI: OTGIEN |= (1 << BCERRE); d88: 80 91 de 00 lds r24, 0x00DE d8c: 84 60 ori r24, 0x04 ; 4 d8e: 80 93 de 00 sts 0x00DE, 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); d92: 80 91 e0 00 lds r24, 0x00E0 d96: 8e 7f andi r24, 0xFE ; 254 d98: 80 93 e0 00 sts 0x00E0, r24 #if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR) static inline void USB_OTGPAD_On(void) ATTR_ALWAYS_INLINE; static inline void USB_OTGPAD_On(void) { USBCON |= (1 << OTGPADE); d9c: 80 91 d8 00 lds r24, 0x00D8 da0: 80 61 ori r24, 0x10 ; 16 da2: 80 93 d8 00 sts 0x00D8, r24 } #if (defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)) USB_OTGPAD_On(); #endif } da6: 08 95 ret 00000da8 : static inline void USB_REG_On(void) ATTR_ALWAYS_INLINE; 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); da8: e7 ed ldi r30, 0xD7 ; 215 daa: f0 e0 ldi r31, 0x00 ; 0 dac: 80 81 ld r24, Z dae: 81 60 ori r24, 0x01 ; 1 db0: 80 83 st Z, r24 UHWCON &= ~(1 << UIDE); USB_CurrentMode = Mode; } #endif USB_IsInitialized = true; db2: 81 e0 ldi r24, 0x01 ; 1 db4: 80 93 22 01 sts 0x0122, r24 USB_ResetInterface(); } db8: a9 cf rjmp .-174 ; 0xd0c 00000dba : #include "../USBInterrupt.h" void USB_INT_DisableAllInterrupts(void) { #if defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR) USBCON &= ~((1 << VBUSTE) | (1 << IDTE)); dba: e8 ed ldi r30, 0xD8 ; 216 dbc: f0 e0 ldi r31, 0x00 ; 0 dbe: 80 81 ld r24, Z dc0: 8c 7f andi r24, 0xFC ; 252 dc2: 80 83 st Z, r24 #if defined(USB_CAN_BE_BOTH) OTGIEN = 0; #endif #if defined(USB_CAN_BE_HOST) UHIEN = 0; dc4: 10 92 a0 00 sts 0x00A0, r1 #endif #if defined(USB_CAN_BE_DEVICE) UDIEN = 0; #endif } dc8: 08 95 ret 00000dca : void USB_INT_ClearAllInterrupts(void) { #if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR) USBINT = 0; dca: 10 92 da 00 sts 0x00DA, r1 #if defined(USB_CAN_BE_BOTH) OTGINT = 0; #endif #if defined(USB_CAN_BE_HOST) UHINT = 0; dce: 10 92 9f 00 sts 0x009F, r1 #endif #if defined(USB_CAN_BE_DEVICE) UDINT = 0; #endif } dd2: 08 95 ret 00000dd4 <__vector_10>: ISR(USB_GEN_vect, ISR_BLOCK) { dd4: 1f 92 push r1 dd6: 0f 92 push r0 dd8: 0f b6 in r0, 0x3f ; 63 dda: 0f 92 push r0 ddc: 0b b6 in r0, 0x3b ; 59 dde: 0f 92 push r0 de0: 11 24 eor r1, r1 de2: 2f 93 push r18 de4: 3f 93 push r19 de6: 4f 93 push r20 de8: 5f 93 push r21 dea: 6f 93 push r22 dec: 7f 93 push r23 dee: 8f 93 push r24 df0: 9f 93 push r25 df2: af 93 push r26 df4: bf 93 push r27 df6: ef 93 push r30 df8: ff 93 push r31 case USB_INT_RXSTPI: return (UEINTX & (1 << RXSTPI)); #endif #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: return (UHINT & (1 << HSOFI)); dfa: 80 91 9f 00 lds r24, 0x009F } #endif #if defined(USB_CAN_BE_HOST) #if !defined(NO_SOF_EVENTS) if (USB_INT_HasOccurred(USB_INT_HSOFI) && USB_INT_IsEnabled(USB_INT_HSOFI)) dfe: 85 ff sbrs r24, 5 e00: 0a c0 rjmp .+20 ; 0xe16 <__vector_10+0x42> case USB_INT_RXSTPI: return (UEIENX & (1 << RXSTPE)); #endif #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: return (UHIEN & (1 << HSOFE)); e02: 80 91 a0 00 lds r24, 0x00A0 e06: 85 ff sbrs r24, 5 e08: 06 c0 rjmp .+12 ; 0xe16 <__vector_10+0x42> UEINTX &= ~(1 << RXSTPI); break; #endif #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: UHINT &= ~(1 << HSOFI); e0a: 80 91 9f 00 lds r24, 0x009F e0e: 8f 7d andi r24, 0xDF ; 223 e10: 80 93 9f 00 sts 0x009F, r24 { USB_INT_Clear(USB_INT_HSOFI); EVENT_USB_Host_StartOfFrame(); e14: 0c d1 rcall .+536 ; 0x102e case USB_INT_HSOFI: return (UHINT & (1 << HSOFI)); case USB_INT_DCONNI: return (UHINT & (1 << DCONNI)); case USB_INT_DDISCI: return (UHINT & (1 << DDISCI)); e16: 80 91 9f 00 lds r24, 0x009F } #endif if (USB_INT_HasOccurred(USB_INT_DDISCI) && USB_INT_IsEnabled(USB_INT_DDISCI)) e1a: 81 ff sbrs r24, 1 e1c: 15 c0 rjmp .+42 ; 0xe48 <__vector_10+0x74> case USB_INT_HSOFI: return (UHIEN & (1 << HSOFE)); case USB_INT_DCONNI: return (UHIEN & (1 << DCONNE)); case USB_INT_DDISCI: return (UHIEN & (1 << DDISCE)); e1e: 80 91 a0 00 lds r24, 0x00A0 e22: 81 ff sbrs r24, 1 e24: 11 c0 rjmp .+34 ; 0xe48 <__vector_10+0x74> break; case USB_INT_DCONNI: UHINT &= ~(1 << DCONNI); break; case USB_INT_DDISCI: UHINT &= ~(1 << DDISCI); e26: 80 91 9f 00 lds r24, 0x009F e2a: 8d 7f andi r24, 0xFD ; 253 e2c: 80 93 9f 00 sts 0x009F, r24 #if defined(USB_CAN_BE_HOST) case USB_INT_HSOFI: UHINT &= ~(1 << HSOFI); break; case USB_INT_DCONNI: UHINT &= ~(1 << DCONNI); e30: 80 91 9f 00 lds r24, 0x009F e34: 8e 7f andi r24, 0xFE ; 254 e36: 80 93 9f 00 sts 0x009F, r24 break; case USB_INT_DCONNI: UHIEN &= ~(1 << DCONNE); break; case USB_INT_DDISCI: UHIEN &= ~(1 << DDISCE); e3a: 80 91 a0 00 lds r24, 0x00A0 e3e: 8d 7f andi r24, 0xFD ; 253 e40: 80 93 a0 00 sts 0x00A0, r24 { USB_INT_Clear(USB_INT_DDISCI); USB_INT_Clear(USB_INT_DCONNI); USB_INT_Disable(USB_INT_DDISCI); EVENT_USB_Host_DeviceUnattached(); e44: a1 da rcall .-2750 ; 0x388 USB_ResetInterface(); e46: 62 df rcall .-316 ; 0xd0c case USB_INT_RSTI: return (UHINT & (1 << RSTI)); case USB_INT_BCERRI: return (OTGINT & (1 << BCERRI)); case USB_INT_VBERRI: return (OTGINT & (1 << VBERRI)); e48: 80 91 df 00 lds r24, 0x00DF } if (USB_INT_HasOccurred(USB_INT_VBERRI) && USB_INT_IsEnabled(USB_INT_VBERRI)) e4c: 81 ff sbrs r24, 1 e4e: 15 c0 rjmp .+42 ; 0xe7a <__vector_10+0xa6> case USB_INT_RSTI: return (UHIEN & (1 << RSTE)); case USB_INT_BCERRI: return (OTGIEN & (1 << BCERRE)); case USB_INT_VBERRI: return (OTGIEN & (1 << VBERRE)); e50: 80 91 de 00 lds r24, 0x00DE e54: 81 ff sbrs r24, 1 e56: 11 c0 rjmp .+34 ; 0xe7a <__vector_10+0xa6> break; case USB_INT_BCERRI: OTGINT &= ~(1 << BCERRI); break; case USB_INT_VBERRI: OTGINT &= ~(1 << VBERRI); e58: 80 91 df 00 lds r24, 0x00DF e5c: 8d 7f andi r24, 0xFD ; 253 e5e: 80 93 df 00 sts 0x00DF, r24 } static inline void USB_Host_VBUS_Manual_Off(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_VBUS_Manual_Off(void) { PORTE &= ~(1 << 7); e62: 77 98 cbi 0x0e, 7 ; 14 } static inline void USB_Host_VBUS_Auto_Off(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_VBUS_Auto_Off(void) { OTGCON |= (1 << VBUSRQC); e64: 80 91 dd 00 lds r24, 0x00DD e68: 81 60 ori r24, 0x01 ; 1 e6a: 80 93 dd 00 sts 0x00DD, r24 USB_INT_Clear(USB_INT_VBERRI); USB_Host_VBUS_Manual_Off(); USB_Host_VBUS_Auto_Off(); EVENT_USB_Host_HostError(HOST_ERROR_VBusVoltageDip); e6e: 80 e0 ldi r24, 0x00 ; 0 e70: 92 da rcall .-2780 ; 0x396 EVENT_USB_Host_DeviceUnattached(); e72: 8a da rcall .-2796 ; 0x388 USB_HostState = HOST_STATE_Unattached; e74: 82 e0 ldi r24, 0x02 ; 2 e76: 80 93 2b 01 sts 0x012B, r24 case USB_INT_BCERRI: return (OTGINT & (1 << BCERRI)); case USB_INT_VBERRI: return (OTGINT & (1 << VBERRI)); case USB_INT_SRPI: return (OTGINT & (1 << SRPI)); e7a: 80 91 df 00 lds r24, 0x00DF } if (USB_INT_HasOccurred(USB_INT_SRPI) && USB_INT_IsEnabled(USB_INT_SRPI)) e7e: 80 ff sbrs r24, 0 e80: 17 c0 rjmp .+46 ; 0xeb0 <__vector_10+0xdc> case USB_INT_BCERRI: return (OTGIEN & (1 << BCERRE)); case USB_INT_VBERRI: return (OTGIEN & (1 << VBERRE)); case USB_INT_SRPI: return (OTGIEN & (1 << SRPE)); e82: 80 91 de 00 lds r24, 0x00DE e86: 80 ff sbrs r24, 0 e88: 13 c0 rjmp .+38 ; 0xeb0 <__vector_10+0xdc> break; case USB_INT_VBERRI: OTGINT &= ~(1 << VBERRI); break; case USB_INT_SRPI: OTGINT &= ~(1 << SRPI); e8a: 80 91 df 00 lds r24, 0x00DF e8e: 8e 7f andi r24, 0xFE ; 254 e90: 80 93 df 00 sts 0x00DF, r24 break; case USB_INT_VBERRI: OTGIEN &= ~(1 << VBERRE); break; case USB_INT_SRPI: OTGIEN &= ~(1 << SRPE); e94: 80 91 de 00 lds r24, 0x00DE e98: 8e 7f andi r24, 0xFE ; 254 e9a: 80 93 de 00 sts 0x00DE, r24 { USB_INT_Clear(USB_INT_SRPI); USB_INT_Disable(USB_INT_SRPI); EVENT_USB_Host_DeviceAttached(); e9e: 6f da rcall .-2850 ; 0x37e break; case USB_INT_DCONNI: UHIEN |= (1 << DCONNE); break; case USB_INT_DDISCI: UHIEN |= (1 << DDISCE); ea0: 80 91 a0 00 lds r24, 0x00A0 ea4: 82 60 ori r24, 0x02 ; 2 ea6: 80 93 a0 00 sts 0x00A0, r24 USB_INT_Enable(USB_INT_DDISCI); USB_HostState = HOST_STATE_Powered; eaa: 83 e0 ldi r24, 0x03 ; 3 eac: 80 93 2b 01 sts 0x012B, r24 case USB_INT_DDISCI: return (UHINT & (1 << DDISCI)); case USB_INT_RSTI: return (UHINT & (1 << RSTI)); case USB_INT_BCERRI: return (OTGINT & (1 << BCERRI)); eb0: 80 91 df 00 lds r24, 0x00DF } if (USB_INT_HasOccurred(USB_INT_BCERRI) && USB_INT_IsEnabled(USB_INT_BCERRI)) eb4: 82 ff sbrs r24, 2 eb6: 0e c0 rjmp .+28 ; 0xed4 <__vector_10+0x100> case USB_INT_DDISCI: return (UHIEN & (1 << DDISCE)); case USB_INT_RSTI: return (UHIEN & (1 << RSTE)); case USB_INT_BCERRI: return (OTGIEN & (1 << BCERRE)); eb8: 80 91 de 00 lds r24, 0x00DE ebc: 82 ff sbrs r24, 2 ebe: 0a c0 rjmp .+20 ; 0xed4 <__vector_10+0x100> break; case USB_INT_RSTI: UHINT &= ~(1 << RSTI); break; case USB_INT_BCERRI: OTGINT &= ~(1 << BCERRI); ec0: 80 91 df 00 lds r24, 0x00DF ec4: 8b 7f andi r24, 0xFB ; 251 ec6: 80 93 df 00 sts 0x00DF, r24 { USB_INT_Clear(USB_INT_BCERRI); EVENT_USB_Host_DeviceEnumerationFailed(HOST_ENUMERROR_NoDeviceDetected, 0); eca: 82 e0 ldi r24, 0x02 ; 2 ecc: 60 e0 ldi r22, 0x00 ; 0 ece: 82 da rcall .-2812 ; 0x3d4 EVENT_USB_Host_DeviceUnattached(); ed0: 5b da rcall .-2890 ; 0x388 USB_ResetInterface(); ed2: 1c df rcall .-456 ; 0xd0c USB_ResetInterface(); EVENT_USB_UIDChange(); } #endif } ed4: ff 91 pop r31 ed6: ef 91 pop r30 ed8: bf 91 pop r27 eda: af 91 pop r26 edc: 9f 91 pop r25 ede: 8f 91 pop r24 ee0: 7f 91 pop r23 ee2: 6f 91 pop r22 ee4: 5f 91 pop r21 ee6: 4f 91 pop r20 ee8: 3f 91 pop r19 eea: 2f 91 pop r18 eec: 0f 90 pop r0 eee: 0b be out 0x3b, r0 ; 59 ef0: 0f 90 pop r0 ef2: 0f be out 0x3f, r0 ; 63 ef4: 0f 90 pop r0 ef6: 1f 90 pop r1 ef8: 18 95 reti 00000efa : #if defined(USB_CAN_BE_HOST) uint8_t USB_Host_GetDeviceConfigDescriptor(const uint8_t ConfigNumber, uint16_t* const ConfigSizePtr, void* const BufferPtr, const uint16_t BufferSize) { efa: cf 92 push r12 efc: df 92 push r13 efe: ef 92 push r14 f00: ff 92 push r15 f02: 0f 93 push r16 f04: 1f 93 push r17 f06: df 93 push r29 f08: cf 93 push r28 f0a: cd b7 in r28, 0x3d ; 61 f0c: de b7 in r29, 0x3e ; 62 f0e: 29 97 sbiw r28, 0x09 ; 9 f10: 0f b6 in r0, 0x3f ; 63 f12: f8 94 cli f14: de bf out 0x3e, r29 ; 62 f16: 0f be out 0x3f, r0 ; 63 f18: cd bf out 0x3d, r28 ; 61 f1a: 6b 01 movw r12, r22 f1c: 8a 01 movw r16, r20 f1e: 79 01 movw r14, r18 uint8_t ErrorCode; uint8_t ConfigHeader[sizeof(USB_Descriptor_Configuration_Header_t)]; USB_ControlRequest = (USB_Request_Header_t) f20: 90 e8 ldi r25, 0x80 ; 128 f22: 90 93 23 01 sts 0x0123, r25 f26: 96 e0 ldi r25, 0x06 ; 6 f28: 90 93 24 01 sts 0x0124, r25 { .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE), .bRequest = REQ_GetDescriptor, .wValue = ((DTYPE_Configuration << 8) | (ConfigNumber - 1)), f2c: 90 e0 ldi r25, 0x00 ; 0 f2e: 01 97 sbiw r24, 0x01 ; 1 f30: 92 60 ori r25, 0x02 ; 2 const uint16_t BufferSize) { uint8_t ErrorCode; uint8_t ConfigHeader[sizeof(USB_Descriptor_Configuration_Header_t)]; USB_ControlRequest = (USB_Request_Header_t) f32: 90 93 26 01 sts 0x0126, r25 f36: 80 93 25 01 sts 0x0125, r24 f3a: 10 92 28 01 sts 0x0128, r1 f3e: 10 92 27 01 sts 0x0127, r1 f42: 89 e0 ldi r24, 0x09 ; 9 f44: 90 e0 ldi r25, 0x00 ; 0 f46: 90 93 2a 01 sts 0x012A, r25 f4a: 80 93 29 01 sts 0x0129, r24 f4e: 10 92 a7 00 sts 0x00A7, r1 .wLength = sizeof(USB_Descriptor_Configuration_Header_t), }; Pipe_SelectPipe(PIPE_CONTROLPIPE); if ((ErrorCode = USB_Host_SendControlRequest(ConfigHeader)) != HOST_SENDCONTROL_Successful) f52: ce 01 movw r24, r28 f54: 01 96 adiw r24, 0x01 ; 1 f56: 95 d0 rcall .+298 ; 0x1082 f58: 88 23 and r24, r24 f5a: b9 f4 brne .+46 ; 0xf8a return ErrorCode; *ConfigSizePtr = DESCRIPTOR_PCAST(ConfigHeader, USB_Descriptor_Configuration_Header_t)->TotalConfigurationSize; f5c: 8b 81 ldd r24, Y+3 ; 0x03 f5e: 9c 81 ldd r25, Y+4 ; 0x04 f60: f6 01 movw r30, r12 f62: 91 83 std Z+1, r25 ; 0x01 f64: 80 83 st Z, r24 if (*ConfigSizePtr > BufferSize) f66: e8 16 cp r14, r24 f68: f9 06 cpc r15, r25 f6a: 70 f0 brcs .+28 ; 0xf88 return HOST_GETCONFIG_BuffOverflow; USB_ControlRequest.wLength = *ConfigSizePtr; f6c: 90 93 2a 01 sts 0x012A, r25 f70: 80 93 29 01 sts 0x0129, r24 if ((ErrorCode = USB_Host_SendControlRequest(BufferPtr)) != HOST_SENDCONTROL_Successful) f74: c8 01 movw r24, r16 f76: 85 d0 rcall .+266 ; 0x1082 f78: 88 23 and r24, r24 f7a: 39 f4 brne .+14 ; 0xf8a return ErrorCode; if (DESCRIPTOR_TYPE(BufferPtr) != DTYPE_Configuration) f7c: f8 01 movw r30, r16 f7e: 91 81 ldd r25, Z+1 ; 0x01 f80: 92 30 cpi r25, 0x02 ; 2 f82: 19 f0 breq .+6 ; 0xf8a return HOST_GETCONFIG_InvalidData; f84: 86 e0 ldi r24, 0x06 ; 6 f86: 01 c0 rjmp .+2 ; 0xf8a return ErrorCode; *ConfigSizePtr = DESCRIPTOR_PCAST(ConfigHeader, USB_Descriptor_Configuration_Header_t)->TotalConfigurationSize; if (*ConfigSizePtr > BufferSize) return HOST_GETCONFIG_BuffOverflow; f88: 85 e0 ldi r24, 0x05 ; 5 if (DESCRIPTOR_TYPE(BufferPtr) != DTYPE_Configuration) return HOST_GETCONFIG_InvalidData; return HOST_GETCONFIG_Successful; } f8a: 29 96 adiw r28, 0x09 ; 9 f8c: 0f b6 in r0, 0x3f ; 63 f8e: f8 94 cli f90: de bf out 0x3e, r29 ; 62 f92: 0f be out 0x3f, r0 ; 63 f94: cd bf out 0x3d, r28 ; 61 f96: cf 91 pop r28 f98: df 91 pop r29 f9a: 1f 91 pop r17 f9c: 0f 91 pop r16 f9e: ff 90 pop r15 fa0: ef 90 pop r14 fa2: df 90 pop r13 fa4: cf 90 pop r12 fa6: 08 95 ret 00000fa8 : } uint8_t USB_GetNextDescriptorComp(uint16_t* const BytesRem, void** const CurrConfigLoc, const ConfigComparatorPtr_t const ComparatorRoutine) { fa8: af 92 push r10 faa: bf 92 push r11 fac: cf 92 push r12 fae: df 92 push r13 fb0: ef 92 push r14 fb2: ff 92 push r15 fb4: 0f 93 push r16 fb6: 1f 93 push r17 fb8: cf 93 push r28 fba: df 93 push r29 fbc: 8c 01 movw r16, r24 fbe: eb 01 movw r28, r22 fc0: 6a 01 movw r12, r20 uint8_t ErrorCode; while (*BytesRem) fc2: 23 c0 rjmp .+70 ; 0x100a { uint8_t* PrevDescLoc = *CurrConfigLoc; fc4: e8 81 ld r30, Y fc6: f9 81 ldd r31, Y+1 ; 0x01 fc8: 5f 01 movw r10, r30 static inline void USB_GetNextDescriptor(uint16_t* const BytesRem, void** CurrConfigLoc) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); static inline void USB_GetNextDescriptor(uint16_t* const BytesRem, void** CurrConfigLoc) { uint16_t CurrDescriptorSize = DESCRIPTOR_CAST(*CurrConfigLoc, USB_Descriptor_Header_t).Size; fca: 20 81 ld r18, Z fcc: 30 e0 ldi r19, 0x00 ; 0 fce: c7 01 movw r24, r14 fd0: 2e 15 cp r18, r14 fd2: 3f 05 cpc r19, r15 fd4: 08 f4 brcc .+2 ; 0xfd8 fd6: c9 01 movw r24, r18 if (*BytesRem < CurrDescriptorSize) CurrDescriptorSize = *BytesRem; *CurrConfigLoc = (void*)((uintptr_t)*CurrConfigLoc + CurrDescriptorSize); fd8: e8 0f add r30, r24 fda: f9 1f adc r31, r25 fdc: f9 83 std Y+1, r31 ; 0x01 fde: e8 83 st Y, r30 *BytesRem -= CurrDescriptorSize; fe0: f8 01 movw r30, r16 fe2: 20 81 ld r18, Z fe4: 31 81 ldd r19, Z+1 ; 0x01 fe6: 28 1b sub r18, r24 fe8: 39 0b sbc r19, r25 fea: 31 83 std Z+1, r19 ; 0x01 fec: 20 83 st Z, r18 uint16_t PrevBytesRem = *BytesRem; USB_GetNextDescriptor(BytesRem, CurrConfigLoc); if ((ErrorCode = ComparatorRoutine(*CurrConfigLoc)) != DESCRIPTOR_SEARCH_NotFound) fee: 88 81 ld r24, Y ff0: 99 81 ldd r25, Y+1 ; 0x01 ff2: f6 01 movw r30, r12 ff4: 09 95 icall ff6: 82 30 cpi r24, 0x02 ; 2 ff8: 41 f0 breq .+16 ; 0x100a { if (ErrorCode == DESCRIPTOR_SEARCH_Fail) ffa: 81 30 cpi r24, 0x01 ; 1 ffc: 69 f4 brne .+26 ; 0x1018 { *CurrConfigLoc = PrevDescLoc; ffe: a8 82 st Y, r10 1000: b9 82 std Y+1, r11 ; 0x01 *BytesRem = PrevBytesRem; 1002: f8 01 movw r30, r16 1004: f1 82 std Z+1, r15 ; 0x01 1006: e0 82 st Z, r14 1008: 07 c0 rjmp .+14 ; 0x1018 void** const CurrConfigLoc, const ConfigComparatorPtr_t const ComparatorRoutine) { uint8_t ErrorCode; while (*BytesRem) 100a: f8 01 movw r30, r16 100c: e0 80 ld r14, Z 100e: f1 80 ldd r15, Z+1 ; 0x01 1010: e1 14 cp r14, r1 1012: f1 04 cpc r15, r1 1014: b9 f6 brne .-82 ; 0xfc4 return ErrorCode; } } return DESCRIPTOR_SEARCH_COMP_EndOfDescriptor; 1016: 82 e0 ldi r24, 0x02 ; 2 } 1018: df 91 pop r29 101a: cf 91 pop r28 101c: 1f 91 pop r17 101e: 0f 91 pop r16 1020: ff 90 pop r15 1022: ef 90 pop r14 1024: df 90 pop r13 1026: cf 90 pop r12 1028: bf 90 pop r11 102a: af 90 pop r10 102c: 08 95 ret 0000102e : #include "Events.h" void USB_Event_Stub(void) { } 102e: 08 95 ret 00001030 : return ReturnStatus; } static uint8_t USB_Host_WaitForIOS(const uint8_t WaitType) { 1030: 1f 93 push r17 1032: cf 93 push r28 1034: df 93 push r29 1036: 18 2f mov r17, r24 #if (USB_HOST_TIMEOUT_MS < 0xFF) uint8_t TimeoutCounter = USB_HOST_TIMEOUT_MS; #else uint16_t TimeoutCounter = USB_HOST_TIMEOUT_MS; 1038: c8 ee ldi r28, 0xE8 ; 232 103a: d3 e0 ldi r29, 0x03 ; 3 #endif while (!(((WaitType == USB_HOST_WAITFOR_SetupSent) && Pipe_IsSETUPSent()) || 103c: 07 c0 rjmp .+14 ; 0x104c ((WaitType == USB_HOST_WAITFOR_InReceived) && Pipe_IsINReceived()) || ((WaitType == USB_HOST_WAITFOR_OutReady) && Pipe_IsOUTReady()))) { uint8_t ErrorCode; if ((ErrorCode = USB_Host_WaitMS(1)) != HOST_WAITERROR_Successful) 103e: 81 e0 ldi r24, 0x01 ; 1 1040: 1e dc rcall .-1988 ; 0x87e 1042: 88 23 and r24, r24 1044: d1 f4 brne .+52 ; 0x107a return ErrorCode; if (!(TimeoutCounter--)) 1046: 20 97 sbiw r28, 0x00 ; 0 1048: b9 f0 breq .+46 ; 0x1078 104a: 21 97 sbiw r28, 0x01 ; 1 uint8_t TimeoutCounter = USB_HOST_TIMEOUT_MS; #else uint16_t TimeoutCounter = USB_HOST_TIMEOUT_MS; #endif while (!(((WaitType == USB_HOST_WAITFOR_SetupSent) && Pipe_IsSETUPSent()) || 104c: 11 23 and r17, r17 104e: 29 f4 brne .+10 ; 0x105a * \return Boolean \c true if the current pipe is ready for a SETUP packet, \c false otherwise. */ static inline bool Pipe_IsSETUPSent(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline bool Pipe_IsSETUPSent(void) { return ((UPINTX & (1 << TXSTPI)) ? true : false); 1050: 80 91 a6 00 lds r24, 0x00A6 1054: 83 ff sbrs r24, 3 1056: f3 cf rjmp .-26 ; 0x103e 1058: 0d c0 rjmp .+26 ; 0x1074 105a: 11 30 cpi r17, 0x01 ; 1 105c: 29 f4 brne .+10 ; 0x1068 * \return Boolean \c true if the current pipe has received an IN packet, \c false otherwise. */ static inline bool Pipe_IsINReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline bool Pipe_IsINReceived(void) { return ((UPINTX & (1 << RXINI)) ? true : false); 105e: 80 91 a6 00 lds r24, 0x00A6 ((WaitType == USB_HOST_WAITFOR_InReceived) && Pipe_IsINReceived()) || 1062: 80 ff sbrs r24, 0 1064: ec cf rjmp .-40 ; 0x103e 1066: 06 c0 rjmp .+12 ; 0x1074 uint8_t TimeoutCounter = USB_HOST_TIMEOUT_MS; #else uint16_t TimeoutCounter = USB_HOST_TIMEOUT_MS; #endif while (!(((WaitType == USB_HOST_WAITFOR_SetupSent) && Pipe_IsSETUPSent()) || 1068: 12 30 cpi r17, 0x02 ; 2 106a: 49 f7 brne .-46 ; 0x103e * \return Boolean \c true if the current pipe is ready for an OUT packet, \c false otherwise. */ static inline bool Pipe_IsOUTReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline bool Pipe_IsOUTReady(void) { return ((UPINTX & (1 << TXOUTI)) ? true : false); 106c: 80 91 a6 00 lds r24, 0x00A6 ((WaitType == USB_HOST_WAITFOR_InReceived) && Pipe_IsINReceived()) || ((WaitType == USB_HOST_WAITFOR_OutReady) && Pipe_IsOUTReady()))) 1070: 82 ff sbrs r24, 2 1072: e5 cf rjmp .-54 ; 0x103e if (!(TimeoutCounter--)) return HOST_SENDCONTROL_SoftwareTimeOut; } return HOST_SENDCONTROL_Successful; 1074: 80 e0 ldi r24, 0x00 ; 0 1076: 01 c0 rjmp .+2 ; 0x107a if ((ErrorCode = USB_Host_WaitMS(1)) != HOST_WAITERROR_Successful) return ErrorCode; if (!(TimeoutCounter--)) return HOST_SENDCONTROL_SoftwareTimeOut; 1078: 84 e0 ldi r24, 0x04 ; 4 } return HOST_SENDCONTROL_Successful; } 107a: df 91 pop r29 107c: cf 91 pop r28 107e: 1f 91 pop r17 1080: 08 95 ret 00001082 : #define __INCLUDE_FROM_HOSTSTDREQ_C #include "HostStandardReq.h" uint8_t USB_Host_SendControlRequest(void* const BufferPtr) { 1082: ef 92 push r14 1084: ff 92 push r15 1086: 0f 93 push r16 1088: 1f 93 push r17 108a: cf 93 push r28 108c: df 93 push r29 108e: 8c 01 movw r16, r24 * \return Boolean \c true if the bus is currently suspended, \c false otherwise. */ static inline bool USB_Host_IsBusSuspended(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline bool USB_Host_IsBusSuspended(void) { return ((UHCON & (1 << SOFEN)) ? false : true); 1090: e0 90 9e 00 lds r14, 0x009E 1094: ff 24 eor r15, r15 1096: 81 e0 ldi r24, 0x01 ; 1 1098: e8 22 and r14, r24 109a: ff 24 eor r15, r15 uint8_t* DataStream = (uint8_t*)BufferPtr; bool BusSuspended = USB_Host_IsBusSuspended(); uint8_t ReturnStatus = HOST_SENDCONTROL_Successful; uint16_t DataLen = USB_ControlRequest.wLength; 109c: c0 91 29 01 lds r28, 0x0129 10a0: d0 91 2a 01 lds r29, 0x012A * host and attached device may occur. */ static inline void USB_Host_ResumeBus(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_ResumeBus(void) { UHCON |= (1 << SOFEN); 10a4: 80 91 9e 00 lds r24, 0x009E 10a8: 81 60 ori r24, 0x01 ; 1 10aa: 80 93 9e 00 sts 0x009E, r24 USB_Host_ResumeBus(); if ((ReturnStatus = USB_Host_WaitMS(1)) != HOST_WAITERROR_Successful) 10ae: 81 e0 ldi r24, 0x01 ; 1 10b0: e6 db rcall .-2100 ; 0x87e 10b2: 88 23 and r24, r24 10b4: 09 f0 breq .+2 ; 0x10b8 10b6: e2 c0 rjmp .+452 ; 0x127c * \param[in] Token New pipe token to set the selected pipe to, as a \c PIPE_TOKEN_* mask. */ static inline void Pipe_SetPipeToken(const uint8_t Token) ATTR_ALWAYS_INLINE; static inline void Pipe_SetPipeToken(const uint8_t Token) { UPCFG0X = ((UPCFG0X & ~(0x03 << PTOKEN0)) | Token); 10b8: 80 91 aa 00 lds r24, 0x00AA 10bc: 8f 7c andi r24, 0xCF ; 207 10be: 80 93 aa 00 sts 0x00AA, r24 /** Clears the error flags for the currently selected pipe. */ static inline void Pipe_ClearError(void) ATTR_ALWAYS_INLINE; static inline void Pipe_ClearError(void) { UPERRX = 0; 10c2: 10 92 f5 00 sts 0x00F5, r1 UPINTX &= ~(1 << PERRI); 10c6: 80 91 a6 00 lds r24, 0x00A6 10ca: 8f 7e andi r24, 0xEF ; 239 10cc: 80 93 a6 00 sts 0x00A6, r24 /** Unfreezes the selected pipe, allowing it to communicate with an attached device. */ static inline void Pipe_Unfreeze(void) ATTR_ALWAYS_INLINE; static inline void Pipe_Unfreeze(void) { UPCONX &= ~(1 << PFREEZE); 10d0: 80 91 a9 00 lds r24, 0x00A9 10d4: 8f 7b andi r24, 0xBF ; 191 10d6: 80 93 a9 00 sts 0x00A9, r24 Pipe_SetPipeToken(PIPE_TOKEN_SETUP); Pipe_ClearError(); Pipe_Unfreeze(); Pipe_Write_8(USB_ControlRequest.bmRequestType); 10da: 80 91 23 01 lds r24, 0x0123 * \param[in] Data Data to write into the the currently selected pipe's FIFO buffer. */ static inline void Pipe_Write_8(const uint8_t Data) ATTR_ALWAYS_INLINE; static inline void Pipe_Write_8(const uint8_t Data) { UPDATX = Data; 10de: 80 93 af 00 sts 0x00AF, r24 Pipe_Write_8(USB_ControlRequest.bRequest); 10e2: 80 91 24 01 lds r24, 0x0124 10e6: 80 93 af 00 sts 0x00AF, r24 Pipe_Write_16_LE(USB_ControlRequest.wValue); 10ea: 90 91 25 01 lds r25, 0x0125 10ee: 80 91 26 01 lds r24, 0x0126 * \param[in] Data Data to write to the currently selected pipe's FIFO buffer. */ static inline void Pipe_Write_16_LE(const uint16_t Data) ATTR_ALWAYS_INLINE; static inline void Pipe_Write_16_LE(const uint16_t Data) { UPDATX = (Data & 0xFF); 10f2: 90 93 af 00 sts 0x00AF, r25 UPDATX = (Data >> 8); 10f6: 80 93 af 00 sts 0x00AF, r24 Pipe_Write_16_LE(USB_ControlRequest.wIndex); 10fa: 90 91 27 01 lds r25, 0x0127 10fe: 80 91 28 01 lds r24, 0x0128 * \param[in] Data Data to write to the currently selected pipe's FIFO buffer. */ static inline void Pipe_Write_16_LE(const uint16_t Data) ATTR_ALWAYS_INLINE; static inline void Pipe_Write_16_LE(const uint16_t Data) { UPDATX = (Data & 0xFF); 1102: 90 93 af 00 sts 0x00AF, r25 UPDATX = (Data >> 8); 1106: 80 93 af 00 sts 0x00AF, r24 Pipe_Write_16_LE(USB_ControlRequest.wLength); 110a: 90 91 29 01 lds r25, 0x0129 110e: 80 91 2a 01 lds r24, 0x012A * \param[in] Data Data to write to the currently selected pipe's FIFO buffer. */ static inline void Pipe_Write_16_LE(const uint16_t Data) ATTR_ALWAYS_INLINE; static inline void Pipe_Write_16_LE(const uint16_t Data) { UPDATX = (Data & 0xFF); 1112: 90 93 af 00 sts 0x00AF, r25 UPDATX = (Data >> 8); 1116: 80 93 af 00 sts 0x00AF, r24 * \ingroup Group_PipePacketManagement_AVR8 */ static inline void Pipe_ClearSETUP(void) ATTR_ALWAYS_INLINE; static inline void Pipe_ClearSETUP(void) { UPINTX &= ~((1 << TXSTPI) | (1 << FIFOCON)); 111a: 80 91 a6 00 lds r24, 0x00A6 111e: 87 77 andi r24, 0x77 ; 119 1120: 80 93 a6 00 sts 0x00A6, r24 Pipe_ClearSETUP(); if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_SetupSent)) != HOST_SENDCONTROL_Successful) 1124: 80 e0 ldi r24, 0x00 ; 0 1126: 84 df rcall .-248 ; 0x1030 1128: 88 23 and r24, r24 112a: 09 f0 breq .+2 ; 0x112e 112c: a7 c0 rjmp .+334 ; 0x127c /** Freezes the selected pipe, preventing it from communicating with an attached device. */ static inline void Pipe_Freeze(void) ATTR_ALWAYS_INLINE; static inline void Pipe_Freeze(void) { UPCONX |= (1 << PFREEZE); 112e: 80 91 a9 00 lds r24, 0x00A9 1132: 80 64 ori r24, 0x40 ; 64 1134: 80 93 a9 00 sts 0x00A9, r24 goto End_Of_Control_Send; Pipe_Freeze(); if ((ReturnStatus = USB_Host_WaitMS(1)) != HOST_WAITERROR_Successful) 1138: 81 e0 ldi r24, 0x01 ; 1 113a: a1 db rcall .-2238 ; 0x87e 113c: 88 23 and r24, r24 113e: 09 f0 breq .+2 ; 0x1142 1140: 9d c0 rjmp .+314 ; 0x127c goto End_Of_Control_Send; if ((USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_DIRECTION) == REQDIR_DEVICETOHOST) 1142: 80 91 23 01 lds r24, 0x0123 1146: 87 ff sbrs r24, 7 1148: 4f c0 rjmp .+158 ; 0x11e8 * \param[in] Token New pipe token to set the selected pipe to, as a \c PIPE_TOKEN_* mask. */ static inline void Pipe_SetPipeToken(const uint8_t Token) ATTR_ALWAYS_INLINE; static inline void Pipe_SetPipeToken(const uint8_t Token) { UPCFG0X = ((UPCFG0X & ~(0x03 << PTOKEN0)) | Token); 114a: 80 91 aa 00 lds r24, 0x00AA 114e: 8f 7c andi r24, 0xCF ; 207 1150: 80 61 ori r24, 0x10 ; 16 1152: 80 93 aa 00 sts 0x00AA, r24 { Pipe_SetPipeToken(PIPE_TOKEN_IN); if (DataStream != NULL) 1156: 01 15 cp r16, r1 1158: 11 05 cpc r17, r1 115a: 61 f5 brne .+88 ; 0x11b4 115c: 2d c0 rjmp .+90 ; 0x11b8 /** Unfreezes the selected pipe, allowing it to communicate with an attached device. */ static inline void Pipe_Unfreeze(void) ATTR_ALWAYS_INLINE; static inline void Pipe_Unfreeze(void) { UPCONX &= ~(1 << PFREEZE); 115e: 80 91 a9 00 lds r24, 0x00A9 1162: 8f 7b andi r24, 0xBF ; 191 1164: 80 93 a9 00 sts 0x00A9, r24 { while (DataLen) { Pipe_Unfreeze(); if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_InReceived)) != HOST_SENDCONTROL_Successful) 1168: 81 e0 ldi r24, 0x01 ; 1 116a: 62 df rcall .-316 ; 0x1030 116c: 88 23 and r24, r24 116e: 09 f0 breq .+2 ; 0x1172 1170: 85 c0 rjmp .+266 ; 0x127c * \return Total number of bytes in the currently selected pipe's FIFO buffer. */ static inline uint16_t Pipe_BytesInPipe(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline uint16_t Pipe_BytesInPipe(void) { return UPBCX; 1172: 80 91 f6 00 lds r24, 0x00F6 1176: 90 91 f7 00 lds r25, 0x00F7 goto End_Of_Control_Send; if (!(Pipe_BytesInPipe())) 117a: 00 97 sbiw r24, 0x00 ; 0 117c: 49 f4 brne .+18 ; 0x1190 DataLen = 0; 117e: c0 e0 ldi r28, 0x00 ; 0 1180: d0 e0 ldi r29, 0x00 ; 0 1182: 06 c0 rjmp .+12 ; 0x1190 * \return Next byte in the currently selected pipe's FIFO buffer. */ static inline uint8_t Pipe_Read_8(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline uint8_t Pipe_Read_8(void) { return UPDATX; 1184: 80 91 af 00 lds r24, 0x00AF while (Pipe_BytesInPipe() && DataLen) { *(DataStream++) = Pipe_Read_8(); 1188: f8 01 movw r30, r16 118a: 81 93 st Z+, r24 118c: 8f 01 movw r16, r30 DataLen--; 118e: 21 97 sbiw r28, 0x01 ; 1 * \return Total number of bytes in the currently selected pipe's FIFO buffer. */ static inline uint16_t Pipe_BytesInPipe(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline uint16_t Pipe_BytesInPipe(void) { return UPBCX; 1190: 80 91 f6 00 lds r24, 0x00F6 1194: 90 91 f7 00 lds r25, 0x00F7 goto End_Of_Control_Send; if (!(Pipe_BytesInPipe())) DataLen = 0; while (Pipe_BytesInPipe() && DataLen) 1198: 00 97 sbiw r24, 0x00 ; 0 119a: 11 f0 breq .+4 ; 0x11a0 119c: 20 97 sbiw r28, 0x00 ; 0 119e: 91 f7 brne .-28 ; 0x1184 /** Freezes the selected pipe, preventing it from communicating with an attached device. */ static inline void Pipe_Freeze(void) ATTR_ALWAYS_INLINE; static inline void Pipe_Freeze(void) { UPCONX |= (1 << PFREEZE); 11a0: 80 91 a9 00 lds r24, 0x00A9 11a4: 80 64 ori r24, 0x40 ; 64 11a6: 80 93 a9 00 sts 0x00A9, r24 * \ingroup Group_PipePacketManagement_AVR8 */ static inline void Pipe_ClearIN(void) ATTR_ALWAYS_INLINE; static inline void Pipe_ClearIN(void) { UPINTX &= ~((1 << RXINI) | (1 << FIFOCON)); 11aa: 80 91 a6 00 lds r24, 0x00A6 11ae: 8e 77 andi r24, 0x7E ; 126 11b0: 80 93 a6 00 sts 0x00A6, r24 { Pipe_SetPipeToken(PIPE_TOKEN_IN); if (DataStream != NULL) { while (DataLen) 11b4: 20 97 sbiw r28, 0x00 ; 0 11b6: 99 f6 brne .-90 ; 0x115e * \param[in] Token New pipe token to set the selected pipe to, as a \c PIPE_TOKEN_* mask. */ static inline void Pipe_SetPipeToken(const uint8_t Token) ATTR_ALWAYS_INLINE; static inline void Pipe_SetPipeToken(const uint8_t Token) { UPCFG0X = ((UPCFG0X & ~(0x03 << PTOKEN0)) | Token); 11b8: 80 91 aa 00 lds r24, 0x00AA 11bc: 8f 7c andi r24, 0xCF ; 207 11be: 80 62 ori r24, 0x20 ; 32 11c0: 80 93 aa 00 sts 0x00AA, r24 /** Unfreezes the selected pipe, allowing it to communicate with an attached device. */ static inline void Pipe_Unfreeze(void) ATTR_ALWAYS_INLINE; static inline void Pipe_Unfreeze(void) { UPCONX &= ~(1 << PFREEZE); 11c4: 80 91 a9 00 lds r24, 0x00A9 11c8: 8f 7b andi r24, 0xBF ; 191 11ca: 80 93 a9 00 sts 0x00A9, r24 } Pipe_SetPipeToken(PIPE_TOKEN_OUT); Pipe_Unfreeze(); if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_OutReady)) != HOST_SENDCONTROL_Successful) 11ce: 82 e0 ldi r24, 0x02 ; 2 11d0: 2f df rcall .-418 ; 0x1030 11d2: 88 23 and r24, r24 11d4: 09 f0 breq .+2 ; 0x11d8 11d6: 52 c0 rjmp .+164 ; 0x127c * \ingroup Group_PipePacketManagement_AVR8 */ static inline void Pipe_ClearOUT(void) ATTR_ALWAYS_INLINE; static inline void Pipe_ClearOUT(void) { UPINTX &= ~((1 << TXOUTI) | (1 << FIFOCON)); 11d8: 80 91 a6 00 lds r24, 0x00A6 11dc: 8b 77 andi r24, 0x7B ; 123 11de: 80 93 a6 00 sts 0x00A6, r24 goto End_Of_Control_Send; Pipe_ClearOUT(); if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_OutReady)) != HOST_SENDCONTROL_Successful) 11e2: 82 e0 ldi r24, 0x02 ; 2 11e4: 25 df rcall .-438 ; 0x1030 11e6: 4a c0 rjmp .+148 ; 0x127c goto End_Of_Control_Send; } else { if (DataStream != NULL) 11e8: 01 15 cp r16, r1 11ea: 11 05 cpc r17, r1 11ec: 99 f1 breq .+102 ; 0x1254 * \param[in] Token New pipe token to set the selected pipe to, as a \c PIPE_TOKEN_* mask. */ static inline void Pipe_SetPipeToken(const uint8_t Token) ATTR_ALWAYS_INLINE; static inline void Pipe_SetPipeToken(const uint8_t Token) { UPCFG0X = ((UPCFG0X & ~(0x03 << PTOKEN0)) | Token); 11ee: 80 91 aa 00 lds r24, 0x00AA 11f2: 8f 7c andi r24, 0xCF ; 207 11f4: 80 62 ori r24, 0x20 ; 32 11f6: 80 93 aa 00 sts 0x00AA, r24 /** Unfreezes the selected pipe, allowing it to communicate with an attached device. */ static inline void Pipe_Unfreeze(void) ATTR_ALWAYS_INLINE; static inline void Pipe_Unfreeze(void) { UPCONX &= ~(1 << PFREEZE); 11fa: 80 91 a9 00 lds r24, 0x00A9 11fe: 8f 7b andi r24, 0xBF ; 191 1200: 80 93 a9 00 sts 0x00A9, r24 { Pipe_SetPipeToken(PIPE_TOKEN_OUT); Pipe_Unfreeze(); while (DataLen) 1204: 1c c0 rjmp .+56 ; 0x123e { if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_OutReady)) != HOST_SENDCONTROL_Successful) 1206: 82 e0 ldi r24, 0x02 ; 2 1208: 13 df rcall .-474 ; 0x1030 120a: 88 23 and r24, r24 120c: b9 f5 brne .+110 ; 0x127c 120e: f8 01 movw r30, r16 1210: 06 c0 rjmp .+12 ; 0x121e goto End_Of_Control_Send; while (DataLen && (Pipe_BytesInPipe() < USB_ControlPipeSize)) { Pipe_Write_8(*(DataStream++)); 1212: 81 91 ld r24, Z+ 1214: 8f 01 movw r16, r30 * \param[in] Data Data to write into the the currently selected pipe's FIFO buffer. */ static inline void Pipe_Write_8(const uint8_t Data) ATTR_ALWAYS_INLINE; static inline void Pipe_Write_8(const uint8_t Data) { UPDATX = Data; 1216: 80 93 af 00 sts 0x00AF, r24 DataLen--; 121a: 21 97 sbiw r28, 0x01 ; 1 while (DataLen) { if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_OutReady)) != HOST_SENDCONTROL_Successful) goto End_Of_Control_Send; while (DataLen && (Pipe_BytesInPipe() < USB_ControlPipeSize)) 121c: 59 f0 breq .+22 ; 0x1234 121e: 8f 01 movw r16, r30 * \return Total number of bytes in the currently selected pipe's FIFO buffer. */ static inline uint16_t Pipe_BytesInPipe(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline uint16_t Pipe_BytesInPipe(void) { return UPBCX; 1220: 20 91 f6 00 lds r18, 0x00F6 1224: 30 91 f7 00 lds r19, 0x00F7 1228: 80 91 1b 01 lds r24, 0x011B 122c: 90 e0 ldi r25, 0x00 ; 0 122e: 28 17 cp r18, r24 1230: 39 07 cpc r19, r25 1232: 78 f3 brcs .-34 ; 0x1212 * \ingroup Group_PipePacketManagement_AVR8 */ static inline void Pipe_ClearOUT(void) ATTR_ALWAYS_INLINE; static inline void Pipe_ClearOUT(void) { UPINTX &= ~((1 << TXOUTI) | (1 << FIFOCON)); 1234: 80 91 a6 00 lds r24, 0x00A6 1238: 8b 77 andi r24, 0x7B ; 123 123a: 80 93 a6 00 sts 0x00A6, r24 if (DataStream != NULL) { Pipe_SetPipeToken(PIPE_TOKEN_OUT); Pipe_Unfreeze(); while (DataLen) 123e: 20 97 sbiw r28, 0x00 ; 0 1240: 11 f7 brne .-60 ; 0x1206 } Pipe_ClearOUT(); } if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_OutReady)) != HOST_SENDCONTROL_Successful) 1242: 82 e0 ldi r24, 0x02 ; 2 1244: f5 de rcall .-534 ; 0x1030 1246: 88 23 and r24, r24 1248: c9 f4 brne .+50 ; 0x127c /** Freezes the selected pipe, preventing it from communicating with an attached device. */ static inline void Pipe_Freeze(void) ATTR_ALWAYS_INLINE; static inline void Pipe_Freeze(void) { UPCONX |= (1 << PFREEZE); 124a: 80 91 a9 00 lds r24, 0x00A9 124e: 80 64 ori r24, 0x40 ; 64 1250: 80 93 a9 00 sts 0x00A9, r24 * \param[in] Token New pipe token to set the selected pipe to, as a \c PIPE_TOKEN_* mask. */ static inline void Pipe_SetPipeToken(const uint8_t Token) ATTR_ALWAYS_INLINE; static inline void Pipe_SetPipeToken(const uint8_t Token) { UPCFG0X = ((UPCFG0X & ~(0x03 << PTOKEN0)) | Token); 1254: 80 91 aa 00 lds r24, 0x00AA 1258: 8f 7c andi r24, 0xCF ; 207 125a: 80 61 ori r24, 0x10 ; 16 125c: 80 93 aa 00 sts 0x00AA, r24 /** Unfreezes the selected pipe, allowing it to communicate with an attached device. */ static inline void Pipe_Unfreeze(void) ATTR_ALWAYS_INLINE; static inline void Pipe_Unfreeze(void) { UPCONX &= ~(1 << PFREEZE); 1260: 80 91 a9 00 lds r24, 0x00A9 1264: 8f 7b andi r24, 0xBF ; 191 1266: 80 93 a9 00 sts 0x00A9, r24 } Pipe_SetPipeToken(PIPE_TOKEN_IN); Pipe_Unfreeze(); if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_InReceived)) != HOST_SENDCONTROL_Successful) 126a: 81 e0 ldi r24, 0x01 ; 1 126c: e1 de rcall .-574 ; 0x1030 126e: 88 23 and r24, r24 1270: 29 f4 brne .+10 ; 0x127c * \ingroup Group_PipePacketManagement_AVR8 */ static inline void Pipe_ClearIN(void) ATTR_ALWAYS_INLINE; static inline void Pipe_ClearIN(void) { UPINTX &= ~((1 << RXINI) | (1 << FIFOCON)); 1272: 90 91 a6 00 lds r25, 0x00A6 1276: 9e 77 andi r25, 0x7E ; 126 1278: 90 93 a6 00 sts 0x00A6, r25 /** Freezes the selected pipe, preventing it from communicating with an attached device. */ static inline void Pipe_Freeze(void) ATTR_ALWAYS_INLINE; static inline void Pipe_Freeze(void) { UPCONX |= (1 << PFREEZE); 127c: 90 91 a9 00 lds r25, 0x00A9 1280: 90 64 ori r25, 0x40 ; 64 1282: 90 93 a9 00 sts 0x00A9, r25 } End_Of_Control_Send: Pipe_Freeze(); if (BusSuspended) 1286: e1 14 cp r14, r1 1288: f1 04 cpc r15, r1 128a: 29 f4 brne .+10 ; 0x1296 * messages to the device. */ static inline void USB_Host_SuspendBus(void) ATTR_ALWAYS_INLINE; static inline void USB_Host_SuspendBus(void) { UHCON &= ~(1 << SOFEN); 128c: 90 91 9e 00 lds r25, 0x009E 1290: 9e 7f andi r25, 0xFE ; 254 1292: 90 93 9e 00 sts 0x009E, r25 * \param[in] PipeNumber Index of the pipe to reset. */ static inline void Pipe_ResetPipe(const uint8_t PipeNumber) ATTR_ALWAYS_INLINE; static inline void Pipe_ResetPipe(const uint8_t PipeNumber) { UPRST = (1 << PipeNumber); 1296: 91 e0 ldi r25, 0x01 ; 1 1298: 90 93 a8 00 sts 0x00A8, r25 UPRST = 0; 129c: 10 92 a8 00 sts 0x00A8, r1 USB_Host_SuspendBus(); Pipe_ResetPipe(PIPE_CONTROLPIPE); return ReturnStatus; } 12a0: df 91 pop r29 12a2: cf 91 pop r28 12a4: 1f 91 pop r17 12a6: 0f 91 pop r16 12a8: ff 90 pop r15 12aa: ef 90 pop r14 12ac: 08 95 ret 000012ae : #if defined(USB_CAN_BE_DEVICE) && !defined(DEVICE_STATE_AS_GPIOR) volatile uint8_t USB_DeviceState; #endif void USB_USBTask(void) { 12ae: 1f 93 push r17 12b0: cf 93 push r28 12b2: df 93 push r29 * \return Index of the currently selected pipe. */ static inline uint8_t Pipe_GetCurrentPipe(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline uint8_t Pipe_GetCurrentPipe(void) { return (UPNUM & PIPE_PIPENUM_MASK); 12b4: c7 ea ldi r28, 0xA7 ; 167 12b6: d0 e0 ldi r29, 0x00 ; 0 12b8: 18 81 ld r17, Y 12ba: 17 70 andi r17, 0x07 ; 7 * \param[in] PipeNumber Index of the pipe to select. */ static inline void Pipe_SelectPipe(const uint8_t PipeNumber) ATTR_ALWAYS_INLINE; static inline void Pipe_SelectPipe(const uint8_t PipeNumber) { UPNUM = PipeNumber; 12bc: 18 82 st Y, r1 { uint8_t PrevPipe = Pipe_GetCurrentPipe(); Pipe_SelectPipe(PIPE_CONTROLPIPE); USB_Host_ProcessNextHostState(); 12be: 34 db rcall .-2456 ; 0x928 12c0: 18 83 st Y, r17 if (USB_CurrentMode == USB_MODE_Device) USB_DeviceTask(); else if (USB_CurrentMode == USB_MODE_Host) USB_HostTask(); #endif } 12c2: df 91 pop r29 12c4: cf 91 pop r28 12c6: 1f 91 pop r17 12c8: 08 95 ret 000012ca : * \param[in] DataByte Byte to transmit through the USART. */ static inline void Serial_SendByte(const char DataByte) ATTR_ALWAYS_INLINE; static inline void Serial_SendByte(const char DataByte) { while (!(UCSR1A & (1 << UDRE1))); 12ca: 90 91 c8 00 lds r25, 0x00C8 12ce: 95 ff sbrs r25, 5 12d0: fc cf rjmp .-8 ; 0x12ca UDR1 = DataByte; 12d2: 80 93 ce 00 sts 0x00CE, r24 { (void)Stream; Serial_SendByte(DataByte); return 0; } 12d6: 80 e0 ldi r24, 0x00 ; 0 12d8: 90 e0 ldi r25, 0x00 ; 0 12da: 08 95 ret 000012dc : * \return Boolean \c true if a character has been received, \c false otherwise. */ static inline bool Serial_IsCharReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE; static inline bool Serial_IsCharReceived(void) { return ((UCSR1A & (1 << RXC1)) ? true : false); 12dc: 80 91 c8 00 lds r24, 0x00C8 int Serial_getchar(FILE *Stream) { (void)Stream; if (!(Serial_IsCharReceived())) 12e0: 87 ff sbrs r24, 7 12e2: 08 c0 rjmp .+16 ; 0x12f4 12e4: 80 91 c8 00 lds r24, 0x00C8 * \return Next byte received from the USART, or a negative value if no byte has been received. */ static inline int16_t Serial_ReceiveByte(void) ATTR_ALWAYS_INLINE; static inline int16_t Serial_ReceiveByte(void) { if (!(Serial_IsCharReceived())) 12e8: 87 ff sbrs r24, 7 12ea: 07 c0 rjmp .+14 ; 0x12fa return -1; return UDR1; 12ec: 20 91 ce 00 lds r18, 0x00CE 12f0: 30 e0 ldi r19, 0x00 ; 0 12f2: 05 c0 rjmp .+10 ; 0x12fe return _FDEV_EOF; 12f4: 2e ef ldi r18, 0xFE ; 254 12f6: 3f ef ldi r19, 0xFF ; 255 12f8: 02 c0 rjmp .+4 ; 0x12fe */ static inline int16_t Serial_ReceiveByte(void) ATTR_ALWAYS_INLINE; static inline int16_t Serial_ReceiveByte(void) { if (!(Serial_IsCharReceived())) return -1; 12fa: 2f ef ldi r18, 0xFF ; 255 12fc: 3f ef ldi r19, 0xFF ; 255 return Serial_ReceiveByte(); } 12fe: c9 01 movw r24, r18 1300: 08 95 ret 00001302 : 1302: df 93 push r29 1304: cf 93 push r28 1306: cd b7 in r28, 0x3d ; 61 1308: de b7 in r29, 0x3e ; 62 130a: fe 01 movw r30, r28 130c: 35 96 adiw r30, 0x05 ; 5 130e: 61 91 ld r22, Z+ 1310: 71 91 ld r23, Z+ 1312: 80 91 3c 01 lds r24, 0x013C 1316: 90 91 3d 01 lds r25, 0x013D 131a: dc 01 movw r26, r24 131c: 13 96 adiw r26, 0x03 ; 3 131e: 2c 91 ld r18, X 1320: 13 97 sbiw r26, 0x03 ; 3 1322: 28 60 ori r18, 0x08 ; 8 1324: 13 96 adiw r26, 0x03 ; 3 1326: 2c 93 st X, r18 1328: af 01 movw r20, r30 132a: 42 d0 rcall .+132 ; 0x13b0 132c: e0 91 3c 01 lds r30, 0x013C 1330: f0 91 3d 01 lds r31, 0x013D 1334: 23 81 ldd r18, Z+3 ; 0x03 1336: 27 7f andi r18, 0xF7 ; 247 1338: 23 83 std Z+3, r18 ; 0x03 133a: cf 91 pop r28 133c: df 91 pop r29 133e: 08 95 ret 00001340 : 1340: ef 92 push r14 1342: ff 92 push r15 1344: 0f 93 push r16 1346: 1f 93 push r17 1348: cf 93 push r28 134a: df 93 push r29 134c: 8c 01 movw r16, r24 134e: e0 91 3c 01 lds r30, 0x013C 1352: f0 91 3d 01 lds r31, 0x013D 1356: 83 81 ldd r24, Z+3 ; 0x03 1358: 81 ff sbrs r24, 1 135a: 20 c0 rjmp .+64 ; 0x139c 135c: c0 e0 ldi r28, 0x00 ; 0 135e: d0 e0 ldi r29, 0x00 ; 0 1360: 0c c0 rjmp .+24 ; 0x137a 1362: db 01 movw r26, r22 1364: 18 96 adiw r26, 0x08 ; 8 1366: ed 91 ld r30, X+ 1368: fc 91 ld r31, X 136a: 19 97 sbiw r26, 0x09 ; 9 136c: 09 95 icall 136e: 00 97 sbiw r24, 0x00 ; 0 1370: 11 f0 breq .+4 ; 0x1376 1372: cf ef ldi r28, 0xFF ; 255 1374: df ef ldi r29, 0xFF ; 255 1376: 0f 5f subi r16, 0xFF ; 255 1378: 1f 4f sbci r17, 0xFF ; 255 137a: f8 01 movw r30, r16 137c: 84 91 lpm r24, Z+ 137e: 60 91 3c 01 lds r22, 0x013C 1382: 70 91 3d 01 lds r23, 0x013D 1386: 88 23 and r24, r24 1388: 61 f7 brne .-40 ; 0x1362 138a: db 01 movw r26, r22 138c: 18 96 adiw r26, 0x08 ; 8 138e: ed 91 ld r30, X+ 1390: fc 91 ld r31, X 1392: 19 97 sbiw r26, 0x09 ; 9 1394: 8a e0 ldi r24, 0x0A ; 10 1396: 09 95 icall 1398: 00 97 sbiw r24, 0x00 ; 0 139a: 11 f0 breq .+4 ; 0x13a0 139c: cf ef ldi r28, 0xFF ; 255 139e: df ef ldi r29, 0xFF ; 255 13a0: ce 01 movw r24, r28 13a2: df 91 pop r29 13a4: cf 91 pop r28 13a6: 1f 91 pop r17 13a8: 0f 91 pop r16 13aa: ff 90 pop r15 13ac: ef 90 pop r14 13ae: 08 95 ret 000013b0 : 13b0: 2f 92 push r2 13b2: 3f 92 push r3 13b4: 4f 92 push r4 13b6: 5f 92 push r5 13b8: 6f 92 push r6 13ba: 7f 92 push r7 13bc: 8f 92 push r8 13be: 9f 92 push r9 13c0: af 92 push r10 13c2: bf 92 push r11 13c4: cf 92 push r12 13c6: df 92 push r13 13c8: ef 92 push r14 13ca: ff 92 push r15 13cc: 0f 93 push r16 13ce: 1f 93 push r17 13d0: df 93 push r29 13d2: cf 93 push r28 13d4: cd b7 in r28, 0x3d ; 61 13d6: de b7 in r29, 0x3e ; 62 13d8: 2c 97 sbiw r28, 0x0c ; 12 13da: 0f b6 in r0, 0x3f ; 63 13dc: f8 94 cli 13de: de bf out 0x3e, r29 ; 62 13e0: 0f be out 0x3f, r0 ; 63 13e2: cd bf out 0x3d, r28 ; 61 13e4: 6c 01 movw r12, r24 13e6: 1b 01 movw r2, r22 13e8: 8a 01 movw r16, r20 13ea: fc 01 movw r30, r24 13ec: 17 82 std Z+7, r1 ; 0x07 13ee: 16 82 std Z+6, r1 ; 0x06 13f0: 83 81 ldd r24, Z+3 ; 0x03 13f2: 81 ff sbrs r24, 1 13f4: c4 c1 rjmp .+904 ; 0x177e 13f6: 2e 01 movw r4, r28 13f8: 08 94 sec 13fa: 41 1c adc r4, r1 13fc: 51 1c adc r5, r1 13fe: f6 01 movw r30, r12 1400: 93 81 ldd r25, Z+3 ; 0x03 1402: f1 01 movw r30, r2 1404: 93 fd sbrc r25, 3 1406: 85 91 lpm r24, Z+ 1408: 93 ff sbrs r25, 3 140a: 81 91 ld r24, Z+ 140c: 1f 01 movw r2, r30 140e: 88 23 and r24, r24 1410: 09 f4 brne .+2 ; 0x1414 1412: b1 c1 rjmp .+866 ; 0x1776 1414: 85 32 cpi r24, 0x25 ; 37 1416: 39 f4 brne .+14 ; 0x1426 1418: 93 fd sbrc r25, 3 141a: 85 91 lpm r24, Z+ 141c: 93 ff sbrs r25, 3 141e: 81 91 ld r24, Z+ 1420: 1f 01 movw r2, r30 1422: 85 32 cpi r24, 0x25 ; 37 1424: 21 f4 brne .+8 ; 0x142e 1426: 90 e0 ldi r25, 0x00 ; 0 1428: b6 01 movw r22, r12 142a: db d1 rcall .+950 ; 0x17e2 142c: e8 cf rjmp .-48 ; 0x13fe 142e: ee 24 eor r14, r14 1430: ff 24 eor r15, r15 1432: 20 e0 ldi r18, 0x00 ; 0 1434: 20 32 cpi r18, 0x20 ; 32 1436: b0 f4 brcc .+44 ; 0x1464 1438: 8b 32 cpi r24, 0x2B ; 43 143a: 69 f0 breq .+26 ; 0x1456 143c: 8c 32 cpi r24, 0x2C ; 44 143e: 28 f4 brcc .+10 ; 0x144a 1440: 80 32 cpi r24, 0x20 ; 32 1442: 51 f0 breq .+20 ; 0x1458 1444: 83 32 cpi r24, 0x23 ; 35 1446: 71 f4 brne .+28 ; 0x1464 1448: 0b c0 rjmp .+22 ; 0x1460 144a: 8d 32 cpi r24, 0x2D ; 45 144c: 39 f0 breq .+14 ; 0x145c 144e: 80 33 cpi r24, 0x30 ; 48 1450: 49 f4 brne .+18 ; 0x1464 1452: 21 60 ori r18, 0x01 ; 1 1454: 2c c0 rjmp .+88 ; 0x14ae 1456: 22 60 ori r18, 0x02 ; 2 1458: 24 60 ori r18, 0x04 ; 4 145a: 29 c0 rjmp .+82 ; 0x14ae 145c: 28 60 ori r18, 0x08 ; 8 145e: 27 c0 rjmp .+78 ; 0x14ae 1460: 20 61 ori r18, 0x10 ; 16 1462: 25 c0 rjmp .+74 ; 0x14ae 1464: 27 fd sbrc r18, 7 1466: 2c c0 rjmp .+88 ; 0x14c0 1468: 38 2f mov r19, r24 146a: 30 53 subi r19, 0x30 ; 48 146c: 3a 30 cpi r19, 0x0A ; 10 146e: 98 f4 brcc .+38 ; 0x1496 1470: 26 ff sbrs r18, 6 1472: 08 c0 rjmp .+16 ; 0x1484 1474: 8e 2d mov r24, r14 1476: 88 0f add r24, r24 1478: e8 2e mov r14, r24 147a: ee 0c add r14, r14 147c: ee 0c add r14, r14 147e: e8 0e add r14, r24 1480: e3 0e add r14, r19 1482: 15 c0 rjmp .+42 ; 0x14ae 1484: 8f 2d mov r24, r15 1486: 88 0f add r24, r24 1488: f8 2e mov r15, r24 148a: ff 0c add r15, r15 148c: ff 0c add r15, r15 148e: f8 0e add r15, r24 1490: f3 0e add r15, r19 1492: 20 62 ori r18, 0x20 ; 32 1494: 0c c0 rjmp .+24 ; 0x14ae 1496: 8e 32 cpi r24, 0x2E ; 46 1498: 21 f4 brne .+8 ; 0x14a2 149a: 26 fd sbrc r18, 6 149c: 6c c1 rjmp .+728 ; 0x1776 149e: 20 64 ori r18, 0x40 ; 64 14a0: 06 c0 rjmp .+12 ; 0x14ae 14a2: 8c 36 cpi r24, 0x6C ; 108 14a4: 11 f4 brne .+4 ; 0x14aa 14a6: 20 68 ori r18, 0x80 ; 128 14a8: 02 c0 rjmp .+4 ; 0x14ae 14aa: 88 36 cpi r24, 0x68 ; 104 14ac: 49 f4 brne .+18 ; 0x14c0 14ae: f1 01 movw r30, r2 14b0: 93 fd sbrc r25, 3 14b2: 85 91 lpm r24, Z+ 14b4: 93 ff sbrs r25, 3 14b6: 81 91 ld r24, Z+ 14b8: 1f 01 movw r2, r30 14ba: 88 23 and r24, r24 14bc: 09 f0 breq .+2 ; 0x14c0 14be: ba cf rjmp .-140 ; 0x1434 14c0: 98 2f mov r25, r24 14c2: 95 54 subi r25, 0x45 ; 69 14c4: 93 30 cpi r25, 0x03 ; 3 14c6: 18 f0 brcs .+6 ; 0x14ce 14c8: 90 52 subi r25, 0x20 ; 32 14ca: 93 30 cpi r25, 0x03 ; 3 14cc: 28 f4 brcc .+10 ; 0x14d8 14ce: 0c 5f subi r16, 0xFC ; 252 14d0: 1f 4f sbci r17, 0xFF ; 255 14d2: ff e3 ldi r31, 0x3F ; 63 14d4: f9 83 std Y+1, r31 ; 0x01 14d6: 0d c0 rjmp .+26 ; 0x14f2 14d8: 83 36 cpi r24, 0x63 ; 99 14da: 31 f0 breq .+12 ; 0x14e8 14dc: 83 37 cpi r24, 0x73 ; 115 14de: 71 f0 breq .+28 ; 0x14fc 14e0: 83 35 cpi r24, 0x53 ; 83 14e2: 09 f0 breq .+2 ; 0x14e6 14e4: 5c c0 rjmp .+184 ; 0x159e 14e6: 21 c0 rjmp .+66 ; 0x152a 14e8: f8 01 movw r30, r16 14ea: 80 81 ld r24, Z 14ec: 89 83 std Y+1, r24 ; 0x01 14ee: 0e 5f subi r16, 0xFE ; 254 14f0: 1f 4f sbci r17, 0xFF ; 255 14f2: 42 01 movw r8, r4 14f4: 71 e0 ldi r23, 0x01 ; 1 14f6: a7 2e mov r10, r23 14f8: b1 2c mov r11, r1 14fa: 15 c0 rjmp .+42 ; 0x1526 14fc: 62 e0 ldi r22, 0x02 ; 2 14fe: 66 2e mov r6, r22 1500: 71 2c mov r7, r1 1502: 60 0e add r6, r16 1504: 71 1e adc r7, r17 1506: f8 01 movw r30, r16 1508: 80 80 ld r8, Z 150a: 91 80 ldd r9, Z+1 ; 0x01 150c: 26 ff sbrs r18, 6 150e: 03 c0 rjmp .+6 ; 0x1516 1510: 6e 2d mov r22, r14 1512: 70 e0 ldi r23, 0x00 ; 0 1514: 02 c0 rjmp .+4 ; 0x151a 1516: 6f ef ldi r22, 0xFF ; 255 1518: 7f ef ldi r23, 0xFF ; 255 151a: c4 01 movw r24, r8 151c: 2c 87 std Y+12, r18 ; 0x0c 151e: 56 d1 rcall .+684 ; 0x17cc 1520: 5c 01 movw r10, r24 1522: 83 01 movw r16, r6 1524: 2c 85 ldd r18, Y+12 ; 0x0c 1526: 2f 77 andi r18, 0x7F ; 127 1528: 16 c0 rjmp .+44 ; 0x1556 152a: 52 e0 ldi r21, 0x02 ; 2 152c: 65 2e mov r6, r21 152e: 71 2c mov r7, r1 1530: 60 0e add r6, r16 1532: 71 1e adc r7, r17 1534: f8 01 movw r30, r16 1536: 80 80 ld r8, Z 1538: 91 80 ldd r9, Z+1 ; 0x01 153a: 26 ff sbrs r18, 6 153c: 03 c0 rjmp .+6 ; 0x1544 153e: 6e 2d mov r22, r14 1540: 70 e0 ldi r23, 0x00 ; 0 1542: 02 c0 rjmp .+4 ; 0x1548 1544: 6f ef ldi r22, 0xFF ; 255 1546: 7f ef ldi r23, 0xFF ; 255 1548: c4 01 movw r24, r8 154a: 2c 87 std Y+12, r18 ; 0x0c 154c: 34 d1 rcall .+616 ; 0x17b6 154e: 5c 01 movw r10, r24 1550: 2c 85 ldd r18, Y+12 ; 0x0c 1552: 20 68 ori r18, 0x80 ; 128 1554: 83 01 movw r16, r6 1556: 23 fd sbrc r18, 3 1558: 1e c0 rjmp .+60 ; 0x1596 155a: 07 c0 rjmp .+14 ; 0x156a 155c: 80 e2 ldi r24, 0x20 ; 32 155e: 90 e0 ldi r25, 0x00 ; 0 1560: b6 01 movw r22, r12 1562: 2c 87 std Y+12, r18 ; 0x0c 1564: 3e d1 rcall .+636 ; 0x17e2 1566: fa 94 dec r15 1568: 2c 85 ldd r18, Y+12 ; 0x0c 156a: 8f 2d mov r24, r15 156c: 90 e0 ldi r25, 0x00 ; 0 156e: a8 16 cp r10, r24 1570: b9 06 cpc r11, r25 1572: a0 f3 brcs .-24 ; 0x155c 1574: 10 c0 rjmp .+32 ; 0x1596 1576: f4 01 movw r30, r8 1578: 27 fd sbrc r18, 7 157a: 85 91 lpm r24, Z+ 157c: 27 ff sbrs r18, 7 157e: 81 91 ld r24, Z+ 1580: 4f 01 movw r8, r30 1582: 90 e0 ldi r25, 0x00 ; 0 1584: b6 01 movw r22, r12 1586: 2c 87 std Y+12, r18 ; 0x0c 1588: 2c d1 rcall .+600 ; 0x17e2 158a: 2c 85 ldd r18, Y+12 ; 0x0c 158c: f1 10 cpse r15, r1 158e: fa 94 dec r15 1590: 08 94 sec 1592: a1 08 sbc r10, r1 1594: b1 08 sbc r11, r1 1596: a1 14 cp r10, r1 1598: b1 04 cpc r11, r1 159a: 69 f7 brne .-38 ; 0x1576 159c: e9 c0 rjmp .+466 ; 0x1770 159e: 84 36 cpi r24, 0x64 ; 100 15a0: 11 f0 breq .+4 ; 0x15a6 15a2: 89 36 cpi r24, 0x69 ; 105 15a4: 41 f5 brne .+80 ; 0x15f6 15a6: 27 ff sbrs r18, 7 15a8: 08 c0 rjmp .+16 ; 0x15ba 15aa: f8 01 movw r30, r16 15ac: 60 81 ld r22, Z 15ae: 71 81 ldd r23, Z+1 ; 0x01 15b0: 82 81 ldd r24, Z+2 ; 0x02 15b2: 93 81 ldd r25, Z+3 ; 0x03 15b4: 0c 5f subi r16, 0xFC ; 252 15b6: 1f 4f sbci r17, 0xFF ; 255 15b8: 09 c0 rjmp .+18 ; 0x15cc 15ba: f8 01 movw r30, r16 15bc: 60 81 ld r22, Z 15be: 71 81 ldd r23, Z+1 ; 0x01 15c0: 88 27 eor r24, r24 15c2: 77 fd sbrc r23, 7 15c4: 80 95 com r24 15c6: 98 2f mov r25, r24 15c8: 0e 5f subi r16, 0xFE ; 254 15ca: 1f 4f sbci r17, 0xFF ; 255 15cc: 4f e6 ldi r20, 0x6F ; 111 15ce: b4 2e mov r11, r20 15d0: b2 22 and r11, r18 15d2: 97 ff sbrs r25, 7 15d4: 09 c0 rjmp .+18 ; 0x15e8 15d6: 90 95 com r25 15d8: 80 95 com r24 15da: 70 95 com r23 15dc: 61 95 neg r22 15de: 7f 4f sbci r23, 0xFF ; 255 15e0: 8f 4f sbci r24, 0xFF ; 255 15e2: 9f 4f sbci r25, 0xFF ; 255 15e4: f0 e8 ldi r31, 0x80 ; 128 15e6: bf 2a or r11, r31 15e8: a2 01 movw r20, r4 15ea: 2a e0 ldi r18, 0x0A ; 10 15ec: 30 e0 ldi r19, 0x00 ; 0 15ee: 25 d1 rcall .+586 ; 0x183a <__ultoa_invert> 15f0: 78 2e mov r7, r24 15f2: 74 18 sub r7, r4 15f4: 44 c0 rjmp .+136 ; 0x167e 15f6: 85 37 cpi r24, 0x75 ; 117 15f8: 31 f4 brne .+12 ; 0x1606 15fa: 3f ee ldi r19, 0xEF ; 239 15fc: b3 2e mov r11, r19 15fe: b2 22 and r11, r18 1600: 2a e0 ldi r18, 0x0A ; 10 1602: 30 e0 ldi r19, 0x00 ; 0 1604: 25 c0 rjmp .+74 ; 0x1650 1606: 99 ef ldi r25, 0xF9 ; 249 1608: b9 2e mov r11, r25 160a: b2 22 and r11, r18 160c: 8f 36 cpi r24, 0x6F ; 111 160e: c1 f0 breq .+48 ; 0x1640 1610: 80 37 cpi r24, 0x70 ; 112 1612: 20 f4 brcc .+8 ; 0x161c 1614: 88 35 cpi r24, 0x58 ; 88 1616: 09 f0 breq .+2 ; 0x161a 1618: ae c0 rjmp .+348 ; 0x1776 161a: 0d c0 rjmp .+26 ; 0x1636 161c: 80 37 cpi r24, 0x70 ; 112 161e: 21 f0 breq .+8 ; 0x1628 1620: 88 37 cpi r24, 0x78 ; 120 1622: 09 f0 breq .+2 ; 0x1626 1624: a8 c0 rjmp .+336 ; 0x1776 1626: 02 c0 rjmp .+4 ; 0x162c 1628: 20 e1 ldi r18, 0x10 ; 16 162a: b2 2a or r11, r18 162c: b4 fe sbrs r11, 4 162e: 0b c0 rjmp .+22 ; 0x1646 1630: 84 e0 ldi r24, 0x04 ; 4 1632: b8 2a or r11, r24 1634: 08 c0 rjmp .+16 ; 0x1646 1636: b4 fe sbrs r11, 4 1638: 09 c0 rjmp .+18 ; 0x164c 163a: e6 e0 ldi r30, 0x06 ; 6 163c: be 2a or r11, r30 163e: 06 c0 rjmp .+12 ; 0x164c 1640: 28 e0 ldi r18, 0x08 ; 8 1642: 30 e0 ldi r19, 0x00 ; 0 1644: 05 c0 rjmp .+10 ; 0x1650 1646: 20 e1 ldi r18, 0x10 ; 16 1648: 30 e0 ldi r19, 0x00 ; 0 164a: 02 c0 rjmp .+4 ; 0x1650 164c: 20 e1 ldi r18, 0x10 ; 16 164e: 32 e0 ldi r19, 0x02 ; 2 1650: b7 fe sbrs r11, 7 1652: 08 c0 rjmp .+16 ; 0x1664 1654: f8 01 movw r30, r16 1656: 60 81 ld r22, Z 1658: 71 81 ldd r23, Z+1 ; 0x01 165a: 82 81 ldd r24, Z+2 ; 0x02 165c: 93 81 ldd r25, Z+3 ; 0x03 165e: 0c 5f subi r16, 0xFC ; 252 1660: 1f 4f sbci r17, 0xFF ; 255 1662: 07 c0 rjmp .+14 ; 0x1672 1664: f8 01 movw r30, r16 1666: 60 81 ld r22, Z 1668: 71 81 ldd r23, Z+1 ; 0x01 166a: 80 e0 ldi r24, 0x00 ; 0 166c: 90 e0 ldi r25, 0x00 ; 0 166e: 0e 5f subi r16, 0xFE ; 254 1670: 1f 4f sbci r17, 0xFF ; 255 1672: a2 01 movw r20, r4 1674: e2 d0 rcall .+452 ; 0x183a <__ultoa_invert> 1676: 78 2e mov r7, r24 1678: 74 18 sub r7, r4 167a: ff e7 ldi r31, 0x7F ; 127 167c: bf 22 and r11, r31 167e: b6 fe sbrs r11, 6 1680: 0b c0 rjmp .+22 ; 0x1698 1682: 2e ef ldi r18, 0xFE ; 254 1684: b2 22 and r11, r18 1686: 7e 14 cp r7, r14 1688: 38 f4 brcc .+14 ; 0x1698 168a: b4 fe sbrs r11, 4 168c: 07 c0 rjmp .+14 ; 0x169c 168e: b2 fc sbrc r11, 2 1690: 05 c0 rjmp .+10 ; 0x169c 1692: 8f ee ldi r24, 0xEF ; 239 1694: b8 22 and r11, r24 1696: 02 c0 rjmp .+4 ; 0x169c 1698: a7 2c mov r10, r7 169a: 01 c0 rjmp .+2 ; 0x169e 169c: ae 2c mov r10, r14 169e: 8b 2d mov r24, r11 16a0: 90 e0 ldi r25, 0x00 ; 0 16a2: b4 fe sbrs r11, 4 16a4: 0d c0 rjmp .+26 ; 0x16c0 16a6: fe 01 movw r30, r28 16a8: e7 0d add r30, r7 16aa: f1 1d adc r31, r1 16ac: 20 81 ld r18, Z 16ae: 20 33 cpi r18, 0x30 ; 48 16b0: 19 f4 brne .+6 ; 0x16b8 16b2: e9 ee ldi r30, 0xE9 ; 233 16b4: be 22 and r11, r30 16b6: 09 c0 rjmp .+18 ; 0x16ca 16b8: a3 94 inc r10 16ba: b2 fe sbrs r11, 2 16bc: 06 c0 rjmp .+12 ; 0x16ca 16be: 04 c0 rjmp .+8 ; 0x16c8 16c0: 86 78 andi r24, 0x86 ; 134 16c2: 90 70 andi r25, 0x00 ; 0 16c4: 00 97 sbiw r24, 0x00 ; 0 16c6: 09 f0 breq .+2 ; 0x16ca 16c8: a3 94 inc r10 16ca: 8b 2c mov r8, r11 16cc: 99 24 eor r9, r9 16ce: b3 fc sbrc r11, 3 16d0: 13 c0 rjmp .+38 ; 0x16f8 16d2: b0 fe sbrs r11, 0 16d4: 0e c0 rjmp .+28 ; 0x16f2 16d6: af 14 cp r10, r15 16d8: 28 f4 brcc .+10 ; 0x16e4 16da: e7 2c mov r14, r7 16dc: ef 0c add r14, r15 16de: ea 18 sub r14, r10 16e0: af 2c mov r10, r15 16e2: 07 c0 rjmp .+14 ; 0x16f2 16e4: e7 2c mov r14, r7 16e6: 05 c0 rjmp .+10 ; 0x16f2 16e8: 80 e2 ldi r24, 0x20 ; 32 16ea: 90 e0 ldi r25, 0x00 ; 0 16ec: b6 01 movw r22, r12 16ee: 79 d0 rcall .+242 ; 0x17e2 16f0: a3 94 inc r10 16f2: af 14 cp r10, r15 16f4: c8 f3 brcs .-14 ; 0x16e8 16f6: 04 c0 rjmp .+8 ; 0x1700 16f8: af 14 cp r10, r15 16fa: 10 f4 brcc .+4 ; 0x1700 16fc: fa 18 sub r15, r10 16fe: 01 c0 rjmp .+2 ; 0x1702 1700: ff 24 eor r15, r15 1702: 84 fe sbrs r8, 4 1704: 0e c0 rjmp .+28 ; 0x1722 1706: 80 e3 ldi r24, 0x30 ; 48 1708: 90 e0 ldi r25, 0x00 ; 0 170a: b6 01 movw r22, r12 170c: 6a d0 rcall .+212 ; 0x17e2 170e: 82 fe sbrs r8, 2 1710: 1d c0 rjmp .+58 ; 0x174c 1712: 81 fe sbrs r8, 1 1714: 03 c0 rjmp .+6 ; 0x171c 1716: 88 e5 ldi r24, 0x58 ; 88 1718: 90 e0 ldi r25, 0x00 ; 0 171a: 10 c0 rjmp .+32 ; 0x173c 171c: 88 e7 ldi r24, 0x78 ; 120 171e: 90 e0 ldi r25, 0x00 ; 0 1720: 0d c0 rjmp .+26 ; 0x173c 1722: c4 01 movw r24, r8 1724: 86 78 andi r24, 0x86 ; 134 1726: 90 70 andi r25, 0x00 ; 0 1728: 00 97 sbiw r24, 0x00 ; 0 172a: 81 f0 breq .+32 ; 0x174c 172c: 81 fc sbrc r8, 1 172e: 02 c0 rjmp .+4 ; 0x1734 1730: 80 e2 ldi r24, 0x20 ; 32 1732: 01 c0 rjmp .+2 ; 0x1736 1734: 8b e2 ldi r24, 0x2B ; 43 1736: b7 fc sbrc r11, 7 1738: 8d e2 ldi r24, 0x2D ; 45 173a: 90 e0 ldi r25, 0x00 ; 0 173c: b6 01 movw r22, r12 173e: 51 d0 rcall .+162 ; 0x17e2 1740: 05 c0 rjmp .+10 ; 0x174c 1742: 80 e3 ldi r24, 0x30 ; 48 1744: 90 e0 ldi r25, 0x00 ; 0 1746: b6 01 movw r22, r12 1748: 4c d0 rcall .+152 ; 0x17e2 174a: ea 94 dec r14 174c: 7e 14 cp r7, r14 174e: c8 f3 brcs .-14 ; 0x1742 1750: 7a 94 dec r7 1752: f2 01 movw r30, r4 1754: e7 0d add r30, r7 1756: f1 1d adc r31, r1 1758: 80 81 ld r24, Z 175a: 90 e0 ldi r25, 0x00 ; 0 175c: b6 01 movw r22, r12 175e: 41 d0 rcall .+130 ; 0x17e2 1760: 77 20 and r7, r7 1762: b1 f7 brne .-20 ; 0x1750 1764: 05 c0 rjmp .+10 ; 0x1770 1766: 80 e2 ldi r24, 0x20 ; 32 1768: 90 e0 ldi r25, 0x00 ; 0 176a: b6 01 movw r22, r12 176c: 3a d0 rcall .+116 ; 0x17e2 176e: fa 94 dec r15 1770: ff 20 and r15, r15 1772: c9 f7 brne .-14 ; 0x1766 1774: 44 ce rjmp .-888 ; 0x13fe 1776: f6 01 movw r30, r12 1778: 26 81 ldd r18, Z+6 ; 0x06 177a: 37 81 ldd r19, Z+7 ; 0x07 177c: 02 c0 rjmp .+4 ; 0x1782 177e: 2f ef ldi r18, 0xFF ; 255 1780: 3f ef ldi r19, 0xFF ; 255 1782: c9 01 movw r24, r18 1784: 2c 96 adiw r28, 0x0c ; 12 1786: 0f b6 in r0, 0x3f ; 63 1788: f8 94 cli 178a: de bf out 0x3e, r29 ; 62 178c: 0f be out 0x3f, r0 ; 63 178e: cd bf out 0x3d, r28 ; 61 1790: cf 91 pop r28 1792: df 91 pop r29 1794: 1f 91 pop r17 1796: 0f 91 pop r16 1798: ff 90 pop r15 179a: ef 90 pop r14 179c: df 90 pop r13 179e: cf 90 pop r12 17a0: bf 90 pop r11 17a2: af 90 pop r10 17a4: 9f 90 pop r9 17a6: 8f 90 pop r8 17a8: 7f 90 pop r7 17aa: 6f 90 pop r6 17ac: 5f 90 pop r5 17ae: 4f 90 pop r4 17b0: 3f 90 pop r3 17b2: 2f 90 pop r2 17b4: 08 95 ret 000017b6 : 17b6: fc 01 movw r30, r24 17b8: 05 90 lpm r0, Z+ 17ba: 61 50 subi r22, 0x01 ; 1 17bc: 70 40 sbci r23, 0x00 ; 0 17be: 01 10 cpse r0, r1 17c0: d8 f7 brcc .-10 ; 0x17b8 17c2: 80 95 com r24 17c4: 90 95 com r25 17c6: 8e 0f add r24, r30 17c8: 9f 1f adc r25, r31 17ca: 08 95 ret 000017cc : 17cc: fc 01 movw r30, r24 17ce: 61 50 subi r22, 0x01 ; 1 17d0: 70 40 sbci r23, 0x00 ; 0 17d2: 01 90 ld r0, Z+ 17d4: 01 10 cpse r0, r1 17d6: d8 f7 brcc .-10 ; 0x17ce 17d8: 80 95 com r24 17da: 90 95 com r25 17dc: 8e 0f add r24, r30 17de: 9f 1f adc r25, r31 17e0: 08 95 ret 000017e2 : 17e2: 0f 93 push r16 17e4: 1f 93 push r17 17e6: cf 93 push r28 17e8: df 93 push r29 17ea: 8c 01 movw r16, r24 17ec: eb 01 movw r28, r22 17ee: 8b 81 ldd r24, Y+3 ; 0x03 17f0: 81 ff sbrs r24, 1 17f2: 1b c0 rjmp .+54 ; 0x182a 17f4: 82 ff sbrs r24, 2 17f6: 0d c0 rjmp .+26 ; 0x1812 17f8: 2e 81 ldd r18, Y+6 ; 0x06 17fa: 3f 81 ldd r19, Y+7 ; 0x07 17fc: 8c 81 ldd r24, Y+4 ; 0x04 17fe: 9d 81 ldd r25, Y+5 ; 0x05 1800: 28 17 cp r18, r24 1802: 39 07 cpc r19, r25 1804: 64 f4 brge .+24 ; 0x181e 1806: e8 81 ld r30, Y 1808: f9 81 ldd r31, Y+1 ; 0x01 180a: 01 93 st Z+, r16 180c: f9 83 std Y+1, r31 ; 0x01 180e: e8 83 st Y, r30 1810: 06 c0 rjmp .+12 ; 0x181e 1812: e8 85 ldd r30, Y+8 ; 0x08 1814: f9 85 ldd r31, Y+9 ; 0x09 1816: 80 2f mov r24, r16 1818: 09 95 icall 181a: 00 97 sbiw r24, 0x00 ; 0 181c: 31 f4 brne .+12 ; 0x182a 181e: 8e 81 ldd r24, Y+6 ; 0x06 1820: 9f 81 ldd r25, Y+7 ; 0x07 1822: 01 96 adiw r24, 0x01 ; 1 1824: 9f 83 std Y+7, r25 ; 0x07 1826: 8e 83 std Y+6, r24 ; 0x06 1828: 02 c0 rjmp .+4 ; 0x182e 182a: 0f ef ldi r16, 0xFF ; 255 182c: 1f ef ldi r17, 0xFF ; 255 182e: c8 01 movw r24, r16 1830: df 91 pop r29 1832: cf 91 pop r28 1834: 1f 91 pop r17 1836: 0f 91 pop r16 1838: 08 95 ret 0000183a <__ultoa_invert>: 183a: fa 01 movw r30, r20 183c: aa 27 eor r26, r26 183e: 28 30 cpi r18, 0x08 ; 8 1840: 51 f1 breq .+84 ; 0x1896 <__ultoa_invert+0x5c> 1842: 20 31 cpi r18, 0x10 ; 16 1844: 81 f1 breq .+96 ; 0x18a6 <__ultoa_invert+0x6c> 1846: e8 94 clt 1848: 6f 93 push r22 184a: 6e 7f andi r22, 0xFE ; 254 184c: 6e 5f subi r22, 0xFE ; 254 184e: 7f 4f sbci r23, 0xFF ; 255 1850: 8f 4f sbci r24, 0xFF ; 255 1852: 9f 4f sbci r25, 0xFF ; 255 1854: af 4f sbci r26, 0xFF ; 255 1856: b1 e0 ldi r27, 0x01 ; 1 1858: 3e d0 rcall .+124 ; 0x18d6 <__ultoa_invert+0x9c> 185a: b4 e0 ldi r27, 0x04 ; 4 185c: 3c d0 rcall .+120 ; 0x18d6 <__ultoa_invert+0x9c> 185e: 67 0f add r22, r23 1860: 78 1f adc r23, r24 1862: 89 1f adc r24, r25 1864: 9a 1f adc r25, r26 1866: a1 1d adc r26, r1 1868: 68 0f add r22, r24 186a: 79 1f adc r23, r25 186c: 8a 1f adc r24, r26 186e: 91 1d adc r25, r1 1870: a1 1d adc r26, r1 1872: 6a 0f add r22, r26 1874: 71 1d adc r23, r1 1876: 81 1d adc r24, r1 1878: 91 1d adc r25, r1 187a: a1 1d adc r26, r1 187c: 20 d0 rcall .+64 ; 0x18be <__ultoa_invert+0x84> 187e: 09 f4 brne .+2 ; 0x1882 <__ultoa_invert+0x48> 1880: 68 94 set 1882: 3f 91 pop r19 1884: 2a e0 ldi r18, 0x0A ; 10 1886: 26 9f mul r18, r22 1888: 11 24 eor r1, r1 188a: 30 19 sub r19, r0 188c: 30 5d subi r19, 0xD0 ; 208 188e: 31 93 st Z+, r19 1890: de f6 brtc .-74 ; 0x1848 <__ultoa_invert+0xe> 1892: cf 01 movw r24, r30 1894: 08 95 ret 1896: 46 2f mov r20, r22 1898: 47 70 andi r20, 0x07 ; 7 189a: 40 5d subi r20, 0xD0 ; 208 189c: 41 93 st Z+, r20 189e: b3 e0 ldi r27, 0x03 ; 3 18a0: 0f d0 rcall .+30 ; 0x18c0 <__ultoa_invert+0x86> 18a2: c9 f7 brne .-14 ; 0x1896 <__ultoa_invert+0x5c> 18a4: f6 cf rjmp .-20 ; 0x1892 <__ultoa_invert+0x58> 18a6: 46 2f mov r20, r22 18a8: 4f 70 andi r20, 0x0F ; 15 18aa: 40 5d subi r20, 0xD0 ; 208 18ac: 4a 33 cpi r20, 0x3A ; 58 18ae: 18 f0 brcs .+6 ; 0x18b6 <__ultoa_invert+0x7c> 18b0: 49 5d subi r20, 0xD9 ; 217 18b2: 31 fd sbrc r19, 1 18b4: 40 52 subi r20, 0x20 ; 32 18b6: 41 93 st Z+, r20 18b8: 02 d0 rcall .+4 ; 0x18be <__ultoa_invert+0x84> 18ba: a9 f7 brne .-22 ; 0x18a6 <__ultoa_invert+0x6c> 18bc: ea cf rjmp .-44 ; 0x1892 <__ultoa_invert+0x58> 18be: b4 e0 ldi r27, 0x04 ; 4 18c0: a6 95 lsr r26 18c2: 97 95 ror r25 18c4: 87 95 ror r24 18c6: 77 95 ror r23 18c8: 67 95 ror r22 18ca: ba 95 dec r27 18cc: c9 f7 brne .-14 ; 0x18c0 <__ultoa_invert+0x86> 18ce: 00 97 sbiw r24, 0x00 ; 0 18d0: 61 05 cpc r22, r1 18d2: 71 05 cpc r23, r1 18d4: 08 95 ret 18d6: 9b 01 movw r18, r22 18d8: ac 01 movw r20, r24 18da: 0a 2e mov r0, r26 18dc: 06 94 lsr r0 18de: 57 95 ror r21 18e0: 47 95 ror r20 18e2: 37 95 ror r19 18e4: 27 95 ror r18 18e6: ba 95 dec r27 18e8: c9 f7 brne .-14 ; 0x18dc <__ultoa_invert+0xa2> 18ea: 62 0f add r22, r18 18ec: 73 1f adc r23, r19 18ee: 84 1f adc r24, r20 18f0: 95 1f adc r25, r21 18f2: a0 1d adc r26, r0 18f4: 08 95 ret 000018f6 <_exit>: 18f6: f8 94 cli 000018f8 <__stop_program>: 18f8: ff cf rjmp .-2 ; 0x18f8 <__stop_program>