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, 287 insertions, 287 deletions

diff --git a/bootloaders/optiboot/optiboot_luminet.lst b/bootloaders/optiboot/optiboot_luminet.lst
index 1be7e4f..8333670 100644
--- a/bootloaders/optiboot/optiboot_luminet.lst
+++ b/bootloaders/optiboot/optiboot_luminet.lst
@@ -3,27 +3,27 @@ optiboot_luminet.elf:     file format elf32-avr
 
 Sections:
 Idx Name          Size      VMA       LMA       File off  Algn
-  0 .version      00000002  00001efe  00001efe  000002c8  2**0
+  0 .version      00000002  00001efe  00001efe  00000298  2**0
                   CONTENTS, READONLY
-  1 .text         00000274  00000000  00000000  00000054  2**1
+  1 .text         00000244  00000000  00000000  00000054  2**1
                   CONTENTS, ALLOC, LOAD, READONLY, CODE
-  2 .debug_aranges 00000028  00000000  00000000  000002ca  2**0
+  2 .debug_aranges 00000028  00000000  00000000  0000029a  2**0
                   CONTENTS, READONLY, DEBUGGING
-  3 .debug_pubnames 00000078  00000000  00000000  000002f2  2**0
+  3 .debug_pubnames 0000006d  00000000  00000000  000002c2  2**0
                   CONTENTS, READONLY, DEBUGGING
-  4 .debug_info   000002a5  00000000  00000000  0000036a  2**0
+  4 .debug_info   000002b0  00000000  00000000  0000032f  2**0
                   CONTENTS, READONLY, DEBUGGING
-  5 .debug_abbrev 0000019d  00000000  00000000  0000060f  2**0
+  5 .debug_abbrev 00000197  00000000  00000000  000005df  2**0
                   CONTENTS, READONLY, DEBUGGING
-  6 .debug_line   000004ac  00000000  00000000  000007ac  2**0
+  6 .debug_line   000004a7  00000000  00000000  00000776  2**0
                   CONTENTS, READONLY, DEBUGGING
-  7 .debug_frame  000000a0  00000000  00000000  00000c58  2**2
+  7 .debug_frame  00000090  00000000  00000000  00000c20  2**2
                   CONTENTS, READONLY, DEBUGGING
-  8 .debug_str    00000150  00000000  00000000  00000cf8  2**0
+  8 .debug_str    00000158  00000000  00000000  00000cb0  2**0
                   CONTENTS, READONLY, DEBUGGING
-  9 .debug_loc    00000194  00000000  00000000  00000e48  2**0
+  9 .debug_loc    00000268  00000000  00000000  00000e08  2**0
                   CONTENTS, READONLY, DEBUGGING
- 10 .debug_ranges 00000088  00000000  00000000  00000fdc  2**0
+ 10 .debug_ranges 00000080  00000000  00000000  00001070  2**0
                   CONTENTS, READONLY, DEBUGGING
 
 Disassembly of section .text:
@@ -47,7 +47,7 @@ int main(void) {
    4:	14 be       	out	0x34, r1	; 52
   if (!(ch & _BV(EXTRF))) appStart();
    6:	81 ff       	sbrs	r24, 1
-   8:	22 d1       	rcall	.+580    	; 0x24e <appStart>
+   8:	18 d1       	rcall	.+560    	; 0x23a <appStart>
 
 #if LED_START_FLASHES > 0
   // Set up Timer 1 for timeout counter
@@ -61,7 +61,7 @@ int main(void) {
   // Set up watchdog to trigger after 500ms
   watchdogConfig(WATCHDOG_1S);
    e:	8e e0       	ldi	r24, 0x0E	; 14
-  10:	1a d1       	rcall	.+564    	; 0x246 <watchdogConfig>
+  10:	00 d1       	rcall	.+512    	; 0x212 <watchdogConfig>
 
   /* Set LED pin as output */
   LED_DDR |= _BV(LED);
@@ -100,8 +100,8 @@ void flash_led(uint8_t count) {
 #else
     LED_PIN |= _BV(LED);
   28:	cc 9a       	sbi	0x19, 4	; 25
-  return getch();
 }
+#endif
 
 // Watchdog functions. These are only safe with interrupts turned off.
 void watchdogReset() {
@@ -121,34 +121,34 @@ void watchdogReset() {
     if(ch == STK_GET_PARAMETER) {
       // GET PARAMETER returns a generic 0x03 reply - enough to keep Avrdude happy
       getNch(1);
-  30:	dd 24       	eor	r13, r13
-  32:	d3 94       	inc	r13
+  30:	bb 24       	eor	r11, r11
+  32:	b3 94       	inc	r11
         __boot_page_fill_short((uint16_t)(void*)addrPtr,a);
         addrPtr += 2;
       } while (--ch);
 
       // Write from programming buffer
       __boot_page_write_short((uint16_t)(void*)address);
-  34:	85 e0       	ldi	r24, 0x05	; 5
-  36:	c8 2e       	mov	r12, r24
+  34:	25 e0       	ldi	r18, 0x05	; 5
+  36:	a2 2e       	mov	r10, r18
         vect -= 4; // Instruction is a relative jump (rjmp), so recalculate.
         buff[8] = vect & 0xff;
         buff[9] = vect >> 8;
 
         // Add jump to bootloader at RESET vector
         buff[0] = 0x7f;
-  38:	0f e7       	ldi	r16, 0x7F	; 127
-  3a:	f0 2e       	mov	r15, r16
+  38:	9f e7       	ldi	r25, 0x7F	; 127
+  3a:	d9 2e       	mov	r13, r25
         buff[1] = 0xce; // rjmp 0x1d00 instruction
-  3c:	1e ec       	ldi	r17, 0xCE	; 206
-  3e:	e1 2e       	mov	r14, r17
+  3c:	8e ec       	ldi	r24, 0xCE	; 206
+  3e:	c8 2e       	mov	r12, r24
 #endif
 
   /* Forever loop */
   for (;;) {
     /* get character from UART */
     ch = getch();
-  40:	e9 d0       	rcall	.+466    	; 0x214 <getch>
+  40:	d4 d0       	rcall	.+424    	; 0x1ea <getch>
 
     if(ch == STK_GET_PARAMETER) {
   42:	81 34       	cpi	r24, 0x41	; 65
@@ -156,10 +156,10 @@ void watchdogReset() {
       // GET PARAMETER returns a generic 0x03 reply - enough to keep Avrdude happy
       getNch(1);
   46:	81 e0       	ldi	r24, 0x01	; 1
-  48:	0d d1       	rcall	.+538    	; 0x264 <getNch>
+  48:	f0 d0       	rcall	.+480    	; 0x22a <getNch>
       putch(0x03);
   4a:	83 e0       	ldi	r24, 0x03	; 3
-  4c:	20 c0       	rjmp	.+64     	; 0x8e <__SREG__+0x4f>
+  4c:	b5 c0       	rjmp	.+362    	; 0x1b8 <__SREG__+0x179>
     }
     else if(ch == STK_SET_DEVICE) {
   4e:	82 34       	cpi	r24, 0x42	; 66
@@ -175,450 +175,450 @@ void watchdogReset() {
       // SET DEVICE EXT is ignored
       getNch(5);
   5a:	85 e0       	ldi	r24, 0x05	; 5
-  5c:	03 d1       	rcall	.+518    	; 0x264 <getNch>
-  5e:	c8 c0       	rjmp	.+400    	; 0x1f0 <__SREG__+0x1b1>
+  5c:	e6 d0       	rcall	.+460    	; 0x22a <getNch>
+  5e:	b3 c0       	rjmp	.+358    	; 0x1c6 <__SREG__+0x187>
     }
     else if(ch == STK_LOAD_ADDRESS) {
   60:	85 35       	cpi	r24, 0x55	; 85
-  62:	81 f4       	brne	.+32     	; 0x84 <__SREG__+0x45>
+  62:	69 f4       	brne	.+26     	; 0x7e <__SREG__+0x3f>
       // LOAD ADDRESS
       uint16_t newAddress;
       newAddress = getch();
-  64:	d7 d0       	rcall	.+430    	; 0x214 <getch>
+  64:	c2 d0       	rcall	.+388    	; 0x1ea <getch>
       newAddress = (newAddress & 0xff) | (getch() << 8);
-  66:	08 2f       	mov	r16, r24
-  68:	10 e0       	ldi	r17, 0x00	; 0
-  6a:	d4 d0       	rcall	.+424    	; 0x214 <getch>
-  6c:	90 e0       	ldi	r25, 0x00	; 0
-  6e:	98 2f       	mov	r25, r24
-  70:	88 27       	eor	r24, r24
-  72:	80 2b       	or	r24, r16
-  74:	91 2b       	or	r25, r17
+  66:	e8 2e       	mov	r14, r24
+  68:	ff 24       	eor	r15, r15
+  6a:	bf d0       	rcall	.+382    	; 0x1ea <getch>
+  6c:	08 2f       	mov	r16, r24
+  6e:	10 e0       	ldi	r17, 0x00	; 0
+  70:	10 2f       	mov	r17, r16
+  72:	00 27       	eor	r16, r16
+  74:	0e 29       	or	r16, r14
+  76:	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
-  76:	88 0f       	add	r24, r24
-  78:	99 1f       	adc	r25, r25
+  78:	00 0f       	add	r16, r16
+  7a:	11 1f       	adc	r17, r17
+  7c:	a3 c0       	rjmp	.+326    	; 0x1c4 <__SREG__+0x185>
       address = newAddress;
-  7a:	90 93 81 01 	sts	0x0181, r25
-  7e:	80 93 80 01 	sts	0x0180, r24
-  82:	b5 c0       	rjmp	.+362    	; 0x1ee <__SREG__+0x1af>
       verifySpace();
     }
     else if(ch == STK_UNIVERSAL) {
-  84:	86 35       	cpi	r24, 0x56	; 86
-  86:	29 f4       	brne	.+10     	; 0x92 <__SREG__+0x53>
+  7e:	86 35       	cpi	r24, 0x56	; 86
+  80:	21 f4       	brne	.+8      	; 0x8a <__SREG__+0x4b>
       // UNIVERSAL command is ignored
       getNch(4);
-  88:	84 e0       	ldi	r24, 0x04	; 4
-  8a:	ec d0       	rcall	.+472    	; 0x264 <getNch>
+  82:	84 e0       	ldi	r24, 0x04	; 4
+  84:	d2 d0       	rcall	.+420    	; 0x22a <getNch>
       putch(0x00);
-  8c:	80 e0       	ldi	r24, 0x00	; 0
-  8e:	b3 d0       	rcall	.+358    	; 0x1f6 <putch>
-  90:	af c0       	rjmp	.+350    	; 0x1f0 <__SREG__+0x1b1>
+  86:	80 e0       	ldi	r24, 0x00	; 0
+  88:	97 c0       	rjmp	.+302    	; 0x1b8 <__SREG__+0x179>
     }
     /* Write memory, length is big endian and is in bytes */
     else if(ch == STK_PROG_PAGE) {
-  92:	84 36       	cpi	r24, 0x64	; 100
-  94:	09 f0       	breq	.+2      	; 0x98 <__SREG__+0x59>
-  96:	6b c0       	rjmp	.+214    	; 0x16e <__SREG__+0x12f>
+  8a:	84 36       	cpi	r24, 0x64	; 100
+  8c:	09 f0       	breq	.+2      	; 0x90 <__SREG__+0x51>
+  8e:	60 c0       	rjmp	.+192    	; 0x150 <__SREG__+0x111>
       // PROGRAM PAGE - we support flash programming only, not EEPROM
       uint8_t *bufPtr;
       uint16_t addrPtr;
 
-      getLen();
-  98:	d1 d0       	rcall	.+418    	; 0x23c <getLen>
-  9a:	c0 e0       	ldi	r28, 0x00	; 0
-  9c:	d1 e0       	ldi	r29, 0x01	; 1
+      getch();			/* getlen() */
+  90:	ac d0       	rcall	.+344    	; 0x1ea <getch>
+      length = getch();
+  92:	ab d0       	rcall	.+342    	; 0x1ea <getch>
+  94:	f8 2e       	mov	r15, r24
+      getch();
+  96:	a9 d0       	rcall	.+338    	; 0x1ea <getch>
+  98:	c0 e0       	ldi	r28, 0x00	; 0
+  9a:	d1 e0       	ldi	r29, 0x01	; 1
       // If we are in RWW section, immediately start page erase
       if (address < NRWWSTART) __boot_page_erase_short((uint16_t)(void*)address);
 
       // While that is going on, read in page contents
       bufPtr = buff;
       do *bufPtr++ = getch();
-  9e:	ba d0       	rcall	.+372    	; 0x214 <getch>
-  a0:	89 93       	st	Y+, r24
+  9c:	a6 d0       	rcall	.+332    	; 0x1ea <getch>
+  9e:	89 93       	st	Y+, r24
       while (--length);
-  a2:	80 91 82 01 	lds	r24, 0x0182
-  a6:	81 50       	subi	r24, 0x01	; 1
-  a8:	80 93 82 01 	sts	0x0182, r24
-  ac:	88 23       	and	r24, r24
-  ae:	b9 f7       	brne	.-18     	; 0x9e <__SREG__+0x5f>
+  a0:	fc 16       	cp	r15, r28
+  a2:	e1 f7       	brne	.-8      	; 0x9c <__SREG__+0x5d>
 
       // 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);
-  b0:	e0 91 80 01 	lds	r30, 0x0180
-  b4:	f0 91 81 01 	lds	r31, 0x0181
-  b8:	83 e0       	ldi	r24, 0x03	; 3
-  ba:	87 bf       	out	0x37, r24	; 55
-  bc:	e8 95       	spm
+  a4:	83 e0       	ldi	r24, 0x03	; 3
+  a6:	f8 01       	movw	r30, r16
+  a8:	87 bf       	out	0x37, r24	; 55
+  aa:	e8 95       	spm
 
       // Read command terminator, start reply
       verifySpace();
-  be:	cc d0       	rcall	.+408    	; 0x258 <verifySpace>
+  ac:	b6 d0       	rcall	.+364    	; 0x21a <verifySpace>
 
       // If only a partial page is to be programmed, the erase might not be complete.
       // So check that here
       boot_spm_busy_wait();
-  c0:	07 b6       	in	r0, 0x37	; 55
-  c2:	00 fc       	sbrc	r0, 0
-  c4:	fd cf       	rjmp	.-6      	; 0xc0 <__SREG__+0x81>
+  ae:	07 b6       	in	r0, 0x37	; 55
+  b0:	00 fc       	sbrc	r0, 0
+  b2:	fd cf       	rjmp	.-6      	; 0xae <__SREG__+0x6f>
 
 #ifdef VIRTUAL_BOOT_PARTITION
       if ((uint16_t)(void*)address == 0) {
-  c6:	80 91 80 01 	lds	r24, 0x0180
-  ca:	90 91 81 01 	lds	r25, 0x0181
-  ce:	89 2b       	or	r24, r25
-  d0:	41 f5       	brne	.+80     	; 0x122 <__SREG__+0xe3>
+  b4:	01 15       	cp	r16, r1
+  b6:	11 05       	cpc	r17, r1
+  b8:	11 f0       	breq	.+4      	; 0xbe <__SREG__+0x7f>
+  ba:	a8 01       	movw	r20, r16
+  bc:	2a c0       	rjmp	.+84     	; 0x112 <__SREG__+0xd3>
         // This is the reset vector page. We need to live-patch the code so the
         // bootloader runs.
         //
         // Move RESET vector to WDT vector
         uint16_t vect = buff[0] | (buff[1]<<8);
-  d2:	80 91 00 01 	lds	r24, 0x0100
-  d6:	20 91 01 01 	lds	r18, 0x0101
-  da:	30 e0       	ldi	r19, 0x00	; 0
-  dc:	32 2f       	mov	r19, r18
-  de:	22 27       	eor	r18, r18
-  e0:	90 e0       	ldi	r25, 0x00	; 0
-  e2:	28 2b       	or	r18, r24
-  e4:	39 2b       	or	r19, r25
+  be:	80 91 00 01 	lds	r24, 0x0100
+  c2:	20 91 01 01 	lds	r18, 0x0101
+  c6:	30 e0       	ldi	r19, 0x00	; 0
+  c8:	32 2f       	mov	r19, r18
+  ca:	22 27       	eor	r18, r18
+  cc:	90 e0       	ldi	r25, 0x00	; 0
+  ce:	28 2b       	or	r18, r24
+  d0:	39 2b       	or	r19, r25
         rstVect = vect;
-  e6:	30 93 85 01 	sts	0x0185, r19
-  ea:	20 93 84 01 	sts	0x0184, r18
+  d2:	30 93 85 01 	sts	0x0185, r19
+  d6:	20 93 84 01 	sts	0x0184, r18
         wdtVect = buff[8] | (buff[9]<<8);
-  ee:	40 91 08 01 	lds	r20, 0x0108
-  f2:	80 91 09 01 	lds	r24, 0x0109
-  f6:	90 e0       	ldi	r25, 0x00	; 0
-  f8:	98 2f       	mov	r25, r24
-  fa:	88 27       	eor	r24, r24
-  fc:	50 e0       	ldi	r21, 0x00	; 0
-  fe:	84 2b       	or	r24, r20
- 100:	95 2b       	or	r25, r21
- 102:	90 93 87 01 	sts	0x0187, r25
- 106:	80 93 86 01 	sts	0x0186, r24
+  da:	40 91 08 01 	lds	r20, 0x0108
+  de:	80 91 09 01 	lds	r24, 0x0109
+  e2:	90 e0       	ldi	r25, 0x00	; 0
+  e4:	98 2f       	mov	r25, r24
+  e6:	88 27       	eor	r24, r24
+  e8:	50 e0       	ldi	r21, 0x00	; 0
+  ea:	84 2b       	or	r24, r20
+  ec:	95 2b       	or	r25, r21
+  ee:	90 93 87 01 	sts	0x0187, r25
+  f2:	80 93 86 01 	sts	0x0186, r24
         vect -= 4; // Instruction is a relative jump (rjmp), so recalculate.
- 10a:	24 50       	subi	r18, 0x04	; 4
- 10c:	30 40       	sbci	r19, 0x00	; 0
+  f6:	24 50       	subi	r18, 0x04	; 4
+  f8:	30 40       	sbci	r19, 0x00	; 0
         buff[8] = vect & 0xff;
- 10e:	20 93 08 01 	sts	0x0108, r18
+  fa:	20 93 08 01 	sts	0x0108, r18
         buff[9] = vect >> 8;
- 112:	23 2f       	mov	r18, r19
- 114:	33 27       	eor	r19, r19
- 116:	20 93 09 01 	sts	0x0109, r18
+  fe:	23 2f       	mov	r18, r19
+ 100:	33 27       	eor	r19, r19
+ 102:	20 93 09 01 	sts	0x0109, r18
 
         // Add jump to bootloader at RESET vector
         buff[0] = 0x7f;
- 11a:	f0 92 00 01 	sts	0x0100, r15
+ 106:	d0 92 00 01 	sts	0x0100, r13
         buff[1] = 0xce; // rjmp 0x1d00 instruction
- 11e:	e0 92 01 01 	sts	0x0101, r14
-      }
-#endif
-
-      // Copy buffer into programming buffer
+ 10a:	c0 92 01 01 	sts	0x0101, r12
+ 10e:	40 e0       	ldi	r20, 0x00	; 0
+ 110:	50 e0       	ldi	r21, 0x00	; 0
+ 112:	a0 e0       	ldi	r26, 0x00	; 0
+ 114:	b1 e0       	ldi	r27, 0x01	; 1
       bufPtr = buff;
       addrPtr = (uint16_t)(void*)address;
- 122:	40 91 80 01 	lds	r20, 0x0180
- 126:	50 91 81 01 	lds	r21, 0x0181
- 12a:	a0 e0       	ldi	r26, 0x00	; 0
- 12c:	b1 e0       	ldi	r27, 0x01	; 1
       ch = SPM_PAGESIZE / 2;
       do {
         uint16_t a;
         a = *bufPtr++;
- 12e:	2c 91       	ld	r18, X
- 130:	30 e0       	ldi	r19, 0x00	; 0
+ 116:	2c 91       	ld	r18, X
+ 118:	30 e0       	ldi	r19, 0x00	; 0
         a |= (*bufPtr++) << 8;
- 132:	11 96       	adiw	r26, 0x01	; 1
- 134:	8c 91       	ld	r24, X
- 136:	11 97       	sbiw	r26, 0x01	; 1
- 138:	90 e0       	ldi	r25, 0x00	; 0
- 13a:	98 2f       	mov	r25, r24
- 13c:	88 27       	eor	r24, r24
- 13e:	82 2b       	or	r24, r18
- 140:	93 2b       	or	r25, r19
+ 11a:	11 96       	adiw	r26, 0x01	; 1
+ 11c:	8c 91       	ld	r24, X
+ 11e:	11 97       	sbiw	r26, 0x01	; 1
+ 120:	90 e0       	ldi	r25, 0x00	; 0
+ 122:	98 2f       	mov	r25, r24
+ 124:	88 27       	eor	r24, r24
+ 126:	82 2b       	or	r24, r18
+ 128:	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) {
- 142:	12 96       	adiw	r26, 0x02	; 2
+ 12a:	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);
- 144:	fa 01       	movw	r30, r20
- 146:	0c 01       	movw	r0, r24
- 148:	d7 be       	out	0x37, r13	; 55
- 14a:	e8 95       	spm
- 14c:	11 24       	eor	r1, r1
+ 12c:	fa 01       	movw	r30, r20
+ 12e:	0c 01       	movw	r0, r24
+ 130:	b7 be       	out	0x37, r11	; 55
+ 132:	e8 95       	spm
+ 134:	11 24       	eor	r1, r1
         addrPtr += 2;
- 14e:	4e 5f       	subi	r20, 0xFE	; 254
- 150:	5f 4f       	sbci	r21, 0xFF	; 255
+ 136:	4e 5f       	subi	r20, 0xFE	; 254
+ 138:	5f 4f       	sbci	r21, 0xFF	; 255
       } while (--ch);
- 152:	f1 e0       	ldi	r31, 0x01	; 1
- 154:	a0 34       	cpi	r26, 0x40	; 64
- 156:	bf 07       	cpc	r27, r31
- 158:	51 f7       	brne	.-44     	; 0x12e <__SREG__+0xef>
+ 13a:	f1 e0       	ldi	r31, 0x01	; 1
+ 13c:	a0 34       	cpi	r26, 0x40	; 64
+ 13e:	bf 07       	cpc	r27, r31
+ 140:	51 f7       	brne	.-44     	; 0x116 <__SREG__+0xd7>
 
       // Write from programming buffer
       __boot_page_write_short((uint16_t)(void*)address);
- 15a:	e0 91 80 01 	lds	r30, 0x0180
- 15e:	f0 91 81 01 	lds	r31, 0x0181
- 162:	c7 be       	out	0x37, r12	; 55
- 164:	e8 95       	spm
+ 142:	f8 01       	movw	r30, r16
+ 144:	a7 be       	out	0x37, r10	; 55
+ 146:	e8 95       	spm
       boot_spm_busy_wait();
- 166:	07 b6       	in	r0, 0x37	; 55
- 168:	00 fc       	sbrc	r0, 0
- 16a:	fd cf       	rjmp	.-6      	; 0x166 <__SREG__+0x127>
- 16c:	41 c0       	rjmp	.+130    	; 0x1f0 <__SREG__+0x1b1>
+ 148:	07 b6       	in	r0, 0x37	; 55
+ 14a:	00 fc       	sbrc	r0, 0
+ 14c:	fd cf       	rjmp	.-6      	; 0x148 <__SREG__+0x109>
+ 14e:	3b c0       	rjmp	.+118    	; 0x1c6 <__SREG__+0x187>
       boot_rww_enable();
 #endif
 
     }
     /* Read memory block mode, length is big endian.  */
     else if(ch == STK_READ_PAGE) {
- 16e:	84 37       	cpi	r24, 0x74	; 116
- 170:	89 f5       	brne	.+98     	; 0x1d4 <__SREG__+0x195>
+ 150:	84 37       	cpi	r24, 0x74	; 116
+ 152:	51 f5       	brne	.+84     	; 0x1a8 <__SREG__+0x169>
       // READ PAGE - we only read flash
-      getLen();
- 172:	64 d0       	rcall	.+200    	; 0x23c <getLen>
+      getch();			/* getlen() */
+ 154:	4a d0       	rcall	.+148    	; 0x1ea <getch>
+      length = getch();
+ 156:	49 d0       	rcall	.+146    	; 0x1ea <getch>
+ 158:	f8 2e       	mov	r15, r24
+      getch();
+ 15a:	47 d0       	rcall	.+142    	; 0x1ea <getch>
+
       verifySpace();
- 174:	71 d0       	rcall	.+226    	; 0x258 <verifySpace>
+ 15c:	5e d0       	rcall	.+188    	; 0x21a <verifySpace>
+ 15e:	e8 01       	movw	r28, r16
+ 160:	ef 2c       	mov	r14, r15
 #ifdef VIRTUAL_BOOT_PARTITION
       do {
         // Undo vector patch in bottom page so verify passes
         if (address == 0)       ch=rstVect & 0xff;
- 176:	e0 91 80 01 	lds	r30, 0x0180
- 17a:	f0 91 81 01 	lds	r31, 0x0181
- 17e:	30 97       	sbiw	r30, 0x00	; 0
- 180:	19 f4       	brne	.+6      	; 0x188 <__SREG__+0x149>
- 182:	20 91 84 01 	lds	r18, 0x0184
- 186:	13 c0       	rjmp	.+38     	; 0x1ae <__SREG__+0x16f>
+ 162:	20 97       	sbiw	r28, 0x00	; 0
+ 164:	19 f4       	brne	.+6      	; 0x16c <__SREG__+0x12d>
+ 166:	80 91 84 01 	lds	r24, 0x0184
+ 16a:	14 c0       	rjmp	.+40     	; 0x194 <__SREG__+0x155>
         else if (address == 1)  ch=rstVect >> 8;
- 188:	e1 30       	cpi	r30, 0x01	; 1
- 18a:	f1 05       	cpc	r31, r1
- 18c:	19 f4       	brne	.+6      	; 0x194 <__SREG__+0x155>
- 18e:	20 91 85 01 	lds	r18, 0x0185
- 192:	0d c0       	rjmp	.+26     	; 0x1ae <__SREG__+0x16f>
+ 16c:	c1 30       	cpi	r28, 0x01	; 1
+ 16e:	d1 05       	cpc	r29, r1
+ 170:	19 f4       	brne	.+6      	; 0x178 <__SREG__+0x139>
+ 172:	80 91 85 01 	lds	r24, 0x0185
+ 176:	0e c0       	rjmp	.+28     	; 0x194 <__SREG__+0x155>
         else if (address == 8)  ch=wdtVect & 0xff;
- 194:	e8 30       	cpi	r30, 0x08	; 8
- 196:	f1 05       	cpc	r31, r1
- 198:	19 f4       	brne	.+6      	; 0x1a0 <__SREG__+0x161>
- 19a:	20 91 86 01 	lds	r18, 0x0186
- 19e:	07 c0       	rjmp	.+14     	; 0x1ae <__SREG__+0x16f>
+ 178:	c8 30       	cpi	r28, 0x08	; 8
+ 17a:	d1 05       	cpc	r29, r1
+ 17c:	19 f4       	brne	.+6      	; 0x184 <__SREG__+0x145>
+ 17e:	80 91 86 01 	lds	r24, 0x0186
+ 182:	08 c0       	rjmp	.+16     	; 0x194 <__SREG__+0x155>
         else if (address == 9) ch=wdtVect >> 8;
- 1a0:	e9 30       	cpi	r30, 0x09	; 9
- 1a2:	f1 05       	cpc	r31, r1
- 1a4:	19 f4       	brne	.+6      	; 0x1ac <__SREG__+0x16d>
- 1a6:	20 91 87 01 	lds	r18, 0x0187
- 1aa:	01 c0       	rjmp	.+2      	; 0x1ae <__SREG__+0x16f>
+ 184:	c9 30       	cpi	r28, 0x09	; 9
+ 186:	d1 05       	cpc	r29, r1
+ 188:	19 f4       	brne	.+6      	; 0x190 <__SREG__+0x151>
+ 18a:	80 91 87 01 	lds	r24, 0x0187
+ 18e:	02 c0       	rjmp	.+4      	; 0x194 <__SREG__+0x155>
         else ch = pgm_read_byte_near(address);
- 1ac:	24 91       	lpm	r18, Z+
+ 190:	fe 01       	movw	r30, r28
+ 192:	84 91       	lpm	r24, Z+
         address++;
- 1ae:	80 91 80 01 	lds	r24, 0x0180
- 1b2:	90 91 81 01 	lds	r25, 0x0181
- 1b6:	01 96       	adiw	r24, 0x01	; 1
- 1b8:	90 93 81 01 	sts	0x0181, r25
- 1bc:	80 93 80 01 	sts	0x0180, r24
+ 194:	21 96       	adiw	r28, 0x01	; 1
         putch(ch);
- 1c0:	82 2f       	mov	r24, r18
- 1c2:	19 d0       	rcall	.+50     	; 0x1f6 <putch>
+ 196:	1a d0       	rcall	.+52     	; 0x1cc <putch>
       } while (--length);
- 1c4:	80 91 82 01 	lds	r24, 0x0182
- 1c8:	81 50       	subi	r24, 0x01	; 1
- 1ca:	80 93 82 01 	sts	0x0182, r24
- 1ce:	88 23       	and	r24, r24
- 1d0:	91 f6       	brne	.-92     	; 0x176 <__SREG__+0x137>
- 1d2:	0e c0       	rjmp	.+28     	; 0x1f0 <__SREG__+0x1b1>
+ 198:	ea 94       	dec	r14
+ 19a:	19 f7       	brne	.-58     	; 0x162 <__SREG__+0x123>
+#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) {
+ 19c:	0f 5f       	subi	r16, 0xFF	; 255
+ 19e:	1f 4f       	sbci	r17, 0xFF	; 255
+ 1a0:	fa 94       	dec	r15
+ 1a2:	0f 0d       	add	r16, r15
+ 1a4:	11 1d       	adc	r17, r1
+ 1a6:	0f c0       	rjmp	.+30     	; 0x1c6 <__SREG__+0x187>
 #endif
 #endif
     }
 
     /* Get device signature bytes  */
     else if(ch == STK_READ_SIGN) {
- 1d4:	85 37       	cpi	r24, 0x75	; 117
- 1d6:	39 f4       	brne	.+14     	; 0x1e6 <__SREG__+0x1a7>
+ 1a8:	85 37       	cpi	r24, 0x75	; 117
+ 1aa:	41 f4       	brne	.+16     	; 0x1bc <__SREG__+0x17d>
       // READ SIGN - return what Avrdude wants to hear
       verifySpace();
- 1d8:	3f d0       	rcall	.+126    	; 0x258 <verifySpace>
+ 1ac:	36 d0       	rcall	.+108    	; 0x21a <verifySpace>
       putch(SIGNATURE_0);
- 1da:	8e e1       	ldi	r24, 0x1E	; 30
- 1dc:	0c d0       	rcall	.+24     	; 0x1f6 <putch>
+ 1ae:	8e e1       	ldi	r24, 0x1E	; 30
+ 1b0:	0d d0       	rcall	.+26     	; 0x1cc <putch>
       putch(SIGNATURE_1);
- 1de:	83 e9       	ldi	r24, 0x93	; 147
- 1e0:	0a d0       	rcall	.+20     	; 0x1f6 <putch>
+ 1b2:	83 e9       	ldi	r24, 0x93	; 147
+ 1b4:	0b d0       	rcall	.+22     	; 0x1cc <putch>
       putch(SIGNATURE_2);
- 1e2:	8c e0       	ldi	r24, 0x0C	; 12
- 1e4:	54 cf       	rjmp	.-344    	; 0x8e <__SREG__+0x4f>
+ 1b6:	8c e0       	ldi	r24, 0x0C	; 12
+ 1b8:	09 d0       	rcall	.+18     	; 0x1cc <putch>
+ 1ba:	05 c0       	rjmp	.+10     	; 0x1c6 <__SREG__+0x187>
     }
     else if (ch == 'Q') {
- 1e6:	81 35       	cpi	r24, 0x51	; 81
- 1e8:	11 f4       	brne	.+4      	; 0x1ee <__SREG__+0x1af>
+ 1bc:	81 35       	cpi	r24, 0x51	; 81
+ 1be:	11 f4       	brne	.+4      	; 0x1c4 <__SREG__+0x185>
       // Adaboot no-wait mod
       watchdogConfig(WATCHDOG_16MS);
- 1ea:	88 e0       	ldi	r24, 0x08	; 8
- 1ec:	2c d0       	rcall	.+88     	; 0x246 <watchdogConfig>
+ 1c0:	88 e0       	ldi	r24, 0x08	; 8
+ 1c2:	27 d0       	rcall	.+78     	; 0x212 <watchdogConfig>
       verifySpace();
     }
     else {
       // This covers the response to commands like STK_ENTER_PROGMODE
       verifySpace();
- 1ee:	34 d0       	rcall	.+104    	; 0x258 <verifySpace>
+ 1c4:	2a d0       	rcall	.+84     	; 0x21a <verifySpace>
     }
     putch(STK_OK);
- 1f0:	80 e1       	ldi	r24, 0x10	; 16
- 1f2:	01 d0       	rcall	.+2      	; 0x1f6 <putch>
- 1f4:	25 cf       	rjmp	.-438    	; 0x40 <__SREG__+0x1>
+ 1c6:	80 e1       	ldi	r24, 0x10	; 16
+ 1c8:	01 d0       	rcall	.+2      	; 0x1cc <putch>
+ 1ca:	3a cf       	rjmp	.-396    	; 0x40 <__SREG__+0x1>
 
-000001f6 <putch>:
+000001cc <putch>:
 void putch(char ch) {
 #ifndef SOFT_UART
   while (!(UCSR0A & _BV(UDRE0)));
   UDR0 = ch;
 #else
   __asm__ __volatile__ (
- 1f6:	2a e0       	ldi	r18, 0x0A	; 10
- 1f8:	30 e0       	ldi	r19, 0x00	; 0
- 1fa:	80 95       	com	r24
- 1fc:	08 94       	sec
- 1fe:	10 f4       	brcc	.+4      	; 0x204 <putch+0xe>
- 200:	da 98       	cbi	0x1b, 2	; 27
- 202:	02 c0       	rjmp	.+4      	; 0x208 <putch+0x12>
- 204:	da 9a       	sbi	0x1b, 2	; 27
- 206:	00 00       	nop
- 208:	15 d0       	rcall	.+42     	; 0x234 <uartDelay>
- 20a:	14 d0       	rcall	.+40     	; 0x234 <uartDelay>
- 20c:	86 95       	lsr	r24
- 20e:	2a 95       	dec	r18
- 210:	b1 f7       	brne	.-20     	; 0x1fe <putch+0x8>
+ 1cc:	2a e0       	ldi	r18, 0x0A	; 10
+ 1ce:	30 e0       	ldi	r19, 0x00	; 0
+ 1d0:	80 95       	com	r24
+ 1d2:	08 94       	sec
+ 1d4:	10 f4       	brcc	.+4      	; 0x1da <putch+0xe>
+ 1d6:	da 98       	cbi	0x1b, 2	; 27
+ 1d8:	02 c0       	rjmp	.+4      	; 0x1de <putch+0x12>
+ 1da:	da 9a       	sbi	0x1b, 2	; 27
+ 1dc:	00 00       	nop
+ 1de:	15 d0       	rcall	.+42     	; 0x20a <uartDelay>
+ 1e0:	14 d0       	rcall	.+40     	; 0x20a <uartDelay>
+ 1e2:	86 95       	lsr	r24
+ 1e4:	2a 95       	dec	r18
+ 1e6:	b1 f7       	brne	.-20     	; 0x1d4 <putch+0x8>
       [uartBit] "I" (UART_TX_BIT)
     :
       "r25"
   );
 #endif
 }
- 212:	08 95       	ret
+ 1e8:	08 95       	ret
 
-00000214 <getch>:
-  return getch();
+000001ea <getch>:
 }
+#endif
 
 // Watchdog functions. These are only safe with interrupts turned off.
 void watchdogReset() {
   __asm__ __volatile__ (
- 214:	a8 95       	wdr
+ 1ea:	a8 95       	wdr
   LED_PIN |= _BV(LED);
 #endif
 #endif
 
   return ch;
 }
- 216:	29 e0       	ldi	r18, 0x09	; 9
- 218:	30 e0       	ldi	r19, 0x00	; 0
- 21a:	cb 99       	sbic	0x19, 3	; 25
- 21c:	fe cf       	rjmp	.-4      	; 0x21a <getch+0x6>
- 21e:	0a d0       	rcall	.+20     	; 0x234 <uartDelay>
- 220:	09 d0       	rcall	.+18     	; 0x234 <uartDelay>
- 222:	08 d0       	rcall	.+16     	; 0x234 <uartDelay>
- 224:	88 94       	clc
- 226:	cb 99       	sbic	0x19, 3	; 25
- 228:	08 94       	sec
- 22a:	2a 95       	dec	r18
- 22c:	11 f0       	breq	.+4      	; 0x232 <getch+0x1e>
- 22e:	87 95       	ror	r24
- 230:	f7 cf       	rjmp	.-18     	; 0x220 <getch+0xc>
- 232:	08 95       	ret
-
-00000234 <uartDelay>:
+ 1ec:	29 e0       	ldi	r18, 0x09	; 9
+ 1ee:	30 e0       	ldi	r19, 0x00	; 0
+ 1f0:	cb 99       	sbic	0x19, 3	; 25
+ 1f2:	fe cf       	rjmp	.-4      	; 0x1f0 <getch+0x6>
+ 1f4:	0a d0       	rcall	.+20     	; 0x20a <uartDelay>
+ 1f6:	09 d0       	rcall	.+18     	; 0x20a <uartDelay>
+ 1f8:	08 d0       	rcall	.+16     	; 0x20a <uartDelay>
+ 1fa:	88 94       	clc
+ 1fc:	cb 99       	sbic	0x19, 3	; 25
+ 1fe:	08 94       	sec
+ 200:	2a 95       	dec	r18
+ 202:	11 f0       	breq	.+4      	; 0x208 <getch+0x1e>
+ 204:	87 95       	ror	r24
+ 206:	f7 cf       	rjmp	.-18     	; 0x1f6 <getch+0xc>
+ 208:	08 95       	ret
+
+0000020a <uartDelay>:
 #if UART_B_VALUE > 255
 #error Baud rate too slow for soft UART
 #endif
 
 void uartDelay() {
   __asm__ __volatile__ (
- 234:	9e e0       	ldi	r25, 0x0E	; 14
- 236:	9a 95       	dec	r25
- 238:	f1 f7       	brne	.-4      	; 0x236 <uartDelay+0x2>
- 23a:	08 95       	ret
-
-0000023c <getLen>:
-  } while (--count);
-}
-#endif
+ 20a:	9e e0       	ldi	r25, 0x0E	; 14
+ 20c:	9a 95       	dec	r25
+ 20e:	f1 f7       	brne	.-4      	; 0x20c <uartDelay+0x2>
+ 210:	08 95       	ret
 
-uint8_t getLen() {
-  getch();
- 23c:	eb df       	rcall	.-42     	; 0x214 <getch>
-  length = getch();
- 23e:	ea df       	rcall	.-44     	; 0x214 <getch>
- 240:	80 93 82 01 	sts	0x0182, r24
-  return getch();
-}
- 244:	e7 cf       	rjmp	.-50     	; 0x214 <getch>
-
-00000246 <watchdogConfig>:
+00000212 <watchdogConfig>:
     "wdr\n"
   );
 }
 
 void watchdogConfig(uint8_t x) {
   WDTCSR = _BV(WDCE) | _BV(WDE);
- 246:	98 e1       	ldi	r25, 0x18	; 24
- 248:	91 bd       	out	0x21, r25	; 33
+ 212:	98 e1       	ldi	r25, 0x18	; 24
+ 214:	91 bd       	out	0x21, r25	; 33
   WDTCSR = x;
- 24a:	81 bd       	out	0x21, r24	; 33
+ 216:	81 bd       	out	0x21, r24	; 33
 }
- 24c:	08 95       	ret
-
-0000024e <appStart>:
-
-void appStart() {
-  watchdogConfig(WATCHDOG_OFF);
- 24e:	80 e0       	ldi	r24, 0x00	; 0
- 250:	fa df       	rcall	.-12     	; 0x246 <watchdogConfig>
-  __asm__ __volatile__ (
- 252:	e4 e0       	ldi	r30, 0x04	; 4
- 254:	ff 27       	eor	r31, r31
- 256:	09 94       	ijmp
+ 218:	08 95       	ret
 
-00000258 <verifySpace>:
+0000021a <verifySpace>:
   do getch(); while (--count);
   verifySpace();
 }
 
 void verifySpace() {
-  if (getch() != CRC_EOP) appStart();
- 258:	dd df       	rcall	.-70     	; 0x214 <getch>
- 25a:	80 32       	cpi	r24, 0x20	; 32
- 25c:	09 f0       	breq	.+2      	; 0x260 <verifySpace+0x8>
- 25e:	f7 df       	rcall	.-18     	; 0x24e <appStart>
+  if (getch() != CRC_EOP) {
+ 21a:	e7 df       	rcall	.-50     	; 0x1ea <getch>
+ 21c:	80 32       	cpi	r24, 0x20	; 32
+ 21e:	19 f0       	breq	.+6      	; 0x226 <verifySpace+0xc>
+    watchdogConfig(WATCHDOG_16MS);    // shorten WD timeout
+ 220:	88 e0       	ldi	r24, 0x08	; 8
+ 222:	f7 df       	rcall	.-18     	; 0x212 <watchdogConfig>
+ 224:	ff cf       	rjmp	.-2      	; 0x224 <verifySpace+0xa>
+    while (1)			      // and busy-loop so that WD causes
+      ;				      //  a reset and app start.
+  }
   putch(STK_INSYNC);
- 260:	84 e1       	ldi	r24, 0x14	; 20
+ 226:	84 e1       	ldi	r24, 0x14	; 20
 }
- 262:	c9 cf       	rjmp	.-110    	; 0x1f6 <putch>
+ 228:	d1 cf       	rjmp	.-94     	; 0x1cc <putch>
 
-00000264 <getNch>:
+0000022a <getNch>:
     ::[count] "M" (UART_B_VALUE)
   );
 }
 #endif
 
 void getNch(uint8_t count) {
- 264:	1f 93       	push	r17
- 266:	18 2f       	mov	r17, r24
+ 22a:	1f 93       	push	r17
+ 22c:	18 2f       	mov	r17, r24
   do getch(); while (--count);
- 268:	d5 df       	rcall	.-86     	; 0x214 <getch>
- 26a:	11 50       	subi	r17, 0x01	; 1
- 26c:	e9 f7       	brne	.-6      	; 0x268 <getNch+0x4>
+ 22e:	dd df       	rcall	.-70     	; 0x1ea <getch>
+ 230:	11 50       	subi	r17, 0x01	; 1
+ 232:	e9 f7       	brne	.-6      	; 0x22e <getNch+0x4>
   verifySpace();
- 26e:	f4 df       	rcall	.-24     	; 0x258 <verifySpace>
+ 234:	f2 df       	rcall	.-28     	; 0x21a <verifySpace>
 }
- 270:	1f 91       	pop	r17
- 272:	08 95       	ret
+ 236:	1f 91       	pop	r17
+ 238:	08 95       	ret
+
+0000023a <appStart>:
+  WDTCSR = _BV(WDCE) | _BV(WDE);
+  WDTCSR = x;
+}
+
+void appStart() {
+  watchdogConfig(WATCHDOG_OFF);
+ 23a:	80 e0       	ldi	r24, 0x00	; 0
+ 23c:	ea df       	rcall	.-44     	; 0x212 <watchdogConfig>
+  __asm__ __volatile__ (
+ 23e:	e4 e0       	ldi	r30, 0x04	; 4
+ 240:	ff 27       	eor	r31, r31
+ 242:	09 94       	ijmp