oep-client-python 0.0.25__py3-none-any.whl → 0.0.27__py3-none-any.whl

oep_client/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.0.25"
+__version__ = "0.0.27"

oep_client/__main__.py

@@ -9,7 +9,9 @@
   oep config uart <probe> oep.fixture.uart#1 115200 --format 8N1
   oep config disable <probe> 3 4           (channels the probe never uses or touches; remove disable CH re-enables)
   oep config remove <probe> bind 1        oep config save <probe>        oep config erase <probe>
-  oep speed <probe> 1500000,921600,500000 (port_speed, core §3.5: try the rates in order on a UART bridge, report)
+  oep speed <probe> [--candidates 921600,500000] [--verify [--flows in:2,out:2]] (port_speed, core §3.5 and the host
+                                           guide §7: try the candidates in order on a UART bridge, report)
+  oep linktest <probe> --rates now,921600 --patterns in,out,duplex --inflight 1,2 --sizes 128,496 --frames 300
 
 <probe>: a serial port, tcp://HOST:PORT or usb[:VID:PID[:SERIAL]]. A change takes the lock (owner "oep config") and
 ends the session after it; it takes effect at once, and stays over a restart only after `save` (or --save).
@@ -30,13 +32,37 @@ def main(argv=None) -> int:
     parser = argparse.ArgumentParser(prog="oep", description="Open Embedded Probe: what a probe offers, its settings")
     sub = parser.add_subparsers(dest="command", required=True)
     _config_parser(sub)
-    sp = sub.add_parser("speed", help="port_speed (core §3.5): try faster rates on a UART bridge, print the report")
+    sp = sub.add_parser("speed", help="port_speed (core §3.5, host guide §7): try faster rates on a UART bridge, "
+                        "print the report")
     sp.add_argument("probe", help="the probe's serial port (a UART bridge this host opens)")
-    sp.add_argument("rates", help="comma-separated, in order of preference (the first that passes is kept)")
+    sp.add_argument("rates", nargs="?", default="", help="the candidates, comma-separated, in order of preference "
+                    "(the first that passes is kept; default 500000). Same as --candidates")
+    sp.add_argument("--candidates", default="", help="the candidates, comma-separated (default 500000)")
+    sp.add_argument("--flows", default="", help="the flows to verify, comma-separated FLOW[:N] (in, out, duplex; N in "
+                    "flight, 0 = the most the link keeps; default: all three at that N). Selects --verify")
+    form = sp.add_mutually_exclusive_group()
+    form.add_argument("--verify", action="store_true", help="the full form (guide §7.3): baseline, the flows measured "
+                      "at every candidate, a failed flow run again one at a time")
+    form.add_argument("--minimal", action="store_true", help="the minimal form (guide §7.2, the default): try, confirm, "
+                      "commit, no measurement")
+    sp.add_argument("--frames", type=int, default=link.FLOW_FRAMES, help="frames per flow when verifying (default 16)")
+    sp.add_argument("--no-record", action="store_true", help="do not read or write the record of passed / failed rates "
+                    "(~/.cache/oep-client/link-speed.json, 30 days; on by default here, off in the library)")
     sp.add_argument("--baud", type=int, default=link.BASE_BAUD, help="the boot speed (default 115200)")
-    sp.add_argument("--verify-bytes", type=int, default=32768)
-    sp.add_argument("--verify-s", type=float, default=1.0)
     sp.add_argument("--json", action="store_true")
+    lt = sub.add_parser("linktest", help="measure the link: traffic patterns at rates the host asks for, what breaks")
+    lt.add_argument("probe", help="a probe: a serial port, tcp://HOST:PORT or usb[:VID:PID]")
+    lt.add_argument("--rates", default="", help="comma-separated rates to switch to with port_speed and measure at "
+                    "(each on its own; 0 or 'now' = the speed in force). Default: only the speed in force")
+    lt.add_argument("--patterns", default="in,out,duplex", help="in (probe->host), out (host->probe), duplex")
+    lt.add_argument("--inflight", default="1", help="comma-separated in-flight counts (above the probe's max: skipped)")
+    lt.add_argument("--sizes", default="", help="comma-separated frame payload sizes (default: a whole frame)")
+    lt.add_argument("--frames", type=int, default=300, help="frames per cell (default 300)")
+    lt.add_argument("--seconds", type=float, default=None, help="per cell for this long instead of --frames")
+    lt.add_argument("--timeout", type=float, default=0.3, help="seconds to wait for one answer (default 0.3)")
+    lt.add_argument("--baud", type=int, default=link.BASE_BAUD, help="the boot speed to open at (default 115200)")
+    lt.add_argument("--low-latency", choices=("on", "off"), default="on", help="the serial driver's low-latency mode")
+    lt.add_argument("--json", action="store_true", help="one JSON object per cell")
     d = sub.add_parser("dump", help="list and describe every interface a probe offers")
     src = d.add_mutually_exclusive_group(required=True)
     src.add_argument("--fake", choices=sorted(fake.PROFILES), help="in-process example probe")
@@ -49,6 +75,8 @@ def main(argv=None) -> int:
         return _config(args)
     if args.command == "speed":
         return _speed(args)
+    if args.command == "linktest":
+        return _linktest(args)
 
     if args.fake:
         call = fake.PROFILES[args.fake]().call
@@ -60,16 +88,70 @@ def main(argv=None) -> int:
     return 0
 
 
+# ---- oep linktest -------------------------------------------------------------------------------------------------
+
+def _linktest(args) -> int:
+    """Every parameter on the command line: no fixed numbers in the measurement."""
+    import dataclasses
+    import json
+    from . import linktest
+    ints = lambda text: [int(v) for v in text.split(",") if v.strip()]   # noqa: E731
+    rates = [None if v.strip() in ("0", "now") else int(v) for v in args.rates.split(",") if v.strip()] or [None]
+    hst = link.open_host(args.probe, baud=args.baud) if args.probe.startswith("/") or ":" not in args.probe \
+        else link.open_host(args.probe)
+    stream = getattr(hst.link, "stream", None)
+    if hasattr(stream, "set_low_latency_mode"):
+        try:
+            stream.set_low_latency_mode(args.low_latency == "on")
+        except (OSError, ValueError, NotImplementedError):
+            pass
+    try:
+        core.take(hst, 30000, owner="oep linktest")
+        for result in linktest.matrix(hst, rates=rates, patterns=[p for p in args.patterns.split(",") if p],
+                                      inflight=ints(args.inflight), sizes=ints(args.sizes) or None,
+                                      frames=args.frames, seconds=args.seconds, timeout=args.timeout):
+            if args.json:
+                for c in result.cells:
+                    print(json.dumps({**dataclasses.asdict(c), "actual": result.actual, "low_latency": args.low_latency}), flush=True)
+                if result.why:
+                    print(json.dumps({"rate": result.rate, "why": result.why}), flush=True)
+            else:
+                print(result.text(), flush=True)
+        try:
+            hst.end()
+        except Exception:
+            pass
+    finally:
+        hst.link.close()
+    return 0
+
+
 # ---- oep speed ----------------------------------------------------------------------------------------------------
 
+def _flows(text: str) -> list[tuple[str, int]] | None:
+    """--flows "in:2,out,duplex:1" -> [("in", 2), ("out", 0), ("duplex", 1)]; "" -> None (the default flows)."""
+    out = []
+    for item in text.replace(" ", "").split(","):
+        if not item:
+            continue
+        name, _, n = item.partition(":")
+        out.append((name, int(n) if n else 0))
+    return out or None
+
+
 def _speed(args) -> int:
-    """Take the lock, raise_speed, print the report; the session's end puts the port back at its boot speed."""
+    """Take the lock, raise_speed by the host guide's procedure, print the report; the session's end puts the port
+    back at its boot speed. The record of passed / failed rates is on unless --no-record."""
     import dataclasses
-    rates = [int(r) for r in args.rates.replace(" ", "").split(",") if r]
+    text = args.candidates or args.rates
+    candidates = [int(r) for r in text.replace(" ", "").split(",") if r] or list(link.DEFAULT_CANDIDATES)
+    flows = _flows(args.flows)
+    verify = True if args.verify or flows else (False if args.minimal else None)
     hst = link.open_host(args.probe, baud=args.baud)
     try:
         core.take(hst, 5000, owner="oep speed")
-        report = link.raise_speed(hst, rates, verify_bytes=args.verify_bytes, verify_s=args.verify_s)
+        report = link.raise_speed(hst, candidates, flows=flows, verify=verify, frames=args.frames,
+                                   record=not args.no_record)
         if args.json:
             sys.stdout.write(json.dumps(dataclasses.asdict(report), indent=2) + "\n")
         else:

oep_client/arm.py

@@ -10,7 +10,7 @@ import struct
 
 from . import host as h, message as m, registry as reg
 from .core import Interface
-from .riscv import OK, TargetError, WireBase, check, ran, status_name  # noqa: F401
+from .riscv import OK, BlockLength, TargetError, WireBase, check, ran, status_name  # noqa: F401
 
 DP_DPIDR = DP_ABORT = 0x0
 DP_CTRL_STAT = 0x4
@@ -37,7 +37,7 @@ class SwdWire(WireBase):
         body = bytes([0]) + self._speed_tlv(self._speed_or_default(max_speed)) + self._pins_tlv(pins) + self._reset_tlv(reset)
         if targetsel is not None:
             body += m.tlv(self.TAG_TARGETSEL, struct.pack("<I", targetsel), critical=True)
-        rd = m.Reader(self._call(self.ATTACH, body).payload)
+        rd = m.Reader(self._call(self.ATTACH, body, expect_ms=reset[1] if reset else 0).payload)
         conn, dpidr, self.flags, self.speed_hz = rd.take("HIBI")
         self.existing = bool(self.flags & self.FLAGS["existing"])
         rd.tail()
@@ -60,7 +60,9 @@ def transfer_reads(steps: bytes) -> list[bool]:
     return out
 
 
-class ArmAdi(Interface):
+class ArmAdi(Interface, BlockLength):
+    """oep.target.arm-adi on one connection. `max_length` / `max_words` bound read_block / write_block (from the
+    probe's describe, oep-if-debug §6: mandatory there)."""
     NAME = "oep.target.arm-adi"
     REVISION = 1
     TRANSFER, READ_BLOCK, WRITE_BLOCK = _ADI.op["transfer"], _ADI.op["read_block"], _ADI.op["write_block"]
@@ -70,6 +72,7 @@ class ArmAdi(Interface):
         self.conn = conn
         self.adiv6 = adiv6
         self._select: int | None = None
+        self._max_length = None
 
     # ---- raw transfers ----
     @staticmethod
@@ -140,10 +143,8 @@ class MemAp:
         csw = adi.ap_read(ap, self.base)
         adi.ap_write(ap, self.base, (((csw & ~0x37) | 0x12) | csw_set) & ~csw_clear)   # 32 bits, AddrInc single
         adi._ap_select(ap, self.base)                        # the bank the block operations assume
-        # Words per block operation, from the probe's frame limit: request header 6 + session 4 + connection 2 +
-        # address 4 + count 2 on the way in (the answer's 5 + done 2 + status 1 is smaller).
-        from .core import confirm
-        self.chunk = max(1, (confirm(adi.host)["max_frame"] - 18) // 4)
+        # Words per block operation: the probe's declared max_length (oep-if-debug §6), never computed from max_frame
+        self.chunk = adi.max_words
 
     def write_many(self, pairs: list[tuple[int, int]]) -> None:
         """Scattered single-word writes in one transfer list (TAR, DRW per word, RDBUFF at the end so the last one

oep_client/capture.py

@@ -335,7 +335,7 @@ class LogicCapture(Interface):
 
     def start(self) -> int:
         """-> blocking_ms (0: the probe keeps answering while it captures). self.generation: the new capture's."""
-        rd = m.Reader(self._call(self.START).payload)
+        rd = m.Reader(self._call(self.START, expect_ms=self.config.blocking_ms if self.config else 0).payload)
         blocking, self.generation = rd.take("II")
         rd.tail()
         self.armed_s = time.monotonic()
@@ -576,7 +576,8 @@ class CaptureGroup(Interface):
     def start(self, tracks: list[LogicCapture] = ()) -> tuple[int, int]:
         """-> (blocking_ms, the group's start_ns). `tracks`: whose armed_s and generation to set (the answer's TLV
         generations names each track's new generation; self.generations keeps them by fn)."""
-        rd = m.Reader(self._call(self.START).payload)
+        rd = m.Reader(self._call(self.START, expect_ms=max([t.config.blocking_ms for t in tracks if t.config] or [0]))
+                      .payload)
         blocking, start_ns = rd.take("IQ")
         gens = rd.tail().get(GROUP_GENERATIONS) or b""
         self.generations = {fn: g for fn, g in struct.iter_unpack("<HI", gens[:len(gens) // 6 * 6])}

oep_client/ch32_flash.py

@@ -17,7 +17,7 @@ import struct
 import time
 from dataclasses import dataclass, field
 
-from . import core, host as h, riscv
+from . import host as h, riscv
 
 # oep-spec experiments/flash-primitives/x035_loader.S, assembled at 0x20000000 (riscv32-esp-elf binutils)
 FAST_PAGE_LOADER = bytes.fromhex(
@@ -91,11 +91,10 @@ LOADER, FAST_BUFFER, FAST_DONE = 0x20000000, 0x20000400, 0x200000B0
 V003_INPUT, V003_STACK, V003_EBREAK, V003_RUN = 0x20000200, 0x20000800, 0x2000015C, 1024
 
 
-def _block_size(hst: h.Host) -> int:
-    info = core.confirm(hst)
-    # request header 6 + session 4 + connection 1 + address 4 + count 2 (the read answer's 5 + done 2 + status 1 is
-    # smaller); a little slack for the result header
-    return (info["max_frame"] - 5 - 6 - 4 - 1 - 4 - 2) // 4 * 4
+def _block_size(dm: riscv.RiscvDm) -> int:
+    """Bytes per read_block / write_block: the probe's declared max_length (oep-if-debug §4.5), never a value computed
+    from max_frame (riscv.NoMaxLength when the probe declares none)."""
+    return dm.max_words * 4
 
 
 def _write_requests(dm: riscv.RiscvDm, address: int, data: bytes, block: int) -> list[tuple[int, int, bytes]]:
@@ -142,7 +141,7 @@ def program(hst: h.Host, dm: riscv.RiscvDm, image: bytes, profile: FlashProfile)
     image = image + b"\xff" * (-len(image) % profile.page)
     if profile.size and len(image) > profile.size:
         raise ValueError(f"image of {len(image)} bytes exceeds {profile.size}")
-    block = _block_size(hst)
+    block = _block_size(dm)
     t = {}
     t0 = time.perf_counter()
     if profile.method == "fast-page":

oep_client/cobs.py

@@ -71,3 +71,8 @@ def unframe(raw: bytes) -> bytes:
     if crc16(body) != got:
         raise CorruptFrame("CRC mismatch")
     return body
+
+def frame_max(message_len: int) -> int:
+    """The longest frame a message of this length makes: CRC16, a COBS code per 254 bytes and one more, the delimiter."""
+    n = message_len + 2
+    return n + (n + 253) // 254 + 1 + 1

oep_client/config.py

@@ -292,6 +292,8 @@ class State:
     binds: list[BindState] = field(default_factory=list)
 
 
+SAVE_EXPECT_MS = 2000   # a save writes the probe's flash: the link waits at least this (Host.expecting)
+
 class ProbeConfig(Interface):
     NAME = "oep.probe.config"
     REVISION = 1
@@ -346,7 +348,7 @@ class ProbeConfig(Interface):
 
     def save(self) -> int:
         """Save the current settings (a probe with storage; the whole is replaced). -> the hash saved."""
-        return self._hash_answer(self._call(self.SAVE))
+        return self._hash_answer(self._call(self.SAVE, expect_ms=SAVE_EXPECT_MS))
 
     def erase(self) -> None:
         self._call(self.ERASE)

oep_client/core.py

@@ -4,6 +4,8 @@ entry, and calls that raise unless they worked)."""
 
 from __future__ import annotations
 
+import contextlib
+
 import struct
 
 from . import catalog, host as h, message as m, registry as reg
@@ -196,12 +198,20 @@ class Interface:
                 raise UnsupportedRevision(f"{self.name} (fn {self.fn}) is revision {rev} on this probe; this client "
                                           f"speaks revision {self.REVISION} only")
 
-    def _call(self, op: int, body: bytes = b"", *, locked: bool = True) -> m.Result:
-        return self.host.call(self.fn, op, self.prefix + body, locked=locked)
+    def _expecting(self, ms: int):
+        """Host.expecting(ms) when the host has it (a stand-in host may not)."""
+        expecting = getattr(self.host, "expecting", None) if ms else None
+        return expecting(ms) if expecting else contextlib.nullcontext()
+
+    def _call(self, op: int, body: bytes = b"", *, locked: bool = True, expect_ms: int = 0) -> m.Result:
+        with self._expecting(expect_ms):
+            return self.host.call(self.fn, op, self.prefix + body, locked=locked)
 
-    def _request(self, op: int, body: bytes = b"", *, locked: bool = True) -> m.Result:
-        """Rejections raise; completed results of any outcome come back for the caller to decode."""
-        return self.host.request(self.fn, op, self.prefix + body, locked=locked)
+    def _request(self, op: int, body: bytes = b"", *, locked: bool = True, expect_ms: int = 0) -> m.Result:
+        """Rejections raise; completed results of any outcome come back for the caller to decode. expect_ms: how
+        long it may take on the probe (Host.expecting)."""
+        with self._expecting(expect_ms):
+            return self.host.request(self.fn, op, self.prefix + body, locked=locked)
 
     def request(self, op: int, body: bytes = b"") -> tuple[int, int, bytes]:
         """The raw (fn, op, payload) of one operation, for Host.pipeline / pipeline_calls."""

oep_client/endpoint.py

@@ -35,11 +35,14 @@ define:
   session ends, then resumes from the session's last host reset. The byte framing itself is `fake_serial`.
 - port_speed (core §3.5, optional): on when the profile's describe declares it (`port_speed_base`, the boot speed;
   None = off: the op is unknown_operation). try / commit / revert on the UART bridge the request came in on (else
-  unavailable cause 6), a rate the fake UART cannot make (outside 300..5000000) unsupported; a try reverts after
-  verify_ms without a commit or at a broken candidate, a commit after idle_ms (at most port_speed_idle_max_ms, 3000;
-  0 and anything longer count as that maximum) with no good frame or 3 broken
-  candidates within 1 s, the session's end reverts after its answer. The line itself is modelled by `broken_rates`
-  (rate -> BrokenRate): frames at such a rate break, from a size and in the directions given (`fake_serial` applies it).
+  unavailable cause 6), a step that does not fit the port's state (commit at the boot speed or when committed,
+  revert at the boot speed, try while trying or committed) unavailable cause 6, a step above 2 malformed, a rate the
+  fake UART cannot make (outside 300..5000000) unsupported; a try reverts after verify_ms without a commit or at a
+  broken candidate once a good frame came at the new speed, a commit after idle_ms (at most port_speed_idle_max_ms,
+  3000; 0 and anything longer count as that maximum) with no good frame or at 3 broken candidates in a row with no
+  good frame between, the session's end reverts after its answer. The line itself is modelled by `broken_rates`
+  (rate -> BrokenRate): frames at such a rate break, from a size and in the directions given, only both ways at once
+  (`duplex`), only every Nth (`every`) (`fake_serial` applies it).
 
 Every other non-core fn gets two stand-in operations so the session rules can be exercised - FAKE ONLY, they mean
 nothing on a real probe:  0x01 write(u32) changes state, 0x02 read -> u32 needs no lock.
@@ -317,13 +320,23 @@ class BrokenRate:
     min_size: int = 0
     to_host: bool = True
     to_probe: bool = True
+    duplex: bool = False       # only while both ways carry such frames at once (a request of min_size and more comes in
+                               # while an answer of min_size and more is still unread): the request breaks (to_probe),
+                               # the unread answer breaks (to_host)
+    every: int = 1             # of the frames that would break, only every Nth does (1: all)
+    seen: int = 0              # the frames that would have broken so far (`every` counts these)
+
+    def hit(self) -> bool:
+        """One more frame that would break: True when this one does (`every`)."""
+        self.seen += 1
+        return self.seen % max(1, self.every) == 0
 
 
 PORT_SPEED_TAG = reg.CORE.tlv["describe"]["port_speed"]
 OP_PORT_SPEED = reg.CORE.op["port_speed"]
 SPEED_STEP = reg.CORE.enum["port_speed_step"]
 SPEED_IDLE_MAX_MS = reg.TIMING["port_speed_idle_max_ms"]   # committed: idle_ms at most this (0 and longer: this)
-SPEED_BAD_MAX, SPEED_BAD_WINDOW_MS = 3, 1000       # committed: this many broken candidates within the window revert
+SPEED_BAD_MAX = 3                                  # committed: this many broken candidates in a row (no good frame between) revert
 SPEED_RATES = (300, 5_000_000)                     # what the fake's UART makes (anything between, exactly)
 
 
@@ -476,7 +489,8 @@ class Endpoint:
         self.speed_until_ms = 0                        # try: the commit's deadline (verify_ms)
         self.speed_idle_ms = 0                         # committed: revert after this long with no good frame
         self.speed_good_ms = 0                         # the last good frame on that port
-        self.speed_bad: list[int] = []                 # committed: the times of the recent broken candidates
+        self.speed_heard = False                       # try: a good frame came at the new speed (before it, no broken counts)
+        self.speed_bad = 0                             # committed: broken candidates in a row since the last good frame
         self.speed_pending: tuple | None = None        # ("switch", port, baud, verify_ms) / ("revert",): after the answer
         self.speed_log: list[tuple[int, int]] = []     # (port, rate) every switch, reverts included
         if self.saved is not None:
@@ -1192,23 +1206,28 @@ class Endpoint:
         port, baud, step, verify_ms, idle_ms = t.take("BIBHI")
         _, ignored = t.tail()
         if step not in SPEED_STEP.values():
-            raise unsupported_fixed()
+            raise Reject(m.MALFORMED)                              # not a defined step (core §4.3 order 5)
         if port != self._transport or port >= len(self.transports) or \
                 self.transports[port] != fake.TRANSPORT["uart_bridge"]:
             raise unavailable("wrong_state")                       # only the UART bridge the request came in on
+        # the port's state (boot speed / trying / committed) decides which step fits (core §3.5): any other is cause 6
         if step == SPEED_STEP["try"]:
+            if self.speed_state != "base":
+                raise unavailable("wrong_state")                   # already trying or committed
             if not SPEED_RATES[0] <= baud <= SPEED_RATES[1]:
                 raise unsupported_fixed()                          # a baud this UART cannot make
             self.speed_pending = ("switch", port, baud, verify_ms)
             return self._answer(struct.pack("<I", baud), ignored)
         if step == SPEED_STEP["commit"]:
-            if self.speed_state == "base" or port != self.speed_port or baud != self.speed_asked:
-                raise unavailable("wrong_state")                   # nothing tried, or another baud
+            if self.speed_state != "try" or port != self.speed_port or baud != self.speed_asked:
+                raise unavailable("wrong_state")                   # nothing tried, committed already, or another baud
             self.speed_state = "committed"
             self.speed_idle_ms = idle_ms if 0 < idle_ms <= SPEED_IDLE_MAX_MS else SPEED_IDLE_MAX_MS
             self.speed_good_ms = self.now()
-            self.speed_bad.clear()
+            self.speed_bad = 0
             return self._answer(struct.pack("<I", self.speed_rate), ignored)
+        if self.speed_state == "base":
+            raise unavailable("wrong_state")                       # a revert at the boot speed: nothing to go back from
         self.speed_pending = ("revert",)
         return self._answer(struct.pack("<I", self.port_speed_base), ignored)
 
@@ -1218,10 +1237,19 @@ class Endpoint:
             return self.speed_rate
         return self.port_speed_base or 115200
 
-    def breaks(self, port: int, size: int, to_host: bool) -> bool:
-        """The line model: a frame of `size` bytes on `port` at its rate now breaks (`broken_rates`)."""
+    def breaks(self, port: int, size: int, to_host: bool, duplex: bool = False) -> bool:
+        """The line model: a frame of `size` bytes on `port` at its rate now breaks (`broken_rates`). duplex: the other
+        way carries a frame of the rate's min_size or more at the same time (a BrokenRate with `duplex` breaks only
+        then)."""
+        b = self.broken_rates.get(self.port_baud(port))
+        if b is None or size < b.min_size or not (b.to_host if to_host else b.to_probe) or (b.duplex and not duplex):
+            return False
+        return b.hit()
+
+    def duplex_rate(self, port: int) -> BrokenRate | None:
+        """The rate `port` runs at now when it breaks only both ways at once (fake_serial checks the unread answers)."""
         b = self.broken_rates.get(self.port_baud(port))
-        return b is not None and size >= b.min_size and (b.to_host if to_host else b.to_probe)
+        return b if b is not None and b.duplex else None
 
     def speed_after_answer(self) -> None:
         """The answer that asked for a switch or a revert is out (at the old speed): now do it."""
@@ -1235,7 +1263,8 @@ class Endpoint:
         self.speed_state, self.speed_port, self.speed_rate, self.speed_asked = "try", port, baud, baud
         self.speed_until_ms = self.now() + verify_ms
         self.speed_good_ms = self.now()
-        self.speed_bad.clear()
+        self.speed_heard = False
+        self.speed_bad = 0
         self.speed_log.append((port, baud))
 
     def _speed_revert(self) -> None:
@@ -1243,24 +1272,32 @@ class Endpoint:
             return
         self.speed_log.append((self.speed_port, self.port_speed_base))
         self.speed_state, self.speed_port, self.speed_rate, self.speed_asked = "base", None, 0, 0
-        self.speed_bad.clear()
+        self.speed_heard, self.speed_bad = False, 0
 
     def speed_frame(self, port: int, good: bool) -> None:
-        """A candidate closed on serial port `port`: a frame (good) or not (a broken candidate)."""
+        """A candidate closed on serial port `port`: a frame (good) or not (a broken candidate). core §3.5's conditions
+        2 (trying: one broken candidate after the first good frame at the new speed; the ones before it are the
+        switch-over's leftovers and do not count) and 4 (committed: SPEED_BAD_MAX broken candidates in a row with no
+        good frame between)."""
         if self.speed_state == "base" or port != self.speed_port:
             return
         if good:
             self.speed_good_ms = self.now()
+            self.speed_heard = True
+            self.speed_bad = 0
             return
         if self.speed_state == "try":
-            self._speed_revert()                                   # the new speed breaks frames: not this one
+            if self.speed_heard:
+                self._speed_revert()                               # the new speed breaks frames: not this one
             return
-        now = self.now()
-        self.speed_bad = [t for t in self.speed_bad if now - t < SPEED_BAD_WINDOW_MS] + [now]
-        if len(self.speed_bad) >= SPEED_BAD_MAX:
+        self.speed_bad += 1
+        if self.speed_bad >= SPEED_BAD_MAX:
             self._speed_revert()
 
     def _speed_tick(self) -> None:
+        # Condition 3 (committed, idle_ms with no good frame) is not counted while a request executes (core §3.5, as
+        # the lease, §6.1). The fake handles every request within one call and its clock does not move meanwhile, so
+        # there is nothing to pause here: a long-running request would need `speed_good_ms` set when its answer goes out.
         if self.speed_pending and self.speed_pending[0] == "revert":
             self.speed_after_answer()
         now = self.now()
@@ -1553,8 +1590,10 @@ class Endpoint:
         if op == _RV.op["read_block"]:
             address, count = t.take("IH")
             t.tail()
-            if 4 * count > self.block_max.get(fn, 1 << 16) or address % 4:
-                raise Reject(m.MALFORMED)                          # past the declared max_length (bytes), or not a word
+            if address % 4:
+                raise Reject(m.MALFORMED)                          # not a word address (core §4.3 order 5)
+            if 4 * count > self.block_max.get(fn, 1 << 16):
+                raise unsupported_fixed()                          # past the declared max_length (bytes; debug §4.5)
             if not tg.halted:
                 return m.COMPLETED, m.FAILED, struct.pack("<HB", 0, STATE)   # a running hart (debug §4.5)
             words, status = [], OK
@@ -1567,8 +1606,10 @@ class Endpoint:
                     struct.pack(f"<HB{len(words)}I", len(words), status, *words))
         if op == _RV.op["write_block"]:
             address, count = t.take("IH")
-            if 4 * count > self.block_max.get(fn, 1 << 16) or address % 4:
+            if address % 4:
                 raise Reject(m.MALFORMED)
+            if 4 * count > self.block_max.get(fn, 1 << 16):
+                raise unsupported_fixed()                          # past the declared max_length (debug §4.5)
             words = struct.unpack(f"<{count}I", t.bytes(4 * count))
             t.tail()
             if not tg.halted:

oep_client/fake.py

@@ -157,6 +157,16 @@ MAX_CONNECTIONS = reg.WIRE_RVSWD.tlv["describe"]["max_connections"]
 _CFG = reg.PROBE_CONFIG.tlv["describe"]
 
 
+BLOCK_HEADERS = 24   # read_block's answer (5 + done 2 + status 1) and write_block's request (10 + connection 2 + address 4 + count 2) both fit
+
+
+def block_max_length(max_frame: int) -> int:
+    """The max_length (bytes, a multiple of 4) a probe with read_block / write_block declares for its max_frame
+    (oep-if-debug §4.5): max_frame - 24 rounded down to a word, so a read's answer and a write's request both fit one
+    frame. The host takes this value; it never computes a block size from max_frame."""
+    return max(0, (max_frame - BLOCK_HEADERS) // 4 * 4)
+
+
 def _transports(kinds: list[tuple[int, int]]) -> tuple[bytes, ...]:
     """(kind, USB interface or 0xFF) per transport, index = position (core §7.5)."""
     return tuple(catalog.tlv(CORE_TRANSPORT, bytes([i, k, itf])) for i, (k, itf) in enumerate(kinds))
@@ -219,7 +229,7 @@ def p4_x035() -> FakeProbe:
             catalog.channel_group(1, [(1, 2), (2, 54)]), catalog.u32(MAX_CLOCK_HZ, 5_000_000), catalog.u8(IMPLEMENTATION, 1),
             catalog.u8(MAX_CONNECTIONS, 1))),
         Offered(2, 0, "oep.target.riscv-dm", (catalog.u32(FEATURES, 0b1111), catalog.u8(IMPLEMENTATION, 1),
-                                              catalog.u16(MAX_LENGTH, 1000))),
+                                              catalog.u16(MAX_LENGTH, block_max_length(1024)))),
         Offered(3, 0, "oep.target.console", (catalog.tlv(MECHANISMS, bytes([0, 1, 2])),)),
         _gpio(4, pins),
         _uart(5, 0, pins, 3_000_000),
@@ -256,7 +266,7 @@ def esp32_v003() -> FakeProbe:
         Offered(1, 0, "oep.wire.swio", (catalog.channel_group(1, [(1, 16)]), catalog.role_channels(3, [23]),
                                         catalog.u8(IMPLEMENTATION, 1), catalog.u8(MAX_CONNECTIONS, 1))),
         Offered(2, 0, "oep.target.riscv-dm", (catalog.u32(FEATURES, 0b0111), catalog.u8(IMPLEMENTATION, 1),
-                                              catalog.u16(MAX_LENGTH, 40))),
+                                              catalog.u16(MAX_LENGTH, block_max_length(64)))),
         Offered(3, 0, "oep.target.console", (catalog.tlv(MECHANISMS, bytes([0, 1, 2])),)),
         _gpio(4, wired + [23], modes=0x7F),                      # no mode 7 (both pulls): unsupported there
         _uart(5, 0, wired, 115_200),
@@ -290,7 +300,7 @@ def p4_bench() -> FakeProbe:
             catalog.channel_group(3, [(1, 6), (2, 7)]), catalog.u32(MAX_CLOCK_HZ, 5_000_000),
             catalog.u8(IMPLEMENTATION, 1), catalog.u8(MAX_CONNECTIONS, 2))),
         Offered(2, 0, "oep.target.riscv-dm", (catalog.u32(FEATURES, 0b1111), catalog.u8(IMPLEMENTATION, 1),
-                                              catalog.u16(MAX_LENGTH, 1000))),
+                                              catalog.u16(MAX_LENGTH, block_max_length(1024)))),
         Offered(3, 0, "oep.target.console", (catalog.tlv(MECHANISMS, bytes([0, 1, 2])),)),
         _gpio(4, pins),
         _uart(5, 0, pins, 3_000_000),
@@ -310,7 +320,7 @@ def rp2350_pins() -> FakeProbe:
         Offered(1, 0, "oep.wire.rvswd", _roles({1: pins, 2: pins, 3: pins}) + (
             catalog.u32(MAX_CLOCK_HZ, 5_000_000), catalog.u8(IMPLEMENTATION, 1), catalog.u8(MAX_CONNECTIONS, 1))),
         Offered(2, 0, "oep.target.riscv-dm", (catalog.u32(FEATURES, 0b1111), catalog.u8(IMPLEMENTATION, 1),
-                                              catalog.u16(MAX_LENGTH, 1000))),
+                                              catalog.u16(MAX_LENGTH, block_max_length(1024)))),
         Offered(3, 0, "oep.target.console", (catalog.tlv(MECHANISMS, bytes([0, 1, 2])),)),
         _gpio(4, pins),
         _uart(5, 0, pins, 3_000_000),