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>
89 lines
3.3 KiB
Python
89 lines
3.3 KiB
Python
#!/usr/bin/env python3
|
|
"""Dirty-page-buffer acceptance test: with no discard in the loader, a page
|
|
filled over words an earlier writer left takes those instead. The whole
|
|
contract is asserted — a bare verify sees the corruption, the repairing
|
|
verify fixes it in one rewrite, and it stays fixed.
|
|
|
|
The state is reached the one way the loader cannot prevent: an application
|
|
dirties the buffer and jumps in with no reset between. Boot-sectioned megas
|
|
forbid that outright (SPM runs only from the boot section, Atmel-8271 §26.2),
|
|
but simavr dispatches SPM from anywhere, which is what makes it constructible.
|
|
|
|
Usage: pbdirty.py <device_bin> <pureboot_elf> <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 main():
|
|
device_bin, elf, mcu, hz, base_hex, page, baud, app_bin, tool, workdir = sys.argv[1:]
|
|
page, baud = 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)
|
|
dump = os.path.join(workdir, "dump.bin")
|
|
|
|
# Reset boots the application on a BOOTRST-unprogrammed mega; its 'L' is
|
|
# the loader entry this test needs, reached without a reset.
|
|
device = pbsim.Device(device_bin, elf, mcu, hz, base_hex, page, baud, dump, reset_hex="0")
|
|
try:
|
|
port = pb.Port(device.pty, baud)
|
|
loader = pb.Loader(port)
|
|
loader.connect(25)
|
|
|
|
# Install the application and hand over to it.
|
|
pb.op_flash(loader, app_bin, erase=False, verify=True)
|
|
loader.run_application()
|
|
if port.read_exact(3, 5.0) != b"APP":
|
|
fail("the application did not start")
|
|
|
|
port.write(b"D")
|
|
if port.read_exact(1, 5.0) != b"D":
|
|
fail("the application did not acknowledge dirtying the page buffer")
|
|
port.write(b"L")
|
|
loader = pb.Loader(port)
|
|
loader.connect(25)
|
|
|
|
# Program by hand, so the corruption is observable before anything
|
|
# repairs it.
|
|
pages = pb.plan_flash(open(app_bin, "rb").read(), loader.info)
|
|
for address in sorted(pages):
|
|
loader.write_page(address, pages[address])
|
|
try:
|
|
pb.verify_pages(loader, pages)
|
|
except pb.Error as error:
|
|
if "verify failed" not in str(error):
|
|
fail(f"the read-back failed, but not at verify: {error}")
|
|
else:
|
|
# Either the fixture no longer dirties the buffer, or the loader
|
|
# clears it again — in which case this test's premise is gone.
|
|
fail("programming over a dirty page buffer came back clean")
|
|
|
|
# What the programming path uses: one rewrite settles it, and it stays
|
|
# settled.
|
|
pb.verify_pages(loader, pages, repair=True)
|
|
pb.verify_pages(loader, pages)
|
|
|
|
# Ground truth beyond the loader's own read-back.
|
|
loader.run_application()
|
|
if port.read_exact(3, 5.0) != b"APP":
|
|
fail("the application did not start after the recovered write")
|
|
port.close()
|
|
finally:
|
|
device.stop()
|
|
print("pbdirty: a dirty page buffer is caught by verify and cleared by the retry")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|