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

oep_client/__init__.py

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

oep_client/__main__.py

@@ -7,7 +7,9 @@
   oep config bind <probe> --port 1 --mode last-reset --stream slot:x035
   oep config plan <probe> oep.fixture.uart#1 rx=48 tx=49       (the fn's whole plan; fn number or name#instance)
   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)
 
 <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).
@@ -28,6 +30,13 @@ 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.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("--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")
     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")
@@ -38,6 +47,8 @@ def main(argv=None) -> int:
     args = parser.parse_args(argv)
     if args.command == "config":
         return _config(args)
+    if args.command == "speed":
+        return _speed(args)
 
     if args.fake:
         call = fake.PROFILES[args.fake]().call
@@ -49,6 +60,26 @@ def main(argv=None) -> int:
     return 0
 
 
+# ---- oep speed ----------------------------------------------------------------------------------------------------
+
+def _speed(args) -> int:
+    """Take the lock, raise_speed, print the report; the session's end puts the port back at its boot speed."""
+    import dataclasses
+    rates = [int(r) for r in args.rates.replace(" ", "").split(",") if r]
+    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)
+        if args.json:
+            sys.stdout.write(json.dumps(dataclasses.asdict(report), indent=2) + "\n")
+        else:
+            sys.stdout.write(report.to_text())
+        hst.end()
+    finally:
+        hst.link.close()
+    return 0 if report.supported else 2
+
+
 # ---- oep config ----------------------------------------------------------------------------------------------------
 
 def _config_parser(sub) -> None:
@@ -98,13 +129,17 @@ def _config_parser(sub) -> None:
     idle.add_argument("channel", type=int)
     idle.add_argument("mode", choices=sorted(config.IDLE))
     idle.add_argument("--save", action="store_true")
+    dis = cs.add_parser("disable", help="channels the probe never uses or touches (not on this board)")
+    dis.add_argument("probe")
+    dis.add_argument("channels", type=int, nargs="+")
+    dis.add_argument("--save", action="store_true")
     uart = cs.add_parser("uart", help="a fixture UART's baud / format, applied whenever its plan has RX or TX")
     uart.add_argument("probe")
     uart.add_argument("fn", help="an fn, or name#instance of the oep.fixture.uart")
     uart.add_argument("baud", type=int)
     uart.add_argument("--format", default="8N1", help="data bits, parity, stop bits: 8N1 (default), 8E1, 7O2 ...")
     uart.add_argument("--save", action="store_true")
-    rm = cs.add_parser("remove", help="remove one item (unset): slot N, bind PORT, plan FN, label CH, idle CH, uart FN")
+    rm = cs.add_parser("remove", help="remove one item (unset): slot N, bind PORT, plan FN, label CH, idle CH, uart FN, disable CH")
     rm.add_argument("probe")
     rm.add_argument("kind", choices=sorted(config.ITEM))
     rm.add_argument("key", type=int)
@@ -235,6 +270,8 @@ def _config(args) -> int:
             _change(hst, cfg, [config.Label(channel=args.channel, text=args.text)], args.save)
         elif args.action == "idle":
             _change(hst, cfg, [config.Idle(channel=args.channel, mode=args.mode)], args.save)
+        elif args.action == "disable":
+            _change(hst, cfg, [config.Disable(channel=ch) for ch in args.channels], args.save)
         elif args.action == "remove":
             _change(hst, cfg, [config.remove(args.kind, args.key)], args.save)
         else:

oep_client/config.py

@@ -1,5 +1,5 @@
 """oep.probe.config revision 1 (oep-spec docs/oep-if-probe-config.ja.md): the probe's settings - plan, labels, idle
-pins, slots, binds, fixture UART settings - read and set as items, removed with unset, saved when the host says so, and
+pins, slots, binds, fixture UART settings, disabled channels - read and set as items, removed with unset, saved when the host says so, and
 the live slot / bind / storage state as its own lock-free operation (describe is declarations only, core §7.3).
 
     cfg = config.ProbeConfig(hst)
@@ -84,6 +84,20 @@ class Idle:
         return struct.pack("<HB", self.channel, IDLE[self.mode])
 
 
+@dataclass(kw_only=True)
+class Disable:
+    """A channel the probe never uses or touches (probe.config §1, item 0x07): not on this board, or wired to another
+    part. Any request naming it is refused unavailable (cause 5, held by settings); describe still declares it."""
+    channel: int
+    TAG = ITEM["disable"]
+
+    def key(self) -> tuple:
+        return (self.channel,)
+
+    def value(self) -> bytes:
+        return struct.pack("<H", self.channel)
+
+
 @dataclass(kw_only=True)
 class Slot:
     """A place a target is wired to (probe.config §1.1). pins: (swdio, swclk), swclk 0xFFFF on one wire (swio).
@@ -160,7 +174,7 @@ class Removal:
     key: int
 
     def encoded(self) -> bytes:
-        """len(u8) tag(u8) key: the key is fn(u16) for plan / uart, channel(u16) for label / idle, slot(u8), port(u8)."""
+        """len(u8) tag(u8) key: the key is fn(u16) for plan / uart, channel(u16) for label / idle / disable, slot(u8), port(u8)."""
         tag = ITEM[self.kind]
         key = bytes([self.key]) if self.kind in ("slot", "bind") else struct.pack("<H", self.key)
         return bytes([1 + len(key), tag]) + key
@@ -172,7 +186,7 @@ def item(it) -> bytes:
 
 def remove(kind: str, key: int) -> Removal:
     """The removal of the item of this key (for `unset`, or in a `set` list): kind plan (key fn: its whole plan), label
-    / idle (channel), slot, bind (port), uart (fn)."""
+    / idle / disable (channel), slot, bind (port), uart (fn)."""
     if kind not in ITEM:
         raise ValueError(f"no item kind {kind!r}")
     return Removal(kind, key)
@@ -187,6 +201,8 @@ def decode(tag: int, v: bytes):
         return Label(channel=struct.unpack_from("<H", v)[0], text=v[2:].decode("utf-8", "replace"))
     if tag == ITEM["idle"] and len(v) >= 3:
         return Idle(channel=struct.unpack_from("<H", v)[0], mode=_name(IDLE, v[2]))
+    if tag == ITEM["disable"] and len(v) >= 2:
+        return Disable(channel=struct.unpack_from("<H", v)[0])
     if tag == ITEM["slot"] and len(v) >= SLOT_HEAD.size + 1:
         n, wire_fn, swdio, swclk, attach, retry_ms, max_speed, idle, mech, name_len = SLOT_HEAD.unpack_from(v)
         at = SLOT_HEAD.size
@@ -219,7 +235,7 @@ def decode(tag: int, v: bytes):
 
 def _sort_key(tag: int, value: bytes) -> tuple:
     """The canonical order's key of one item (probe.config §2): tag, then the key - plan (fn, role, channel), label /
-    idle channel, slot, port, uart fn."""
+    idle / disable channel, slot, port, uart fn."""
     if tag == ITEM["plan"] and len(value) >= 5:
         return (tag,) + struct.unpack_from("<HBH", value)
     if tag in (ITEM["slot"], ITEM["bind"]):
@@ -299,7 +315,7 @@ class ProbeConfig(Interface):
                     return h, out
 
     def items(self) -> list:
-        """The current settings, decoded (Plan, Label, Idle, Slot, Bind, Uart)."""
+        """The current settings, decoded (Plan, Label, Idle, Slot, Bind, Uart, Disable)."""
         return [decode(t, v) for t, v in self.get()[1]]
 
     def set(self, items: list) -> int:

oep_client/core.py

@@ -140,7 +140,7 @@ def plan_apply(hst: h.Host, assignments: list[tuple[int, int, int]]) -> None:
 
 class PinsTaken(h.Rejected):
     """plan_apply refused (unavailable) and the probe's settings say why: a pin kept by another fn's saved plan or by a
-    slot (oep.probe.config). `holders`: (channel, what holds it)."""
+    slot, or a channel the settings disable (oep.probe.config). `holders`: (channel, what holds it)."""
 
     def __init__(self, result, holders: list[tuple[int, str]]):
         super().__init__(result)
@@ -167,6 +167,8 @@ def _pin_holders(hst: h.Host, assignments: list[tuple[int, int, int]]) -> list[t
                 out.append((ch, f"the saved plan of fn {it.fn} (role {it.role})"))
             elif isinstance(it, config.Slot) and ch in it.pins:
                 out.append((ch, f"slot {it.slot} {it.name}"))
+            elif isinstance(it, config.Disable) and it.channel == ch:
+                out.append((ch, "the settings (disabled; oep config remove <probe> disable <channel> enables it)"))
     return out
 
 

oep_client/endpoint.py

@@ -28,10 +28,18 @@ define:
   `FakeTarget` per pin pair (dmi / run answers count their values; run's stopped 2), oep.target.console streams (one
   live stream per connection, lifetime by its users, the streams list), oep.fixture.gpio, oep.fixture.uart (its stream
   made by the plan, status, the settings' uart item), and oep.probe.config (plan / label / idle / slot / bind / uart
-  items, get / set / unset / save / erase, the state op - describe is declarations only)
+  / disable items, get / set / unset / save / erase, the state op - describe is declarations only; a disabled channel
+  is refused everywhere with unavailable cause 5 and never parked: `parked` records the free pins' states it set)
 - the serial ports' raw side (core §3.4, probe.config §1.2): `port_input` / `port_output` carry the bytes outside
   the frames for each serial port by its bind; a port the lock holder's requests came in on is held until the
   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).
 
 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.
@@ -301,6 +309,24 @@ class Flow:
     last_ms: int = 0
 
 
+@dataclass
+class BrokenRate:
+    """How a line rate breaks frames in the fake (port_speed tests): frames of `min_size` bytes and more (on the wire)
+    break, towards the host and / or towards the probe. A broken frame towards the probe is a candidate whose CRC does
+    not match; towards the host its CRC is spoiled."""
+    min_size: int = 0
+    to_host: bool = True
+    to_probe: bool = True
+
+
+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_RATES = (300, 5_000_000)                     # what the fake's UART makes (anything between, exactly)
+
+
 class Endpoint:
     MARKS_PER_ANSWER = 3                     # small, so hosts must follow `more`
     CHUNK = 64                               # raw bytes a serial port takes at a time (probe guide §3.6)
@@ -387,6 +413,10 @@ class Endpoint:
         self.bind_modes = struct.unpack_from("<I", cfg[CFG_DESCRIBE["bind_modes"]])[0] if CFG_DESCRIBE["bind_modes"] in cfg else 0
         self.console_accept = 64
         self.uart_accept = 256
+        # port_speed (core §3.5): on when the profile declares it; the boot speed every revert goes back to
+        self.port_speed_base: int | None = 115200 if any(t[0] == PORT_SPEED_TAG for t in self.static.get(0, ())) else None
+        self.broken_rates: dict[int, BrokenRate] = {}   # the line: rates that break frames (fake_serial applies it)
+        self._transport = 0                             # the transport the request being handled came in on
         self._boot()
 
     def _boot(self) -> None:
@@ -438,8 +468,49 @@ class Endpoint:
         self.mixed_out: dict[int, bytearray] = {}
         self.held_ports: set[int] = set()
         self.session_resets: dict[tuple[int, int], tuple[object, int]] = {}   # stream key -> (sid, position)
+        self.parked: dict[int, int] = {}               # channel -> the idle mode the probe put the free pin in
+        self.speed_state = "base"                      # port_speed: "base", "try" or "committed" (core §3.5)
+        self.speed_port: int | None = None             # the port off its boot speed
+        self.speed_rate = 0                            # the rate it runs at
+        self.speed_asked = 0                           # the baud the try asked (the commit names it again)
+        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_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:
-            self._apply_saved()
+            self._apply_saved()                        # the saved disable items first: those pins are never parked
+        self._park(self._all_channels())               # then the free pins' idle state (probe.config §2 boot order)
+
+    @property
+    def disabled(self) -> set[int]:
+        """The channels the settings' disable items take away (probe.config §1): never used, driven or configured."""
+        return {key for tag, key in self.config if tag == ITEM["disable"]}
+
+    def _refuse_disabled(self, channels, extra: bytes = b"") -> None:
+        """A request naming a disabled channel: rejected unavailable cause 5 (held by settings) with the channel."""
+        for ch in channels:
+            if ch != 0xFFFF and ch in self.disabled:
+                raise unavailable("held_by_settings", ch, holder_kind="disabled", extra=extra)
+
+    def _all_channels(self) -> set[int]:
+        """Every channel some fn's describe offers (role_channels, channel_group, the wires' pairs and reset lines)."""
+        out = {ch for fn in self.static if fn != m.CORE_FN for ch in self._declared_channels(fn)}
+        out |= {p for pairs in self.pairs.values() for pair in pairs for p in pair}
+        out |= {ch for chs in self.reset_channels.values() for ch in chs}
+        out.discard(0xFFFF)
+        return out
+
+    def _park(self, channels) -> None:
+        """Free pins go to their idle state (the idle item, else Hi-Z) at boot and whenever released (probe.config §1);
+        a disabled channel stays as the reset left it (never parked), a held one is not free."""
+        busy = self._held()
+        for ch in channels:
+            if ch == 0xFFFF or ch in self.disabled or ch in busy:
+                continue
+            item = self.config.get((ITEM["idle"], ch))
+            self.parked[ch] = item[2] if item else 0               # 0 = Hi-Z
 
     @property
     def target_id(self) -> int | None:
@@ -676,6 +747,7 @@ class Endpoint:
             return None
         req = m.Request.unpack(data)
         self.requests.append(req)
+        self._transport = transport
         remembered = self._resent(req)
         if remembered is not None:
             return remembered
@@ -696,6 +768,8 @@ class Endpoint:
         out = m.Result(req.corr, res, detail, payload).pack()
         if req.session is not None and req.session == self.last:
             self._remember(req, out)
+        if transport not in self.serial_ports:
+            self.speed_after_answer()                              # the answer is not on a port whose speed changes
         return out
 
     def _interface(self, fn: int):
@@ -732,6 +806,8 @@ class Endpoint:
             return self._open(req.payload)
         if req.fn != m.CORE_FN and req.fn not in self.names:
             return m.REJECTED, m.UNKNOWN_FUNCTION, b""
+        if req.fn == m.CORE_FN and req.op == OP_PORT_SPEED and self.port_speed_base is None:
+            return m.REJECTED, m.UNKNOWN_OPERATION, b""            # the optional feature off (core §3.5)
         if not self._lock_free(req.fn, req.op):
             refused = self._check(req.session)
             if refused:
@@ -919,6 +995,8 @@ class Endpoint:
         if op == m.OP_KEEPALIVE:
             _, ignored = t.tail()
             return self._answer(b"", ignored)
+        if op == OP_PORT_SPEED:
+            return self._port_speed(t)
         if op == m.OP_SUBSCRIBE:
             fn, _min_bytes, max_delay_ms = t.take("HHI")           # max_delay_ms u32 (core §11.3)
             t.tail()
@@ -959,6 +1037,7 @@ class Endpoint:
                 raise unavailable("held_by_settings", holder_fn=min(named & self.plan_from_config),
                                   holder_kind="settings_plan")
             self._check_plan(got)
+            self._refuse_disabled(ch for _, _, ch in got)          # a disabled channel (probe.config §1): cause 5
             if self.plan_roles is not None and len([a for a in self.plan if a[0] not in named]) + len(got) > self.plan_roles:
                 raise unavailable("limit")                          # plan_roles (core §8)
             self.plan = {a for a in self.plan if a[0] not in named} | set(got)
@@ -1034,11 +1113,14 @@ class Endpoint:
         return out
 
     def _drop_plan(self, fn: int) -> None:
+        released = set()
         for a in [a for a in self.plan if a[0] == fn]:
             self.gpio_modes.pop(a[2], None)
             self.plan.discard(a)
+            released.add(a[2])
         self.plan_from_config.discard(fn)
         self._uart_plan_changed(fn)
+        self._park(released)
 
     # ---- oep.fixture.uart's stream: made by the plan, gone with it (fixture §2) ---------------------
     def _uart_plan_changed(self, fn: int) -> None:
@@ -1097,9 +1179,96 @@ class Endpoint:
     # ---- describe: the static declarations plus the live ones -----------------------------------
     def _declarations(self, fn: int) -> list[bytes]:
         """describe: the profile's declarations as they are (core §7.3: nothing that changes - the firmware's labels
-        only, the settings' are read by get; probe.config's state is its op state)."""
+        only, the settings' are read by get; probe.config's state is its op state). fn 0's port_speed follows
+        `port_speed_base` (a test turns the feature off or on)."""
+        if fn == m.CORE_FN:
+            out = [t for t in self.static[fn] if t[0] != PORT_SPEED_TAG]
+            return out + [catalog.u8(PORT_SPEED_TAG, 1)] if self.port_speed_base is not None else out
         return list(self.static[fn])
 
+    # ---- port_speed (core §3.5) -----------------------------------------------------------------
+    def _port_speed(self, t: "Take") -> tuple[int, int, bytes]:
+        """port(u8) baud(u32) step(u8) verify_ms(u16) idle_ms(u32) [TLV] -> baud(u32): the rate that applies."""
+        port, baud, step, verify_ms, idle_ms = t.take("BIBHI")
+        _, ignored = t.tail()
+        if step not in SPEED_STEP.values():
+            raise unsupported_fixed()
+        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
+        if step == SPEED_STEP["try"]:
+            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
+            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()
+            return self._answer(struct.pack("<I", self.speed_rate), ignored)
+        self.speed_pending = ("revert",)
+        return self._answer(struct.pack("<I", self.port_speed_base), ignored)
+
+    def port_baud(self, port: int) -> int:
+        """The rate serial port `port` runs at now (its boot speed, or what port_speed set)."""
+        if self.speed_state != "base" and port == self.speed_port:
+            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`)."""
+        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)
+
+    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."""
+        pending, self.speed_pending = self.speed_pending, None
+        if pending is None:
+            return
+        if pending[0] == "revert":
+            self._speed_revert()
+            return
+        _, port, baud, verify_ms = pending
+        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_log.append((port, baud))
+
+    def _speed_revert(self) -> None:
+        if self.speed_state == "base":
+            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()
+
+    def speed_frame(self, port: int, good: bool) -> None:
+        """A candidate closed on serial port `port`: a frame (good) or not (a broken candidate)."""
+        if self.speed_state == "base" or port != self.speed_port:
+            return
+        if good:
+            self.speed_good_ms = self.now()
+            return
+        if self.speed_state == "try":
+            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_revert()
+
+    def _speed_tick(self) -> None:
+        if self.speed_pending and self.speed_pending[0] == "revert":
+            self.speed_after_answer()
+        now = self.now()
+        if self.speed_state == "try" and now >= self.speed_until_ms:
+            self._speed_revert()                                   # no commit within verify_ms
+        elif self.speed_state == "committed" and now - self.speed_good_ms >= self.speed_idle_ms:
+            self._speed_revert()
+
     def _page(self, tlvs: list[bytes], first: int) -> bytes:
         budget = self.probe.max_frame - m.RESULT_HEADER - 1
         out, sent = b"", 0
@@ -1129,12 +1298,13 @@ class Endpoint:
                 raise Reject(m.MALFORMED)
             live = [c.pair for c in self.conns.values() if c.fn == fn]
             full = len(live) >= self.max_connections.get(fn, 1)   # every seat taken: the live pairs only
+            self._refuse_disabled(ch for p in pairs if self._allows(fn, p) for ch in p)   # cause 5 (probe.config §1)
             if any(not self._allows(fn, p) or set(p) & self._held(fn, p) or (full and p not in live) for p in pairs):
                 raise Reject(m.UNAVAILABLE)                        # not allowed, held (§8.1), or no seat to try it on
             if not pairs:                                          # the count-0 list, from `skip` on (oep-if-debug §1)
                 skip = struct.unpack("<H", skip_tlv)[0] if skip_tlv is not None else 0
-                pairs = [p for p in self._allowed_pairs(fn)
-                         if not set(p) & self._held(fn, p) and (not full or p in live)][skip:]
+                pairs = [p for p in self._allowed_pairs(fn) if not set(p) & self.disabled   # disabled: not listed
+                         and not set(p) & self._held(fn, p) and (not full or p in live)][skip:]
             pairs = pairs[:255]                                    # tried is a u8
             found = []
             for p in pairs:
@@ -1164,6 +1334,7 @@ class Endpoint:
                     raise Reject(m.UNSUPPORTED, bytes([_T_ATTACH["reset"] | m.TAG_CRITICAL]))   # not a reset line here (§3)
                 if hold_ms > self.max_op_ms:
                     raise Reject(m.UNSUPPORTED, bytes([_T_ATTACH["reset"] | m.TAG_CRITICAL]))   # longer than one request may take
+                self._refuse_disabled([channel])                   # a disabled reset line: cause 5 (probe.config §1)
                 if any(a[2] == channel for a in self.plan):
                     raise unavailable("pin_in_use", channel, next(a[0] for a in self.plan if a[2] == channel), "plan")
             idle_clock = idle_tlv[0] if idle_tlv is not None else 0
@@ -1241,13 +1412,17 @@ class Endpoint:
             pair = struct.unpack("<HH", got[0x03])
             if not self._allows(fn, pair):
                 raise Reject(m.UNSUPPORTED, bytes([_T_ATTACH["pins"] | m.TAG_CRITICAL]))   # not a pair this wire offers (core §4.3 order 6)
+            self._refuse_disabled(pair)                            # a disabled channel: cause 5 (probe.config §1)
             if set(pair) & self._held(fn, pair):
                 raise unavailable("pin_in_use", next(iter(set(pair) & self._held(fn, pair))))   # held (§8.1)
             return pair
         live = [c.pair for c in self.conns.values() if c.fn == fn]
         if len(live) == 1:
             return live[0]                                         # no pins: the wire's one live connection
-        allowed = self._allowed_pairs(fn)
+        offered = self._allowed_pairs(fn)
+        allowed = [p for p in offered if not set(p) & self.disabled]   # the probe never picks a disabled channel
+        if not live and len(offered) == 1 and not allowed:
+            self._refuse_disabled(offered[0])                      # its one pair is disabled: cause 5
         if live or len(allowed) != 1:
             raise Reject(m.UNAVAILABLE)                            # the host chooses among several
         return allowed[0]
@@ -1281,8 +1456,10 @@ class Endpoint:
 
     def _close_conn(self, cid: int, mark: int) -> None:
         """The connection goes; its streams close (mark `mark`, then closed 4) and stay readable (console §2)."""
-        self.conns.pop(cid, None)
+        gone = self.conns.pop(cid, None)
         self.resources.pop(cid, None)
+        if gone is not None:
+            self._park(gone.pair)                                  # its pins are free again: their idle state
         for (c, _), sid in list(self.stream_keys.items()):
             if c == cid and not self.streams[sid].closed:
                 self.streams[sid].add_mark(mark, self.now_ns())
@@ -1612,6 +1789,7 @@ class Endpoint:
                 if not self.gpio_allowed.get(fn, 0xFF) >> mode & 1:   # a mode it does not drive (fixture §1)
                     raise unsupported_fixed(m.tlv(_UNA["channel"], struct.pack("<H", ch)), m.tlv(index_tag, bytes([i])))
             for i, (ch, mode) in enumerate(pairs):
+                self._refuse_disabled([ch], m.tlv(index_tag, bytes([i])))   # disabled: cause 5 (probe.config §1)
                 if ch not in mine:                                 # the position as the gpio's TLV (fixture §1)
                     raise unavailable(channel=ch, extra=m.tlv(index_tag, bytes([i])))
             for ch, mode in pairs:
@@ -1623,6 +1801,7 @@ class Endpoint:
             chans = [t.take("H") for _ in range(n)]
             _, ignored = t.tail()
             for i, ch in enumerate(chans):
+                self._refuse_disabled([ch], m.tlv(_GPIO.tlv["unavailable_payload"]["index"], bytes([i])))
                 if ch not in mine:
                     raise unavailable(channel=ch, extra=m.tlv(_GPIO.tlv["unavailable_payload"]["index"], bytes([i])))
             levels = []
@@ -1872,6 +2051,10 @@ class Endpoint:
         places = [(s.wire_fn, s.pair) for s in slots.values()]
         if len(set(places)) != len(places):
             raise Reject(m.MALFORMED)                              # two slots on one place: the settings contradict
+        disabled = {key for tag, key in new if tag == ITEM["disable"]}
+        idles = {key for tag, key in new if tag == ITEM["idle"]}
+        if disabled & idles:
+            raise Reject(m.MALFORMED)                              # idle and disable for one channel (probe.config §1)
         for fn in self.pairs:                                      # every wire (pin_roles wires have an empty list)
             if sum(1 for s in slots.values() if s.wire_fn == fn and s.attach == SLOT_ATTACH["at_boot"]) > \
                     self.max_connections.get(fn, 1):
@@ -1891,6 +2074,9 @@ class Endpoint:
             elif tag == ITEM["idle"]:
                 if len(value) != 3 or value[2] > 2:
                     raise Reject(m.MALFORMED)
+            elif tag == ITEM["disable"] and key not in self._all_channels():
+                # a channel the firmware does not declare: unsupported, as idle (probe.config §1)
+                raise unsupported_fixed(m.tlv(_UNA["channel"], struct.pack("<H", key)))
             elif tag == ITEM["label"]:
                 if len(value) < 3:
                     raise Reject(m.MALFORMED)
@@ -1911,13 +2097,16 @@ class Endpoint:
         self.slots = slots                                         # the pin check below sees the new slots
         try:
             self._check_plan(want)
+            self._check_disabled(new, disabled, plans, want, slots)
         except Reject:
             self.slots = {k: self._parse_slot(v) for (t, k), v in self.config.items() if t == ITEM["slot"]}
             raise
         # accepted: make it current
-        for fn in old_plan_fns - set(plans):
+        old_idle = {key: v for (tag, key), v in self.config.items() if tag == ITEM["idle"]}
+        repark = (self.disabled - disabled) | {key for key in idles | set(old_idle) if new.get((ITEM["idle"], key)) != old_idle.get(key)}
+        self.config = new                                          # the disable items first: a dropped plan's pins
+        for fn in old_plan_fns - set(plans):                       # are not parked when the same set disables them
             self._drop_plan(fn)
-        self.config = new
         for fn, assigned in plans.items():
             self.plan = {a for a in self.plan if a[0] != fn} | set(assigned)
             self.plan_from_config.add(fn)
@@ -1937,12 +2126,40 @@ class Endpoint:
                     self.flows.pop((port, key), None)
                 self.mixed_out.pop(port, None)
         self.binds = binds
+        if not boot:
+            self._park(repark)                                     # an idle item set, or a channel enabled again: now
         for n, s in slots.items():
             if s.attach == SLOT_ATTACH["at_boot"] and (boot or changed_slots is None or n in changed_slots):
                 self.slot_rt[n].evicted = False
                 self._auto_attach(n)
         self._refresh()
 
+    def _check_disabled(self, new: dict, disabled: set[int], plans: dict, want: list, slots: dict) -> None:
+        """probe.config §1 disable: a channel in use now (a plan, a connection, a slot this set keeps) cannot be disabled
+        (unavailable cause 1); an item naming a disabled channel (a plan, a slot's pins) is cause 5 with the channel."""
+        for ch in sorted(disabled - self.disabled):
+            for fn, _, c in sorted(self.plan):
+                if c != ch:
+                    continue
+                if fn in self.plan_from_config:
+                    if new.get((ITEM["plan"], fn)) == self.config.get((ITEM["plan"], fn)):
+                        raise unavailable("pin_in_use", ch, fn, "settings_plan")
+                elif fn not in plans:                              # a session's plan this set does not replace
+                    raise unavailable("pin_in_use", ch, fn, "plan")
+            conn = next((c for c in self.conns.values() if ch in c.pair), None)
+            if conn is not None:
+                raise unavailable("pin_in_use", ch, conn.fn, "connection")
+            for (tag, key), value in self.config.items():
+                if tag == ITEM["slot"] and new.get((tag, key)) == value and ch in self._parse_slot(value).pair:
+                    raise unavailable("pin_in_use", ch, holder_kind="slot")
+        self._refuse_disabled_in(disabled, [c for _, _, c in want] + [p for s in slots.values() for p in s.pair])
+
+    @staticmethod
+    def _refuse_disabled_in(disabled: set[int], channels: list[int]) -> None:
+        for ch in channels:
+            if ch != 0xFFFF and ch in disabled:
+                raise unavailable("held_by_settings", ch, holder_kind="disabled")
+
     def _parse_slot(self, v: bytes) -> Slot:
         """probe.config §1.1, refused in core §4.3's order: the form (malformed), then what this probe lacks
         (unsupported), then unknown fns."""
@@ -2093,8 +2310,9 @@ class Endpoint:
                         self.flows[(port, key)] = Flow(sid, 0)
 
     def tick(self) -> None:
-        """Time passes: the lease, at-boot retries, mixed lines closed by quiet, the captures."""
+        """Time passes: the lease, at-boot retries, mixed lines closed by quiet, the captures, port_speed's timers."""
         self._lapse()
+        self._speed_tick()
         now = self.now()
         for fn, cap in self.captures.items():
             self._events(fn, cap.tick(now))
@@ -2229,7 +2447,10 @@ class Endpoint:
             s.written += data
 
     def _session_over(self) -> None:
-        """The session ended (end, lapse, force): the ports it held resume from its last host reset (or now)."""
+        """The session ended (end, lapse, force): the ports it held resume from its last host reset (or now); a port
+        off its boot speed goes back after the answer (core §3.5)."""
+        if self.speed_state != "base":
+            self.speed_pending = ("revert",)
         for port in self.held_ports:
             b = self.binds.get(port)
             if b is None:

oep_client/fake.py

@@ -118,6 +118,7 @@ _CAPD = reg.FIXTURE_LOGIC.tlv["describe"]
 _ANAD = reg.FIXTURE_ANALOG.tlv["describe"]
 _GRPD = reg.FIXTURE_CAPTURE_GROUP.tlv["describe"]
 CORE_CHIP = reg.CORE.tlv["describe"]["chip"]
+CORE_PORT_SPEED = reg.CORE.tlv["describe"]["port_speed"]   # the optional port_speed is on (core §3.5)
 
 
 def _analog_decl(frontends: list[tuple[int, int, int, int]], max_samples: int) -> tuple[bytes, ...]:
@@ -245,13 +246,13 @@ def p4_x035() -> FakeProbe:
 
 def esp32_v003() -> FakeProbe:
     """A small probe with 64-byte frames over a 115200 bps UART bridge (its only transport, serial port 0):
-    classic ESP32 on a CH32V003 (SWIO) jig."""
+    classic ESP32 on a CH32V003 (SWIO) jig. port_speed on (core §3.5), as the reference classic ESP32 firmware."""
     reserved = [0, 1, 2, 3, 6, 7, 8, 9, 10, 11, 12, 15, 16]
     wired = [4, 5, 13, 14, 17, 18, 19, 21, 22, 25, 26, 27, 32, 33]
     return FakeProbe("esp32-v003", 64, [
         _core("3.0.0", "esp32", "0070070d9394", 40, reserved, f"{NS}.esp32-v003",
               {16: "SWIO", 23: "NRST", 22: "DUT TX", 21: "DUT RX"},
-              _transports([(TRANSPORT["uart_bridge"], 0xFF)])),
+              _transports([(TRANSPORT["uart_bridge"], 0xFF)]) + (catalog.u8(CORE_PORT_SPEED, 1),)),
         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),