cmake_minimum_required(VERSION 3.28)

project(tsb_libavr LANGUAGES CXX)

# libavr from a local checkout (LIBAVR_ROOT) or the forge; the toolchain file
# comes from the same checkout via CMakePresets.json.
include(FetchContent)
if(NOT LIBAVR_ROOT AND DEFINED ENV{LIBAVR_ROOT})
	set(LIBAVR_ROOT $ENV{LIBAVR_ROOT})
endif()
if(LIBAVR_ROOT)
	FetchContent_Declare(libavr SOURCE_DIR ${LIBAVR_ROOT})
else()
	FetchContent_Declare(libavr GIT_REPOSITORY git@git.blackmark.me:avr/libavr.git GIT_TAG main)
endif()
FetchContent_MakeAvailable(libavr)

if(PROJECT_IS_TOP_LEVEL)
	add_compile_options(-Werror) # warnings are errors for the port's own code
	enable_testing()

	# The behavioral tests drive the real wire protocols over a simavr pty
	# (as the host tools do) and actually flash the device. The runners are
	# host programs built at configure time against libsimavr; if they or
	# Python are missing, only the size tests run.
	find_program(_host_cc NAMES cc gcc)
	find_package(Python3 COMPONENTS Interpreter)
	if(_host_cc AND Python3_FOUND AND LIBAVR_MCU STREQUAL "atmega328p")
		set(TSB_DEVICE ${CMAKE_BINARY_DIR}/tsb_device)
		execute_process(
		    COMMAND ${_host_cc} -O2 -I/usr/include/simavr -I/usr/include/simavr/parts
		            -o ${TSB_DEVICE} ${CMAKE_CURRENT_SOURCE_DIR}/test/device.c
		            -lsimavr -lsimavrparts -lelf
		    RESULT_VARIABLE _dev_res ERROR_VARIABLE _dev_err)
		if(NOT _dev_res EQUAL 0)
			message(STATUS "tsb_device not built (${_dev_err}) — protocol tests skipped")
			unset(TSB_DEVICE)
		endif()
	endif()
endif()

# The TinySafeBoot protocol reimplemented on libavr in three variants that trade
# clarity for size. Each links into the ATmega328P boot section (BOOTSZ selects
# its size; BOOTRST vectors a reset to its base) with -nostartfiles — a polled
# loader has no use for the crt or the vector table. The naked entry sits in
# .vectors, laid first, and runs. The boot base is FLASHEND+1 minus the section
# size; the linker section-start and the source's boot_bytes agree. tsb_app is
# the application's reset vector, pinned to 0 here so the loaders jump to a
# named function; --pmem-wrap-around lets relaxation turn that absolute jump
# into the wrapped rjmp AVR's modulo-flash PC actually executes.
# All three implement the full oracle feature set (see oracle/README.md):
# watchdog bail, one-wire half-duplex, config-page activation timeout, password
# gate, emergency erase, config/flash/EEPROM read-write. They differ only in how,
# and the size gradient is the cost of that "how" — see dev/lessons.md.
#   tsb_asm   — the tricks tier's C++ with exactly two routines in asm (the
#                 bounded rx and the page-store loop — the two whose remaining
#                 cost is the C ABI itself): 510 B in the 512 B section the
#                 hand-written 500 B oracle occupies. Everything else, from
#                 bring-up to dispatch, is C++ on libavr.
#   tsb_tricks — no asm at all: the whole-loader register allocation lives in
#                 global register variables (Y walks the page pointer), every
#                 helper is a tiny noinline primitive placed by the
#                 global-register store rules, pages stream straight to
#                 SPM/EEPROM, and the bring-up is the two reset-non-default
#                 registers only. 526 B in the 1 KB section (BOOTSZ=10) — 14
#                 over the oracle's section, from 168 over at this tier's first
#                 floor.
#   tsb_pure  — pure idiomatic libavr, one function per command, TU-local
#                 (internal linkage), streaming (no SRAM page buffer): 836 B in
#                 the 1 KB section.
#
# add_tsb_variant(<name> <boot-section-bytes>)
function(add_tsb_variant name bytes)
	math(EXPR base_dec "32768 - ${bytes}")
	math(EXPR base_hex "${base_dec}" OUTPUT_FORMAT HEXADECIMAL)
	add_executable(${name} tsb/${name}.cpp)
	target_link_libraries(${name} PRIVATE libavr)
	target_link_options(${name} PRIVATE -nostartfiles -Wl,--section-start=.text=${base_hex}
	                    -Wl,--defsym=tsb_app=0 -Wl,--pmem-wrap-around=32k)
	add_custom_command(TARGET ${name} POST_BUILD COMMAND ${CMAKE_SIZE} $<TARGET_FILE:${name}>)
	if(PROJECT_IS_TOP_LEVEL)
		add_test(NAME ${name}.size
		         COMMAND ${CMAKE_COMMAND} -DSIZE_TOOL=${CMAKE_SIZE} -DELF=$<TARGET_FILE:${name}>
		                 -DLIMIT=${bytes} -P ${CMAKE_CURRENT_SOURCE_DIR}/test/check_size.cmake)
		if(DEFINED TSB_DEVICE)
			add_test(NAME ${name}.protocol
			         COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/tsbtest.py
			                 ${TSB_DEVICE} $<TARGET_FILE:${name}> ${base_hex})
		endif()
	endif()
endfunction()

# The tsb tiers reimplement the ATmega328P-only reference protocol; the other
# chips build pureboot alone.
if(LIBAVR_MCU STREQUAL "atmega328p")
	add_tsb_variant(tsb_asm 512)
	add_tsb_variant(tsb_pure 1024)
	add_tsb_variant(tsb_tricks 1024)
endif()

# pureboot — the pure-constraint port (see pureboot/README.md): one source,
# no inline assembly, no global register variables, every libavr chip, 512
# bytes each. The loader owns the top 512 bytes of flash on every chip; the
# application entry symbol is address 0 on the mega (reset re-vectors to the
# loader through BOOTRST, so word 0 stays the application's own vector) and
# the trampoline word just below the loader on the tinies (host-side vector
# surgery points it at the application). --pmem-wrap-around models AVR's
# modulo-flash PC where the flash is big enough to need it.
if(LIBAVR_MCU STREQUAL "attiny13a")
	set(_pb_flash 1024)
	set(_pb_wrap "")
elseif(LIBAVR_MCU STREQUAL "attiny85")
	set(_pb_flash 8192)
	set(_pb_wrap -Wl,--pmem-wrap-around=8k)
else()
	set(_pb_flash 32768)
	set(_pb_wrap -Wl,--pmem-wrap-around=32k)
endif()
math(EXPR _pb_base "${_pb_flash} - 512")
math(EXPR _pb_base_hex "${_pb_base}" OUTPUT_FORMAT HEXADECIMAL)
if(LIBAVR_MCU STREQUAL "atmega328p")
	set(_pb_app 0)
else()
	math(EXPR _pb_app "${_pb_base} - 2")
endif()

add_executable(pureboot pureboot/pureboot.cpp)
target_link_libraries(pureboot PRIVATE libavr)
target_link_options(pureboot PRIVATE -nostartfiles -Wl,--section-start=.text=${_pb_base_hex}
                    -Wl,--defsym=pureboot_app=${_pb_app} ${_pb_wrap})
add_custom_command(TARGET pureboot POST_BUILD COMMAND ${CMAKE_SIZE} $<TARGET_FILE:pureboot>)
if(PROJECT_IS_TOP_LEVEL)
	add_test(NAME pureboot.size
	         COMMAND ${CMAKE_COMMAND} -DSIZE_TOOL=${CMAKE_SIZE} -DELF=$<TARGET_FILE:pureboot>
	                 -DLIMIT=512 -P ${CMAKE_CURRENT_SOURCE_DIR}/test/check_size.cmake)
endif()