Custom linker script.

Implement a hack to derive section start addresses from the
information like FLASHEND that is present in the source code (via
io.h) This requires a custom linker script that uses symbols defined
by inline ASM in the C program, the inline ASM itself, and some
calculations/guesswork to figure out bootloader size for those
VIRTUAL_BOOT platforms that have a bootloader size larger than 512
bytes but significantly smaller than 1024 bytes.

optiboot/bootloaders/optiboot/Makefile

@@ -60,7 +60,7 @@ export
 
 # defaults
 MCU_TARGET = atmega168
-LDSECTIONS  = -Wl,--section-start=.text=0x3e00 -Wl,--section-start=.version=0x3ffe
+LDSECTIONS  = -Wl,-Tlink_optiboot.ld
 
 # Build environments
 # Start of some ugly makefile-isms to allow optiboot to be built
@@ -349,8 +349,6 @@ virboot8: TARGET = atmega8
 virboot8: MCU_TARGET = atmega8
 virboot8: CFLAGS += $(COMMON_OPTIONS) '-DVIRTUAL_BOOT_PARTITION' '-Dsave_vect_num=EE_RDY_vect_num'
 virboot8: AVR_FREQ ?= 16000000L 
-# Start address of 1D80 allows for size up to 640 bytes, app up to 7552
-virboot8: LDSECTIONS  = -Wl,--section-start=.text=0x1d80 -Wl,--section-start=.version=0x1ffe
 virboot8: $(PROGRAM)_virboot8.hex
 ifndef PRODUCTION
 virboot8: $(PROGRAM)_virboot8.lst
@@ -362,7 +360,6 @@ virboot328: TARGET = atmega328
 virboot328: MCU_TARGET = atmega328p
 virboot328: CFLAGS += $(COMMON_OPTIONS) '-DVIRTUAL_BOOT_PARTITION'
 virboot328: AVR_FREQ ?= 16000000L
-virboot328: LDSECTIONS  = -Wl,--section-start=.text=0x7d80 -Wl,--section-start=.version=0x7ffe
 virboot328: $(PROGRAM)_virboot328.hex
 ifndef PRODUCTION
 virboot328: $(PROGRAM)_virboot328.lst
@@ -403,11 +400,6 @@ atmega8: TARGET = atmega8
 atmega8: MCU_TARGET = atmega8
 atmega8: CFLAGS += $(COMMON_OPTIONS)
 atmega8: AVR_FREQ ?= 16000000L 
-ifndef BIGBOOT
-atmega8: LDSECTIONS  = -Wl,--section-start=.text=0x1e00 -Wl,--section-start=.version=0x1ffe -Wl,--gc-sections -Wl,--undefined=optiboot_version
-else
-atmega8: LDSECTIONS  = -Wl,--section-start=.text=0x1c00 -Wl,--section-start=.version=0x1ffe -Wl,--gc-sections -Wl,--undefined=optiboot_version
-endif
 atmega8: $(PROGRAM)_atmega8.hex
 ifndef PRODUCTION
 atmega8: $(PROGRAM)_atmega8.lst
@@ -432,11 +424,6 @@ atmega168: TARGET = atmega168
 atmega168: MCU_TARGET = atmega168
 atmega168: CFLAGS += $(COMMON_OPTIONS)
 atmega168: AVR_FREQ ?= 16000000L
-ifndef BIGBOOT
-atmega168: LDSECTIONS  = -Wl,--section-start=.text=0x3e00 -Wl,--section-start=.version=0x3ffe
-else
-atmega168: LDSECTIONS  = -Wl,--section-start=.text=0x3c00 -Wl,--section-start=.version=0x3ffe
-endif
 atmega168: $(PROGRAM)_atmega168.hex
 ifndef PRODUCTION
 atmega168: $(PROGRAM)_atmega168.lst
@@ -462,12 +449,6 @@ atmega328: TARGET = atmega328
 atmega328: MCU_TARGET = atmega328p
 atmega328: CFLAGS += $(COMMON_OPTIONS)
 atmega328: AVR_FREQ ?= 16000000L
-ifndef BIGBOOT
-atmega328: LDSECTIONS  = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
-else
-# bigboot version is 1k long; starts earlier
-atmega328: LDSECTIONS  = -Wl,--section-start=.text=0x7c00 -Wl,--section-start=.version=0x7ffe
-endif
 atmega328: $(PROGRAM)_atmega328.hex
 ifndef PRODUCTION
 atmega328: $(PROGRAM)_atmega328.lst
@@ -494,7 +475,6 @@ atmega328_isp: isp
 atmega1280: MCU_TARGET = atmega1280
 atmega1280: CFLAGS += $(COMMON_OPTIONS) -DBIGBOOT $(UART_CMD)
 atmega1280: AVR_FREQ ?= 16000000L
-atmega1280: LDSECTIONS  = -Wl,--section-start=.text=0x1fc00  -Wl,--section-start=.version=0x1fffe
 atmega1280: $(PROGRAM)_atmega1280.hex
 ifndef PRODUCTION
 atmega1280: $(PROGRAM)_atmega1280.lst

optiboot/bootloaders/optiboot/Makefile.1284

@@ -12,7 +12,6 @@ atmega644p: TARGET = atmega644p
 atmega644p: MCU_TARGET = atmega644p
 atmega644p: CFLAGS += $(COMMON_OPTIONS) -DBIGBOOT
 atmega644p: AVR_FREQ ?= 16000000L
-atmega644p: LDSECTIONS  = -Wl,--section-start=.text=0xfc00 -Wl,--section-start=.version=0xfffe
 atmega644p: CFLAGS += $(UART_CMD)
 atmega644p: $(PROGRAM)_atmega644p.hex
 ifndef PRODUCTION
@@ -24,7 +23,6 @@ atmega1284: TARGET = atmega1284p
 atmega1284: MCU_TARGET = atmega1284p
 atmega1284: CFLAGS += $(COMMON_OPTIONS) -DBIGBOOT
 atmega1284: AVR_FREQ ?= 16000000L
-atmega1284: LDSECTIONS  = -Wl,--section-start=.text=0x1fc00 -Wl,--section-start=.version=0x1fffe
 atmega1284: CFLAGS += $(UART_CMD)
 atmega1284: $(PROGRAM)_atmega1284p.hex
 ifndef PRODUCTION

optiboot/bootloaders/optiboot/Makefile.2560

@@ -12,7 +12,6 @@ atmega2560: TARGET = atmega2560
 atmega2560: MCU_TARGET = atmega2560
 atmega2560: CFLAGS += $(COMMON_OPTIONS) -DBIGBOOT
 atmega2560: AVR_FREQ ?= 16000000L
-atmega2560: LDSECTIONS  = -Wl,--section-start=.text=0x3fc00 -Wl,--section-start=.version=0x3fffe
 atmega2560: CFLAGS += $(UART_CMD)
 atmega2560: $(PROGRAM)_atmega2560.hex
 ifndef PRODUCTION

optiboot/bootloaders/optiboot/Makefile.extras

@@ -19,7 +19,6 @@ atmega88: TARGET = atmega88
 atmega88: MCU_TARGET = atmega88
 atmega88: CFLAGS += $(COMMON_OPTIONS)
 atmega88: AVR_FREQ ?= 16000000L 
-atmega88: LDSECTIONS  = -Wl,--section-start=.text=0x1e00 -Wl,--section-start=.version=0x1ffe -Wl,--gc-sections -Wl,--undefined=optiboot_version
 atmega88: $(PROGRAM)_atmega88.hex
 atmega88: $(PROGRAM)_atmega88.lst
 
@@ -82,7 +81,6 @@ atmega32: TARGET = atmega32
 atmega32: MCU_TARGET = atmega32
 atmega32: CFLAGS += $(COMMON_OPTIONS)
 atmega32: AVR_FREQ ?= 11059200L
-atmega32: LDSECTIONS  = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
 atmega32: $(PROGRAM)_atmega32.hex
 atmega32: $(PROGRAM)_atmega32.lst
 
@@ -100,7 +98,6 @@ HELPTEXT += "target atmega128rfa1  - ATmega128RFA1 (100pin, 128k)\n"
 atmega128rfa1: MCU_TARGET = atmega128rfa1
 atmega128rfa1: CFLAGS += $(COMMON_OPTIONS) -DBIGBOOT $(UART_CMD)
 atmega128rfa1: AVR_FREQ ?= 16000000L
-atmega128rfa1: LDSECTIONS  = -Wl,--section-start=.text=0x1fc00  -Wl,--section-start=.version=0x1fffe
 atmega128rfa1: $(PROGRAM)_atmega128rfa1.hex
 ifndef PRODUCTION
 atmega128rfa1: $(PROGRAM)_atmega128rfa1.lst

optiboot/bootloaders/optiboot/Makefile.mcudude

@@ -25,7 +25,6 @@ atmega16: TARGET = atmega16
 atmega16: MCU_TARGET = atmega16
 atmega16: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega16: AVR_FREQ ?= 16000000L
-atmega16: LDSECTIONS = -Wl,--section-start=.text=0x3e00 -Wl,--section-start=.version=0x3ffe
 atmega16: $(PROGRAM)_atmega16_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega16: $(PROGRAM)_atmega16_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -37,7 +36,6 @@ atmega64: TARGET = atmega64
 atmega64: MCU_TARGET = atmega64
 atmega64: CFLAGS += $(COMMON_OPTIONS) -DBIGBOOT $(UART_CMD)
 atmega64: AVR_FREQ ?= 16000000L
-atmega64: LDSECTIONS = -Wl,--section-start=.text=0xfc00 -Wl,--section-start=.version=0xfffe
 atmega64: $(PROGRAM)_atmega64_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega64: $(PROGRAM)_atmega64_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -49,7 +47,6 @@ atmega88p: TARGET = atmega88p
 atmega88p: MCU_TARGET = atmega88p
 atmega88p: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega88p: AVR_FREQ ?= 16000000L 
-atmega88p: LDSECTIONS = -Wl,--section-start=.text=0x1e00 -Wl,--section-start=.version=0x1ffe -Wl,--gc-sections -Wl,--undefined=optiboot_version
 atmega88p: $(PROGRAM)_atmega88p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega88p: $(PROGRAM)_atmega88p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -61,7 +58,6 @@ atmega88pb: TARGET = atmega88pb
 atmega88pb: MCU_TARGET = atmega88pb
 atmega88pb: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega88pb: AVR_FREQ ?= 16000000L
-atmega88pb: LDSECTIONS = -Wl,--section-start=.text=0x1e00 -Wl,--section-start=.version=0x1ffe -Wl,--gc-sections -Wl,--undefined=optiboot_version
 atmega88pb: $(PROGRAM)_atmega88pb_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega88pb: $(PROGRAM)_atmega88pb_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -72,7 +68,6 @@ atmega128: TARGET = atmega128
 atmega128: MCU_TARGET = atmega128
 atmega128: CFLAGS += $(COMMON_OPTIONS) -DBIGBOOT $(UART_CMD)
 atmega128: AVR_FREQ ?= 16000000L
-atmega128: LDSECTIONS = -Wl,--section-start=.text=0x1fc00 -Wl,--section-start=.version=0x1fffe
 atmega128: $(PROGRAM)_atmega128_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega128: $(PROGRAM)_atmega128_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -84,7 +79,6 @@ atmega162: TARGET = atmega162
 atmega162: MCU_TARGET = atmega162
 atmega162: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega162: AVR_FREQ ?= 16000000L
-atmega162: LDSECTIONS = -Wl,--section-start=.text=0x3e00 -Wl,--section-start=.version=0x3ffe
 atmega162: $(PROGRAM)_atmega162_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega162: $(PROGRAM)_atmega162_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -95,7 +89,6 @@ atmega164a: TARGET = atmega164a
 atmega164a: MCU_TARGET = atmega164a
 atmega164a: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega164a: AVR_FREQ ?= 16000000L
-atmega164a: LDSECTIONS = -Wl,--section-start=.text=0x3e00 -Wl,--section-start=.version=0x3ffe
 atmega164a: $(PROGRAM)_atmega164a_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega164a: $(PROGRAM)_atmega164a_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -107,7 +100,6 @@ atmega164p: TARGET = atmega164p
 atmega164p: MCU_TARGET = atmega164p
 atmega164p: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega164p: AVR_FREQ ?= 16000000L
-atmega164p: LDSECTIONS = -Wl,--section-start=.text=0x3e00 -Wl,--section-start=.version=0x3ffe
 atmega164p: $(PROGRAM)_atmega164p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega164p: $(PROGRAM)_atmega164p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -119,7 +111,6 @@ atmega164pa: atmega164p
 #atmega168: MCU_TARGET = atmega168
 #atmega168: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 #atmega168: AVR_FREQ ?= 16000000L 
-#atmega168: LDSECTIONS = -Wl,--section-start=.text=0x3e00 -Wl,--section-start=.version=0x3ffe
 #atmega168: $(PROGRAM)_atmega168_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 #ifndef PRODUCTION
 #atmega168: $(PROGRAM)_atmega168_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -131,7 +122,6 @@ atmega168p: TARGET = atmega168p
 atmega168p: MCU_TARGET = atmega168p
 atmega168p: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega168p: AVR_FREQ ?= 16000000L 
-atmega168p: LDSECTIONS = -Wl,--section-start=.text=0x3e00 -Wl,--section-start=.version=0x3ffe
 atmega168p: $(PROGRAM)_atmega168p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega168p: $(PROGRAM)_atmega168p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -143,7 +133,6 @@ atmega168pb: TARGET = atmega168pb
 atmega168pb: MCU_TARGET = atmega168pb
 atmega168pb: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega168pb: AVR_FREQ ?= 16000000L 
-atmega168pb: LDSECTIONS = -Wl,--section-start=.text=0x3e00 -Wl,--section-start=.version=0x3ffe
 atmega168pb: $(PROGRAM)_atmega168pb_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega168pb: $(PROGRAM)_atmega168pb_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -154,7 +143,6 @@ atmega169: TARGET = atmega169
 atmega169: MCU_TARGET = atmega169
 atmega169: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega169: AVR_FREQ ?= 16000000L
-atmega169: LDSECTIONS = -Wl,--section-start=.text=0x3e00 -Wl,--section-start=.version=0x3ffe
 atmega169: $(PROGRAM)_atmega169_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega169: $(PROGRAM)_atmega169_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -166,7 +154,6 @@ atmega169p: TARGET = atmega169p
 atmega169p: MCU_TARGET = atmega169p
 atmega169p: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega169p: AVR_FREQ ?= 16000000L
-atmega169p: LDSECTIONS = -Wl,--section-start=.text=0x3e00 -Wl,--section-start=.version=0x3ffe
 atmega169p: $(PROGRAM)_atmega169p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega169p: $(PROGRAM)_atmega169p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -178,7 +165,6 @@ atmega324a: TARGET = atmega324a
 atmega324a: MCU_TARGET = atmega324a
 atmega324a: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega324a: AVR_FREQ ?= 16000000L
-atmega324a: LDSECTIONS = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
 atmega324a: $(PROGRAM)_atmega324a_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega324a: $(PROGRAM)_atmega324a_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -190,7 +176,6 @@ atmega324p: TARGET = atmega324p
 atmega324p: MCU_TARGET = atmega324p
 atmega324p: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega324p: AVR_FREQ ?= 16000000L
-atmega324p: LDSECTIONS = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
 atmega324p: $(PROGRAM)_atmega324p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega324p: $(PROGRAM)_atmega324p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -201,7 +186,6 @@ atmega324pa: TARGET = atmega324pa
 atmega324pa: MCU_TARGET = atmega324pa
 atmega324pa: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega324pa: AVR_FREQ ?= 16000000L
-atmega324pa: LDSECTIONS = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
 atmega324pa: $(PROGRAM)_atmega324pa_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega324pa: $(PROGRAM)_atmega324pa_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -212,7 +196,6 @@ atmega324pb: TARGET = atmega324pb
 atmega324pb: MCU_TARGET = atmega324pb
 atmega324pb: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega324pb: AVR_FREQ ?= 16000000L
-atmega324pb: LDSECTIONS = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
 atmega324pb: $(PROGRAM)_atmega324pb_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega324pb: $(PROGRAM)_atmega324pb_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -223,7 +206,6 @@ atmega328pb: TARGET = atmega328pb
 atmega328pb: MCU_TARGET = atmega328pb
 atmega328pb: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega328pb: AVR_FREQ ?= 16000000L
-atmega328pb: LDSECTIONS = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
 atmega328pb: $(PROGRAM)_atmega328pb_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega328pb: $(PROGRAM)_atmega328pb_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -234,7 +216,6 @@ atmega329: TARGET = atmega329
 atmega329: MCU_TARGET = atmega329
 atmega329: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega329: AVR_FREQ ?= 16000000L
-atmega329: LDSECTIONS = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
 atmega329: $(PROGRAM)_atmega329_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega329: $(PROGRAM)_atmega329_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -246,7 +227,6 @@ atmega329p: TARGET = atmega329p
 atmega329p: MCU_TARGET = atmega329p
 atmega329p: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega329p: AVR_FREQ ?= 16000000L
-atmega329p: LDSECTIONS = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
 atmega329p: $(PROGRAM)_atmega329p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega329p: $(PROGRAM)_atmega329p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -258,7 +238,6 @@ atmega640: TARGET = atmega640
 atmega640: MCU_TARGET = atmega640
 atmega640: CFLAGS += $(COMMON_OPTIONS) -DBIGBOOT $(UART_CMD)
 atmega640: AVR_FREQ ?= 16000000L
-atmega640: LDSECTIONS = -Wl,--section-start=.text=0xfc00 -Wl,--section-start=.version=0xfffe
 atmega640: $(PROGRAM)_atmega640_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega640: $(PROGRAM)_atmega640_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -269,7 +248,6 @@ atmega649: TARGET = atmega649
 atmega649: MCU_TARGET = atmega649
 atmega649: CFLAGS += $(COMMON_OPTIONS) -DBIGBOOT $(UART_CMD)
 atmega649: AVR_FREQ ?= 16000000L
-atmega649: LDSECTIONS = -Wl,--section-start=.text=0xfc00 -Wl,--section-start=.version=0xfffe
 atmega649: $(PROGRAM)_atmega649_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega649: $(PROGRAM)_atmega649_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -280,7 +258,6 @@ atmega649p: TARGET = atmega649p
 atmega649p: MCU_TARGET = atmega649p
 atmega649p: CFLAGS += $(COMMON_OPTIONS) -DBIGBOOT $(UART_CMD)
 atmega649p: AVR_FREQ ?= 16000000L
-atmega649p: LDSECTIONS = -Wl,--section-start=.text=0xfc00 -Wl,--section-start=.version=0xfffe
 atmega649p: $(PROGRAM)_atmega649p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega649p: $(PROGRAM)_atmega649p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -291,7 +268,6 @@ atmega1281: TARGET = atmega1281
 atmega1281: MCU_TARGET = atmega1281
 atmega1281: CFLAGS += $(COMMON_OPTIONS) -DBIGBOOT $(UART_CMD)
 atmega1281: AVR_FREQ ?= 16000000L
-atmega1281: LDSECTIONS = -Wl,--section-start=.text=0x1fc00 -Wl,--section-start=.version=0x1fffe
 atmega1281: $(PROGRAM)_atmega1281_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega1281: $(PROGRAM)_atmega1281_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -302,7 +278,6 @@ atmega2561: TARGET = atmega2561
 atmega2561: MCU_TARGET = atmega2561
 atmega2561: CFLAGS += $(COMMON_OPTIONS) -DBIGBOOT $(UART_CMD)
 atmega2561: AVR_FREQ ?= 16000000L
-atmega2561: LDSECTIONS = -Wl,--section-start=.text=0x3fc00 -Wl,--section-start=.version=0x3fffe
 atmega2561: $(PROGRAM)_atmega2561_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega2561: $(PROGRAM)_atmega2561_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -313,7 +288,6 @@ atmega3290: TARGET = atmega3290
 atmega3290: MCU_TARGET = atmega3290
 atmega3290: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega3290: AVR_FREQ ?= 16000000L
-atmega3290: LDSECTIONS = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
 atmega3290: $(PROGRAM)_atmega3290_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega3290: $(PROGRAM)_atmega3290_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -324,7 +298,6 @@ atmega3290p: TARGET = atmega3290p
 atmega3290p: MCU_TARGET = atmega3290p
 atmega3290p: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega3290p: AVR_FREQ ?= 16000000L
-atmega3290p: LDSECTIONS = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
 atmega3290p: $(PROGRAM)_atmega3290p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega3290p: $(PROGRAM)_atmega3290p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -336,7 +309,6 @@ atmega6490: TARGET = atmega6490
 atmega6490: MCU_TARGET = atmega6490
 atmega6490: CFLAGS += $(COMMON_OPTIONS) -DBIGBOOT $(UART_CMD)
 atmega6490: AVR_FREQ ?= 16000000L
-atmega6490: LDSECTIONS = -Wl,--section-start=.text=0xfc00 -Wl,--section-start=.version=0xfffe
 atmega6490: $(PROGRAM)_atmega6490_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega6490: $(PROGRAM)_atmega6490_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -347,7 +319,6 @@ atmega6490p: TARGET = atmega6490p
 atmega6490p: MCU_TARGET = atmega6490p
 atmega6490p: CFLAGS += $(COMMON_OPTIONS) -DBIGBOOT $(UART_CMD)
 atmega6490p: AVR_FREQ ?= 16000000L
-atmega6490p: LDSECTIONS = -Wl,--section-start=.text=0xfc00 -Wl,--section-start=.version=0xfffe
 atmega6490p: $(PROGRAM)_atmega6490p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega6490p: $(PROGRAM)_atmega6490p_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -358,7 +329,6 @@ atmega8515: TARGET = atmega8515
 atmega8515: MCU_TARGET = atmega8515
 atmega8515: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega8515: AVR_FREQ ?= 16000000L
-atmega8515: LDSECTIONS = -Wl,--section-start=.text=0x1e00 -Wl,--section-start=.version=0x1ffe
 atmega8515: $(PROGRAM)_atmega8515_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega8515: $(PROGRAM)_atmega8515_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst
@@ -369,7 +339,6 @@ atmega8535: TARGET := atmega8535
 atmega8535: MCU_TARGET = atmega8535
 atmega8535: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega8535: AVR_FREQ ?= 16000000L
-atmega8535: LDSECTIONS = -Wl,--section-start=.text=0x1e00 -Wl,--section-start=.version=0x1ffe
 atmega8535: $(PROGRAM)_atmega8535_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).hex
 ifndef PRODUCTION
 atmega8535: $(PROGRAM)_atmega8535_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ).lst

optiboot/bootloaders/optiboot/Makefile.tiny

@@ -10,7 +10,6 @@ attiny1634:	MCU_TARGET = attiny1634
 attiny1634:	LED_CMD ?= -DLED=C0
 attiny1634: CFLAGS += $(COMMON_OPTIONS) -DVIRTUAL_BOOT_PARTITION -DFOURPAGEERASE $(UART_CMD)
 attiny1634: AVR_FREQ ?= 8000000L
-attiny1634: LDSECTIONS  = -Wl,--section-start=.text=0x3d80 -Wl,--section-start=.version=0x3ffe
 attiny1634: $(PROGRAM)_attiny1634.hex
 ifndef PRODUCTION
 attiny1634: $(PROGRAM)_attiny1634.lst
@@ -178,7 +177,6 @@ attiny841: TARGET = attiny841
 attiny841: MCU_TARGET = attiny841
 attiny841: CFLAGS += $(COMMON_OPTIONS) '-DVIRTUAL_BOOT_PARTITION' '-DFOURPAGEERASE' $(UART_CMD)
 attiny841: AVR_FREQ ?= 8000000L
-attiny841: LDSECTIONS  = -Wl,--section-start=.text=0x1d80 -Wl,--section-start=.version=0x1ffe
 attiny841: $(PROGRAM)_attiny841.hex
 ifndef PRODUCTION
 attiny841: $(PROGRAM)_attiny841.lst
@@ -363,21 +361,21 @@ endif
 #-----------------------
 
 attiny841at20noLED:
-	$(MAKE) attiny841	 AVR_FREQ=20000000L LED_START_FLASHES=0  LDSECTIONS  = -Wl,--section-start=.text=0x1dc0 -Wl,--section-start=.version=0x1ffe
+	$(MAKE) attiny841	 AVR_FREQ=20000000L LED_START_FLASHES=0
 	mv $(PROGRAM)_attiny841.hex $(PROGRAM)_attiny841_20000000L_noLED.hex
 ifndef PRODUCTION
 	mv $(PROGRAM)_attiny841.lst $(PROGRAM)_attiny841_20000000L_noLED.lst
 endif
 
 attiny841at16noLED:
-	$(MAKE) attiny841	 AVR_FREQ=16000000L LED_START_FLASHES=0 LDSECTIONS  = -Wl,--section-start=.text=0x1dc0 -Wl,--section-start=.version=0x1ffe
+	$(MAKE) attiny841	 AVR_FREQ=16000000L LED_START_FLASHES=0
 	mv $(PROGRAM)_attiny841.hex $(PROGRAM)_attiny841_16000000L_noLED.hex
 ifndef PRODUCTION
 	mv $(PROGRAM)_attiny841.lst $(PROGRAM)_attiny841_16000000L_noLED.lst
 endif
 
 attiny841at8noLED:
-	$(MAKE) attiny841	 AVR_FREQ=8000000L  BAUD_RATE=57600 LED_START_FLASHES=0 LDSECTIONS  = -Wl,--section-start=.text=0x1dc0 -Wl,--section-start=.version=0x1ffe
+	$(MAKE) attiny841	 AVR_FREQ=8000000L  BAUD_RATE=57600 LED_START_FLASHES=0
 	mv $(PROGRAM)_attiny841.hex $(PROGRAM)_attiny841_8000000L_noLED.hex
 ifndef PRODUCTION
 	mv $(PROGRAM)_attiny841.lst $(PROGRAM)_attiny841_8000000L_noLED.lst
@@ -395,7 +393,6 @@ attiny441: TARGET = attiny441
 attiny441: MCU_TARGET = attiny441
 attiny441: CFLAGS += $(COMMON_OPTIONS) '-DVIRTUAL_BOOT_PARTITION' '-DFOURPAGEERASE' $(UART_CMD)
 attiny441: AVR_FREQ ?= 8000000L
-attiny441: LDSECTIONS  = -Wl,--section-start=.text=0x0d80 -Wl,--section-start=.version=0x0ffe
 attiny441: $(PROGRAM)_attiny441.hex
 ifndef PRODUCTION
 attiny441: $(PROGRAM)_attiny441.lst
@@ -586,21 +583,21 @@ endif
 #-----------------------
 
 attiny441at20noLED:
-	$(MAKE) attiny441	 AVR_FREQ=20000000L LED_START_FLASHES=0  LDSECTIONS  = -Wl,--section-start=.text=0x0dc0 -Wl,--section-start=.version=0x0ffe
+	$(MAKE) attiny441	 AVR_FREQ=20000000L LED_START_FLASHES=0
 	mv $(PROGRAM)_attiny441.hex $(PROGRAM)_attiny441_20000000L_noLED.hex
 ifndef PRODUCTION
 	mv $(PROGRAM)_attiny441.lst $(PROGRAM)_attiny441_20000000L_noLED.lst
 endif
 
 attiny441at16noLED:
-	$(MAKE) attiny441	 AVR_FREQ=16000000L LED_START_FLASHES=0 LDSECTIONS  = -Wl,--section-start=.text=0x0dc0 -Wl,--section-start=.version=0x0ffe
+	$(MAKE) attiny441	 AVR_FREQ=16000000L LED_START_FLASHES=0
 	mv $(PROGRAM)_attiny441.hex $(PROGRAM)_attiny441_16000000L_noLED.hex
 ifndef PRODUCTION
 	mv $(PROGRAM)_attiny441.lst $(PROGRAM)_attiny441_16000000L_noLED.lst
 endif
 
 attiny441at8noLED:
-	$(MAKE) attiny441	 AVR_FREQ=8000000L  BAUD_RATE=57600 LED_START_FLASHES=0 LDSECTIONS  = -Wl,--section-start=.text=0x0dc0 -Wl,--section-start=.version=0x0ffe
+	$(MAKE) attiny441	 AVR_FREQ=8000000L  BAUD_RATE=57600 LED_START_FLASHES=0
 	mv $(PROGRAM)_attiny441.hex $(PROGRAM)_attiny441_8000000L_noLED.hex
 ifndef PRODUCTION
 	mv $(PROGRAM)_attiny441.lst $(PROGRAM)_attiny441_8000000L_noLED.lst
@@ -617,7 +614,6 @@ attiny828: TARGET = attiny828
 attiny828: MCU_TARGET = attiny828
 attiny828: CFLAGS += $(COMMON_OPTIONS)
 attiny828: AVR_FREQ ?= 8000000L
-attiny828: LDSECTIONS  = -Wl,--section-start=.text=0x1E00 -Wl,--section-start=.version=0x1ffe
 attiny828: $(PROGRAM)_attiny828.hex
 ifndef PRODUCTION
 attiny828: $(PROGRAM)_attiny828.lst
@@ -683,7 +679,6 @@ attiny88: TARGET = attiny88
 attiny88: MCU_TARGET = attiny88
 attiny88: CFLAGS += $(COMMON_OPTIONS) '-DVIRTUAL_BOOT_PARTITION' '-DSOFT_UART'
 attiny88: AVR_FREQ ?= 8000000L
-attiny88: LDSECTIONS  = -Wl,--section-start=.text=0x1D80 -Wl,--section-start=.version=0x1ffe
 attiny88: $(PROGRAM)_attiny88.hex
 ifndef PRODUCTION
 attiny88: $(PROGRAM)_attiny88.lst
@@ -750,7 +745,6 @@ attiny48: TARGET = attiny48
 attiny48: MCU_TARGET = attiny48
 attiny48: CFLAGS += $(COMMON_OPTIONS) '-DVIRTUAL_BOOT_PARTITION' '-DSOFT_UART'
 attiny48: AVR_FREQ ?= 8000000L
-attiny48: LDSECTIONS  = -Wl,--section-start=.text=0x0D80 -Wl,--section-start=.version=0x0ffe
 attiny48: $(PROGRAM)_attiny48.hex
 ifndef PRODUCTION
 attiny48: $(PROGRAM)_attiny48.lst
@@ -817,7 +811,6 @@ attiny85: MCU_TARGET = attiny85
 attiny85: LED_START_FLASHES_CMD = '-DLED_START_FLASHES=0'
 attiny85: CFLAGS += $(COMMON_OPTIONS) '-DVIRTUAL_BOOT_PARTITION' '-DSOFT_UART'
 attiny85: AVR_FREQ ?= 8000000L
-attiny85: LDSECTIONS  = -Wl,--section-start=.text=0x1DC0 -Wl,--section-start=.version=0x1ffe
 attiny85: $(PROGRAM)_attiny85.hex
 ifndef PRODUCTION
 attiny85: $(PROGRAM)_attiny85.lst
@@ -904,7 +897,6 @@ attiny45: MCU_TARGET = attiny45
 attiny45: LED_START_FLASHES_CMD = '-DLED_START_FLASHES=0'
 attiny45: CFLAGS += $(COMMON_OPTIONS) '-DVIRTUAL_BOOT_PARTITION' '-DSOFT_UART'
 attiny45: AVR_FREQ ?= 8000000L
-attiny45: LDSECTIONS  = -Wl,--section-start=.text=0x0DC0 -Wl,--section-start=.version=0x0ffe
 attiny45: $(PROGRAM)_attiny45.hex
 ifndef PRODUCTION
 attiny45: $(PROGRAM)_attiny45.lst
@@ -991,7 +983,6 @@ attiny84: TARGET = attiny84
 attiny84: MCU_TARGET = attiny84
 attiny84: CFLAGS += $(COMMON_OPTIONS) '-DVIRTUAL_BOOT_PARTITION' '-DSOFT_UART'
 attiny84: AVR_FREQ ?= 8000000L
-attiny84: LDSECTIONS  = -Wl,--section-start=.text=0x1D80 -Wl,--section-start=.version=0x1ffe
 attiny84: $(PROGRAM)_attiny84.hex
 ifndef PRODUCTION
 attiny84: $(PROGRAM)_attiny84.lst
@@ -1078,7 +1069,6 @@ attiny44: TARGET = attiny44
 attiny44: MCU_TARGET = attiny44
 attiny44: CFLAGS += $(COMMON_OPTIONS) '-DVIRTUAL_BOOT_PARTITION' '-DSOFT_UART'
 attiny44: AVR_FREQ ?= 8000000L
-attiny44: LDSECTIONS  = -Wl,--section-start=.text=0x0D80 -Wl,--section-start=.version=0x0ffe
 attiny44: $(PROGRAM)_attiny44.hex
 ifndef PRODUCTION
 attiny44: $(PROGRAM)_attiny44.lst
@@ -1166,7 +1156,6 @@ attiny861: TARGET = attiny861
 attiny861: MCU_TARGET = attiny861
 attiny861: CFLAGS += $(COMMON_OPTIONS) '-DVIRTUAL_BOOT_PARTITION' '-DSOFT_UART'
 attiny861: AVR_FREQ ?= 8000000L
-attiny861: LDSECTIONS  = -Wl,--section-start=.text=0x1D80 -Wl,--section-start=.version=0x1ffe
 attiny861: $(PROGRAM)_attiny861.hex
 ifndef PRODUCTION
 attiny861: $(PROGRAM)_attiny861.lst
@@ -1253,7 +1242,6 @@ attiny461: TARGET = attiny461
 attiny461: MCU_TARGET = attiny461
 attiny461: CFLAGS += $(COMMON_OPTIONS) '-DVIRTUAL_BOOT_PARTITION' '-DSOFT_UART'
 attiny461: AVR_FREQ ?= 8000000L
-attiny461: LDSECTIONS  = -Wl,--section-start=.text=0x0D80 -Wl,--section-start=.version=0x0ffe
 attiny461: $(PROGRAM)_attiny461.hex
 ifndef PRODUCTION
 attiny461: $(PROGRAM)_attiny461.lst
@@ -1341,7 +1329,6 @@ attiny167: TARGET = attiny167
 attiny167: MCU_TARGET = attiny167
 attiny167: AVR_FREQ ?= 8000000L
 attiny167: CFLAGS += $(COMMON_OPTIONS) '-DVIRTUAL_BOOT_PARTITION'
-attiny167: LDSECTIONS  = -Wl,--section-start=.text=0x3d80 -Wl,--section-start=.version=0x3ffe
 attiny167: $(PROGRAM)_attiny167.hex
 ifndef PRODUCTION
 attiny167: $(PROGRAM)_attiny167.lst
@@ -1352,7 +1339,6 @@ attiny87: TARGET = attiny87
 attiny87: MCU_TARGET = attiny87
 attiny87: CFLAGS += $(COMMON_OPTIONS) '-DVIRTUAL_BOOT_PARTITION'
 attiny87: AVR_FREQ ?= 8000000L
-attiny87: LDSECTIONS  = -Wl,--section-start=.text=0x1d80 -Wl,--section-start=.version=0x1ffe
 attiny87: $(PROGRAM)_attiny87.hex
 ifndef PRODUCTION
 attiny87: $(PROGRAM)_attiny87.lst

optiboot/bootloaders/optiboot/Makefile.usbmcus

@@ -23,11 +23,6 @@ atmega8u2atUART: TARGET = atmega8u2
 atmega8u2atUART: MCU_TARGET = atmega8u2
 atmega8u2atUART: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega8u2atUART: AVR_FREQ ?= 16000000L
-ifndef BIGBOOT ## standard version is 512 Bytes long; starts earlier
-atmega8u2atUART: LDSECTIONS = -Wl,--section-start=.text=0x1e00 -Wl,--section-start=.version=0x1ffe
-else ## bigboot version is 1024 Bytes long; starts earlier
-atmega8u2atUART: LDSECTIONS = -Wl,--section-start=.text=0x1c00 -Wl,--section-start=.version=0x1ffe
-endif
 atmega8u2atUART: $(PROGRAM)_atmega8u2_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).hex
 ifndef PRODUCTION
 atmega8u2atUART: $(PROGRAM)_atmega8u2_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).lst
@@ -57,11 +52,6 @@ atmega16u2atUART: TARGET = atmega16u2
 atmega16u2atUART: MCU_TARGET = atmega16u2
 atmega16u2atUART: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega16u2atUART: AVR_FREQ ?= 16000000L
-ifndef BIGBOOT ## standard version is 512 Bytes long; starts earlier
-atmega16u2atUART: LDSECTIONS = -Wl,--section-start=.text=0x3e00 -Wl,--section-start=.version=0x3ffe
-else ## bigboot version is 1024 Bytes long; starts earlier
-atmega16u2atUART: LDSECTIONS = -Wl,--section-start=.text=0x3c00 -Wl,--section-start=.version=0x3ffe
-endif
 atmega16u2atUART: $(PROGRAM)_atmega16u2_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).hex
 ifndef PRODUCTION
 atmega16u2atUART: $(PROGRAM)_atmega16u2_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).lst
@@ -91,11 +81,6 @@ atmega32u2atUART: TARGET = atmega32u2
 atmega32u2atUART: MCU_TARGET = atmega32u2
 atmega32u2atUART: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega32u2atUART: AVR_FREQ ?= 16000000L
-ifndef BIGBOOT ## standard version is 512 Bytes long; starts earlier
-atmega32u2atUART: LDSECTIONS = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
-else ## bigboot version is 1024 Bytes long; starts earlier
-atmega32u2atUART: LDSECTIONS = -Wl,--section-start=.text=0x7c00 -Wl,--section-start=.version=0x7ffe
-endif
 atmega32u2atUART: $(PROGRAM)_atmega32u2_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).hex
 ifndef PRODUCTION
 atmega32u2atUART: $(PROGRAM)_atmega32u2_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).lst
@@ -125,11 +110,6 @@ atmega16u4atUART: TARGET = atmega16u4
 atmega16u4atUART: MCU_TARGET = atmega16u4
 atmega16u4atUART: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega16u4atUART: AVR_FREQ ?= 16000000L
-ifndef BIGBOOT ## standard version is 512 Bytes long; starts earlier
-atmega16u4atUART: LDSECTIONS = -Wl,--section-start=.text=0x3e00 -Wl,--section-start=.version=0x3ffe
-else ## bigboot version is 1024 Bytes long; starts earlier
-atmega16u4atUART: LDSECTIONS = -Wl,--section-start=.text=0x3c00 -Wl,--section-start=.version=0x3ffe
-endif
 atmega16u4atUART: $(PROGRAM)_atmega16u4_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).hex
 ifndef PRODUCTION
 atmega16u4atUART: $(PROGRAM)_atmega16u4_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).lst
@@ -160,11 +140,6 @@ atmega32u4atUART: TARGET = atmega32u4
 atmega32u4atUART: MCU_TARGET = atmega32u4
 atmega32u4atUART: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega32u4atUART: AVR_FREQ ?= 16000000L
-ifndef BIGBOOT ## standard version is 512 Bytes long; starts earlier
-atmega32u4atUART: LDSECTIONS = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
-else ## bigboot version is 1024 Bytes long; starts earlier
-atmega32u4atUART: LDSECTIONS = -Wl,--section-start=.text=0x7c00 -Wl,--section-start=.version=0x7ffe
-endif
 atmega32u4atUART: $(PROGRAM)_atmega32u4_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).hex
 ifndef PRODUCTION
 atmega32u4atUART: $(PROGRAM)_atmega32u4_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).lst
@@ -195,11 +170,6 @@ atmega32u6atUART: TARGET = atmega32u6
 atmega32u6atUART: MCU_TARGET = atmega32u6
 atmega32u6atUART: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 atmega32u6atUART: AVR_FREQ ?= 16000000L
-ifndef BIGBOOT ## standard version is 512 Bytes long; starts earlier
-atmega32u6atUART: LDSECTIONS = -Wl,--section-start=.text=0x7e00 -Wl,--section-start=.version=0x7ffe
-else ## bigboot version is 1024 Bytes long; starts earlier
-atmega32u6atUART: LDSECTIONS = -Wl,--section-start=.text=0x7c00 -Wl,--section-start=.version=0x7ffe
-endif
 atmega32u6atUART: $(PROGRAM)_atmega32u6_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).hex
 ifndef PRODUCTION
 atmega32u6atUART: $(PROGRAM)_atmega32u6_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).lst
@@ -229,11 +199,6 @@ at90usb646atUART: TARGET = at90usb646
 at90usb646atUART: MCU_TARGET = at90usb646
 at90usb646atUART: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 at90usb646atUART: AVR_FREQ ?= 16000000L
-ifndef BIGBOOT ## standard version is 512 Bytes long; starts earlier
-at90usb646atUART: LDSECTIONS = -Wl,--section-start=.text=0xfc00 -Wl,--section-start=.version=0xfffe
-else ## bigboot version is 1024 Bytes long; starts earlier
-at90usb646atUART: LDSECTIONS = -Wl,--section-start=.text=0xf800 -Wl,--section-start=.version=0xfffe
-endif
 at90usb646atUART: $(PROGRAM)_at90usb646_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).hex
 ifndef PRODUCTION
 at90usb646atUART: $(PROGRAM)_at90usb646_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).lst
@@ -244,11 +209,7 @@ at90usb646:
 at90usb646_isp: at90usb646
 at90usb646_isp: TARGET = at90usb646
 at90usb646_isp: MCU_TARGET = at90usb646
-ifndef BIGBOOT ## standard version is 1024 Bytes long; starts earlier
 at90usb646_isp: HFUSE ?= DE# = 1024 byte boot, SPI (ISP!!!) enabled, JTAG disabled
-else ## bigboot version is 2048 Bytes long; starts earlier
-at90usb646_isp: HFUSE ?= DC# = 2048 byte boot, SPI (ISP!!!) enabled, JTAG disabled
-endif
 at90usb646_isp: LFUSE ?= FF# = Full Swing xtal (16MHz) 16KCK/14CK+65ms
 at90usb646_isp: EFUSE ?= FB# = 2.6V brownout
 at90usb646_isp: LOCK  ?= 2F# = APP protect mode 1, BL protect mode 2
@@ -263,11 +224,6 @@ at90usb647atUART: TARGET = at90usb647
 at90usb647atUART: MCU_TARGET = at90usb647
 at90usb647atUART: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 at90usb647atUART: AVR_FREQ ?= 16000000L
-ifndef BIGBOOT ## standard version is 1024 Bytes long; starts earlier
-at90usb647atUART: LDSECTIONS = -Wl,--section-start=.text=0xfc00 -Wl,--section-start=.version=0xfffe
-else ## bigboot version is 2048 Bytes long; starts earlier
-at90usb647atUART: LDSECTIONS = -Wl,--section-start=.text=0xf800 -Wl,--section-start=.version=0xfffe
-endif
 at90usb647atUART: $(PROGRAM)_at90usb647_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).hex
 ifndef PRODUCTION
 at90usb647atUART: $(PROGRAM)_at90usb647_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).lst
@@ -278,11 +234,7 @@ at90usb647:
 at90usb647_isp: at90usb647
 at90usb647_isp: TARGET = at90usb647
 at90usb647_isp: MCU_TARGET = at90usb647	
-ifndef BIGBOOT ## standard version is 1024 Bytes long; starts earlier
 at90usb647_isp: HFUSE ?= DE# = 1024 byte boot, SPI (ISP!!!) enabled, JTAG disabled
-else ## bigboot version is 2048 Bytes long; starts earlier
-at90usb647_isp: HFUSE ?= DC# = 2048 byte boot, SPI (ISP!!!) enabled, JTAG disabled
-endif
 at90usb647_isp: LFUSE ?= FF# = Full Swing xtal (16MHz) 16KCK/14CK+65ms
 at90usb647_isp: EFUSE ?= FB# = 2.6V brownout
 at90usb647_isp: LOCK  ?= 2F# = APP protect mode 1, BL protect mode 2
@@ -297,11 +249,6 @@ at90usb1286atUART: TARGET = at90usb1286
 at90usb1286atUART: MCU_TARGET = at90usb1286
 at90usb1286atUART: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 at90usb1286atUART: AVR_FREQ ?= 16000000L
-ifndef BIGBOOT ## standard version is 1024 Bytes long; starts earlier
-at90usb1286atUART: LDSECTIONS = -Wl,--section-start=.text=0x1fc00 -Wl,--section-start=.version=0x1fffe
-else ## bigboot version is 2048 Bytes long; starts earlier
-at90usb1286atUART: LDSECTIONS = -Wl,--section-start=.text=0x1f800 -Wl,--section-start=.version=0x1fffe
-endif
 at90usb1286atUART: $(PROGRAM)_at90usb1286_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).hex
 ifndef PRODUCTION
 at90usb1286atUART: $(PROGRAM)_at90usb1286_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).lst
@@ -312,11 +259,7 @@ at90usb1286:
 at90usb1286_isp: at90usb1286
 at90usb1286_isp: TARGET = at90usb1286
 at90usb1286_isp: MCU_TARGET = at90usb1286	
-ifndef BIGBOOT ## standard version is 1024 Bytes long; starts earlier
 at90usb1286_isp: HFUSE ?= DE# = 1024 byte boot, SPI (ISP!!!) enabled, JTAG disabled
-else ## bigboot version is 2048 Bytes long; starts earlier
-at90usb1286_isp: HFUSE ?= DC# = 2048 byte boot, SPI (ISP!!!) enabled, JTAG disabled
-endif
 at90usb1286_isp: LFUSE ?= FF# = Full Swing xtal (16MHz) 16KCK/14CK+65ms
 at90usb1286_isp: EFUSE ?= FB# = 2.6V brownout
 at90usb1286_isp: LOCK  ?= 2F# = APP protect mode 1, BL protect mode 2
@@ -331,11 +274,6 @@ at90usb1287atUART: TARGET = at90usb1287
 at90usb1287atUART: MCU_TARGET = at90usb1287
 at90usb1287atUART: CFLAGS += $(COMMON_OPTIONS) $(UART_CMD)
 at90usb1287atUART: AVR_FREQ ?= 16000000L
-ifndef BIGBOOT ## standard version is 1024 Bytes long; starts earlier
-at90usb1287atUART: LDSECTIONS = -Wl,--section-start=.text=0x1fc00 -Wl,--section-start=.version=0x1fffe
-else ## bigboot version is 2048 Bytes long; starts earlier
-at90usb1287atUART: LDSECTIONS = -Wl,--section-start=.text=0x1f800 -Wl,--section-start=.version=0x1fffe
-endif
 at90usb1287atUART: $(PROGRAM)_at90usb1287_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).hex
 ifndef PRODUCTION
 at90usb1287atUART: $(PROGRAM)_at90usb1287_UART$(UART)_$(BAUD_RATE)_$(AVR_FREQ)_BB$(BIGBOOT).lst
@@ -346,11 +284,7 @@ at90usb1287:
 at90usb1287_isp: at90usb1287
 at90usb1287_isp: TARGET = at90usb1287
 at90usb1287_isp: MCU_TARGET = at90usb1287	
-ifndef BIGBOOT ## standard version is 1024 Bytes long; starts earlier
 at90usb1287_isp: HFUSE ?= DE# = 1024 byte boot, SPI (ISP!!!) enabled, JTAG disabled
-else ## bigboot version is 2048 Bytes long; starts earlier
-at90usb1287_isp: HFUSE ?= DC# = 2048 byte boot, SPI (ISP!!!) enabled, JTAG disabled
-endif
 at90usb1287_isp: LFUSE ?= FF# = Full Swing xtal (16MHz) 16KCK/14CK+65ms
 at90usb1287_isp: EFUSE ?= FB# = 2.6V brownout
 at90usb1287_isp: LOCK  ?= 2F# = APP protect mode 1, BL protect mode 2

optiboot/bootloaders/optiboot/link_optiboot.ld

@@ -0,0 +1,145 @@
+/* Customized Linker script for Optiboot */
+
+/* Copyright (C) 2014-2015 Free Software Foundation, Inc.
+   Copyright (C) 2021 by William Westfield
+   Copying and distribution of this script, with or without modification,
+   are permitted in any medium without royalty provided the copyright
+   notice and this notice are preserved.
+*/
+
+/*
+ * this is based off of the default ATmega328 linker script, but it
+ * has been generalized (since optiboot makes little use of the standard
+ * chip-specific values), and also specialized to based start addresses
+ * of the code on symbols passed from the C program, instead of needing
+ * --section-start commands in the linker command line.
+ * (The C program does this by using asm() statements to define absolute
+ * symbols that the linker can see.
+ * The .data and .bss segments are removed, since the bootloader must not
+ * use them (and does its own memory management) (this has the added
+ * "benefit" of spitting out error messages if the code DOES try to
+ * use data or bss variables.
+ */
+
+OUTPUT_FORMAT("elf32-avr","elf32-avr","elf32-avr")
+__FUSE_REGION_LENGTH__ = DEFINED(__FUSE_REGION_LENGTH__) ? __FUSE_REGION_LENGTH__ : 1K;
+/* This makes the disassembly listings prettier */
+__RAM__ = 0x800000;
+
+MEMORY
+{
+  text   (rx)   : ORIGIN = __BOOT_START__, LENGTH = __BOOT_SIZE__
+  version   (rx)   : ORIGIN = __VERSION_START__, LENGTH = 2
+  fuse      (rw!x) : ORIGIN = 0x820000, LENGTH = __FUSE_REGION_LENGTH__
+}
+
+SECTIONS
+{
+  /* Read-only sections, merged into text segment: */
+  /* Internal text space or external memory.  */
+  .text   :
+  {
+    *(.vectors)
+    KEEP(*(.vectors))
+    /* For data that needs to reside in the lower 64k of progmem.  */
+     *(.progmem.gcc*)
+    /* PR 13812: Placing the trampolines here gives a better chance
+       that they will be in range of the code that uses them.  */
+    . = ALIGN(2);
+    *(.init0)  /* Start here after reset.  */
+    KEEP (*(.init0))
+    *(.init1)
+    KEEP (*(.init1))
+    *(.init2)  /* Clear __zero_reg__, set up stack pointer.  */
+    KEEP (*(.init2))
+    *(.init3)
+    KEEP (*(.init3))
+    *(.init4)  /* Initialize data and BSS.  */
+    KEEP (*(.init4))
+    *(.init5)
+    KEEP (*(.init5))
+    *(.init6)  /* C++ constructors.  */
+    KEEP (*(.init6))
+    *(.init7)
+    KEEP (*(.init7))
+    *(.init8)
+    KEEP (*(.init8))
+    *(.init9)  /* Call main().  */
+    KEEP (*(.init9))
+    *(.text)
+    . = ALIGN(2);
+     *(.text.*)
+    . = ALIGN(2);
+    *(.fini9)  /* _exit() starts here.  */
+    KEEP (*(.fini9))
+    *(.fini8)
+    KEEP (*(.fini8))
+    *(.fini7)
+    KEEP (*(.fini7))
+    *(.fini6)  /* C++ destructors.  */
+    KEEP (*(.fini6))
+    *(.fini5)
+    KEEP (*(.fini5))
+    *(.fini4)
+    KEEP (*(.fini4))
+    *(.fini3)
+    KEEP (*(.fini3))
+    *(.fini2)
+    KEEP (*(.fini2))
+    *(.fini1)
+    KEEP (*(.fini1))
+    *(.fini0)  /* Infinite loop after program termination.  */
+    KEEP (*(.fini0))
+     _etext = . ;
+  }  > text
+  .version __VERSION_START__ :
+  {
+    *(.version)
+  } > text
+  .fuse  :
+  {
+    KEEP(*(.fuse))
+    KEEP(*(.lfuse))
+    KEEP(*(.hfuse))
+    KEEP(*(.efuse))
+  }  > fuse
+  /* Stabs debugging sections.  */
+  .stab 0 : { *(.stab) }
+  .stabstr 0 : { *(.stabstr) }
+  .stab.excl 0 : { *(.stab.excl) }
+  .stab.exclstr 0 : { *(.stab.exclstr) }
+  .stab.index 0 : { *(.stab.index) }
+  .stab.indexstr 0 : { *(.stab.indexstr) }
+  .comment 0 : { *(.comment) }
+  .note.gnu.build-id : { *(.note.gnu.build-id) }
+  /* DWARF debug sections.
+     Symbols in the DWARF debugging sections are relative to the beginning
+     of the section so we begin them at 0.  */
+  /* DWARF 1 */
+  .debug          0 : { *(.debug) }
+  .line           0 : { *(.line) }
+  /* GNU DWARF 1 extensions */
+  .debug_srcinfo  0 : { *(.debug_srcinfo) }
+  .debug_sfnames  0 : { *(.debug_sfnames) }
+  /* DWARF 1.1 and DWARF 2 */
+  .debug_aranges  0 : { *(.debug_aranges) }
+  .debug_pubnames 0 : { *(.debug_pubnames) }
+  /* DWARF 2 */
+  .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
+  .debug_abbrev   0 : { *(.debug_abbrev) }
+  .debug_line     0 : { *(.debug_line .debug_line.* .debug_line_end ) }
+  .debug_frame    0 : { *(.debug_frame) }
+  .debug_str      0 : { *(.debug_str) }
+  .debug_loc      0 : { *(.debug_loc) }
+  .debug_macinfo  0 : { *(.debug_macinfo) }
+  /* SGI/MIPS DWARF 2 extensions */
+  .debug_weaknames 0 : { *(.debug_weaknames) }
+  .debug_funcnames 0 : { *(.debug_funcnames) }
+  .debug_typenames 0 : { *(.debug_typenames) }
+  .debug_varnames  0 : { *(.debug_varnames) }
+  /* DWARF 3 */
+  .debug_pubtypes 0 : { *(.debug_pubtypes) }
+  .debug_ranges   0 : { *(.debug_ranges) }
+  /* DWARF Extension.  */
+  .debug_macro    0 : { *(.debug_macro) }
+}

optiboot/bootloaders/optiboot/makeall.everycpu.sh

@@ -0,0 +1,115 @@
+#
+# Makefile to make one image for each chip that optiboot supports.
+# includes Arduino, Spence Konde ATtinyCore, Hans MCUDude cores, and
+# some others.
+# this is mainly used to sanity check modifications, especially those
+# that are expected to cause "no binary changes" (you can diff the
+# resulting .hex file with a reference implementation.)
+#
+
+make clean
+
+#Attinycore
+make attiny841at16
+make attiny841at16ser1
+make attiny441at16
+make attiny441at16ser1
+make attiny87at16
+make attiny167at16
+make attiny1634at16
+make attiny1634at16ser1
+make attiny828at16
+make attiny88at16
+make attiny48at16
+make attiny85at16
+make attiny45at16
+make attiny84at16
+make attiny44at16
+make attiny861at16
+make attiny461at16
+
+# mega
+make mega2560
+make mega1280
+
+# usb
+make atmega8u2   LED=D5 LED_START_FLASHES=2 UART=1
+make atmega16u2  LED=D5 LED_START_FLASHES=2 UART=1
+make atmega32u2  LED=D5 LED_START_FLASHES=2 UART=1
+make atmega16u4  LED=C7 LED_START_FLASHES=0 UART=1
+make atmega32u4  LED=C7 LED_START_FLASHES=0 UART=1
+make atmega32u6  LED=C6 LED_START_FLASHES=2 UART=1
+make at90usb646  LED=C6 LED_START_FLASHES=2 UART=1  NODATE=1 BIGBOOT=1
+make at90usb647  LED=C6 LED_START_FLASHES=2 UART=1  NODATE=1 BIGBOOT=1
+make at90usb1286  LED=C6 LED_START_FLASHES=2 UART=1 NODATE=1 BIGBOOT=1
+make at90usb1287  LED=C6 LED_START_FLASHES=2 UART=1 NODATE=1 BIGBOOT=1
+
+#  buildable platforms of somewhat questionable support level
+make lilypad
+make pro8
+make pro16
+make pro20
+make atmega328_pro8
+make sanguino
+make mega1280
+make luminet
+make diecimila
+make bobuino
+make wildfirev2
+make atmega1284
+make atmega32
+make atmega168p
+
+# Atmel development board targets
+make xplained168pb
+make xplained328p
+make xplained328pb
+
+# mcudude cores
+make atmega8     LED=B5 LED_START_FLASHES=2 UART=0
+make atmega16    LED=B0 LED_START_FLASHES=2 UART=0
+make atmega32    LED=B0 LED_START_FLASHES=2 UART=0
+make atmega64    LED=B5 LED_START_FLASHES=2 UART=0 BIGBOOT=1 NODATE=1
+make atmega88    LED=B5 LED_START_FLASHES=2 UART=0
+make atmega88p   LED=B5 LED_START_FLASHES=2 UART=0
+make atmega88pb  LED=B5 LED_START_FLASHES=2 UART=0
+make atmega128   LED=B5 LED_START_FLASHES=2 UART=0 BIGBOOT=1 NODATE=1
+make atmega162   LED=B0 LED_START_FLASHES=0 UART=0
+make atmega164a  LED=B0 LED_START_FLASHES=2 UART=0
+make atmega164p  LED=B0 LED_START_FLASHES=2 UART=0
+make atmega168   LED=B5 LED_START_FLASHES=2 UART=0
+make atmega168p  LED=B5 LED_START_FLASHES=2 UART=0
+make atmega168pb LED=B5 LED_START_FLASHES=2 UART=0
+make atmega169   LED=B5 LED_START_FLASHES=2 UART=0
+make atmega169p  LED=B5 LED_START_FLASHES=2 UART=0
+make atmega324a  LED=B0 LED_START_FLASHES=2 UART=0
+make atmega324p  LED=B0 LED_START_FLASHES=2 UART=0
+make atmega324pa LED=B0 LED_START_FLASHES=2 UART=0
+make atmega324pb LED=B0 LED_START_FLASHES=2 UART=0
+make atmega328   LED=B5 LED_START_FLASHES=2 UART=0
+make atmega328pb LED=B5 LED_START_FLASHES=2 UART=0
+make atmega329   LED=B5 LED_START_FLASHES=2 UART=0
+make atmega329p  LED=B5 LED_START_FLASHES=2 UART=0
+make atmega640   LED=B7 LED_START_FLASHES=2 UART=0 BIGBOOT=1 NODATE=1
+make atmega644p  LED=B0 LED_START_FLASHES=2 UART=0 BIGBOOT=1 NODATE=1
+make atmega649   LED=B5 LED_START_FLASHES=2 UART=0 BIGBOOT=1 NODATE=1
+make atmega649p  LED=B5 LED_START_FLASHES=2 UART=0 BIGBOOT=1 NODATE=1
+make atmega1280  LED=B7 LED_START_FLASHES=2 UART=0 BIGBOOT=1 NODATE=1
+make atmega1281  LED=B5 LED_START_FLASHES=2 UART=0 BIGBOOT=1 NODATE=1
+make atmega1284  LED=B0 LED_START_FLASHES=2 UART=0 BIGBOOT=1 NODATE=1
+make atmega1284p LED=B0 LED_START_FLASHES=2 UART=0 BIGBOOT=1 NODATE=1
+make atmega2560  LED=B7 LED_START_FLASHES=2 UART=0 BIGBOOT=1 NODATE=1
+make atmega2561  LED=B5 LED_START_FLASHES=2 UART=0 BIGBOOT=1 NODATE=1
+make atmega3290  LED=B5 LED_START_FLASHES=2 UART=0
+make atmega3290p LED=B5 LED_START_FLASHES=2 UART=0
+make atmega6490  LED=B5 LED_START_FLASHES=2 UART=0 BIGBOOT=1 NODATE=1
+make atmega6490p LED=B5 LED_START_FLASHES=2 UART=0 BIGBOOT=1 NODATE=1
+make atmega8515  LED=B0 LED_START_FLASHES=2 UART=0
+make atmega8535  LED=B0 LED_START_FLASHES=2 UART=0
+
+# default generic platforms
+# These need to be built AFTER the platforms, or they'll get renamed
+make atmega8
+make atmega168
+make atmega328
+

optiboot/bootloaders/optiboot/optiboot.c

@@ -239,6 +239,10 @@
 /**********************************************************/
 /* Edit History:                                          */
 /*                                                        */
+/* Oct 2021                                               */
+/* 8.3 WestfW add section-start determination code to     */
+/*     the C source.  In theory, this causes no changes   */
+/*     to the binary, but it's "risky", so ... bump.      */
 /* Aug 2019                                               */
 /* 8.1  WestfW Fix bug in calculation of Vboot offset     */
 /* Sep 2018                                               */
@@ -328,7 +332,7 @@
 /**********************************************************/
 
 #define OPTIBOOT_MAJVER 8
-#define OPTIBOOT_MINVER 2
+#define OPTIBOOT_MINVER 3
 
 /*
  * OPTIBOOT_CUSTOMVER should be defined (by the makefile) for custom edits
@@ -597,6 +601,92 @@ static addr16_t buff = {(uint8_t *)(RAMSTART)};
 
 #endif // VIRTUAL_BOOT_PARTITION
 
+void sectionOpts() __attribute__((naked));
+void sectionOpts() {
+/*
+ * Mysterious Magic code to allow section-start addresses to be
+ * specifed by the C code (which, after all, has access to CPP symbols
+ * like FLASHEND, and can make a "safer" guess than putting manually
+ * determined constants in the Makefile.  This is dependent on a custom
+ * linker script that makes use of the __BOOT_ symbols that we define.
+ * Fortunately, that script can be used to link optiboot on any of its
+ * usual chips.
+ *
+ * with some judicious use of asm directives, we can define symbols
+ * that the linker will look at for positioning our segments (in
+ * combination with a custom linker script) based on the flash size
+ * defined via io.h, instead of requiring magic --section-start
+ * constants on the build line.
+ *
+ * This apparently needs to be inside a function in order to pass
+ * arguments to the asm command (even though the asm doesn't
+ * generate any code)  But we can make sure the function (which doesn't
+ * actually contain any code) doesn't actually end up in the binary.
+ */
+#if BIGBOOT
+  /*
+   * BIGBOOT images are easy, because they're much smaller than the
+   * flash size that they are defined to occupy (1k)
+   */
+  asm(" .global __BOOT_SIZE__, __BOOT_START__, __VERSION_START__\n"
+      " .equ __BOOT_SIZE__, 1024\n"
+      " .equ __BOOT_START__, (%0-1023)\n"
+      " .equ __VERSION_START__, (%0-1)\n"
+      ::"i"((uint32_t)FLASHEND));
+#else
+  /*
+   * non-BIGBOOT images try to fit in 512bytes, but don't quite fit
+   * on chips that don't have HW support for a boot section.  We try
+   * to guess how big the extra bits of code are, and then round up
+   * to the next larger flash page boundry (which can be nearly 4 pages
+   * away on chips with FOURPAGEERASE)
+   * These numbers are determined manually by building a reference
+   * implementation with various options and comparing sizes.
+   */
+# if VIRTUAL_BOOT_PARTITION
+/*  VIRTUAL_BOOT_PARTITION code is about 100 bytes */
+#   define VBSIZE 110
+# else
+#   define VBSIZE 0
+# endif
+# if LED_START_FLASHES==0
+/*  if LED_START_FLASHES is 0 (eg on 8pin chips), it saves some code */
+#   define LEDSIZE (-30)
+# else
+#   define LEDSIZE 0
+# endif
+# if SOFT_UART
+/*  But not having a hardware UART costs a bit */
+#   define SOFTUSIZE 16
+# else
+#   define SOFTUSIZE 0
+# endif
+
+# if FOURPAGEERASE
+/*  FOURPAGEERASE adds some code, and also affects how we round */
+#   define ERASESIZE 8
+#   define PAGSIZ_B (SPM_PAGESIZE*4)
+# else
+#   define PAGSIZ_B (SPM_PAGESIZE)
+#   define ERASESIZE 0
+# endif
+
+/*
+ * Round our guess up to next page size.  So 560 byte images occupy 576bytes,
+ * 600 byte images occupy 640 bytes, etc.  Depending on chip.
+ * Note that SPM_PAGESIZE is already in bytes in the .h files.
+ */  
+# define ROUNDTOPAGE(size) (((size + (PAGSIZ_B/2))/(PAGSIZ_B))*(PAGSIZ_B))
+/* use 511 here so we don't round up to the next page on normal systems. */
+# define BOOTSIZE (511+ERASESIZE+VBSIZE+SOFTUSIZE+LEDSIZE)
+  asm(" .global __BOOT_SIZE__, __BOOT_START__, __VERSION_START__\n"
+      " .equ __BOOT_SIZE__, %1\n"
+      " .equ __BOOT_START__, ((%0+1)-%1)\n"
+      " .equ __VERSION_START__, (%0-1)\n"
+      ::"i"((uint32_t)FLASHEND), "i"(ROUNDTOPAGE(BOOTSIZE)));
+#endif
+/* Wasn't that FUN! */
+}
 
 /* everything that needs to run VERY early */
 void pre_main(void) {
@@ -1566,7 +1656,10 @@ OPT2FLASH(SOFT_UART);
 OPT2FLASH(UART);
 #endif
 
+#if (!defined(NODATE)) || (NODATE == 0)
+// Leave out the date, useful if we want to compare binaries
 OPTFLASHSECT const char f_date[] = "Built:" __DATE__ ":" __TIME__;
+#endif
 #if BIGBOOT
 OPT2FLASH(BIGBOOT);
 #endif

optiboot/bootloaders/optiboot/optiboot_atmega1280.hex

@@ -1,55 +1,54 @@
 :020000021000EC
-:10FC000001C022C1112484B7882369F0982F9A700B
+:10FC000001C01DC1112484B7882369F0982F9A7010
 :10FC1000923049F081FF02C097EF94BF282E80E018
-:10FC2000FED00C94000085E08093810082E08093F8
+:10FC2000F9D00C94000085E08093810082E08093FD
 :10FC3000C00088E18093C10086E08093C20080E12B
-:10FC40008093C4008EE0EBD0279A86E020E33CEF5F
+:10FC40008093C4008EE0E6D0279A86E020E33CEF64
 :10FC500091E0309385002093840096BBB09BFECF4B
 :10FC60001F9AA8954091C00047FD02C0815089F7B6
-:10FC7000FF24F39455E0E52E61E1D62EC4D0813403
+:10FC7000FF24F39455E0E52E61E1D62EBFD0813408
-:10FC8000C9F4C1D0C82FD1D0C23811F481E010C05E
+:10FC800049F4BCD0C82FCCD0C13809F0A6C088E058
-:10FC9000C13869F488E00CC0843709F482C0853724
+:10FC9000AED0AAC0823411F484E103C0853419F4D3
-:10FCA00009F0A2C0C2D08EE1A7D087E9A5D083E039
+:10FCA00085E0C6D0A1C0853579F4A8D0082FA6D0AC
-:10FCB000A3D09FC0823411F484E103C0853419F4C9
+:10FCB000182F87FF03C08BB7816002C08BB78E7F80
-:10FCC00085E0BBD096C0853579F49DD0082F9BD0B8
+:10FCC0008BBF000F111F8FC0863581F497D08D3404
-:10FCD000182F87FF03C08BB7816002C08BB78E7F60
+:10FCD00049F494D0CBB792D0C170880FC82BCBBF5A
-:10FCE0008BBF000F111F84C0863581F48CD08D34FA
+:10FCE00081E001C083E0A4D080E0D2CF843609F067
-:10FCF00049F489D0CBB787D0C170880FC82BCBBF50
+:10FCF00048C084D0C82FD0E0DC2FCC277FD0C82BC1
-:10FD000081E001C083E099D080E0D2CF843609F051
+:10FD00007DD0C82E5E01812C32E0932E77D0F40195
-:10FD1000C3CF79D0C82FD0E0DC2FCC2774D0C82B2C
+:10FD100081934F01F1E0AF1AB108C1F781D085E4BA
-:10FD200072D0C82E5E01812C32E0932E6CD0F4018B
+:10FD2000C81212C0DE5F4801A12C92E0B92EAC16B9
-:10FD300081934F01F1E0AF1AB108C1F776D085E4A5
+:10FD3000BD0609F459C0F50161915F01C40197D076
-:10FD4000C81212C0DE5F4801A12C92E0B92EAC1699
+:10FD4000FFEF8F1A9F0AF3CF83E0F80187BFE89592
-:10FD5000BD0609F44EC0F50161915F01C4018CD06C
+:10FD500007B600FCFDCFA0E0B2E0F8018D919D91C7
-:10FD6000FFEF8F1A9F0AF3CF83E0F80187BFE89572
+:10FD60000C01F7BEE8951124229732962097B1F73F
-:10FD700007B600FCFDCFA0E0B2E0F8018D919D91A7
+:10FD7000F801E7BEE89507B600FCFDCFD7BEE895D1
-:10FD80000C01F7BEE8951124229732962097B1F71F
+:10FD800033C0843719F53AD0C82FD0E0DC2FCC2708
-:10FD9000F801E7BEE89507B600FCFDCFD7BEE895B1
+:10FD900035D05E01A82A32D0982E42D0E801F5E491
-:10FDA00028C031D0C82FD0E0DC2FCC272CD05E016A
+:10FDA0009F120BC0CE015BD022D081E0A81AB1080F
-:10FDB000A82A29D0982E39D0E801F5E49F120BC06B
+:10FDB0002196A114B104B1F717C0FE018791EF019C
-:10FDC000CE0152D019D081E0A81AB1082196A11411
+:10FDC00016D0E1E0AE1AB108C1F70EC0853739F49C
-:10FDD000B104B1F70EC0FE018791EF010DD0E1E053
+:10FDD00027D08EE10CD087E90AD083E059CF813556
-:10FDE000AE1AB108C1F705C0813511F488E017D00B
+:10FDE00011F488E017D01CD080E101D047CF90916A
-:10FDF0001CD080E101D042CF9091C00095FFFCCF94
+:10FDF000C00095FFFCCF8093C60008958091C0009D
-:10FE00008093C60008958091C00087FFFCCF809149
+:10FE000087FFFCCF8091C00084FD01C0A895809140
-:10FE1000C00084FD01C0A8958091C6000895E0E669
+:10FE1000C6000895E0E6F0E098E1908380830895BD
-:10FE2000F0E098E1908380830895EDDF803219F04F
+:10FE2000EDDF803219F088E0F5DFFFCF84E1DFCF2E
-:10FE300088E0F5DFFFCF84E1DFCFCF93C82FE3DF8A
+:10FE3000CF93C82FE3DFC150E9F7CF91F1CFFC0199
-:10FE4000C150E9F7CF91F1CFFC010A0167BFE895F6
+:10FE40000A0167BFE895112407B600FCFDCF667074
-:10FE5000112407B600FCFDCF667029F0452B19F47C
+:10FE500029F0452B19F481E187BFE8950895F999B8
-:10FE600081E187BFE8950895F999FECF92BD81BDE4
+:10FE6000FECF92BD81BDF89A992780B50895262FBF
-:10FE7000F89A992780B50895262FF999FECF1FBAD1
+:10FE7000F999FECF1FBA92BD81BD20BD0FB6F8948F
-:10FE800092BD81BD20BD0FB6F894FA9AF99A0FBEC3
+:10FE8000FA9AF99A0FBE01960895FF566572736942
-:10FE90000196089556657273696F6E3D382E310074
+:10FE90006F6E3D382E33004465766963653D61744D
-:10FEA0004F505449424F4F545F435553544F4D5652
+:10FEA0006D6567613132383000465F4350553D31F2
-:10FEB00045523D30004465766963653D61746D650A
+:10FEB000363030303030304C00424947424F4F549A
-:10FEC00067613132383000465F4350553D3136303E
+:10FEC0003D31004275696C743A4E6F7620203420C3
-:10FED00030303030304C00424947424F4F543D3172
+:10FED000323032313A31383A30333A3033005541EA
-:10FEE000004275696C743A4D6179203239203230A4
+:10FEE00052543D3000424155445F524154453D31EA
-:10FEF00032303A30313A30323A343000554152548F
+:10FEF0003135323030004C45443D4237004C4544AA
-:10FF00003D3000424155445F524154453D31313509
+:10FF00005F53544152545F464C41534845533D332F
-:10FF1000323030004C45443D4237004C45445F533D
+:01FF100000F0
-:0FFF2000544152545F464C41534845533D3300C2
+:02FFFE000308F6
-:02FFFE000108F8
 :040000031000FC00ED
 :00000001FF

optiboot/bootloaders/optiboot/optiboot_atmega328.hex

@@ -1,33 +1,33 @@
-:107E000001C0DEC0112484B7882361F0982F9A70D6
+:107E000001C0DAC0112484B7882361F0982F9A70DA
 :107E1000923041F081FF02C097EF94BF282E80E09E
-:107E2000BAD0EEC085E08093810082E08093C000EC
+:107E2000B6D0EEC085E08093810082E08093C000F0
 :107E300088E18093C10086E08093C20080E1809356
-:107E4000C4008EE0A8D0259A86E020E33CEF91E0C4
+:107E4000C4008EE0A4D0259A86E020E33CEF91E0C8
 :107E5000309385002093840096BBB09BFECF1D9A83
 :107E6000A8954091C00047FD02C0815089F7EE24DB
-:107E7000E39495E0D92E21E1C22E81D0813471F4B2
+:107E7000E39495E0D92E21E1C22E7DD0813451F4D6
-:107E80007ED0182F8ED0123811F481E005C0113841
+:107E80007AD0182F8AD0113811F083E001C088E031
-:107E900011F488E001C083E06BD067C0823411F434
+:107E90006BD067C0823411F484E103C0853419F4D7
-:107EA00084E103C0853419F485E083D05EC0853554
+:107EA00085E083D05EC0853539F465D0C82F63D0B6
-:107EB00039F465D0C82F63D0D82FCC0FDD1F54C044
+:107EB000D82FCC0FDD1F54C0863521F484E075D057
-:107EC000863521F484E075D080E0E6CF843609F071
+:107EC00080E0E6CF843609F02EC055D054D0F82E8D
-:107ED0002EC055D054D0F82E52D0B82E00E011E06C
+:107ED00052D0B82E00E011E04ED0F80181938F010E
-:107EE0004ED0F80181938F01FE12FACF5AD0F5E4FB
+:107EE000FE12FACF5AD0F5E4BF1201C0FFCF83E0F3
-:107EF000BF1201C0FFCF83E0FE0187BFE89507B640
+:107EF000FE0187BFE89507B600FCFDCFA0E0B1E02A
-:107F000000FCFDCFA0E0B1E0FE018D919D910C0140
+:107F0000FE018D919D910C01E7BEE89511243296FA
-:107F1000E7BEE89511243296FA12F7CFFE01D7BEDC
+:107F1000FA12F7CFFE01D7BEE89507B600FCFDCFF9
-:107F2000E89507B600FCFDCFC7BEE8951EC08437B4
+:107F2000C7BEE8951EC0843771F425D024D0F82E42
-:107F300071F425D024D0F82E22D033D08E01F80150
+:107F300022D033D08E01F80185918F0115D0FA94AB
-:107F400085918F0115D0FA94F110F9CF0EC08537C5
+:107F4000F110F9CF0EC0853739F427D08EE10CD06F
-:107F500039F427D08EE10CD085E90AD08FE09CCF90
+:107F500085E90AD08FE09CCF813511F488E017D0F5
-:107F6000813511F488E017D01CD080E101D085CF95
+:107F60001CD080E101D089CF9091C00095FFFCCF5B
-:107F70009091C00095FFFCCF8093C600089580913A
+:107F70008093C60008958091C00087FFFCCF809158
-:107F8000C00087FFFCCF8091C00084FD01C0A89590
+:107F8000C00084FD01C0A8958091C6000895E0E678
-:107F90008091C6000895E0E6F0E098E19083808348
+:107F9000F0E098E1908380830895EDDF803219F05E
-:107FA0000895EDDF803219F088E0F5DFFFCF84E13E
+:107FA00088E0F5DFFFCF84E1DFCFCF93C82FE3DF99
-:107FB000DFCFCF93C82FE3DFC150E9F7CF91F1CFE7
+:107FB000C150E9F7CF91F1CFFC010A0167BFE89505
-:107FC000FC010A0167BFE895112407B600FCFDCF4C
+:107FC000112407B600FCFDCF667029F0452B19F48B
-:107FD000667029F0452B19F481E187BFE895089573
+:087FD00081E187BFE8950895E7
-:027FFE00010878
+:027FFE00030876
 :0400000300007E007B
 :00000001FF

optiboot/bootloaders/optiboot/optiboot_atmega328.lst

@@ -3,29 +3,29 @@ optiboot_atmega328.elf:     file format elf32-avr
 
 Sections:
 Idx Name          Size      VMA       LMA       File off  Algn
-  0 .data         00000000  00800100  00007fe0  00000274  2**0
+  0 .text         000001d8  00007e00  00007e00  00000074  2**0
-                  CONTENTS, ALLOC, LOAD, DATA
-  1 .text         000001e0  00007e00  00007e00  00000094  2**1
                   CONTENTS, ALLOC, LOAD, READONLY, CODE
-  2 .version      00000002  00007ffe  00007ffe  00000274  2**0
+  1 .trampolines  00000000  00007fd8  00007fd8  0000024c  2**1
+                  CONTENTS, ALLOC, LOAD, READONLY, CODE
+  2 .version      00000002  00007ffe  00007ffe  0000024c  2**0
                   CONTENTS, ALLOC, LOAD, READONLY, DATA
-  3 .comment      0000002f  00000000  00000000  00000276  2**0
+  3 .comment      0000002f  00000000  00000000  0000024e  2**0
                   CONTENTS, READONLY
-  4 .debug_aranges 00000030  00000000  00000000  000002a5  2**0
+  4 .debug_aranges 00000030  00000000  00000000  0000027d  2**0
                   CONTENTS, READONLY, DEBUGGING
-  5 .debug_info   000005f9  00000000  00000000  000002d5  2**0
+  5 .debug_info   00000638  00000000  00000000  000002ad  2**0
                   CONTENTS, READONLY, DEBUGGING
-  6 .debug_abbrev 000002c1  00000000  00000000  000008ce  2**0
+  6 .debug_abbrev 000002e6  00000000  00000000  000008e5  2**0
                   CONTENTS, READONLY, DEBUGGING
-  7 .debug_line   0000033b  00000000  00000000  00000b8f  2**0
+  7 .debug_line   00000344  00000000  00000000  00000bcb  2**0
                   CONTENTS, READONLY, DEBUGGING
-  8 .debug_frame  0000009c  00000000  00000000  00000ecc  2**2
+  8 .debug_frame  000000ac  00000000  00000000  00000f10  2**2
                   CONTENTS, READONLY, DEBUGGING
-  9 .debug_str    00000200  00000000  00000000  00000f68  2**0
+  9 .debug_str    00000220  00000000  00000000  00000fbc  2**0
                   CONTENTS, READONLY, DEBUGGING
- 10 .debug_loc    00000359  00000000  00000000  00001168  2**0
+ 10 .debug_loc    00000359  00000000  00000000  000011dc  2**0
                   CONTENTS, READONLY, DEBUGGING
- 11 .debug_ranges 00000080  00000000  00000000  000014c1  2**0
+ 11 .debug_ranges 00000068  00000000  00000000  00001535  2**0
                   CONTENTS, READONLY, DEBUGGING
 
 Disassembly of section .text:
@@ -33,12 +33,12 @@ Disassembly of section .text:
 00007e00 <pre_main>:
 /* everything that needs to run VERY early */
 void pre_main(void) {
-  // Allow convenient way of calling do_spm function - jump table,
+  // Allow convenient way of calling do_spm function - jump table, so
-  //   so entry to this function will always be here, indepedent of compilation,
+  //   entry to this function will always be here, independent of
-  //   features etc
+  //   compilation, features etc
   asm volatile (
     7e00:	01 c0       	rjmp	.+2      	; 0x7e04 <main>
-    7e02:	de c0       	rjmp	.+444    	; 0x7fc0 <do_spm>
+    7e02:	da c0       	rjmp	.+436    	; 0x7fb8 <do_spm>
 
 00007e04 <main>:
   //  SP points to RAMEND
@@ -48,37 +48,36 @@ void pre_main(void) {
   // cli();
   asm volatile ("  clr __zero_reg__");
     7e04:	11 24       	eor	r1, r1
-#if defined(__AVR_ATmega8515__) || defined(__AVR_ATmega8535__) ||	\
+#  warning "START_APP_ON_EXTR is defined and NO_START_APP_ON_POR isn't"
-    defined(__AVR_ATmega16__)   || defined(__AVR_ATmega162__) ||	\
+#  define APP_START_REASONS 1 /* Always start rge App. */
-    defined (__AVR_ATmega128__)
+#  define WDRF_CLR_REASONS 0  /* Never clear WDRF */
-  ch = MCUCSR;
+#endif
-#else
+
   ch = MCUSR;
     7e06:	84 b7       	in	r24, 0x34	; 52
-#endif
+
   // Skip all logic and run bootloader if MCUSR is cleared (application request)
   if (ch != 0) {
     7e08:	88 23       	and	r24, r24
     7e0a:	61 f0       	breq	.+24     	; 0x7e24 <main+0x20>
-       *  2. we clear WDRF if it's set with EXTRF to avoid loops
      * One problematic scenario: broken application code sets watchdog timer
      * without clearing MCUSR before and triggers it quickly. But it's
      * recoverable by power-on with pushed reset button.
      */
-      if ((ch & (_BV(WDRF) | _BV(EXTRF))) != _BV(EXTRF)) { 
+
+    if (APP_START_REASONS) {
     7e0c:	98 2f       	mov	r25, r24
     7e0e:	9a 70       	andi	r25, 0x0A	; 10
     7e10:	92 30       	cpi	r25, 0x02	; 2
     7e12:	41 f0       	breq	.+16     	; 0x7e24 <main+0x20>
-	  if (ch & _BV(EXTRF)) {
+      if (WDRF_CLR_REASONS) {
     7e14:	81 ff       	sbrs	r24, 1
     7e16:	02 c0       	rjmp	.+4      	; 0x7e1c <main+0x18>
-    defined(__AVR_ATmega16__)   || defined(__AVR_ATmega162__) ||	\
+        /*
-    defined(__AVR_ATmega128__)
+         * Clear WDRF if it was most probably set by wdr in bootloader.
-               // Fix missing definitions in avr-libc
+         */
-	      MCUCSR = ~(_BV(WDRF));
+        if ((uint16_t)&MCUSR > 0x1F) {
-#else
+          MCUSR = ~(_BV(WDRF));   // optimize to LDI/OUT
-	      MCUSR = ~(_BV(WDRF));
     7e18:	97 ef       	ldi	r25, 0xF7	; 247
     7e1a:	94 bf       	out	0x34, r25	; 52
       /*
@@ -92,11 +91,11 @@ void pre_main(void) {
       // switch off watchdog
       watchdogConfig(WATCHDOG_OFF);
     7e1e:	80 e0       	ldi	r24, 0x00	; 0
-    7e20:	ba d0       	rcall	.+372    	; 0x7f96 <watchdogConfig>
+    7e20:	b6 d0       	rcall	.+364    	; 0x7f8e <watchdogConfig>
       // Note that appstart_vec is defined so that this works with either
       // real or virtual boot partitions.
       __asm__ __volatile__ (
-    7e22:	ee c0       	rjmp	.+476    	; 0x8000 <optiboot_version+0x2>
+    7e22:	ee c0       	rjmp	.+476    	; 0x8000 <__VERSION_START__+0x2>
 #elif defined(__AVR_ATtiny25__)||defined(__AVR_ATtiny45__)||defined(__AVR_ATtiny85__)
   TCCR1 = 0x0E; //div 8196 - it's an 8-bit timer.
 #elif defined(__AVR_ATtiny43__)
@@ -104,35 +103,35 @@ void pre_main(void) {
 #else
   TCCR1B = _BV(CS12) | _BV(CS10); // div 1024
     7e24:	85 e0       	ldi	r24, 0x05	; 5
-    7e26:	80 93 81 00 	sts	0x0081, r24	; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>
+    7e26:	80 93 81 00 	sts	0x0081, r24	; 0x800081 <__RAM__+0x81>
   LINBTR = (1 << LDISR) | (8 << LBT0); 
   LINCR = _BV(LENA) | _BV(LCMD2) | _BV(LCMD1) | _BV(LCMD0);
   LINDAT=0;
 #else
-      #ifndef SINGLESPEED
+#if (SINGLESPEED == 0)
   UART_SRA = _BV(U2X0); //Double speed mode USART0
     7e2a:	82 e0       	ldi	r24, 0x02	; 2
-    7e2c:	80 93 c0 00 	sts	0x00C0, r24	; 0x8000c0 <__TEXT_REGION_LENGTH__+0x7e00c0>
+    7e2c:	80 93 c0 00 	sts	0x00C0, r24	; 0x8000c0 <__RAM__+0xc0>
 #endif
   UART_SRB = _BV(RXEN0) | _BV(TXEN0);
     7e30:	88 e1       	ldi	r24, 0x18	; 24
-    7e32:	80 93 c1 00 	sts	0x00C1, r24	; 0x8000c1 <__TEXT_REGION_LENGTH__+0x7e00c1>
+    7e32:	80 93 c1 00 	sts	0x00C1, r24	; 0x8000c1 <__RAM__+0xc1>
   UART_SRC = _BV(UCSZ00) | _BV(UCSZ01);
     7e36:	86 e0       	ldi	r24, 0x06	; 6
-    7e38:	80 93 c2 00 	sts	0x00C2, r24	; 0x8000c2 <__TEXT_REGION_LENGTH__+0x7e00c2>
+    7e38:	80 93 c2 00 	sts	0x00C2, r24	; 0x8000c2 <__RAM__+0xc2>
   UART_SRL = (uint8_t)BAUD_SETTING;
     7e3c:	80 e1       	ldi	r24, 0x10	; 16
-    7e3e:	80 93 c4 00 	sts	0x00C4, r24	; 0x8000c4 <__TEXT_REGION_LENGTH__+0x7e00c4>
+    7e3e:	80 93 c4 00 	sts	0x00C4, r24	; 0x8000c4 <__RAM__+0xc4>
-    #endif // LIN_UART
+  RS485_PORT &= ~_BV(RS485_BIT);
-  #endif // mega8/etc
+  #endif
-#endif // soft_uart
+#endif
 
   // Set up watchdog to trigger after desired timeout
   watchdogConfig(WDTPERIOD);
     7e42:	8e e0       	ldi	r24, 0x0E	; 14
-    7e44:	a8 d0       	rcall	.+336    	; 0x7f96 <watchdogConfig>
+    7e44:	a4 d0       	rcall	.+328    	; 0x7f8e <watchdogConfig>
 
-#if (LED_START_FLASHES > 0) || defined(LED_DATA_FLASH) || defined(LED_START_ON)
+#if (LED_START_FLASHES > 0) || LED_DATA_FLASH || LED_START_ON
   /* Set LED pin as output */
   LED_DDR |= _BV(LED);
     7e46:	25 9a       	sbi	0x04, 5	; 4
@@ -147,9 +146,14 @@ void pre_main(void) {
     7e4c:	3c ef       	ldi	r19, 0xFC	; 252
     TIFR1 = _BV(TOV1);
     7e4e:	91 e0       	ldi	r25, 0x01	; 1
+    TIFR = _BV(TOV1);
+    while (!(TIFR & _BV(TOV1)));
+#elif defined(__AVR_ATtiny43__)
+#error "LED flash for Tiny43 not yet supported"
+#else
     TCNT1 = -(F_CPU/(1024*16));
-    7e50:	30 93 85 00 	sts	0x0085, r19	; 0x800085 <__TEXT_REGION_LENGTH__+0x7e0085>
+    7e50:	30 93 85 00 	sts	0x0085, r19	; 0x800085 <__RAM__+0x85>
-    7e54:	20 93 84 00 	sts	0x0084, r18	; 0x800084 <__TEXT_REGION_LENGTH__+0x7e0084>
+    7e54:	20 93 84 00 	sts	0x0084, r18	; 0x800084 <__RAM__+0x84>
     TIFR1 = _BV(TOV1);
     7e58:	96 bb       	out	0x16, r25	; 22
     while (!(TIFR1 & _BV(TOV1)));
@@ -160,7 +164,7 @@ void pre_main(void) {
   defined(__AVR_ATmega64__)   || defined(__AVR_ATmega128__)
   LED_PORT ^= _BV(LED);
 #else
-    LED_PIN |= _BV(LED);
+  LED_PIN |= _BV(LED);  // Newer AVRs can toggle by writing PINx
     7e5e:	1d 9a       	sbi	0x03, 5	; 3
 }
 #endif
@@ -169,14 +173,29 @@ void pre_main(void) {
 void watchdogReset() {
   __asm__ __volatile__ (
     7e60:	a8 95       	wdr
+     *  by the UART hardware, avrdude sends several attempts in rather
+     *  quick succession, some of which will be lost and cause us to
+     *  get out of sync.  So if we see any data; stop blinking.
+     */
+#ifndef LIN_UART
     if (UART_SRA & _BV(RXC0))
-    7e62:	40 91 c0 00 	lds	r20, 0x00C0	; 0x8000c0 <__TEXT_REGION_LENGTH__+0x7e00c0>
+    7e62:	40 91 c0 00 	lds	r20, 0x00C0	; 0x8000c0 <__RAM__+0xc0>
     7e66:	47 fd       	sbrc	r20, 7
     7e68:	02 c0       	rjmp	.+4      	; 0x7e6e <main+0x6a>
     7e6a:	81 50       	subi	r24, 0x01	; 1
+#else
+// This doesn't seem to work?
+//    if ((UART_PIN & (1<<UART_RX_BIT)) == 0)
+//      break;  // detect start bit on soft uart too.
+#endif
   } while (--count);
     7e6c:	89 f7       	brne	.-30     	; 0x7e50 <main+0x4c>
-	  putch(optiboot_version & 0xFF);
+
+      /*
+       * Copy data from the buffer into the flash write buffer.
+       */
+      do {
+        __boot_page_fill_short((uint16_t)(void*)addrPtr, *(mybuff.wptr++));
     7e6e:	ee 24       	eor	r14, r14
     7e70:	e3 94       	inc	r14
       } while (len -= 2);
@@ -192,282 +211,426 @@ void watchdogReset() {
       // Reenable read access to flash
       __boot_rww_enable_short();
     7e76:	21 e1       	ldi	r18, 0x11	; 17
+#endif
+
+  /* Forever loop: exits by causing WDT reset */
+  for (;;) {
+    /* get character from UART */
     ch = getch();
     7e78:	c2 2e       	mov	r12, r18
+
     if (ch == STK_GET_PARAMETER) {
-    7e7a:	81 d0       	rcall	.+258    	; 0x7f7e <getch>
+    7e7a:	7d d0       	rcall	.+250    	; 0x7f76 <getch>
       unsigned char which = getch();
     7e7c:	81 34       	cpi	r24, 0x41	; 65
-    7e7e:	71 f4       	brne	.+28     	; 0x7e9c <main+0x98>
+    7e7e:	51 f4       	brne	.+20     	; 0x7e94 <main+0x90>
-    7e80:	7e d0       	rcall	.+252    	; 0x7f7e <getch>
+    7e80:	7a d0       	rcall	.+244    	; 0x7f76 <getch>
       verifySpace();
     7e82:	18 2f       	mov	r17, r24
-    7e84:	8e d0       	rcall	.+284    	; 0x7fa2 <verifySpace>
+    7e84:	8a d0       	rcall	.+276    	; 0x7f9a <verifySpace>
+       * Send optiboot version as "SW version"
+       * Note that the references to memory are optimized away.
+       */
       if (which == STK_SW_MINOR) {
-    7e86:	12 38       	cpi	r17, 0x82	; 130
-    7e88:	11 f4       	brne	.+4      	; 0x7e8e <main+0x8a>
         putch(optiboot_version & 0xFF);
-    7e8a:	81 e0       	ldi	r24, 0x01	; 1
-    7e8c:	05 c0       	rjmp	.+10     	; 0x7e98 <main+0x94>
       } else if (which == STK_SW_MAJOR) {
-    7e8e:	11 38       	cpi	r17, 0x81	; 129
+    7e86:	11 38       	cpi	r17, 0x81	; 129
+      /*
+       * Send optiboot version as "SW version"
+       * Note that the references to memory are optimized away.
+       */
+      if (which == STK_SW_MINOR) {
+        putch(optiboot_version & 0xFF);
+    7e88:	11 f0       	breq	.+4      	; 0x7e8e <main+0x8a>
+    7e8a:	83 e0       	ldi	r24, 0x03	; 3
+      } else if (which == STK_SW_MAJOR) {
         putch(optiboot_version >> 8);
-    7e90:	11 f4       	brne	.+4      	; 0x7e96 <main+0x92>
+    7e8c:	01 c0       	rjmp	.+2      	; 0x7e90 <main+0x8c>
-    7e92:	88 e0       	ldi	r24, 0x08	; 8
+    7e8e:	88 e0       	ldi	r24, 0x08	; 8
+    7e90:	6b d0       	rcall	.+214    	; 0x7f68 <putch>
+    7e92:	67 c0       	rjmp	.+206    	; 0x7f62 <main+0x15e>
+         * other parameters - enough to keep Avrdude happy
+         */
         putch(0x03);
-    7e94:	01 c0       	rjmp	.+2      	; 0x7e98 <main+0x94>
+      }
-    7e96:	83 e0       	ldi	r24, 0x03	; 3
+    }
-    7e98:	6b d0       	rcall	.+214    	; 0x7f70 <putch>
-    7e9a:	67 c0       	rjmp	.+206    	; 0x7f6a <main+0x166>
     else if (ch == STK_SET_DEVICE) {
-    7e9c:	82 34       	cpi	r24, 0x42	; 66
+    7e94:	82 34       	cpi	r24, 0x42	; 66
+      // SET DEVICE is ignored
       getNch(20);
-    7e9e:	11 f4       	brne	.+4      	; 0x7ea4 <main+0xa0>
+    7e96:	11 f4       	brne	.+4      	; 0x7e9c <main+0x98>
-    7ea0:	84 e1       	ldi	r24, 0x14	; 20
+    7e98:	84 e1       	ldi	r24, 0x14	; 20
+    }
     else if (ch == STK_SET_DEVICE_EXT) {
-    7ea2:	03 c0       	rjmp	.+6      	; 0x7eaa <main+0xa6>
+    7e9a:	03 c0       	rjmp	.+6      	; 0x7ea2 <main+0x9e>
+      // SET DEVICE EXT is ignored
       getNch(5);
-    7ea4:	85 34       	cpi	r24, 0x45	; 69
+    7e9c:	85 34       	cpi	r24, 0x45	; 69
-    7ea6:	19 f4       	brne	.+6      	; 0x7eae <main+0xaa>
+    7e9e:	19 f4       	brne	.+6      	; 0x7ea6 <main+0xa2>
-    7ea8:	85 e0       	ldi	r24, 0x05	; 5
+    7ea0:	85 e0       	ldi	r24, 0x05	; 5
+    }
     else if (ch == STK_LOAD_ADDRESS) {
-    7eaa:	83 d0       	rcall	.+262    	; 0x7fb2 <getNch>
+    7ea2:	83 d0       	rcall	.+262    	; 0x7faa <getNch>
-    7eac:	5e c0       	rjmp	.+188    	; 0x7f6a <main+0x166>
+    7ea4:	5e c0       	rjmp	.+188    	; 0x7f62 <main+0x15e>
+      // LOAD ADDRESS
       address.bytes[0] = getch();
-    7eae:	85 35       	cpi	r24, 0x55	; 85
+    7ea6:	85 35       	cpi	r24, 0x55	; 85
-    7eb0:	39 f4       	brne	.+14     	; 0x7ec0 <main+0xbc>
+    7ea8:	39 f4       	brne	.+14     	; 0x7eb8 <main+0xb4>
-    7eb2:	65 d0       	rcall	.+202    	; 0x7f7e <getch>
+    7eaa:	65 d0       	rcall	.+202    	; 0x7f76 <getch>
       address.bytes[1] = getch();
-    7eb4:	c8 2f       	mov	r28, r24
+    7eac:	c8 2f       	mov	r28, r24
-    7eb6:	63 d0       	rcall	.+198    	; 0x7f7e <getch>
+    7eae:	63 d0       	rcall	.+198    	; 0x7f76 <getch>
+      }
+      else {
+        RAMPZ &= 0xFE;
+      }
+#endif
       address.word *= 2; // Convert from word address to byte address
-    7eb8:	d8 2f       	mov	r29, r24
+    7eb0:	d8 2f       	mov	r29, r24
-    7eba:	cc 0f       	add	r28, r28
+    7eb2:	cc 0f       	add	r28, r28
-    7ebc:	dd 1f       	adc	r29, r29
+    7eb4:	dd 1f       	adc	r29, r29
+      verifySpace();
+    }
     else if (ch == STK_UNIVERSAL) {
-    7ebe:	54 c0       	rjmp	.+168    	; 0x7f68 <main+0x164>
+    7eb6:	54 c0       	rjmp	.+168    	; 0x7f60 <main+0x15c>
-      getNch(4);
+        getNch(3);
-    7ec0:	86 35       	cpi	r24, 0x56	; 86
-    7ec2:	21 f4       	brne	.+8      	; 0x7ecc <main+0xc8>
         putch(0x00);
-    7ec4:	84 e0       	ldi	r24, 0x04	; 4
+      }
-    7ec6:	75 d0       	rcall	.+234    	; 0x7fb2 <getNch>
+#else
+      // UNIVERSAL command is ignored
+      getNch(4);
+    7eb8:	86 35       	cpi	r24, 0x56	; 86
+    7eba:	21 f4       	brne	.+8      	; 0x7ec4 <main+0xc0>
+      putch(0x00);
+    7ebc:	84 e0       	ldi	r24, 0x04	; 4
+    7ebe:	75 d0       	rcall	.+234    	; 0x7faa <getNch>
+#endif
+    }
+    /* Write memory, length is big endian and is in bytes */
     else if (ch == STK_PROG_PAGE) {
-    7ec8:	80 e0       	ldi	r24, 0x00	; 0
+    7ec0:	80 e0       	ldi	r24, 0x00	; 0
-    7eca:	e6 cf       	rjmp	.-52     	; 0x7e98 <main+0x94>
+    7ec2:	e6 cf       	rjmp	.-52     	; 0x7e90 <main+0x8c>
+      // PROGRAM PAGE - we support flash programming only, not EEPROM
+      uint8_t desttype;
+      uint8_t *bufPtr;
+      pagelen_t savelength;
+
       GETLENGTH(length);
-    7ecc:	84 36       	cpi	r24, 0x64	; 100
+    7ec4:	84 36       	cpi	r24, 0x64	; 100
-    7ece:	09 f0       	breq	.+2      	; 0x7ed2 <main+0xce>
+    7ec6:	09 f0       	breq	.+2      	; 0x7eca <main+0xc6>
-    7ed0:	2e c0       	rjmp	.+92     	; 0x7f2e <main+0x12a>
+    7ec8:	2e c0       	rjmp	.+92     	; 0x7f26 <main+0x122>
-    7ed2:	55 d0       	rcall	.+170    	; 0x7f7e <getch>
+    7eca:	55 d0       	rcall	.+170    	; 0x7f76 <getch>
+      savelength = length;
       desttype = getch();
-    7ed4:	54 d0       	rcall	.+168    	; 0x7f7e <getch>
+    7ecc:	54 d0       	rcall	.+168    	; 0x7f76 <getch>
-    7ed6:	f8 2e       	mov	r15, r24
+    7ece:	f8 2e       	mov	r15, r24
-    7ed8:	52 d0       	rcall	.+164    	; 0x7f7e <getch>
+    7ed0:	52 d0       	rcall	.+164    	; 0x7f76 <getch>
-    7eda:	b8 2e       	mov	r11, r24
+    7ed2:	b8 2e       	mov	r11, r24
-    7edc:	00 e0       	ldi	r16, 0x00	; 0
+    7ed4:	00 e0       	ldi	r16, 0x00	; 0
+
+      // read a page worth of contents
+      bufPtr = buff.bptr;
       do *bufPtr++ = getch();
-    7ede:	11 e0       	ldi	r17, 0x01	; 1
+    7ed6:	11 e0       	ldi	r17, 0x01	; 1
-    7ee0:	4e d0       	rcall	.+156    	; 0x7f7e <getch>
+    7ed8:	4e d0       	rcall	.+156    	; 0x7f76 <getch>
-    7ee2:	f8 01       	movw	r30, r16
+    7eda:	f8 01       	movw	r30, r16
-    7ee4:	81 93       	st	Z+, r24
+    7edc:	81 93       	st	Z+, r24
-    7ee6:	8f 01       	movw	r16, r30
+    7ede:	8f 01       	movw	r16, r30
       while (--length);
-    7ee8:	fe 12       	cpse	r15, r30
+    7ee0:	fe 12       	cpse	r15, r30
-    7eea:	fa cf       	rjmp	.-12     	; 0x7ee0 <main+0xdc>
+    7ee2:	fa cf       	rjmp	.-12     	; 0x7ed8 <main+0xd4>
+
+      // Read command terminator, start reply
       verifySpace();
-    7eec:	5a d0       	rcall	.+180    	; 0x7fa2 <verifySpace>
+    7ee4:	5a d0       	rcall	.+180    	; 0x7f9a <verifySpace>
-    7eee:	f5 e4       	ldi	r31, 0x45	; 69
+    7ee6:	f5 e4       	ldi	r31, 0x45	; 69
+ * void writebuffer(memtype, buffer, address, length)
+ */
+static inline void writebuffer(int8_t memtype, addr16_t mybuff,
+                               addr16_t address, pagelen_t len)
+{
   switch (memtype) {
-    7ef0:	bf 12       	cpse	r11, r31
+    7ee8:	bf 12       	cpse	r11, r31
-    7ef2:	01 c0       	rjmp	.+2      	; 0x7ef6 <main+0xf2>
+    7eea:	01 c0       	rjmp	.+2      	; 0x7eee <main+0xea>
-    7ef4:	ff cf       	rjmp	.-2      	; 0x7ef4 <main+0xf0>
+    7eec:	ff cf       	rjmp	.-2      	; 0x7eec <main+0xe8>
-    7ef6:	83 e0       	ldi	r24, 0x03	; 3
+    7eee:	83 e0       	ldi	r24, 0x03	; 3
+       * and we needed the space back.
+       */
+#ifdef FOURPAGEERASE
+      if ((address.bytes[0] & ((SPM_PAGESIZE<<2)-1))==0) {
+#endif
         __boot_page_erase_short(address.word);
-    7ef8:	fe 01       	movw	r30, r28
+    7ef0:	fe 01       	movw	r30, r28
-    7efa:	87 bf       	out	0x37, r24	; 55
+    7ef2:	87 bf       	out	0x37, r24	; 55
-    7efc:	e8 95       	spm
+    7ef4:	e8 95       	spm
-    7efe:	07 b6       	in	r0, 0x37	; 55
+    7ef6:	07 b6       	in	r0, 0x37	; 55
         boot_spm_busy_wait();
-    7f00:	00 fc       	sbrc	r0, 0
+    7ef8:	00 fc       	sbrc	r0, 0
-    7f02:	fd cf       	rjmp	.-6      	; 0x7efe <main+0xfa>
+    7efa:	fd cf       	rjmp	.-6      	; 0x7ef6 <main+0xf2>
-    7f04:	a0 e0       	ldi	r26, 0x00	; 0
+    7efc:	a0 e0       	ldi	r26, 0x00	; 0
-    7f06:	b1 e0       	ldi	r27, 0x01	; 1
+    7efe:	b1 e0       	ldi	r27, 0x01	; 1
-    7f08:	fe 01       	movw	r30, r28
+    7f00:	fe 01       	movw	r30, r28
-    7f0a:	8d 91       	ld	r24, X+
+    7f02:	8d 91       	ld	r24, X+
+
+      /*
+       * Copy data from the buffer into the flash write buffer.
+       */
+      do {
         __boot_page_fill_short((uint16_t)(void*)addrPtr, *(mybuff.wptr++));
-    7f0c:	9d 91       	ld	r25, X+
+    7f04:	9d 91       	ld	r25, X+
-    7f0e:	0c 01       	movw	r0, r24
+    7f06:	0c 01       	movw	r0, r24
-    7f10:	e7 be       	out	0x37, r14	; 55
+    7f08:	e7 be       	out	0x37, r14	; 55
-    7f12:	e8 95       	spm
+    7f0a:	e8 95       	spm
-    7f14:	11 24       	eor	r1, r1
+    7f0c:	11 24       	eor	r1, r1
-    7f16:	32 96       	adiw	r30, 0x02	; 2
+    7f0e:	32 96       	adiw	r30, 0x02	; 2
+        addrPtr += 2;
       } while (len -= 2);
-    7f18:	fa 12       	cpse	r15, r26
+    7f10:	fa 12       	cpse	r15, r26
+
+      /*
+       * Actually Write the buffer to flash (and wait for it to finish.)
+       */
       __boot_page_write_short(address.word);
-    7f1a:	f7 cf       	rjmp	.-18     	; 0x7f0a <main+0x106>
+    7f12:	f7 cf       	rjmp	.-18     	; 0x7f02 <main+0xfe>
-    7f1c:	fe 01       	movw	r30, r28
+    7f14:	fe 01       	movw	r30, r28
       boot_spm_busy_wait();
-    7f1e:	d7 be       	out	0x37, r13	; 55
+    7f16:	d7 be       	out	0x37, r13	; 55
-    7f20:	e8 95       	spm
+    7f18:	e8 95       	spm
+#if defined(RWWSRE)
+      // Reenable read access to flash
       __boot_rww_enable_short();
-    7f22:	07 b6       	in	r0, 0x37	; 55
+    7f1a:	07 b6       	in	r0, 0x37	; 55
-    7f24:	00 fc       	sbrc	r0, 0
+    7f1c:	00 fc       	sbrc	r0, 0
-    7f26:	fd cf       	rjmp	.-6      	; 0x7f22 <main+0x11e>
+    7f1e:	fd cf       	rjmp	.-6      	; 0x7f1a <main+0x116>
+      writebuffer(desttype, buff, address, savelength);
+
+
+    }
+/* Read memory block mode, length is big endian.  */
     else if (ch == STK_READ_PAGE) {
-    7f28:	c7 be       	out	0x37, r12	; 55
+    7f20:	c7 be       	out	0x37, r12	; 55
-    7f2a:	e8 95       	spm
+    7f22:	e8 95       	spm
+      uint8_t desttype;
       GETLENGTH(length);
-    7f2c:	1e c0       	rjmp	.+60     	; 0x7f6a <main+0x166>
+    7f24:	1e c0       	rjmp	.+60     	; 0x7f62 <main+0x15e>
-    7f2e:	84 37       	cpi	r24, 0x74	; 116
+    7f26:	84 37       	cpi	r24, 0x74	; 116
-    7f30:	71 f4       	brne	.+28     	; 0x7f4e <main+0x14a>
+    7f28:	71 f4       	brne	.+28     	; 0x7f46 <main+0x142>
+
       desttype = getch();
-    7f32:	25 d0       	rcall	.+74     	; 0x7f7e <getch>
+    7f2a:	25 d0       	rcall	.+74     	; 0x7f76 <getch>
+
       verifySpace();
-    7f34:	24 d0       	rcall	.+72     	; 0x7f7e <getch>
+    7f2c:	24 d0       	rcall	.+72     	; 0x7f76 <getch>
-    7f36:	f8 2e       	mov	r15, r24
+    7f2e:	f8 2e       	mov	r15, r24
-    7f38:	22 d0       	rcall	.+68     	; 0x7f7e <getch>
+    7f30:	22 d0       	rcall	.+68     	; 0x7f76 <getch>
       //      while (--length);
       // read a Flash and increment the address (may increment RAMPZ)
       __asm__ ("  elpm %0,Z+\n" : "=r" (ch), "=z" (address.bptr): "1" (address));
 #else
       // read a Flash byte and increment the address
       __asm__ ("  lpm %0,Z+\n" : "=r" (ch), "=z" (address.bptr): "1" (address));
-    7f3a:	33 d0       	rcall	.+102    	; 0x7fa2 <verifySpace>
+    7f32:	33 d0       	rcall	.+102    	; 0x7f9a <verifySpace>
-    7f3c:	8e 01       	movw	r16, r28
+    7f34:	8e 01       	movw	r16, r28
 #endif
       putch(ch);
-    7f3e:	f8 01       	movw	r30, r16
+    7f36:	f8 01       	movw	r30, r16
     } while (--length);
-    7f40:	85 91       	lpm	r24, Z+
+    7f38:	85 91       	lpm	r24, Z+
-    7f42:	8f 01       	movw	r16, r30
+    7f3a:	8f 01       	movw	r16, r30
-    7f44:	15 d0       	rcall	.+42     	; 0x7f70 <putch>
+    7f3c:	15 d0       	rcall	.+42     	; 0x7f68 <putch>
-    7f46:	fa 94       	dec	r15
+    7f3e:	fa 94       	dec	r15
+
+      read_mem(desttype, address, length);
+    }
+
+/* Get device signature bytes  */
     else if (ch == STK_READ_SIGN) {
-    7f48:	f1 10       	cpse	r15, r1
+    7f40:	f1 10       	cpse	r15, r1
-    7f4a:	f9 cf       	rjmp	.-14     	; 0x7f3e <main+0x13a>
+    7f42:	f9 cf       	rjmp	.-14     	; 0x7f36 <main+0x132>
+      // READ SIGN - return what Avrdude wants to hear
       verifySpace();
-    7f4c:	0e c0       	rjmp	.+28     	; 0x7f6a <main+0x166>
+    7f44:	0e c0       	rjmp	.+28     	; 0x7f62 <main+0x15e>
-    7f4e:	85 37       	cpi	r24, 0x75	; 117
+    7f46:	85 37       	cpi	r24, 0x75	; 117
       putch(SIGNATURE_0);
-    7f50:	39 f4       	brne	.+14     	; 0x7f60 <main+0x15c>
+    7f48:	39 f4       	brne	.+14     	; 0x7f58 <main+0x154>
-    7f52:	27 d0       	rcall	.+78     	; 0x7fa2 <verifySpace>
+    7f4a:	27 d0       	rcall	.+78     	; 0x7f9a <verifySpace>
-    7f54:	8e e1       	ldi	r24, 0x1E	; 30
+    7f4c:	8e e1       	ldi	r24, 0x1E	; 30
       putch(SIGNATURE_1);
-    7f56:	0c d0       	rcall	.+24     	; 0x7f70 <putch>
+    7f4e:	0c d0       	rcall	.+24     	; 0x7f68 <putch>
-    7f58:	85 e9       	ldi	r24, 0x95	; 149
+    7f50:	85 e9       	ldi	r24, 0x95	; 149
-    7f5a:	0a d0       	rcall	.+20     	; 0x7f70 <putch>
+    7f52:	0a d0       	rcall	.+20     	; 0x7f68 <putch>
       putch(SIGNATURE_2);
-    7f5c:	8f e0       	ldi	r24, 0x0F	; 15
+    7f54:	8f e0       	ldi	r24, 0x0F	; 15
-    7f5e:	9c cf       	rjmp	.-200    	; 0x7e98 <main+0x94>
+    7f56:	9c cf       	rjmp	.-200    	; 0x7e90 <main+0x8c>
+    }
     else if (ch == STK_LEAVE_PROGMODE) { /* 'Q' */
-    7f60:	81 35       	cpi	r24, 0x51	; 81
+    7f58:	81 35       	cpi	r24, 0x51	; 81
-    7f62:	11 f4       	brne	.+4      	; 0x7f68 <main+0x164>
+    7f5a:	11 f4       	brne	.+4      	; 0x7f60 <main+0x15c>
+      // Adaboot no-wait mod
       watchdogConfig(WATCHDOG_16MS);
-    7f64:	88 e0       	ldi	r24, 0x08	; 8
+    7f5c:	88 e0       	ldi	r24, 0x08	; 8
-    7f66:	17 d0       	rcall	.+46     	; 0x7f96 <watchdogConfig>
+    7f5e:	17 d0       	rcall	.+46     	; 0x7f8e <watchdogConfig>
-    7f68:	1c d0       	rcall	.+56     	; 0x7fa2 <verifySpace>
+    7f60:	1c d0       	rcall	.+56     	; 0x7f9a <verifySpace>
       verifySpace();
-    7f6a:	80 e1       	ldi	r24, 0x10	; 16
+    }
-    7f6c:	01 d0       	rcall	.+2      	; 0x7f70 <putch>
+    else {
+      // This covers the response to commands like STK_ENTER_PROGMODE
+      verifySpace();
+    7f62:	80 e1       	ldi	r24, 0x10	; 16
+    7f64:	01 d0       	rcall	.+2      	; 0x7f68 <putch>
+    }
     putch(STK_OK);
-    7f6e:	85 cf       	rjmp	.-246    	; 0x7e7a <main+0x76>
+    7f66:	89 cf       	rjmp	.-238    	; 0x7e7a <main+0x76>
 
-00007f70 <putch>:
+00007f68 <putch>:
-    7f70:	90 91 c0 00 	lds	r25, 0x00C0	; 0x8000c0 <__TEXT_REGION_LENGTH__+0x7e00c0>
+    7f68:	90 91 c0 00 	lds	r25, 0x00C0	; 0x8000c0 <__RAM__+0xc0>
   }
-    7f74:	95 ff       	sbrs	r25, 5
+    7f6c:	95 ff       	sbrs	r25, 5
+  RS485_PORT |= _BV(RS485_BIT);
+# else
+  RS485_PORT &= ~_BV(RS485_BIT);
+# endif
+#else //not RS485
   while (!(UART_SRA & _BV(UDRE0))) {  /* Spin */ }
-    7f76:	fc cf       	rjmp	.-8      	; 0x7f70 <putch>
+    7f6e:	fc cf       	rjmp	.-8      	; 0x7f68 <putch>
   UART_UDR = ch;
-    7f78:	80 93 c6 00 	sts	0x00C6, r24	; 0x8000c6 <__TEXT_REGION_LENGTH__+0x7e00c6>
+    7f70:	80 93 c6 00 	sts	0x00C6, r24	; 0x8000c6 <__RAM__+0xc6>
-    7f7c:	08 95       	ret
+    7f74:	08 95       	ret
 
-00007f7e <getch>:
+00007f76 <getch>:
+    :
+    "r25"
+    );
+#else
+#ifndef LIN_UART
   while (!(UART_SRA & _BV(RXC0)))  {  /* Spin */ }
-    7f7e:	80 91 c0 00 	lds	r24, 0x00C0	; 0x8000c0 <__TEXT_REGION_LENGTH__+0x7e00c0>
+    7f76:	80 91 c0 00 	lds	r24, 0x00C0	; 0x8000c0 <__RAM__+0xc0>
-    7f82:	87 ff       	sbrs	r24, 7
+    7f7a:	87 ff       	sbrs	r24, 7
-    7f84:	fc cf       	rjmp	.-8      	; 0x7f7e <getch>
+    7f7c:	fc cf       	rjmp	.-8      	; 0x7f76 <getch>
   if (!(UART_SRA & _BV(FE0))) {
-    7f86:	80 91 c0 00 	lds	r24, 0x00C0	; 0x8000c0 <__TEXT_REGION_LENGTH__+0x7e00c0>
+    7f7e:	80 91 c0 00 	lds	r24, 0x00C0	; 0x8000c0 <__RAM__+0xc0>
-    7f8a:	84 fd       	sbrc	r24, 4
+    7f82:	84 fd       	sbrc	r24, 4
-    7f8c:	01 c0       	rjmp	.+2      	; 0x7f90 <getch+0x12>
+    7f84:	01 c0       	rjmp	.+2      	; 0x7f88 <getch+0x12>
+}
+#endif
+
+// Watchdog functions. These are only safe with interrupts turned off.
+void watchdogReset() {
   __asm__ __volatile__ (
-    7f8e:	a8 95       	wdr
+    7f86:	a8 95       	wdr
+  while (!(LINSIR & _BV(LRXOK)))  {  /* Spin */ }
+  if (!(LINSIR & _BV(LFERR))) {
+    watchdogReset();  /* Eventually abort if wrong speed */
+  }
+#endif
   ch = UART_UDR;
-    7f90:	80 91 c6 00 	lds	r24, 0x00C6	; 0x8000c6 <__TEXT_REGION_LENGTH__+0x7e00c6>
+    7f88:	80 91 c6 00 	lds	r24, 0x00C6	; 0x8000c6 <__RAM__+0xc6>
-}
+#if LED_DATA_FLASH
-    7f94:	08 95       	ret
+  toggle_led();
+#endif
 
-00007f96 <watchdogConfig>:
+  return ch;
+}
+    7f8c:	08 95       	ret
+
+00007f8e <watchdogConfig>:
+}
+
+void watchdogConfig(uint8_t x) {
+#ifdef WDCE //does it have a Watchdog Change Enable?
+#ifdef WDTCSR
   WDTCSR = _BV(WDCE) | _BV(WDE);
-    7f96:	e0 e6       	ldi	r30, 0x60	; 96
+    7f8e:	e0 e6       	ldi	r30, 0x60	; 96
-    7f98:	f0 e0       	ldi	r31, 0x00	; 0
+    7f90:	f0 e0       	ldi	r31, 0x00	; 0
-    7f9a:	98 e1       	ldi	r25, 0x18	; 24
+    7f92:	98 e1       	ldi	r25, 0x18	; 24
-    7f9c:	90 83       	st	Z, r25
+    7f94:	90 83       	st	Z, r25
+#else //then it must be one of those newfangled ones that use CCP
+  CCP=0xD8; //so write this magic number to CCP
+#endif
+
+#ifdef WDTCSR
   WDTCSR = x;
-    7f9e:	80 83       	st	Z, r24
+    7f96:	80 83       	st	Z, r24
-    7fa0:	08 95       	ret
+    7f98:	08 95       	ret
 
-00007fa2 <verifySpace>:
+00007f9a <verifySpace>:
-  if (getch() != CRC_EOP) {
-    7fa2:	ed df       	rcall	.-38     	; 0x7f7e <getch>
-    7fa4:	80 32       	cpi	r24, 0x20	; 32
-    7fa6:	19 f0       	breq	.+6      	; 0x7fae <verifySpace+0xc>
-    watchdogConfig(WATCHDOG_16MS);    // shorten WD timeout
-    7fa8:	88 e0       	ldi	r24, 0x08	; 8
-    7faa:	f5 df       	rcall	.-22     	; 0x7f96 <watchdogConfig>
-    7fac:	ff cf       	rjmp	.-2      	; 0x7fac <verifySpace+0xa>
-  putch(STK_INSYNC);
-    7fae:	84 e1       	ldi	r24, 0x14	; 20
-    7fb0:	df cf       	rjmp	.-66     	; 0x7f70 <putch>
-
-00007fb2 <getNch>:
-void getNch(uint8_t count) {
-    7fb2:	cf 93       	push	r28
-    7fb4:	c8 2f       	mov	r28, r24
   do getch(); while (--count);
-    7fb6:	e3 df       	rcall	.-58     	; 0x7f7e <getch>
-    7fb8:	c1 50       	subi	r28, 0x01	; 1
-    7fba:	e9 f7       	brne	.-6      	; 0x7fb6 <getNch+0x4>
-}
-    7fbc:	cf 91       	pop	r28
   verifySpace();
-    7fbe:	f1 cf       	rjmp	.-30     	; 0x7fa2 <verifySpace>
+}
 
-00007fc0 <do_spm>:
+void verifySpace() {
-    7fc0:	fc 01       	movw	r30, r24
+  if (getch() != CRC_EOP) {
+    7f9a:	ed df       	rcall	.-38     	; 0x7f76 <getch>
+    7f9c:	80 32       	cpi	r24, 0x20	; 32
+    7f9e:	19 f0       	breq	.+6      	; 0x7fa6 <verifySpace+0xc>
+    watchdogConfig(WATCHDOG_16MS);    // shorten WD timeout
+    7fa0:	88 e0       	ldi	r24, 0x08	; 8
+    7fa2:	f5 df       	rcall	.-22     	; 0x7f8e <watchdogConfig>
+    7fa4:	ff cf       	rjmp	.-2      	; 0x7fa4 <verifySpace+0xa>
+    while (1)                         // and busy-loop so that WD causes
+      ;                               //  a reset and app start.
+  }
+  putch(STK_INSYNC);
+    7fa6:	84 e1       	ldi	r24, 0x14	; 20
+    7fa8:	df cf       	rjmp	.-66     	; 0x7f68 <putch>
+
+00007faa <getNch>:
+    ::[count] "M" (UART_B_VALUE)
+    );
+}
+#endif
+
+void getNch(uint8_t count) {
+    7faa:	cf 93       	push	r28
+    7fac:	c8 2f       	mov	r28, r24
+  do getch(); while (--count);
+    7fae:	e3 df       	rcall	.-58     	; 0x7f76 <getch>
+    7fb0:	c1 50       	subi	r28, 0x01	; 1
+    7fb2:	e9 f7       	brne	.-6      	; 0x7fae <getNch+0x4>
+  verifySpace();
+}
+    7fb4:	cf 91       	pop	r28
+}
+#endif
+
+void getNch(uint8_t count) {
+  do getch(); while (--count);
+  verifySpace();
+    7fb6:	f1 cf       	rjmp	.-30     	; 0x7f9a <verifySpace>
+
+00007fb8 <do_spm>:
+    7fb8:	fc 01       	movw	r30, r24
  *   data=0 in WRITE
  */
 static void do_spm(uint16_t address, uint8_t command, uint16_t data)  __attribute__ ((used));
 static void do_spm(uint16_t address, uint8_t command, uint16_t data) {
   // Do spm stuff
   asm volatile (
-    7fc2:	0a 01       	movw	r0, r20
+    7fba:	0a 01       	movw	r0, r20
-    7fc4:	67 bf       	out	0x37, r22	; 55
+    7fbc:	67 bf       	out	0x37, r22	; 55
-    7fc6:	e8 95       	spm
+    7fbe:	e8 95       	spm
-    7fc8:	11 24       	eor	r1, r1
+    7fc0:	11 24       	eor	r1, r1
-    7fca:	07 b6       	in	r0, 0x37	; 55
+    7fc2:	07 b6       	in	r0, 0x37	; 55
     );
 
   // wait for spm to complete
   //   it doesn't have much sense for __BOOT_PAGE_FILL,
   //   but it doesn't hurt and saves some bytes on 'if'
   boot_spm_busy_wait();
-    7fcc:	00 fc       	sbrc	r0, 0
+    7fc4:	00 fc       	sbrc	r0, 0
-    7fce:	fd cf       	rjmp	.-6      	; 0x7fca <do_spm+0xa>
+    7fc6:	fd cf       	rjmp	.-6      	; 0x7fc2 <do_spm+0xa>
-    7fd0:	66 70       	andi	r22, 0x06	; 6
+    7fc8:	66 70       	andi	r22, 0x06	; 6
 #if defined(RWWSRE)
   // this 'if' condition should be: (command == __BOOT_PAGE_WRITE || command == __BOOT_PAGE_ERASE)...
   // but it's tweaked a little assuming that in every command we are interested in here, there
   // must be also SELFPRGEN set. If we skip checking this bit, we save here 4B
   if ((command & (_BV(PGWRT)|_BV(PGERS))) && (data == 0) ) {
-    7fd2:	29 f0       	breq	.+10     	; 0x7fde <do_spm+0x1e>
+    7fca:	29 f0       	breq	.+10     	; 0x7fd6 <do_spm+0x1e>
-    7fd4:	45 2b       	or	r20, r21
+    7fcc:	45 2b       	or	r20, r21
-    7fd6:	19 f4       	brne	.+6      	; 0x7fde <do_spm+0x1e>
+    7fce:	19 f4       	brne	.+6      	; 0x7fd6 <do_spm+0x1e>
-    7fd8:	81 e1       	ldi	r24, 0x11	; 17
+    7fd0:	81 e1       	ldi	r24, 0x11	; 17
     // Reenable read access to flash
     __boot_rww_enable_short();
-    7fda:	87 bf       	out	0x37, r24	; 55
+    7fd2:	87 bf       	out	0x37, r24	; 55
-    7fdc:	e8 95       	spm
+    7fd4:	e8 95       	spm
-    7fde:	08 95       	ret
+    7fd6:	08 95       	ret

optiboot/bootloaders/optiboot/optiboot_atmega644p.hex

@@ -1,52 +1,50 @@
-:10FC000001C00DC1112484B7882361F0982F9A7028
+:10FC000001C009C1112484B7882361F0982F9A702C
 :10FC1000923041F081FF02C097EF94BF282E80E020
-:10FC2000E9D0EEC185E08093810082E08093C0003E
+:10FC2000E5D0EEC185E08093810082E08093C00042
 :10FC300088E18093C10086E08093C20080E18093D8
-:10FC4000C4008EE0D7D0209A86E020E33CEF91E01C
+:10FC4000C4008EE0D3D0209A86E020E33CEF91E020
 :10FC5000309385002093840096BBB09BFECF189A0A
 :10FC6000A8954091C00047FD02C0815089F7FF244C
-:10FC7000F39455E0E52E61E1D62EB0D0813471F4D5
+:10FC7000F39455E0E52E61E1D62EACD0813451F4F9
-:10FC8000ADD0C82FBDD0C23811F481E005C0C13855
+:10FC8000A9D0C82FB9D0C13811F083E001C088E0F5
-:10FC900011F488E001C083E09AD096C0823411F458
+:10FC90009AD096C0823411F484E103C0853419F4FB
-:10FCA00084E103C0853419F485E0B2D08DC0853578
+:10FCA00085E0B2D08DC0853539F494D0082F92D03C
-:10FCB00039F494D0082F92D0182F000F111F83C051
+:10FCB000182F000F111F83C0863521F484E0A4D0D3
-:10FCC000863521F484E0A4D080E0E6CF843609F0C4
+:10FCC00080E0E6CF843609F048C084D0C82FD0E069
-:10FCD00048C084D0C82FD0E0DC2FCC277FD0C82BE1
+:10FCD000DC2FCC277FD0C82B7DD0C82E5E01812C95
-:10FCE0007DD0C82E5E01812C9924939477D0F401A5
+:10FCE0009924939477D0F40181934F01F1E0AF1AF6
-:10FCF00081934F01F1E0AF1AB108C1F781D085E4DB
+:10FCF000B108C1F781D085E4C81212C0D39548017C
-:10FD0000C81212C0D3954801A12CBB24B394AC16E1
+:10FD0000A12CBB24B394AC16BD0609F459C0F5016F
-:10FD1000BD0609F459C0F50161915F01C40197D096
+:10FD100061915F01C40197D0FFEF8F1A9F0AF3CF63
-:10FD2000FFEF8F1A9F0AF3CF83E0F80187BFE895B2
+:10FD200083E0F80187BFE89507B600FCFDCFA0E0AF
-:10FD300007B600FCFDCFA0E0B1E0F8018D919D91E8
+:10FD3000B1E0F8018D919D910C01F7BEE895112479
-:10FD40000C01F7BEE8951124229732962097B1F75F
+:10FD4000229732962097B1F7F801E7BEE89507B6FB
-:10FD5000F801E7BEE89507B600FCFDCFD7BEE895F1
+:10FD500000FCFDCFD7BEE89533C0843719F53AD003
-:10FD600033C0843719F53AD0C82FD0E0DC2FCC2728
+:10FD6000C82FD0E0DC2FCC2735D05E01A82A32D0B6
-:10FD700035D05E01A82A32D0982E42D0E801F5E4B1
+:10FD7000982E42D0E801F5E49F120BC0CE015BD073
-:10FD80009F120BC0CE015BD022D081E0A81AB1082F
+:10FD800022D081E0A81AB1082196A114B104B1F7DC
-:10FD90002196A114B104B1F717C0FE018591EF01BE
+:10FD900017C0FE018591EF0116D0E1E0AE1AB1085F
-:10FDA00016D0E1E0AE1AB108C1F70EC0853739F4BC
+:10FDA000C1F70EC0853739F427D08EE10CD086E933
-:10FDB00027D08EE10CD086E90AD08AE06DCF81355C
+:10FDB0000AD08AE06DCF813511F488E017D01CD0CD
-:10FDC00011F488E017D01CD080E101D056CF90917B
+:10FDC00080E101D05ACF9091C00095FFFCCF809385
-:10FDD000C00095FFFCCF8093C60008958091C000BD
+:10FDD000C60008958091C00087FFFCCF8091C000CD
-:10FDE00087FFFCCF8091C00084FD01C0A895809161
+:10FDE00084FD01C0A8958091C6000895E0E6F0E08A
-:10FDF000C6000895E0E6F0E098E1908380830895DE
+:10FDF00098E1908380830895EDDF803219F088E0E8
-:10FE0000EDDF803219F088E0F5DFFFCF84E1DFCF4E
+:10FE0000F5DFFFCF84E1DFCFCF93C82FE3DFC15011
-:10FE1000CF93C82FE3DFC150E9F7CF91F1CFFC01B9
+:10FE1000E9F7CF91F1CFFC010A0167BFE895112402
-:10FE20000A0167BFE895112407B600FCFDCF667094
+:10FE200007B600FCFDCF667029F0452B19F481E17F
-:10FE300029F0452B19F481E187BFE8950895F999D8
+:10FE300087BFE8950895F999FECF92BD81BDF89AE4
-:10FE4000FECF92BD81BDF89A992780B50895262FDF
+:10FE4000992780B50895262FF999FECF1FBA92BD44
-:10FE5000F999FECF1FBA92BD81BD20BD0FB6F894AF
+:10FE500081BD20BD0FB6F894FA9AF99A0FBE0196AB
-:10FE6000FA9AF99A0FBE0196089556657273696FF2
+:10FE60000895FF56657273696F6E3D382E330044F6
-:10FE70006E3D382E31004F505449424F4F545F432E
+:10FE700065766963653D61746D65676136343470BC
-:10FE80005553544F4D5645523D3000446576696395
+:10FE800000465F4350553D31363030303030304CD5
-:10FE9000653D61746D6567613634347000465F435B
+:10FE900000424947424F4F543D31004275696C74EE
-:10FEA00050553D31363030303030304C00424947CB
+:10FEA0003A4E6F7620203420323032313A31383AAF
-:10FEB000424F4F543D31004275696C743A4D61793F
+:10FEB00030333A313400554152543D3000424155BF
-:10FEC00020323920323032303A30313A30323A3220
+:10FEC000445F524154453D313135323030004C456C
-:10FED0003600554152543D3000424155445F524135
+:10FED000443D4230004C45445F53544152545F46C8
-:10FEE00054453D313135323030004C45443D42308F
+:09FEE0004C41534845533D3300E9
-:10FEF000004C45445F53544152545F464C41534873
+:02FFFE000308F6
-:05FF000045533D3300F4
-:02FFFE000108F8
 :040000030000FC00FD
 :00000001FF