BlackMark
8f106b636d
The word-addressed 1284s were the one family deploying in a 1 KiB slot, because the far-flash machinery (ELPM reads, RAMPZ page commands, a word-addressed wire) did not fit 512 B. It does now: 478 B stock, 494 B in the heaviest configuration the build can produce. They take the 644s' geometry, where the smallest boot section holds the resident slot and its staging slot together. The loader's version goes to 3; the host tool did not change, so its own version stays 2 and only the window it speaks widens. Most of the saving is one restructure. The info block and a flash read are the same act, so giving all four streamed commands one address-and-count path leaves exactly one call site for the flash streamer: it inlines into the never-returning command loop and its 24-bit cursor stops being saved and restored around every transmit. Around it, the ack byte moved out of line, the wire's byte pair is bit_cast into the word it already is, the fuse loop ends on its count, the info block's in-slot offset is taken as the one-byte relocation it is, and -fno-expensive-optimizations gives way to -fno-move-loop-invariants -fno-tree-ter. Every chip shrank 14-18 B. The size matrix grew the axes it was missing: the USART1 instance across the whole clock ladder, and the shape a slow baud gives a software UART — past 255 delay iterations libavr takes the 16-bit delay loop, which the ladder default never selects and which was 4 B over the 1284's slot the first time it was built. The protocol fixture stopped deriving the loader entry from the flash size; on the 1284s it had been jumping a slot low and reaching the loader only because erased flash walked it up. Docs and comments were consolidated across the port in the same pass: the README carries a per-chip size table instead of prose, and prose that restated the code is gone — 190 lines, no behaviour with it. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
97 lines
4.1 KiB
Python
97 lines
4.1 KiB
Python
#!/usr/bin/env python3
|
|
"""Re-homing acceptance test: an image programmed somewhere other than its
|
|
canonical slot must still be a working loader, and the ordinary
|
|
--update-loader flow must put a build into the top slot from there.
|
|
|
|
Two positions. Address 0, a raw .bin handed to a programmer: the staging
|
|
install and the word-0 redirect run from copies outside page 0's slot, so the
|
|
running-slot guard never blocks them. And the staging slot itself, where a
|
|
loader already sitting there IS the staging copy — recognized by its embedded
|
|
block and left in place, then streaming the new resident like any staged copy.
|
|
|
|
Usage: pbrehome.py <device_bin> <pureboot_elf> <update_bin> <mcu> <hz>
|
|
<base_hex> <page> <baud> <app_bin> <tool_py> <workdir>
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
|
|
|
|
def fail(message):
|
|
print(f"FAIL: {message}")
|
|
sys.exit(1)
|
|
|
|
|
|
def rehome_from(pbsim, pb, device_bin, elf, place_hex, guard_probe, update_bin, base, page, baud, app_bin, workdir,
|
|
mcu, hz):
|
|
"""Place the loader at `place_hex`, heal through --update-loader, flash
|
|
the application, expect the banner."""
|
|
dump = os.path.join(workdir, f"dump-{place_hex}.bin")
|
|
state = os.path.join(workdir, f"rehome-{place_hex}.pbstate")
|
|
if os.path.exists(state):
|
|
os.unlink(state)
|
|
device = pbsim.Device(device_bin, elf, mcu, hz, place_hex, page, baud, dump, reset_hex="0")
|
|
try:
|
|
port = pb.Port(device.pty, baud)
|
|
loader = pb.Loader(port)
|
|
info = loader.connect(25)
|
|
if info.base != base:
|
|
fail(f"the misplaced copy reports base {info.base:#06x} — the info block must stay canonical")
|
|
|
|
# The accidental slot still guards itself; re-homing rides on the
|
|
# canonical slots being writable from it.
|
|
probe = int(guard_probe, 0)
|
|
before = loader.read_flash(probe, info.page)
|
|
loader.write_page(probe, bytes(info.page))
|
|
if loader.read_flash(probe, info.page) != before:
|
|
fail("the misplaced copy's guard let its own slot change")
|
|
|
|
# The ordinary update flow puts the build into the top slot.
|
|
pb.op_update_loader(loader, 25, update_bin, state, None)
|
|
update = open(update_bin, "rb").read()
|
|
if loader.read_flash(base, len(update)) != update:
|
|
fail("the canonical slot does not hold the update image")
|
|
|
|
# An application flashed through the healed resident overwrites the
|
|
# stale copy (surgery included) and launches.
|
|
pages = pb.plan_flash(open(app_bin, "rb").read(), loader.info)
|
|
for address in pb.covered(pages, loader.info, skip_blank=False):
|
|
loader.write_page(address, pages[address])
|
|
pb.verify_pages(loader, pages)
|
|
loader.run_application()
|
|
if port.read_exact(3, 5.0) != b"APP":
|
|
fail(f"application does not banner after the re-home from {place_hex}")
|
|
port.close()
|
|
finally:
|
|
device.stop()
|
|
|
|
|
|
def main():
|
|
(device_bin, elf, update_bin, mcu, hz, base_hex, page, baud, app_bin, tool, workdir) = sys.argv[1:]
|
|
base, page, baud = int(base_hex, 0), int(page), int(baud)
|
|
sys.path.insert(0, os.path.dirname(os.path.abspath(tool)))
|
|
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
|
import pbsim
|
|
import pureboot as pb
|
|
|
|
os.makedirs(workdir, exist_ok=True)
|
|
|
|
# Address 0: the raw-.bin-to-a-programmer accident. The guard probe is
|
|
# the copy's own page 0.
|
|
rehome_from(pbsim, pb, device_bin, elf, "0x0", "0x0", update_bin, base, page, baud, app_bin, workdir, mcu, hz)
|
|
print("re-home from address 0: converged")
|
|
|
|
# The staging slot: erased flash with the loader sitting exactly where
|
|
# a staging copy would — the tool must leave it in place and let it
|
|
# stream the (different) update build into the resident slot.
|
|
stage = base - pb.SLOT
|
|
rehome_from(pbsim, pb, device_bin, elf, hex(stage), hex(stage), update_bin, base, page, baud, app_bin, workdir,
|
|
mcu, hz)
|
|
print("re-home from the staging slot: converged")
|
|
|
|
print("pbrehome: a misplaced loader re-homes through the ordinary update flow")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|