111 lines
5.7 KiB
Python
111 lines
5.7 KiB
Python
from __future__ import annotations
|
|
|
|
import argparse
|
|
from pathlib import Path
|
|
|
|
from ..formatting import h16, parse_int
|
|
from .eeprom_image import write_eeprom_snapshot
|
|
from .memory import describe_regions
|
|
from .runner import H8536Emulator
|
|
|
|
|
|
def discover_rom_path(root: Path) -> Path | None:
|
|
candidates = [
|
|
root / "ROM" / "M27C512@DIP28_1.BIN",
|
|
root / "rom.bin",
|
|
]
|
|
candidates.extend(sorted((root / "ROM").glob("*.BIN")) if (root / "ROM").exists() else [])
|
|
candidates.extend(sorted((root / "ROM").glob("*.bin")) if (root / "ROM").exists() else [])
|
|
for candidate in candidates:
|
|
if candidate.is_file():
|
|
return candidate
|
|
return None
|
|
|
|
|
|
def load_rom(path: Path | None = None, root: Path | None = None) -> tuple[bytes, Path]:
|
|
root = root if root is not None else Path.cwd()
|
|
rom_path = path if path is not None else discover_rom_path(root)
|
|
if rom_path is None:
|
|
raise FileNotFoundError(
|
|
"could not discover ROM bytes; pass --rom PATH, expected ROM/M27C512@DIP28_1.BIN or another ROM/*.BIN"
|
|
)
|
|
return rom_path.read_bytes(), rom_path
|
|
|
|
|
|
def build_arg_parser() -> argparse.ArgumentParser:
|
|
parser = argparse.ArgumentParser(description="Minimal H8/536 emulation harness scaffold")
|
|
parser.add_argument("--rom", type=Path, help="ROM image path; defaults to ROM/M27C512@DIP28_1.BIN when present")
|
|
parser.add_argument("--max-steps", type=int, default=64, help="maximum CPU steps to execute")
|
|
parser.add_argument("--trace", action="store_true", help="print decoded/executed instruction trace")
|
|
parser.add_argument("--stop-on-heartbeat", action="store_true", help="stop only when 00 00 00 00 80 DA is emitted through SCI1 TDR")
|
|
parser.add_argument("--memory-map", action="store_true", help="print the scaffolded memory map before running")
|
|
parser.add_argument("--interval-steps", type=int, default=2048, help="rough step period for the scaffolded timer interrupt")
|
|
parser.add_argument("--clock-hz", type=parse_int, default=10_000_000, help="CPU/phi clock in Hz for calibrated FRT timing")
|
|
parser.add_argument("--frt1-ocia-steps", type=int, default=None, help="legacy step-period override for FRT1 OCIA")
|
|
parser.add_argument("--frt2-ocia-steps", type=int, default=None, help="legacy step-period override for FRT2 OCIA")
|
|
parser.add_argument("--p9-fast-path", action="store_true", help="shortcut known P9 bit-banged transfer routines for exploration")
|
|
parser.add_argument("--p9-fast-input", type=parse_int, default=0xFF, help="default byte returned by the P9 fast-path read routine")
|
|
parser.add_argument("--p9-fast-optimistic-wrapper", action="store_true", help="legacy fallback for older wrapper experiments; known BFE0/BFFE wrappers use the X24164 model")
|
|
parser.add_argument("--p7-input", type=parse_int, default=0xFF, help="external P7 pin state for input bits; DIP-off board default is 0xFF")
|
|
parser.add_argument("--eeprom-seed", choices=("blank", "factory"), default="blank", help="initial X24164/shadow state before reset")
|
|
parser.add_argument("--eeprom-load", type=Path, help="load a 0x1000-byte logical EEPROM image before running")
|
|
parser.add_argument("--eeprom-save", type=Path, help="save the final 0x1000-byte logical EEPROM image after running")
|
|
parser.add_argument("--eeprom-report", type=Path, help="write a readable EEPROM snapshot report after running")
|
|
parser.add_argument("--eeprom-report-json", type=Path, help="write a structured EEPROM snapshot report after running")
|
|
parser.add_argument("--eeprom-report-include-image", action="store_true", help="include the full EEPROM image as hex in JSON reports")
|
|
return parser
|
|
|
|
|
|
def main(argv: list[str] | None = None) -> int:
|
|
args = build_arg_parser().parse_args(argv)
|
|
try:
|
|
rom_bytes, rom_path = load_rom(args.rom)
|
|
except FileNotFoundError as exc:
|
|
print(str(exc))
|
|
return 2
|
|
|
|
emulator = H8536Emulator(
|
|
rom_bytes,
|
|
interval_steps=args.interval_steps,
|
|
frt1_ocia_steps=args.frt1_ocia_steps,
|
|
frt2_ocia_steps=args.frt2_ocia_steps,
|
|
clock_hz=args.clock_hz,
|
|
p9_fast_path_enabled=args.p9_fast_path,
|
|
p9_fast_default_input_byte=args.p9_fast_input,
|
|
p9_fast_default_wrapper_success=args.p9_fast_optimistic_wrapper,
|
|
p7_input=args.p7_input,
|
|
eeprom_seed=args.eeprom_seed,
|
|
)
|
|
if args.eeprom_load:
|
|
emulator.memory.load_eeprom_image(args.eeprom_load.read_bytes())
|
|
print(f"eeprom_loaded={args.eeprom_load}")
|
|
print(f"rom={rom_path}")
|
|
print(f"reset_vector={h16(emulator.reset_vector())}")
|
|
if args.memory_map:
|
|
print(describe_regions())
|
|
report = emulator.run(args.max_steps, trace=args.trace, stop_on_heartbeat=args.stop_on_heartbeat)
|
|
if args.trace:
|
|
for line in report.trace:
|
|
print(line)
|
|
for line in report.summary_lines():
|
|
print(line)
|
|
if not report.heartbeat_seen:
|
|
print("heartbeat_status=not reached; no heartbeat is reported unless bytes are emitted via SCI1_TDR")
|
|
if args.eeprom_save:
|
|
args.eeprom_save.parent.mkdir(parents=True, exist_ok=True)
|
|
args.eeprom_save.write_bytes(emulator.memory.dump_eeprom_image())
|
|
print(f"eeprom_saved={args.eeprom_save}")
|
|
if args.eeprom_report:
|
|
write_eeprom_snapshot(emulator.memory, args.eeprom_report, rom_bytes=rom_bytes)
|
|
print(f"eeprom_report={args.eeprom_report}")
|
|
if args.eeprom_report_json:
|
|
write_eeprom_snapshot(
|
|
emulator.memory,
|
|
args.eeprom_report_json,
|
|
rom_bytes=rom_bytes,
|
|
as_json=True,
|
|
include_image_hex=args.eeprom_report_include_image,
|
|
)
|
|
print(f"eeprom_report_json={args.eeprom_report_json}")
|
|
return 0
|