tsb: the protocol the tiers share is written once, and its bytes by name

tsb/tsb.hpp holds the link, the handshake and command bytes, the guard
policy and SPM interlock, the boot geometry, act_min/comm_window and a
consteval builder for the 16-byte info block, whose BUILDSTATE and ATmega
marker bytes are now named rather than commented. Every tier's image is
byte-identical to before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

tsb/tsb_asm.cpp

@@ -30,82 +30,26 @@
 // line safe: the device drives it only between a received command and its
 // reply, and releases it (RXEN0 only) whenever it waits.
 
-#include <libavr/libavr.hpp>
+#include "tsb.hpp"
 
 #include <avr/io.h> // SPMCSR's I/O address for the page-store routine
 
-using namespace avr::literals;
-namespace spm = avr::spm;
-namespace ee = avr::eeprom;
 namespace hw = avr::hw;
 
 namespace tsb {
 namespace {
 
-// The loader is purely polled - it never enables interrupts - so every SPM and
-// EEPROM lock folds to nothing under this posture.
-constexpr auto off = avr::irq::guard_policy::unused;
-
-// Strict request/response: every SPM operation is waited out before the next
-// byte moves, so no flash operation is ever in flight at an EEPROM access -
-// the write procedure's step 2 has nothing to guard, the omission the
-// datasheet grants (DS40002061B section 8.6.3).
-constexpr auto no_spm = ee::spm_interlock::omitted;
-
-constexpr std::uint8_t confirm = '!';
-constexpr std::uint8_t request = '?';
-constexpr std::uint8_t knock = '@';
-
-constexpr auto clock = 16_MHz;
-
-// Boot geometry for the 512 B boot section (BOOTSZ=11); the page size and the
-// flash/EEPROM extents are the chip database's to know. app_end is the config
-// page (TSB's LASTPAGE), one page below the boot section.
-constexpr std::uint16_t page = spm::page_bytes;
+// The boot section: 512 B, BOOTSZ=11.
 constexpr std::uint16_t boot_bytes = 512;
-constexpr std::uint16_t app_end = spm::flash_bytes - boot_bytes - page;
-constexpr std::uint16_t eeprom_end = avr::hw::db.mem.eeprom_size - 1;
+constexpr std::uint16_t app_end = config_page(boot_bytes);
 
-// Lockout-proof floor for the activation window: the oracle's F_CPU/1MHz, so
-// it follows the clock rather than restating it.
-constexpr auto act_min = static_cast<std::uint8_t>(clock.hz / 1'000'000);
-// Post-activation window: the host gets seconds, not milliseconds, mid-session.
-constexpr std::uint8_t comm_window = 200;
-
-constexpr std::uint16_t build_date = 26 * 512 + 7 * 32 + 20;
-
-// Fixed 115200 8N1; the library solves UBRR + U2X from clock and baud.
-constexpr auto baud = avr::uart::solve_baud(clock, 115200_Bd, 8, avr::uart::parity::none);
-
-// One bit time on the wire: the turn-around a shared-line peer needs to stop
-// driving before this one starts. Derived from the solved rate, so it follows
-// the link rather than a count measured against one.
-constexpr auto guard_cycles = static_cast<std::uint32_t>(clock.hz / baud.actual);
-
-// The 16-byte device-info block, streamed out on activation.
-// clang-format off
-[[gnu::progmem]] constexpr auto info = std::to_array<std::uint8_t>({
-    'T', 'S', 'B',
-    build_date & 0xFF, build_date >> 8,
-    0xF3,             // status: native-UART fixed-baud lineage
-    avr::hw::db.signature[0], avr::hw::db.signature[1], avr::hw::db.signature[2],
-    page / 2,         // page size in words
-    (app_end / 2) & 0xFF, (app_end / 2) >> 8,
-    eeprom_end & 0xFF, eeprom_end >> 8,
-    0xAA, 0xAA,
-});
-// clang-format on
+[[gnu::progmem]] constexpr auto info = info_block(date_stamp(26, 7, 20), app_end);
 
 register std::uint16_t g_addr asm("r28");
 register std::uint8_t g_cnt asm("r16");
 register std::uint8_t g_window asm("r7");
 register std::uint8_t g_receiving asm("r6");
 
-const std::uint8_t *flash_ptr(std::uint16_t addr)
-{
-	return reinterpret_cast<const std::uint8_t *>(addr);
-}
-
 // Bounded byte receive (asm 1 of 2): release the one-wire line on a direction
 // change, poll RXC0 under the oracle's nested X-register countdown seeded from
 // g_window (floored against lockout), byte or 0-on-silence in r24. Z survives
@@ -288,23 +232,23 @@ extern "C" [[noreturn]] void tsb_app(); // the application's reset vector: --def
 	// same reason.
 	g_receiving = 0;
 
-	// Activation: 3x'@', each inside the config page's timeout window (rx
-	// floors it so a corrupt page cannot lock the loader out); anything else -
-	// including silence - hands over.
-	g_window = avr::flash_load(flash_ptr(app_end + 2));
-	for (std::uint8_t k = 3; k; --k) {
+	// Activation: activation_knocks '@', each inside the config page's timeout
+	// window (rx floors it so a corrupt page cannot lock the loader out);
+	// anything else - including silence - hands over.
+	g_window = avr::flash_load(flash_ptr(app_end + timeout_at));
+	for (std::uint8_t k = activation_knocks; k; --k) {
 		if (rx() != knock) {
 			appjump();
 		}
 	}
 	g_window = comm_window;
 
-	// Password gate (config page from app_end+3, 0xff-terminated; a blank
+	// Password gate (config page from password_at, 0xff-terminated; a blank
 	// page is no password). A wrong byte blanks the comparison and drains the
 	// line forever, so a wrong password can never fall through; a 0 requests
 	// emergency erase behind two confirms. On pass the info block goes out;
 	// the emergency path skips it and drops into the command loop.
-	g_addr = app_end + 3;
+	g_addr = app_end + password_at;
 	std::uint8_t mask = 0xff;
 	for (;;) {
 		std::uint8_t expected = avr::flash_load(flash_ptr(g_addr)) & mask;
@@ -340,7 +284,7 @@ extern "C" [[noreturn]] void tsb_app(); // the application's reset vector: --def
 		tx(confirm); // Mainloop ready
 		g_addr = 0;
 		switch (rx()) {
-		case 'f': // read application flash, one page per host '!'
+		case command::read_flash: // one page per host '!'
 			for (;;) {
 				if (rx() != confirm) {
 					break;
@@ -352,13 +296,13 @@ extern "C" [[noreturn]] void tsb_app(); // the application's reset vector: --def
 				}
 			}
 			break;
-		case 'F':                // erase the application, then take pages behind '?'
-			erase_application(); // leaves g_addr = 0, the write start
+		case command::write_flash: // erase the application, then take pages behind '?'
+			erase_application();   // leaves g_addr = 0, the write start
 			while (rcnf() == confirm) {
 				store_flash();
 			}
 			break;
-		case 'e': // read EEPROM, one page per host '!', until the host stops
+		case command::read_eeprom: // one page per host '!', until the host stops
 			for (;;) {
 				if (rx() != confirm) {
 					break;
@@ -369,7 +313,7 @@ extern "C" [[noreturn]] void tsb_app(); // the application's reset vector: --def
 				} while (--g_cnt);
 			}
 			break;
-		case 'E': // take EEPROM pages behind '?'
+		case command::write_eeprom: // pages behind '?'
 			while (rcnf() == confirm) {
 				g_cnt = page;
 				do {
@@ -377,13 +321,13 @@ extern "C" [[noreturn]] void tsb_app(); // the application's reset vector: --def
 				} while (--g_cnt);
 			}
 			break;
-		case 'c': // read the config page
+		case command::read_config:
 		read_config:
 			g_addr = app_end;
 			g_cnt = page;
 			sendf();
 			break;
-		case 'C': // replace the config page, then echo it back to verify
+		case command::write_config: // then echo it back to verify
 			if (rcnf() != confirm) {
 				break;
 			}