first commitHEADmaster

1 files changed, 533 insertions, 0 deletions

diff --git a/test/ardmake/hardware/bootloaders/optiboot/optiboot_lilypad.lst b/test/ardmake/hardware/bootloaders/optiboot/optiboot_lilypad.lst
new file mode 100644
index 0000000..0e46bd1
--- /dev/null
+++ b/test/ardmake/hardware/bootloaders/optiboot/optiboot_lilypad.lst
@@ -0,0 +1,533 @@
+
+optiboot_lilypad.elf:     file format elf32-avr
+
+Sections:
+Idx Name          Size      VMA       LMA       File off  Algn
+  0 .text         000001fc  00003e00  00003e00  00000054  2**1
+                  CONTENTS, ALLOC, LOAD, READONLY, CODE
+  1 .debug_aranges 00000028  00000000  00000000  00000250  2**0
+                  CONTENTS, READONLY, DEBUGGING
+  2 .debug_pubnames 00000078  00000000  00000000  00000278  2**0
+                  CONTENTS, READONLY, DEBUGGING
+  3 .debug_info   00000277  00000000  00000000  000002f0  2**0
+                  CONTENTS, READONLY, DEBUGGING
+  4 .debug_abbrev 00000194  00000000  00000000  00000567  2**0
+                  CONTENTS, READONLY, DEBUGGING
+  5 .debug_line   000003bb  00000000  00000000  000006fb  2**0
+                  CONTENTS, READONLY, DEBUGGING
+  6 .debug_frame  000000a0  00000000  00000000  00000ab8  2**2
+                  CONTENTS, READONLY, DEBUGGING
+  7 .debug_str    0000013f  00000000  00000000  00000b58  2**0
+                  CONTENTS, READONLY, DEBUGGING
+  8 .debug_loc    000001a0  00000000  00000000  00000c97  2**0
+                  CONTENTS, READONLY, DEBUGGING
+  9 .debug_ranges 00000070  00000000  00000000  00000e37  2**0
+                  CONTENTS, READONLY, DEBUGGING
+
+Disassembly of section .text:
+
+00003e00 <main>:
+#ifdef VIRTUAL_BOOT_PARTITION
+#define rstVect (*(uint16_t*)(0x204))
+#define wdtVect (*(uint16_t*)(0x206))
+#endif
+/* main program starts here */
+int main(void) {
+    3e00:	85 e0       	ldi	r24, 0x05	; 5
+    3e02:	80 93 81 00 	sts	0x0081, r24
+  UCSR0C = _BV(UCSZ00) | _BV(UCSZ01);
+  UBRR0L = (uint8_t)( (F_CPU + BAUD_RATE * 4L) / (BAUD_RATE * 8L) - 1 );
+#endif
+
+  // Adaboot no-wait mod
+  ch = MCUSR;
+    3e06:	84 b7       	in	r24, 0x34	; 52
+  MCUSR = 0;
+    3e08:	14 be       	out	0x34, r1	; 52
+  if (!(ch & _BV(EXTRF))) appStart();
+    3e0a:	81 ff       	sbrs	r24, 1
+    3e0c:	e4 d0       	rcall	.+456    	; 0x3fd6 <appStart>
+
+  // Set up watchdog to trigger after 500ms
+  watchdogConfig(WATCHDOG_500MS);
+    3e0e:	8d e0       	ldi	r24, 0x0D	; 13
+    3e10:	dc d0       	rcall	.+440    	; 0x3fca <watchdogConfig>
+
+  /* Set LED pin as output */
+  LED_DDR |= _BV(LED);
+    3e12:	25 9a       	sbi	0x04, 5	; 4
+
+#ifdef SOFT_UART
+  /* Set TX pin as output */
+  UART_DDR |= _BV(UART_TX_BIT);
+    3e14:	51 9a       	sbi	0x0a, 1	; 10
+    3e16:	86 e0       	ldi	r24, 0x06	; 6
+}
+
+#if LED_START_FLASHES > 0
+void flash_led(uint8_t count) {
+  do {
+    TCNT1 = -(F_CPU/(1024*16));
+    3e18:	28 e1       	ldi	r18, 0x18	; 24
+    3e1a:	3e ef       	ldi	r19, 0xFE	; 254
+    TIFR1 = _BV(TOV1);
+    3e1c:	91 e0       	ldi	r25, 0x01	; 1
+}
+
+#if LED_START_FLASHES > 0
+void flash_led(uint8_t count) {
+  do {
+    TCNT1 = -(F_CPU/(1024*16));
+    3e1e:	30 93 85 00 	sts	0x0085, r19
+    3e22:	20 93 84 00 	sts	0x0084, r18
+    TIFR1 = _BV(TOV1);
+    3e26:	96 bb       	out	0x16, r25	; 22
+    while(!(TIFR1 & _BV(TOV1)));
+    3e28:	b0 9b       	sbis	0x16, 0	; 22
+    3e2a:	fe cf       	rjmp	.-4      	; 0x3e28 <main+0x28>
+    LED_PIN |= _BV(LED);
+    3e2c:	1d 9a       	sbi	0x03, 5	; 3
+  return getch();
+}
+
+// Watchdog functions. These are only safe with interrupts turned off.
+void watchdogReset() {
+  __asm__ __volatile__ (
+    3e2e:	a8 95       	wdr
+    TCNT1 = -(F_CPU/(1024*16));
+    TIFR1 = _BV(TOV1);
+    while(!(TIFR1 & _BV(TOV1)));
+    LED_PIN |= _BV(LED);
+    watchdogReset();
+  } while (--count);
+    3e30:	81 50       	subi	r24, 0x01	; 1
+    3e32:	a9 f7       	brne	.-22     	; 0x3e1e <main+0x1e>
+    /* get character from UART */
+    ch = getch();
+
+    if(ch == STK_GET_PARAMETER) {
+      // GET PARAMETER returns a generic 0x03 reply - enough to keep Avrdude happy
+      getNch(1);
+    3e34:	dd 24       	eor	r13, r13
+    3e36:	d3 94       	inc	r13
+        boot_page_fill((uint16_t)(void*)addrPtr,a);
+        addrPtr += 2;
+      } while (--ch);
+      
+      // Write from programming buffer
+      boot_page_write((uint16_t)(void*)address);
+    3e38:	a5 e0       	ldi	r26, 0x05	; 5
+    3e3a:	ea 2e       	mov	r14, r26
+      boot_spm_busy_wait();
+
+#if defined(RWWSRE)
+      // Reenable read access to flash
+      boot_rww_enable();
+    3e3c:	f1 e1       	ldi	r31, 0x11	; 17
+    3e3e:	ff 2e       	mov	r15, r31
+#endif
+
+  /* Forever loop */
+  for (;;) {
+    /* get character from UART */
+    ch = getch();
+    3e40:	ab d0       	rcall	.+342    	; 0x3f98 <getch>
+
+    if(ch == STK_GET_PARAMETER) {
+    3e42:	81 34       	cpi	r24, 0x41	; 65
+    3e44:	21 f4       	brne	.+8      	; 0x3e4e <main+0x4e>
+      // GET PARAMETER returns a generic 0x03 reply - enough to keep Avrdude happy
+      getNch(1);
+    3e46:	81 e0       	ldi	r24, 0x01	; 1
+    3e48:	d1 d0       	rcall	.+418    	; 0x3fec <verifySpace+0xc>
+      putch(0x03);
+    3e4a:	83 e0       	ldi	r24, 0x03	; 3
+    3e4c:	24 c0       	rjmp	.+72     	; 0x3e96 <main+0x96>
+    }
+    else if(ch == STK_SET_DEVICE) {
+    3e4e:	82 34       	cpi	r24, 0x42	; 66
+    3e50:	11 f4       	brne	.+4      	; 0x3e56 <main+0x56>
+      // SET DEVICE is ignored
+      getNch(20);
+    3e52:	84 e1       	ldi	r24, 0x14	; 20
+    3e54:	03 c0       	rjmp	.+6      	; 0x3e5c <main+0x5c>
+    }
+    else if(ch == STK_SET_DEVICE_EXT) {
+    3e56:	85 34       	cpi	r24, 0x45	; 69
+    3e58:	19 f4       	brne	.+6      	; 0x3e60 <main+0x60>
+      // SET DEVICE EXT is ignored
+      getNch(5);
+    3e5a:	85 e0       	ldi	r24, 0x05	; 5
+    3e5c:	c7 d0       	rcall	.+398    	; 0x3fec <verifySpace+0xc>
+    3e5e:	8a c0       	rjmp	.+276    	; 0x3f74 <main+0x174>
+    }
+    else if(ch == STK_LOAD_ADDRESS) {
+    3e60:	85 35       	cpi	r24, 0x55	; 85
+    3e62:	a1 f4       	brne	.+40     	; 0x3e8c <main+0x8c>
+      // LOAD ADDRESS
+      address = getch();
+    3e64:	99 d0       	rcall	.+306    	; 0x3f98 <getch>
+    3e66:	08 2f       	mov	r16, r24
+    3e68:	10 e0       	ldi	r17, 0x00	; 0
+    3e6a:	10 93 01 02 	sts	0x0201, r17
+    3e6e:	00 93 00 02 	sts	0x0200, r16
+      address = (address & 0xff) | (getch() << 8);
+    3e72:	92 d0       	rcall	.+292    	; 0x3f98 <getch>
+    3e74:	90 e0       	ldi	r25, 0x00	; 0
+    3e76:	98 2f       	mov	r25, r24
+    3e78:	88 27       	eor	r24, r24
+    3e7a:	80 2b       	or	r24, r16
+    3e7c:	91 2b       	or	r25, r17
+      address += address; // Convert from word address to byte address
+    3e7e:	88 0f       	add	r24, r24
+    3e80:	99 1f       	adc	r25, r25
+    3e82:	90 93 01 02 	sts	0x0201, r25
+    3e86:	80 93 00 02 	sts	0x0200, r24
+    3e8a:	73 c0       	rjmp	.+230    	; 0x3f72 <main+0x172>
+      verifySpace();
+    }
+    else if(ch == STK_UNIVERSAL) {
+    3e8c:	86 35       	cpi	r24, 0x56	; 86
+    3e8e:	29 f4       	brne	.+10     	; 0x3e9a <main+0x9a>
+      // UNIVERSAL command is ignored
+      getNch(4);
+    3e90:	84 e0       	ldi	r24, 0x04	; 4
+    3e92:	ac d0       	rcall	.+344    	; 0x3fec <verifySpace+0xc>
+      putch(0x00);
+    3e94:	80 e0       	ldi	r24, 0x00	; 0
+    3e96:	71 d0       	rcall	.+226    	; 0x3f7a <putch>
+    3e98:	6d c0       	rjmp	.+218    	; 0x3f74 <main+0x174>
+    }
+    /* Write memory, length is big endian and is in bytes  */
+    else if(ch == STK_PROG_PAGE) {
+    3e9a:	84 36       	cpi	r24, 0x64	; 100
+    3e9c:	09 f0       	breq	.+2      	; 0x3ea0 <main+0xa0>
+    3e9e:	43 c0       	rjmp	.+134    	; 0x3f26 <main+0x126>
+      // PROGRAM PAGE - we support flash programming only, not EEPROM
+      uint8_t *bufPtr;
+      uint16_t addrPtr;
+
+      getLen();
+    3ea0:	8f d0       	rcall	.+286    	; 0x3fc0 <getLen>
+
+      // Immediately start page erase - this will 4.5ms
+      boot_page_erase((uint16_t)(void*)address);
+    3ea2:	e0 91 00 02 	lds	r30, 0x0200
+    3ea6:	f0 91 01 02 	lds	r31, 0x0201
+    3eaa:	83 e0       	ldi	r24, 0x03	; 3
+    3eac:	80 93 57 00 	sts	0x0057, r24
+    3eb0:	e8 95       	spm
+    3eb2:	c0 e0       	ldi	r28, 0x00	; 0
+    3eb4:	d1 e0       	ldi	r29, 0x01	; 1
+
+      // While that is going on, read in page contents
+      bufPtr = buff;
+      do *bufPtr++ = getch();
+    3eb6:	70 d0       	rcall	.+224    	; 0x3f98 <getch>
+    3eb8:	89 93       	st	Y+, r24
+      while (--length);
+    3eba:	80 91 02 02 	lds	r24, 0x0202
+    3ebe:	81 50       	subi	r24, 0x01	; 1
+    3ec0:	80 93 02 02 	sts	0x0202, r24
+    3ec4:	88 23       	and	r24, r24
+    3ec6:	b9 f7       	brne	.-18     	; 0x3eb6 <main+0xb6>
+
+      // Read command terminator, start reply
+      verifySpace();
+    3ec8:	8b d0       	rcall	.+278    	; 0x3fe0 <verifySpace>
+      
+      // If only a partial page is to be programmed, the erase might not be complete.
+      // So check that here
+      boot_spm_busy_wait();
+    3eca:	07 b6       	in	r0, 0x37	; 55
+    3ecc:	00 fc       	sbrc	r0, 0
+    3ece:	fd cf       	rjmp	.-6      	; 0x3eca <main+0xca>
+      }
+#endif
+
+      // Copy buffer into programming buffer
+      bufPtr = buff;
+      addrPtr = (uint16_t)(void*)address;
+    3ed0:	40 91 00 02 	lds	r20, 0x0200
+    3ed4:	50 91 01 02 	lds	r21, 0x0201
+    3ed8:	a0 e0       	ldi	r26, 0x00	; 0
+    3eda:	b1 e0       	ldi	r27, 0x01	; 1
+      ch = SPM_PAGESIZE / 2;
+      do {
+        uint16_t a;
+        a = *bufPtr++;
+    3edc:	2c 91       	ld	r18, X
+    3ede:	30 e0       	ldi	r19, 0x00	; 0
+        a |= (*bufPtr++) << 8;
+    3ee0:	11 96       	adiw	r26, 0x01	; 1
+    3ee2:	8c 91       	ld	r24, X
+    3ee4:	11 97       	sbiw	r26, 0x01	; 1
+    3ee6:	90 e0       	ldi	r25, 0x00	; 0
+    3ee8:	98 2f       	mov	r25, r24
+    3eea:	88 27       	eor	r24, r24
+    3eec:	82 2b       	or	r24, r18
+    3eee:	93 2b       	or	r25, r19
+#ifdef VIRTUAL_BOOT_PARTITION
+#define rstVect (*(uint16_t*)(0x204))
+#define wdtVect (*(uint16_t*)(0x206))
+#endif
+/* main program starts here */
+int main(void) {
+    3ef0:	12 96       	adiw	r26, 0x02	; 2
+      ch = SPM_PAGESIZE / 2;
+      do {
+        uint16_t a;
+        a = *bufPtr++;
+        a |= (*bufPtr++) << 8;
+        boot_page_fill((uint16_t)(void*)addrPtr,a);
+    3ef2:	fa 01       	movw	r30, r20
+    3ef4:	0c 01       	movw	r0, r24
+    3ef6:	d0 92 57 00 	sts	0x0057, r13
+    3efa:	e8 95       	spm
+    3efc:	11 24       	eor	r1, r1
+        addrPtr += 2;
+    3efe:	4e 5f       	subi	r20, 0xFE	; 254
+    3f00:	5f 4f       	sbci	r21, 0xFF	; 255
+      } while (--ch);
+    3f02:	f1 e0       	ldi	r31, 0x01	; 1
+    3f04:	a0 38       	cpi	r26, 0x80	; 128
+    3f06:	bf 07       	cpc	r27, r31
+    3f08:	49 f7       	brne	.-46     	; 0x3edc <main+0xdc>
+      
+      // Write from programming buffer
+      boot_page_write((uint16_t)(void*)address);
+    3f0a:	e0 91 00 02 	lds	r30, 0x0200
+    3f0e:	f0 91 01 02 	lds	r31, 0x0201
+    3f12:	e0 92 57 00 	sts	0x0057, r14
+    3f16:	e8 95       	spm
+      boot_spm_busy_wait();
+    3f18:	07 b6       	in	r0, 0x37	; 55
+    3f1a:	00 fc       	sbrc	r0, 0
+    3f1c:	fd cf       	rjmp	.-6      	; 0x3f18 <main+0x118>
+
+#if defined(RWWSRE)
+      // Reenable read access to flash
+      boot_rww_enable();
+    3f1e:	f0 92 57 00 	sts	0x0057, r15
+    3f22:	e8 95       	spm
+    3f24:	27 c0       	rjmp	.+78     	; 0x3f74 <main+0x174>
+#endif
+
+    }
+    /* Read memory block mode, length is big endian.  */
+    else if(ch == STK_READ_PAGE) {
+    3f26:	84 37       	cpi	r24, 0x74	; 116
+    3f28:	b9 f4       	brne	.+46     	; 0x3f58 <main+0x158>
+      // READ PAGE - we only read flash
+      getLen();
+    3f2a:	4a d0       	rcall	.+148    	; 0x3fc0 <getLen>
+      verifySpace();
+    3f2c:	59 d0       	rcall	.+178    	; 0x3fe0 <verifySpace>
+        else ch = pgm_read_byte_near(address);
+        address++;
+        putch(ch);
+      } while (--length);
+#else
+      do putch(pgm_read_byte_near(address++));
+    3f2e:	e0 91 00 02 	lds	r30, 0x0200
+    3f32:	f0 91 01 02 	lds	r31, 0x0201
+    3f36:	31 96       	adiw	r30, 0x01	; 1
+    3f38:	f0 93 01 02 	sts	0x0201, r31
+    3f3c:	e0 93 00 02 	sts	0x0200, r30
+    3f40:	31 97       	sbiw	r30, 0x01	; 1
+    3f42:	e4 91       	lpm	r30, Z+
+    3f44:	8e 2f       	mov	r24, r30
+    3f46:	19 d0       	rcall	.+50     	; 0x3f7a <putch>
+      while (--length);
+    3f48:	80 91 02 02 	lds	r24, 0x0202
+    3f4c:	81 50       	subi	r24, 0x01	; 1
+    3f4e:	80 93 02 02 	sts	0x0202, r24
+    3f52:	88 23       	and	r24, r24
+    3f54:	61 f7       	brne	.-40     	; 0x3f2e <main+0x12e>
+    3f56:	0e c0       	rjmp	.+28     	; 0x3f74 <main+0x174>
+#endif
+    }
+
+    /* Get device signature bytes  */
+    else if(ch == STK_READ_SIGN) {
+    3f58:	85 37       	cpi	r24, 0x75	; 117
+    3f5a:	39 f4       	brne	.+14     	; 0x3f6a <main+0x16a>
+      // READ SIGN - return what Avrdude wants to hear
+      verifySpace();
+    3f5c:	41 d0       	rcall	.+130    	; 0x3fe0 <verifySpace>
+      putch(SIGNATURE_0);
+    3f5e:	8e e1       	ldi	r24, 0x1E	; 30
+    3f60:	0c d0       	rcall	.+24     	; 0x3f7a <putch>
+      putch(SIGNATURE_1);
+    3f62:	84 e9       	ldi	r24, 0x94	; 148
+    3f64:	0a d0       	rcall	.+20     	; 0x3f7a <putch>
+      putch(SIGNATURE_2);
+    3f66:	86 e0       	ldi	r24, 0x06	; 6
+    3f68:	96 cf       	rjmp	.-212    	; 0x3e96 <main+0x96>
+    }
+    else if (ch == 'Q') {
+    3f6a:	81 35       	cpi	r24, 0x51	; 81
+    3f6c:	11 f4       	brne	.+4      	; 0x3f72 <main+0x172>
+      // Adaboot no-wait mod
+      watchdogConfig(WATCHDOG_16MS);
+    3f6e:	88 e0       	ldi	r24, 0x08	; 8
+    3f70:	2c d0       	rcall	.+88     	; 0x3fca <watchdogConfig>
+      verifySpace();
+    }
+    else {
+      // This covers the response to commands like STK_ENTER_PROGMODE
+      verifySpace();
+    3f72:	36 d0       	rcall	.+108    	; 0x3fe0 <verifySpace>
+    }
+    putch(STK_OK);
+    3f74:	80 e1       	ldi	r24, 0x10	; 16
+    3f76:	01 d0       	rcall	.+2      	; 0x3f7a <putch>
+    3f78:	63 cf       	rjmp	.-314    	; 0x3e40 <main+0x40>
+
+00003f7a <putch>:
+void putch(char ch) {
+#ifndef SOFT_UART
+  while (!(UCSR0A & _BV(UDRE0)));
+  UDR0 = ch;
+#else
+  __asm__ __volatile__ (
+    3f7a:	2a e0       	ldi	r18, 0x0A	; 10
+    3f7c:	30 e0       	ldi	r19, 0x00	; 0
+    3f7e:	80 95       	com	r24
+    3f80:	08 94       	sec
+    3f82:	10 f4       	brcc	.+4      	; 0x3f88 <putch+0xe>
+    3f84:	59 98       	cbi	0x0b, 1	; 11
+    3f86:	02 c0       	rjmp	.+4      	; 0x3f8c <putch+0x12>
+    3f88:	59 9a       	sbi	0x0b, 1	; 11
+    3f8a:	00 00       	nop
+    3f8c:	15 d0       	rcall	.+42     	; 0x3fb8 <uartDelay>
+    3f8e:	14 d0       	rcall	.+40     	; 0x3fb8 <uartDelay>
+    3f90:	86 95       	lsr	r24
+    3f92:	2a 95       	dec	r18
+    3f94:	b1 f7       	brne	.-20     	; 0x3f82 <putch+0x8>
+      [uartBit] "I" (UART_TX_BIT)
+    :
+      "r25"
+  );
+#endif
+}
+    3f96:	08 95       	ret
+
+00003f98 <getch>:
+  return getch();
+}
+
+// Watchdog functions. These are only safe with interrupts turned off.
+void watchdogReset() {
+  __asm__ __volatile__ (
+    3f98:	a8 95       	wdr
+#ifdef LED_DATA_FLASH
+  LED_PIN |= _BV(LED);
+#endif
+
+  return ch;
+}
+    3f9a:	29 e0       	ldi	r18, 0x09	; 9
+    3f9c:	30 e0       	ldi	r19, 0x00	; 0
+    3f9e:	48 99       	sbic	0x09, 0	; 9
+    3fa0:	fe cf       	rjmp	.-4      	; 0x3f9e <getch+0x6>
+    3fa2:	0a d0       	rcall	.+20     	; 0x3fb8 <uartDelay>
+    3fa4:	09 d0       	rcall	.+18     	; 0x3fb8 <uartDelay>
+    3fa6:	08 d0       	rcall	.+16     	; 0x3fb8 <uartDelay>
+    3fa8:	88 94       	clc
+    3faa:	48 99       	sbic	0x09, 0	; 9
+    3fac:	08 94       	sec
+    3fae:	2a 95       	dec	r18
+    3fb0:	11 f0       	breq	.+4      	; 0x3fb6 <getch+0x1e>
+    3fb2:	87 95       	ror	r24
+    3fb4:	f7 cf       	rjmp	.-18     	; 0x3fa4 <getch+0xc>
+    3fb6:	08 95       	ret
+
+00003fb8 <uartDelay>:
+#if UART_B_VALUE > 255
+#error Baud rate too slow for soft UART
+#endif
+
+void uartDelay() {
+  __asm__ __volatile__ (
+    3fb8:	98 e0       	ldi	r25, 0x08	; 8
+    3fba:	9a 95       	dec	r25
+    3fbc:	f1 f7       	brne	.-4      	; 0x3fba <uartDelay+0x2>
+    3fbe:	08 95       	ret
+
+00003fc0 <getLen>:
+  } while (--count);
+}
+#endif
+
+uint8_t getLen() {
+  getch();
+    3fc0:	eb df       	rcall	.-42     	; 0x3f98 <getch>
+  length = getch();
+    3fc2:	ea df       	rcall	.-44     	; 0x3f98 <getch>
+    3fc4:	80 93 02 02 	sts	0x0202, r24
+  return getch();
+}
+    3fc8:	e7 cf       	rjmp	.-50     	; 0x3f98 <getch>
+
+00003fca <watchdogConfig>:
+    "wdr\n"
+  );
+}
+
+void watchdogConfig(uint8_t x) {
+  WDTCSR = _BV(WDCE) | _BV(WDE);
+    3fca:	e0 e6       	ldi	r30, 0x60	; 96
+    3fcc:	f0 e0       	ldi	r31, 0x00	; 0
+    3fce:	98 e1       	ldi	r25, 0x18	; 24
+    3fd0:	90 83       	st	Z, r25
+  WDTCSR = x;
+    3fd2:	80 83       	st	Z, r24
+}
+    3fd4:	08 95       	ret
+
+00003fd6 <appStart>:
+
+void appStart() {
+  watchdogConfig(WATCHDOG_OFF);
+    3fd6:	80 e0       	ldi	r24, 0x00	; 0
+    3fd8:	f8 df       	rcall	.-16     	; 0x3fca <watchdogConfig>
+  __asm__ __volatile__ (
+    3fda:	ee 27       	eor	r30, r30
+    3fdc:	ff 27       	eor	r31, r31
+    3fde:	09 94       	ijmp
+
+00003fe0 <verifySpace>:
+  do getch(); while (--count);
+  verifySpace();
+}
+
+void verifySpace() {
+  if (getch() != CRC_EOP) appStart();
+    3fe0:	db df       	rcall	.-74     	; 0x3f98 <getch>
+    3fe2:	80 32       	cpi	r24, 0x20	; 32
+    3fe4:	09 f0       	breq	.+2      	; 0x3fe8 <verifySpace+0x8>
+    3fe6:	f7 df       	rcall	.-18     	; 0x3fd6 <appStart>
+  putch(STK_INSYNC);
+    3fe8:	84 e1       	ldi	r24, 0x14	; 20
+}
+    3fea:	c7 cf       	rjmp	.-114    	; 0x3f7a <putch>
+    ::[count] "M" (UART_B_VALUE)
+  );
+}
+#endif
+
+void getNch(uint8_t count) {
+    3fec:	1f 93       	push	r17
+    3fee:	18 2f       	mov	r17, r24
+
+00003ff0 <getNch>:
+  do getch(); while (--count);
+    3ff0:	d3 df       	rcall	.-90     	; 0x3f98 <getch>
+    3ff2:	11 50       	subi	r17, 0x01	; 1
+    3ff4:	e9 f7       	brne	.-6      	; 0x3ff0 <getNch>
+  verifySpace();
+    3ff6:	f4 df       	rcall	.-24     	; 0x3fe0 <verifySpace>
+}
+    3ff8:	1f 91       	pop	r17
+    3ffa:	08 95       	ret