Shrink code by using registers for variables "length" and "address"

http://code.google.com/p/optiboot/issues/detail?id=33

Fix high-value watchdog timeouts on ATmega8
http://code.google.com/p/optiboot/issues/detail?id=38

Change "start app on bad commands" code to start the app via the
watchdog timer, so that the app is always started with the chip
in fully reset state.
http://code.google.com/p/optiboot/issues/detail?id=37

1 files changed, 222 insertions, 217 deletions

diff --git a/bootloaders/optiboot/optiboot_pro_8MHz.lst b/bootloaders/optiboot/optiboot_pro_8MHz.lst
index 23d5e1a..d3d760e 100644
--- a/bootloaders/optiboot/optiboot_pro_8MHz.lst
+++ b/bootloaders/optiboot/optiboot_pro_8MHz.lst
@@ -3,27 +3,27 @@ optiboot_pro_8MHz.elf:     file format elf32-avr
 
 Sections:
 Idx Name          Size      VMA       LMA       File off  Algn
-  0 .text         000001fc  00003e00  00003e00  00000054  2**1
+  0 .text         000001da  00003e00  00003e00  00000054  2**1
                   CONTENTS, ALLOC, LOAD, READONLY, CODE
-  1 .version      00000002  00003ffe  00003ffe  00000250  2**0
+  1 .version      00000002  00003ffe  00003ffe  0000022e  2**0
                   CONTENTS, READONLY
-  2 .debug_aranges 00000028  00000000  00000000  00000252  2**0
+  2 .debug_aranges 00000028  00000000  00000000  00000230  2**0
                   CONTENTS, READONLY, DEBUGGING
-  3 .debug_pubnames 0000006a  00000000  00000000  0000027a  2**0
+  3 .debug_pubnames 0000005f  00000000  00000000  00000258  2**0
                   CONTENTS, READONLY, DEBUGGING
-  4 .debug_info   00000285  00000000  00000000  000002e4  2**0
+  4 .debug_info   0000028c  00000000  00000000  000002b7  2**0
                   CONTENTS, READONLY, DEBUGGING
-  5 .debug_abbrev 0000019f  00000000  00000000  00000569  2**0
+  5 .debug_abbrev 00000199  00000000  00000000  00000543  2**0
                   CONTENTS, READONLY, DEBUGGING
-  6 .debug_line   00000453  00000000  00000000  00000708  2**0
+  6 .debug_line   00000456  00000000  00000000  000006dc  2**0
                   CONTENTS, READONLY, DEBUGGING
-  7 .debug_frame  00000090  00000000  00000000  00000b5c  2**2
+  7 .debug_frame  00000080  00000000  00000000  00000b34  2**2
                   CONTENTS, READONLY, DEBUGGING
-  8 .debug_str    00000141  00000000  00000000  00000bec  2**0
+  8 .debug_str    00000149  00000000  00000000  00000bb4  2**0
                   CONTENTS, READONLY, DEBUGGING
-  9 .debug_loc    000001e1  00000000  00000000  00000d2d  2**0
+  9 .debug_loc    0000027e  00000000  00000000  00000cfd  2**0
                   CONTENTS, READONLY, DEBUGGING
- 10 .debug_ranges 00000068  00000000  00000000  00000f0e  2**0
+ 10 .debug_ranges 00000060  00000000  00000000  00000f7b  2**0
                   CONTENTS, READONLY, DEBUGGING
 
 Disassembly of section .text:
@@ -47,7 +47,7 @@ int main(void) {
     3e04:	14 be       	out	0x34, r1	; 52
   if (!(ch & _BV(EXTRF))) appStart();
     3e06:	81 ff       	sbrs	r24, 1
-    3e08:	e6 d0       	rcall	.+460    	; 0x3fd6 <appStart>
+    3e08:	e3 d0       	rcall	.+454    	; 0x3fd0 <appStart>
 
 #if LED_START_FLASHES > 0
   // Set up Timer 1 for timeout counter
@@ -77,7 +77,7 @@ int main(void) {
   // Set up watchdog to trigger after 500ms
   watchdogConfig(WATCHDOG_1S);
     3e28:	8e e0       	ldi	r24, 0x0E	; 14
-    3e2a:	cf d0       	rcall	.+414    	; 0x3fca <watchdogConfig>
+    3e2a:	bc d0       	rcall	.+376    	; 0x3fa4 <watchdogConfig>
 
   /* Set LED pin as output */
   LED_DDR |= _BV(LED);
@@ -111,8 +111,8 @@ void flash_led(uint8_t count) {
 #else
     LED_PIN |= _BV(LED);
     3e44:	1d 9a       	sbi	0x03, 5	; 3
-  return getch();
 }
+#endif
 
 // Watchdog functions. These are only safe with interrupts turned off.
 void watchdogReset() {
@@ -132,8 +132,8 @@ void watchdogReset() {
     if(ch == STK_GET_PARAMETER) {
       // GET PARAMETER returns a generic 0x03 reply - enough to keep Avrdude happy
       getNch(1);
-    3e4c:	dd 24       	eor	r13, r13
-    3e4e:	d3 94       	inc	r13
+    3e4c:	99 24       	eor	r9, r9
+    3e4e:	93 94       	inc	r9
         __boot_page_fill_short((uint16_t)(void*)addrPtr,a);
         addrPtr += 2;
       } while (--ch);
@@ -141,21 +141,21 @@ void watchdogReset() {
       // Write from programming buffer
       __boot_page_write_short((uint16_t)(void*)address);
     3e50:	a5 e0       	ldi	r26, 0x05	; 5
-    3e52:	ea 2e       	mov	r14, r26
+    3e52:	aa 2e       	mov	r10, r26
       boot_spm_busy_wait();
 
 #if defined(RWWSRE)
       // Reenable read access to flash
       boot_rww_enable();
     3e54:	f1 e1       	ldi	r31, 0x11	; 17
-    3e56:	ff 2e       	mov	r15, r31
+    3e56:	bf 2e       	mov	r11, r31
 #endif
 
   /* Forever loop */
   for (;;) {
     /* get character from UART */
     ch = getch();
-    3e58:	ab d0       	rcall	.+342    	; 0x3fb0 <getch>
+    3e58:	9d d0       	rcall	.+314    	; 0x3f94 <getch>
 
     if(ch == STK_GET_PARAMETER) {
     3e5a:	81 34       	cpi	r24, 0x41	; 65
@@ -163,10 +163,10 @@ void watchdogReset() {
       // GET PARAMETER returns a generic 0x03 reply - enough to keep Avrdude happy
       getNch(1);
     3e5e:	81 e0       	ldi	r24, 0x01	; 1
-    3e60:	c5 d0       	rcall	.+394    	; 0x3fec <getNch>
+    3e60:	af d0       	rcall	.+350    	; 0x3fc0 <getNch>
       putch(0x03);
     3e62:	83 e0       	ldi	r24, 0x03	; 3
-    3e64:	20 c0       	rjmp	.+64     	; 0x3ea6 <main+0xa6>
+    3e64:	1f c0       	rjmp	.+62     	; 0x3ea4 <main+0xa4>
     }
     else if(ch == STK_SET_DEVICE) {
     3e66:	82 34       	cpi	r24, 0x42	; 66
@@ -182,71 +182,77 @@ void watchdogReset() {
       // SET DEVICE EXT is ignored
       getNch(5);
     3e72:	85 e0       	ldi	r24, 0x05	; 5
-    3e74:	bb d0       	rcall	.+374    	; 0x3fec <getNch>
-    3e76:	91 c0       	rjmp	.+290    	; 0x3f9a <main+0x19a>
+    3e74:	a5 d0       	rcall	.+330    	; 0x3fc0 <getNch>
+    3e76:	83 c0       	rjmp	.+262    	; 0x3f7e <main+0x17e>
     }
     else if(ch == STK_LOAD_ADDRESS) {
     3e78:	85 35       	cpi	r24, 0x55	; 85
-    3e7a:	81 f4       	brne	.+32     	; 0x3e9c <main+0x9c>
+    3e7a:	79 f4       	brne	.+30     	; 0x3e9a <main+0x9a>
       // LOAD ADDRESS
       uint16_t newAddress;
       newAddress = getch();
-    3e7c:	99 d0       	rcall	.+306    	; 0x3fb0 <getch>
+    3e7c:	8b d0       	rcall	.+278    	; 0x3f94 <getch>
       newAddress = (newAddress & 0xff) | (getch() << 8);
-    3e7e:	08 2f       	mov	r16, r24
-    3e80:	10 e0       	ldi	r17, 0x00	; 0
-    3e82:	96 d0       	rcall	.+300    	; 0x3fb0 <getch>
-    3e84:	90 e0       	ldi	r25, 0x00	; 0
-    3e86:	98 2f       	mov	r25, r24
-    3e88:	88 27       	eor	r24, r24
-    3e8a:	80 2b       	or	r24, r16
-    3e8c:	91 2b       	or	r25, r17
+    3e7e:	e8 2e       	mov	r14, r24
+    3e80:	ff 24       	eor	r15, r15
+    3e82:	88 d0       	rcall	.+272    	; 0x3f94 <getch>
+    3e84:	08 2f       	mov	r16, r24
+    3e86:	10 e0       	ldi	r17, 0x00	; 0
+    3e88:	10 2f       	mov	r17, r16
+    3e8a:	00 27       	eor	r16, r16
+    3e8c:	0e 29       	or	r16, r14
+    3e8e:	1f 29       	or	r17, r15
 #ifdef RAMPZ
       // Transfer top bit to RAMPZ
       RAMPZ = (newAddress & 0x8000) ? 1 : 0;
 #endif
       newAddress += newAddress; // Convert from word address to byte address
-    3e8e:	88 0f       	add	r24, r24
-    3e90:	99 1f       	adc	r25, r25
+    3e90:	00 0f       	add	r16, r16
+    3e92:	11 1f       	adc	r17, r17
       address = newAddress;
-    3e92:	90 93 01 02 	sts	0x0201, r25
-    3e96:	80 93 00 02 	sts	0x0200, r24
-    3e9a:	7e c0       	rjmp	.+252    	; 0x3f98 <main+0x198>
       verifySpace();
+    3e94:	8d d0       	rcall	.+282    	; 0x3fb0 <verifySpace>
+    3e96:	68 01       	movw	r12, r16
+    3e98:	72 c0       	rjmp	.+228    	; 0x3f7e <main+0x17e>
     }
     else if(ch == STK_UNIVERSAL) {
-    3e9c:	86 35       	cpi	r24, 0x56	; 86
-    3e9e:	29 f4       	brne	.+10     	; 0x3eaa <main+0xaa>
+    3e9a:	86 35       	cpi	r24, 0x56	; 86
+    3e9c:	29 f4       	brne	.+10     	; 0x3ea8 <main+0xa8>
       // UNIVERSAL command is ignored
       getNch(4);
-    3ea0:	84 e0       	ldi	r24, 0x04	; 4
-    3ea2:	a4 d0       	rcall	.+328    	; 0x3fec <getNch>
+    3e9e:	84 e0       	ldi	r24, 0x04	; 4
+    3ea0:	8f d0       	rcall	.+286    	; 0x3fc0 <getNch>
       putch(0x00);
-    3ea4:	80 e0       	ldi	r24, 0x00	; 0
-    3ea6:	7c d0       	rcall	.+248    	; 0x3fa0 <putch>
-    3ea8:	78 c0       	rjmp	.+240    	; 0x3f9a <main+0x19a>
+    3ea2:	80 e0       	ldi	r24, 0x00	; 0
+    3ea4:	6f d0       	rcall	.+222    	; 0x3f84 <putch>
+    3ea6:	6b c0       	rjmp	.+214    	; 0x3f7e <main+0x17e>
     }
     /* Write memory, length is big endian and is in bytes */
     else if(ch == STK_PROG_PAGE) {
-    3eaa:	84 36       	cpi	r24, 0x64	; 100
-    3eac:	09 f0       	breq	.+2      	; 0x3eb0 <main+0xb0>
-    3eae:	4e c0       	rjmp	.+156    	; 0x3f4c <main+0x14c>
+    3ea8:	84 36       	cpi	r24, 0x64	; 100
+    3eaa:	09 f0       	breq	.+2      	; 0x3eae <main+0xae>
+    3eac:	42 c0       	rjmp	.+132    	; 0x3f32 <main+0x132>
       // PROGRAM PAGE - we support flash programming only, not EEPROM
       uint8_t *bufPtr;
       uint16_t addrPtr;
 
-      getLen();
-    3eb0:	87 d0       	rcall	.+270    	; 0x3fc0 <getLen>
+      getch();			/* getlen() */
+    3eae:	72 d0       	rcall	.+228    	; 0x3f94 <getch>
+      length = getch();
+    3eb0:	71 d0       	rcall	.+226    	; 0x3f94 <getch>
+    3eb2:	08 2f       	mov	r16, r24
+      getch();
+    3eb4:	6f d0       	rcall	.+222    	; 0x3f94 <getch>
 
       // If we are in RWW section, immediately start page erase
       if (address < NRWWSTART) __boot_page_erase_short((uint16_t)(void*)address);
-    3eb2:	e0 91 00 02 	lds	r30, 0x0200
-    3eb6:	f0 91 01 02 	lds	r31, 0x0201
+    3eb6:	80 e0       	ldi	r24, 0x00	; 0
+    3eb8:	c8 16       	cp	r12, r24
     3eba:	88 e3       	ldi	r24, 0x38	; 56
-    3ebc:	e0 30       	cpi	r30, 0x00	; 0
-    3ebe:	f8 07       	cpc	r31, r24
-    3ec0:	18 f4       	brcc	.+6      	; 0x3ec8 <main+0xc8>
-    3ec2:	83 e0       	ldi	r24, 0x03	; 3
+    3ebc:	d8 06       	cpc	r13, r24
+    3ebe:	20 f4       	brcc	.+8      	; 0x3ec8 <main+0xc8>
+    3ec0:	83 e0       	ldi	r24, 0x03	; 3
+    3ec2:	f6 01       	movw	r30, r12
     3ec4:	87 bf       	out	0x37, r24	; 55
     3ec6:	e8 95       	spm
     3ec8:	c0 e0       	ldi	r28, 0x00	; 0
@@ -255,302 +261,301 @@ void watchdogReset() {
       // While that is going on, read in page contents
       bufPtr = buff;
       do *bufPtr++ = getch();
-    3ecc:	71 d0       	rcall	.+226    	; 0x3fb0 <getch>
+    3ecc:	63 d0       	rcall	.+198    	; 0x3f94 <getch>
     3ece:	89 93       	st	Y+, r24
       while (--length);
-    3ed0:	80 91 02 02 	lds	r24, 0x0202
-    3ed4:	81 50       	subi	r24, 0x01	; 1
-    3ed6:	80 93 02 02 	sts	0x0202, r24
-    3eda:	88 23       	and	r24, r24
-    3edc:	b9 f7       	brne	.-18     	; 0x3ecc <main+0xcc>
+    3ed0:	0c 17       	cp	r16, r28
+    3ed2:	e1 f7       	brne	.-8      	; 0x3ecc <main+0xcc>
 
       // If we are in NRWW section, page erase has to be delayed until now.
       // Todo: Take RAMPZ into account
       if (address >= NRWWSTART) __boot_page_erase_short((uint16_t)(void*)address);
-    3ede:	e0 91 00 02 	lds	r30, 0x0200
-    3ee2:	f0 91 01 02 	lds	r31, 0x0201
-    3ee6:	88 e3       	ldi	r24, 0x38	; 56
-    3ee8:	e0 30       	cpi	r30, 0x00	; 0
-    3eea:	f8 07       	cpc	r31, r24
-    3eec:	18 f0       	brcs	.+6      	; 0x3ef4 <main+0xf4>
-    3eee:	83 e0       	ldi	r24, 0x03	; 3
-    3ef0:	87 bf       	out	0x37, r24	; 55
-    3ef2:	e8 95       	spm
+    3ed4:	f0 e0       	ldi	r31, 0x00	; 0
+    3ed6:	cf 16       	cp	r12, r31
+    3ed8:	f8 e3       	ldi	r31, 0x38	; 56
+    3eda:	df 06       	cpc	r13, r31
+    3edc:	20 f0       	brcs	.+8      	; 0x3ee6 <main+0xe6>
+    3ede:	83 e0       	ldi	r24, 0x03	; 3
+    3ee0:	f6 01       	movw	r30, r12
+    3ee2:	87 bf       	out	0x37, r24	; 55
+    3ee4:	e8 95       	spm
 
       // Read command terminator, start reply
       verifySpace();
-    3ef4:	75 d0       	rcall	.+234    	; 0x3fe0 <verifySpace>
+    3ee6:	64 d0       	rcall	.+200    	; 0x3fb0 <verifySpace>
 
       // If only a partial page is to be programmed, the erase might not be complete.
       // So check that here
       boot_spm_busy_wait();
-    3ef6:	07 b6       	in	r0, 0x37	; 55
-    3ef8:	00 fc       	sbrc	r0, 0
-    3efa:	fd cf       	rjmp	.-6      	; 0x3ef6 <main+0xf6>
-      }
-#endif
-
-      // Copy buffer into programming buffer
+    3ee8:	07 b6       	in	r0, 0x37	; 55
+    3eea:	00 fc       	sbrc	r0, 0
+    3eec:	fd cf       	rjmp	.-6      	; 0x3ee8 <main+0xe8>
+    3eee:	a6 01       	movw	r20, r12
+    3ef0:	a0 e0       	ldi	r26, 0x00	; 0
+    3ef2:	b1 e0       	ldi	r27, 0x01	; 1
       bufPtr = buff;
       addrPtr = (uint16_t)(void*)address;
-    3efc:	40 91 00 02 	lds	r20, 0x0200
-    3f00:	50 91 01 02 	lds	r21, 0x0201
-    3f04:	a0 e0       	ldi	r26, 0x00	; 0
-    3f06:	b1 e0       	ldi	r27, 0x01	; 1
       ch = SPM_PAGESIZE / 2;
       do {
         uint16_t a;
         a = *bufPtr++;
-    3f08:	2c 91       	ld	r18, X
-    3f0a:	30 e0       	ldi	r19, 0x00	; 0
+    3ef4:	2c 91       	ld	r18, X
+    3ef6:	30 e0       	ldi	r19, 0x00	; 0
         a |= (*bufPtr++) << 8;
-    3f0c:	11 96       	adiw	r26, 0x01	; 1
-    3f0e:	8c 91       	ld	r24, X
-    3f10:	11 97       	sbiw	r26, 0x01	; 1
-    3f12:	90 e0       	ldi	r25, 0x00	; 0
-    3f14:	98 2f       	mov	r25, r24
-    3f16:	88 27       	eor	r24, r24
-    3f18:	82 2b       	or	r24, r18
-    3f1a:	93 2b       	or	r25, r19
+    3ef8:	11 96       	adiw	r26, 0x01	; 1
+    3efa:	8c 91       	ld	r24, X
+    3efc:	11 97       	sbiw	r26, 0x01	; 1
+    3efe:	90 e0       	ldi	r25, 0x00	; 0
+    3f00:	98 2f       	mov	r25, r24
+    3f02:	88 27       	eor	r24, r24
+    3f04:	82 2b       	or	r24, r18
+    3f06:	93 2b       	or	r25, r19
 #define rstVect (*(uint16_t*)(RAMSTART+SPM_PAGESIZE*2+4))
 #define wdtVect (*(uint16_t*)(RAMSTART+SPM_PAGESIZE*2+6))
 #endif
 
 /* main program starts here */
 int main(void) {
-    3f1c:	12 96       	adiw	r26, 0x02	; 2
+    3f08:	12 96       	adiw	r26, 0x02	; 2
       ch = SPM_PAGESIZE / 2;
       do {
         uint16_t a;
         a = *bufPtr++;
         a |= (*bufPtr++) << 8;
         __boot_page_fill_short((uint16_t)(void*)addrPtr,a);
-    3f1e:	fa 01       	movw	r30, r20
-    3f20:	0c 01       	movw	r0, r24
-    3f22:	d7 be       	out	0x37, r13	; 55
-    3f24:	e8 95       	spm
-    3f26:	11 24       	eor	r1, r1
+    3f0a:	fa 01       	movw	r30, r20
+    3f0c:	0c 01       	movw	r0, r24
+    3f0e:	97 be       	out	0x37, r9	; 55
+    3f10:	e8 95       	spm
+    3f12:	11 24       	eor	r1, r1
         addrPtr += 2;
-    3f28:	4e 5f       	subi	r20, 0xFE	; 254
-    3f2a:	5f 4f       	sbci	r21, 0xFF	; 255
+    3f14:	4e 5f       	subi	r20, 0xFE	; 254
+    3f16:	5f 4f       	sbci	r21, 0xFF	; 255
       } while (--ch);
-    3f2c:	f1 e0       	ldi	r31, 0x01	; 1
-    3f2e:	a0 38       	cpi	r26, 0x80	; 128
-    3f30:	bf 07       	cpc	r27, r31
-    3f32:	51 f7       	brne	.-44     	; 0x3f08 <main+0x108>
+    3f18:	f1 e0       	ldi	r31, 0x01	; 1
+    3f1a:	a0 38       	cpi	r26, 0x80	; 128
+    3f1c:	bf 07       	cpc	r27, r31
+    3f1e:	51 f7       	brne	.-44     	; 0x3ef4 <main+0xf4>
 
       // Write from programming buffer
       __boot_page_write_short((uint16_t)(void*)address);
-    3f34:	e0 91 00 02 	lds	r30, 0x0200
-    3f38:	f0 91 01 02 	lds	r31, 0x0201
-    3f3c:	e7 be       	out	0x37, r14	; 55
-    3f3e:	e8 95       	spm
+    3f20:	f6 01       	movw	r30, r12
+    3f22:	a7 be       	out	0x37, r10	; 55
+    3f24:	e8 95       	spm
       boot_spm_busy_wait();
-    3f40:	07 b6       	in	r0, 0x37	; 55
-    3f42:	00 fc       	sbrc	r0, 0
-    3f44:	fd cf       	rjmp	.-6      	; 0x3f40 <main+0x140>
+    3f26:	07 b6       	in	r0, 0x37	; 55
+    3f28:	00 fc       	sbrc	r0, 0
+    3f2a:	fd cf       	rjmp	.-6      	; 0x3f26 <main+0x126>
 
 #if defined(RWWSRE)
       // Reenable read access to flash
       boot_rww_enable();
-    3f46:	f7 be       	out	0x37, r15	; 55
-    3f48:	e8 95       	spm
-    3f4a:	27 c0       	rjmp	.+78     	; 0x3f9a <main+0x19a>
+    3f2c:	b7 be       	out	0x37, r11	; 55
+    3f2e:	e8 95       	spm
+    3f30:	26 c0       	rjmp	.+76     	; 0x3f7e <main+0x17e>
 #endif
 
     }
     /* Read memory block mode, length is big endian.  */
     else if(ch == STK_READ_PAGE) {
-    3f4c:	84 37       	cpi	r24, 0x74	; 116
-    3f4e:	b9 f4       	brne	.+46     	; 0x3f7e <main+0x17e>
+    3f32:	84 37       	cpi	r24, 0x74	; 116
+    3f34:	b1 f4       	brne	.+44     	; 0x3f62 <main+0x162>
       // READ PAGE - we only read flash
-      getLen();
-    3f50:	37 d0       	rcall	.+110    	; 0x3fc0 <getLen>
+      getch();			/* getlen() */
+    3f36:	2e d0       	rcall	.+92     	; 0x3f94 <getch>
+      length = getch();
+    3f38:	2d d0       	rcall	.+90     	; 0x3f94 <getch>
+    3f3a:	f8 2e       	mov	r15, r24
+      getch();
+    3f3c:	2b d0       	rcall	.+86     	; 0x3f94 <getch>
+
       verifySpace();
-    3f52:	46 d0       	rcall	.+140    	; 0x3fe0 <verifySpace>
+    3f3e:	38 d0       	rcall	.+112    	; 0x3fb0 <verifySpace>
+    3f40:	f6 01       	movw	r30, r12
+    3f42:	ef 2c       	mov	r14, r15
         putch(result);
         address++;
       }
       while (--length);
 #else
       do putch(pgm_read_byte_near(address++));
-    3f54:	e0 91 00 02 	lds	r30, 0x0200
-    3f58:	f0 91 01 02 	lds	r31, 0x0201
-    3f5c:	31 96       	adiw	r30, 0x01	; 1
-    3f5e:	f0 93 01 02 	sts	0x0201, r31
-    3f62:	e0 93 00 02 	sts	0x0200, r30
-    3f66:	31 97       	sbiw	r30, 0x01	; 1
-    3f68:	e4 91       	lpm	r30, Z+
-    3f6a:	8e 2f       	mov	r24, r30
-    3f6c:	19 d0       	rcall	.+50     	; 0x3fa0 <putch>
+    3f44:	8f 01       	movw	r16, r30
+    3f46:	0f 5f       	subi	r16, 0xFF	; 255
+    3f48:	1f 4f       	sbci	r17, 0xFF	; 255
+    3f4a:	84 91       	lpm	r24, Z+
+    3f4c:	1b d0       	rcall	.+54     	; 0x3f84 <putch>
       while (--length);
-    3f6e:	80 91 02 02 	lds	r24, 0x0202
-    3f72:	81 50       	subi	r24, 0x01	; 1
-    3f74:	80 93 02 02 	sts	0x0202, r24
-    3f78:	88 23       	and	r24, r24
-    3f7a:	61 f7       	brne	.-40     	; 0x3f54 <main+0x154>
-    3f7c:	0e c0       	rjmp	.+28     	; 0x3f9a <main+0x19a>
+    3f4e:	ea 94       	dec	r14
+    3f50:	f8 01       	movw	r30, r16
+    3f52:	c1 f7       	brne	.-16     	; 0x3f44 <main+0x144>
+#define rstVect (*(uint16_t*)(RAMSTART+SPM_PAGESIZE*2+4))
+#define wdtVect (*(uint16_t*)(RAMSTART+SPM_PAGESIZE*2+6))
+#endif
+
+/* main program starts here */
+int main(void) {
+    3f54:	08 94       	sec
+    3f56:	c1 1c       	adc	r12, r1
+    3f58:	d1 1c       	adc	r13, r1
+    3f5a:	fa 94       	dec	r15
+    3f5c:	cf 0c       	add	r12, r15
+    3f5e:	d1 1c       	adc	r13, r1
+    3f60:	0e c0       	rjmp	.+28     	; 0x3f7e <main+0x17e>
 #endif
 #endif
     }
 
     /* Get device signature bytes  */
     else if(ch == STK_READ_SIGN) {
-    3f7e:	85 37       	cpi	r24, 0x75	; 117
-    3f80:	39 f4       	brne	.+14     	; 0x3f90 <main+0x190>
+    3f62:	85 37       	cpi	r24, 0x75	; 117
+    3f64:	39 f4       	brne	.+14     	; 0x3f74 <main+0x174>
       // READ SIGN - return what Avrdude wants to hear
       verifySpace();
-    3f82:	2e d0       	rcall	.+92     	; 0x3fe0 <verifySpace>
+    3f66:	24 d0       	rcall	.+72     	; 0x3fb0 <verifySpace>
       putch(SIGNATURE_0);
-    3f84:	8e e1       	ldi	r24, 0x1E	; 30
-    3f86:	0c d0       	rcall	.+24     	; 0x3fa0 <putch>
+    3f68:	8e e1       	ldi	r24, 0x1E	; 30
+    3f6a:	0c d0       	rcall	.+24     	; 0x3f84 <putch>
       putch(SIGNATURE_1);
-    3f88:	84 e9       	ldi	r24, 0x94	; 148
-    3f8a:	0a d0       	rcall	.+20     	; 0x3fa0 <putch>
+    3f6c:	84 e9       	ldi	r24, 0x94	; 148
+    3f6e:	0a d0       	rcall	.+20     	; 0x3f84 <putch>
       putch(SIGNATURE_2);
-    3f8c:	86 e0       	ldi	r24, 0x06	; 6
-    3f8e:	8b cf       	rjmp	.-234    	; 0x3ea6 <main+0xa6>
+    3f70:	86 e0       	ldi	r24, 0x06	; 6
+    3f72:	98 cf       	rjmp	.-208    	; 0x3ea4 <main+0xa4>
     }
     else if (ch == 'Q') {
-    3f90:	81 35       	cpi	r24, 0x51	; 81
-    3f92:	11 f4       	brne	.+4      	; 0x3f98 <main+0x198>
+    3f74:	81 35       	cpi	r24, 0x51	; 81
+    3f76:	11 f4       	brne	.+4      	; 0x3f7c <main+0x17c>
       // Adaboot no-wait mod
       watchdogConfig(WATCHDOG_16MS);
-    3f94:	88 e0       	ldi	r24, 0x08	; 8
-    3f96:	19 d0       	rcall	.+50     	; 0x3fca <watchdogConfig>
+    3f78:	88 e0       	ldi	r24, 0x08	; 8
+    3f7a:	14 d0       	rcall	.+40     	; 0x3fa4 <watchdogConfig>
       verifySpace();
     }
     else {
       // This covers the response to commands like STK_ENTER_PROGMODE
       verifySpace();
-    3f98:	23 d0       	rcall	.+70     	; 0x3fe0 <verifySpace>
+    3f7c:	19 d0       	rcall	.+50     	; 0x3fb0 <verifySpace>
     }
     putch(STK_OK);
-    3f9a:	80 e1       	ldi	r24, 0x10	; 16
-    3f9c:	01 d0       	rcall	.+2      	; 0x3fa0 <putch>
-    3f9e:	5c cf       	rjmp	.-328    	; 0x3e58 <main+0x58>
+    3f7e:	80 e1       	ldi	r24, 0x10	; 16
+    3f80:	01 d0       	rcall	.+2      	; 0x3f84 <putch>
+    3f82:	6a cf       	rjmp	.-300    	; 0x3e58 <main+0x58>
 
-00003fa0 <putch>:
+00003f84 <putch>:
   }
 }
 
 void putch(char ch) {
-    3fa0:	98 2f       	mov	r25, r24
+    3f84:	98 2f       	mov	r25, r24
 #ifndef SOFT_UART
   while (!(UCSR0A & _BV(UDRE0)));
-    3fa2:	80 91 c0 00 	lds	r24, 0x00C0
-    3fa6:	85 ff       	sbrs	r24, 5
-    3fa8:	fc cf       	rjmp	.-8      	; 0x3fa2 <putch+0x2>
+    3f86:	80 91 c0 00 	lds	r24, 0x00C0
+    3f8a:	85 ff       	sbrs	r24, 5
+    3f8c:	fc cf       	rjmp	.-8      	; 0x3f86 <putch+0x2>
   UDR0 = ch;
-    3faa:	90 93 c6 00 	sts	0x00C6, r25
+    3f8e:	90 93 c6 00 	sts	0x00C6, r25
       [uartBit] "I" (UART_TX_BIT)
     :
       "r25"
   );
 #endif
 }
-    3fae:	08 95       	ret
+    3f92:	08 95       	ret
 
-00003fb0 <getch>:
-  return getch();
+00003f94 <getch>:
 }
+#endif
 
 // Watchdog functions. These are only safe with interrupts turned off.
 void watchdogReset() {
   __asm__ __volatile__ (
-    3fb0:	a8 95       	wdr
+    3f94:	a8 95       	wdr
       [uartBit] "I" (UART_RX_BIT)
     :
       "r25"
 );
 #else
   while(!(UCSR0A & _BV(RXC0)));
-    3fb2:	80 91 c0 00 	lds	r24, 0x00C0
-    3fb6:	87 ff       	sbrs	r24, 7
-    3fb8:	fc cf       	rjmp	.-8      	; 0x3fb2 <getch+0x2>
+    3f96:	80 91 c0 00 	lds	r24, 0x00C0
+    3f9a:	87 ff       	sbrs	r24, 7
+    3f9c:	fc cf       	rjmp	.-8      	; 0x3f96 <getch+0x2>
   ch = UDR0;
-    3fba:	80 91 c6 00 	lds	r24, 0x00C6
+    3f9e:	80 91 c6 00 	lds	r24, 0x00C6
   LED_PIN |= _BV(LED);
 #endif
 #endif
 
   return ch;
 }
-    3fbe:	08 95       	ret
-
-00003fc0 <getLen>:
-  } while (--count);
-}
-#endif
-
-uint8_t getLen() {
-  getch();
-    3fc0:	f7 df       	rcall	.-18     	; 0x3fb0 <getch>
-  length = getch();
-    3fc2:	f6 df       	rcall	.-20     	; 0x3fb0 <getch>
-    3fc4:	80 93 02 02 	sts	0x0202, r24
-  return getch();
-}
-    3fc8:	f3 cf       	rjmp	.-26     	; 0x3fb0 <getch>
+    3fa2:	08 95       	ret
 
-00003fca <watchdogConfig>:
+00003fa4 <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
+    3fa4:	e0 e6       	ldi	r30, 0x60	; 96
+    3fa6:	f0 e0       	ldi	r31, 0x00	; 0
+    3fa8:	98 e1       	ldi	r25, 0x18	; 24
+    3faa:	90 83       	st	Z, r25
   WDTCSR = x;
-    3fd2:	80 83       	st	Z, r24
+    3fac:	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
+    3fae:	08 95       	ret
 
-00003fe0 <verifySpace>:
+00003fb0 <verifySpace>:
   do getch(); while (--count);
   verifySpace();
 }
 
 void verifySpace() {
-  if (getch() != CRC_EOP) appStart();
-    3fe0:	e7 df       	rcall	.-50     	; 0x3fb0 <getch>
-    3fe2:	80 32       	cpi	r24, 0x20	; 32
-    3fe4:	09 f0       	breq	.+2      	; 0x3fe8 <verifySpace+0x8>
-    3fe6:	f7 df       	rcall	.-18     	; 0x3fd6 <appStart>
+  if (getch() != CRC_EOP) {
+    3fb0:	f1 df       	rcall	.-30     	; 0x3f94 <getch>
+    3fb2:	80 32       	cpi	r24, 0x20	; 32
+    3fb4:	19 f0       	breq	.+6      	; 0x3fbc <verifySpace+0xc>
+    watchdogConfig(WATCHDOG_16MS);    // shorten WD timeout
+    3fb6:	88 e0       	ldi	r24, 0x08	; 8
+    3fb8:	f5 df       	rcall	.-22     	; 0x3fa4 <watchdogConfig>
+    3fba:	ff cf       	rjmp	.-2      	; 0x3fba <verifySpace+0xa>
+    while (1)			      // and busy-loop so that WD causes
+      ;				      //  a reset and app start.
+  }
   putch(STK_INSYNC);
-    3fe8:	84 e1       	ldi	r24, 0x14	; 20
+    3fbc:	84 e1       	ldi	r24, 0x14	; 20
 }
-    3fea:	da cf       	rjmp	.-76     	; 0x3fa0 <putch>
+    3fbe:	e2 cf       	rjmp	.-60     	; 0x3f84 <putch>
 
-00003fec <getNch>:
+00003fc0 <getNch>:
     ::[count] "M" (UART_B_VALUE)
   );
 }
 #endif
 
 void getNch(uint8_t count) {
-    3fec:	1f 93       	push	r17
-    3fee:	18 2f       	mov	r17, r24
+    3fc0:	1f 93       	push	r17
+    3fc2:	18 2f       	mov	r17, r24
   do getch(); while (--count);
-    3ff0:	df df       	rcall	.-66     	; 0x3fb0 <getch>
-    3ff2:	11 50       	subi	r17, 0x01	; 1
-    3ff4:	e9 f7       	brne	.-6      	; 0x3ff0 <getNch+0x4>
+    3fc4:	e7 df       	rcall	.-50     	; 0x3f94 <getch>
+    3fc6:	11 50       	subi	r17, 0x01	; 1
+    3fc8:	e9 f7       	brne	.-6      	; 0x3fc4 <getNch+0x4>
   verifySpace();
-    3ff6:	f4 df       	rcall	.-24     	; 0x3fe0 <verifySpace>
+    3fca:	f2 df       	rcall	.-28     	; 0x3fb0 <verifySpace>
+}
+    3fcc:	1f 91       	pop	r17
+    3fce:	08 95       	ret
+
+00003fd0 <appStart>:
+  WDTCSR = _BV(WDCE) | _BV(WDE);
+  WDTCSR = x;
 }
-    3ff8:	1f 91       	pop	r17
-    3ffa:	08 95       	ret
+
+void appStart() {
+  watchdogConfig(WATCHDOG_OFF);
+    3fd0:	80 e0       	ldi	r24, 0x00	; 0
+    3fd2:	e8 df       	rcall	.-48     	; 0x3fa4 <watchdogConfig>
+  __asm__ __volatile__ (
+    3fd4:	ee 27       	eor	r30, r30
+    3fd6:	ff 27       	eor	r31, r31
+    3fd8:	09 94       	ijmp