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

oep_client/__init__.py

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

oep_client/__main__.py

@@ -12,6 +12,8 @@
   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
+  oep pins <probe> --power 5 --wire swio  (find the target's debug pins and reset line: classify the channels, scan,
+                                           identify, hold-low + attach under reset; prints a slot, --save writes it)
 
 <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).
@@ -63,6 +65,19 @@ def main(argv=None) -> int:
     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")
+    pn = sub.add_parser("pins", help="find where a target is wired: classify the channels, scan the wire, find the "
+                        "reset line, suggest a slot (writes nothing without --save)")
+    pn.add_argument("probe", help="a probe: a serial port, tcp://HOST:PORT or usb[:VID:PID[:SERIAL]]")
+    pn.add_argument("--power", type=int, help="the gpio channel that powers the target: switched off, then on, to "
+                    "see which channels follow it (never touched without this)")
+    pn.add_argument("--exclude", default="", help="channels never to read, scan or hold, comma-separated")
+    pn.add_argument("--wire", choices=("swio", "rvswd", "swd"), default="swio")
+    pn.add_argument("--steps", default="classify,hold,scan,identify,reset,slot",
+                    help="the steps to run, comma-separated (default all: classify, hold, scan, identify, reset, slot)")
+    pn.add_argument("--save", action="store_true", help="write the suggested slot (config set, then save)")
+    pn.add_argument("--slot", type=int, default=0, help="--save: the slot number (default 0)")
+    pn.add_argument("--name", help="--save: the slot's name (default: the target family, else 'target')")
+    pn.add_argument("--json", action="store_true", help="the report as JSON (the steps' lines go to stderr)")
     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")
@@ -77,6 +92,8 @@ def main(argv=None) -> int:
         return _speed(args)
     if args.command == "linktest":
         return _linktest(args)
+    if args.command == "pins":
+        return _pins_cmd(args)
 
     if args.fake:
         call = fake.PROFILES[args.fake]().call
@@ -88,6 +105,33 @@ def main(argv=None) -> int:
     return 0
 
 
+# ---- oep pins -----------------------------------------------------------------------------------------------------
+
+def _pins_cmd(args) -> int:
+    from . import pins
+    exclude = [int(x, 0) for x in args.exclude.replace(" ", "").split(",") if x]
+    say = (lambda t: print(t, file=sys.stderr, flush=True)) if args.json else (lambda t: print(t, flush=True))  # noqa: E731
+    hst = link.open_host(args.probe)
+    try:
+        core.take(hst, 10000, owner="oep pins")
+        finder = pins.PinFinder(hst, wire=args.wire, power=args.power, exclude=exclude, say=say, probe=args.probe,
+                                save=args.save, slot=args.slot, name=args.name)
+        report = finder.run(steps=tuple(s for s in args.steps.split(",") if s))
+        say(f"done in {report.elapsed_s:.1f} s")
+        if args.json:
+            print(json.dumps(report.as_dict(), indent=2))
+        try:
+            hst.end()
+        except host.OepError:
+            pass
+    except host.Rejected as e:
+        print(f"refused: {e}", file=sys.stderr)
+        return 2
+    finally:
+        hst.link.close()
+    return 0 if report.found else 1
+
+
 # ---- oep linktest -------------------------------------------------------------------------------------------------
 
 def _linktest(args) -> int:

oep_client/config.py

@@ -73,14 +73,23 @@ class Label:
 
 @dataclass(kw_only=True)
 class Idle:
+    """The state of a channel no plan or connection uses (probe.config §1): at boot and after every release. mode:
+    hi-z, pull-up, pull-down, output-low, output-high (output_low / output_high too). An output mode keeps driving that
+    level while the channel is free - a target's power switch kept on - and a gpio plan that takes the channel keeps
+    it until its first set (fixture §1); a probe that cannot drive the channel refuses it unsupported."""
     channel: int
-    mode: str = "pull-up"          # hi-z, pull-up, pull-down
+    mode: str = "pull-up"          # hi-z, pull-up, pull-down, output-low, output-high
     TAG = ITEM["idle"]
 
+    def __post_init__(self):
+        self.mode = self.mode.replace("_", "-")
+
     def key(self) -> tuple:
         return (self.channel,)
 
     def value(self) -> bytes:
+        if self.mode not in IDLE:
+            raise ValueError(f"idle mode {self.mode!r}: one of {', '.join(IDLE)}")
         return struct.pack("<HB", self.channel, IDLE[self.mode])
 
 
@@ -395,3 +404,50 @@ class ProbeConfig(Interface):
                 return st
             first_slot += n_slots
             first_bind += n_binds
+
+
+# The label names of a target's power and reset lines (host-development-guide §8.1): `nrst` its reset, `power_hi` high
+# powers it, `power_lo` low powers it. On a probe with several slots they are `<slot name>.<name>`.
+LINE_NAMES = ("nrst", "power_hi", "power_lo")
+
+
+class AmbiguousLine(LookupError):
+    """find_line could not tell which channel is meant; `candidates` holds (label text, channel)."""
+
+    def __init__(self, message: str, candidates: list[tuple[str, int]]):
+        super().__init__(message)
+        self.candidates = candidates
+
+
+def find_line(hst_or_items, name: str, slot: int | str | None = None) -> int | None:
+    """The channel labelled for `name` (nrst, power_hi, power_lo: host-development-guide §8.1), or None when there is
+    none. hst_or_items: a Host (its settings are read: `ProbeConfig.items()`, no lock) or the decoded items. slot: the
+    slot's name or number; None picks the probe's one slot.
+
+    `<slot>.<name>` first, then the bare `name` - the bare name only when the settings hold at most one slot (a bare
+    name is for a one-slot probe). With several slots and no `slot`, or two channels with the same label, it raises
+    AmbiguousLine listing the candidates."""
+    items = hst_or_items if isinstance(hst_or_items, (list, tuple)) else ProbeConfig(hst_or_items).items()
+    labels = [(it.text, it.channel) for it in items if isinstance(it, Label)]
+    slots = [it for it in items if isinstance(it, Slot)]
+    if isinstance(slot, int):
+        named = [s.name for s in slots if s.slot == slot]
+        if not named:
+            raise LookupError(f"no slot {slot} in the probe's settings")
+        slot = named[0]
+    if slot is None and len(slots) > 1:
+        candidates = sorted((t, c) for t, c in labels if t == name or t.endswith("." + name))
+        if candidates:
+            listed = ", ".join(f"{t} (channel {c})" for t, c in candidates)
+            raise AmbiguousLine(f"{name}: {len(slots)} slots and no slot given; candidates: {listed}", candidates)
+        return None
+    if slot is None and slots:
+        slot = slots[0].name
+    texts = ([f"{slot}.{name}"] if slot is not None else []) + ([name] if len(slots) <= 1 else [])
+    for text in texts:
+        found = sorted(c for t, c in labels if t == text)
+        if len(found) > 1:
+            raise AmbiguousLine(f"{text}: on {len(found)} channels", [(text, c) for c in found])
+        if found:
+            return found[0]
+    return None

oep_client/endpoint.py

@@ -26,10 +26,16 @@ define:
   interfaces the profiles offer: oep.wire.rvswd / swio (scan with its TLVs, attach on declared pin pairs with the
   reset TLV, several connections up to max_connections, the seat rule, connections), oep.target.riscv-dm on one
   `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
+  live stream per connection, lifetime by its users, the streams list), oep.fixture.gpio (the lines outside through
+  the test hook `gpio_world`; a target's `reset_line` makes the other reset channels reset nothing), oep.fixture.uart (its stream
+  made by the plan, status, the settings' uart item), oep.fixture.i2c-target / spi-target (fixture §3 / §4: the plan's
+  SDA / SCL and SCK / MOSI / MISO / CS, role_channels and an exact channel_group; configure, arm, preload, read_rx,
+  status, reset, stretch when declared; no bus controller of its own - the test hooks `i2c_write` / `i2c_read` /
+  `spi_transfer` are one transaction on the bus), and oep.probe.config (plan / label / idle / slot / bind / uart
   / 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)
+  is refused everywhere with unavailable cause 5 and never parked: `parked` records the free pins' states it set -
+  idle modes 3 / 4 drive their level, refused unsupported on `input_only` channels; every release goes there, and a
+  gpio line taken keeps that state until its first 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`.
@@ -74,6 +80,7 @@ STREAM_STATE, STREAM_USERS = _CON.enum["stream_state"], _CON.enum["stream_users"
 ATTACH_FLAGS = reg.WIRE_RVSWD.enum["attach_flags"]
 RUN_STOPPED = _RV.enum["run_stopped"]
 ITEM = _CFG.tlv["item"]
+IDLE_MODE = _CFG.enum["idle_mode"]
 CFG_DESCRIBE = _CFG.tlv["describe"]
 SLOT_ATTACH = _CFG.enum["slot_attach"]
 SLOT_STATE = _CFG.enum["slot_state"]
@@ -87,6 +94,10 @@ NO_SLOT, NEVER_NS = 0xFF, 0xFFFFFFFFFFFFFFFF
 PIN_ROLE_RESET = reg.WIRE_RVSWD.enum["pin_role"]["reset"]   # the channels an attach's reset TLV may take
 TARGET_ID_LEN = reg.WIRE_RVSWD.enum["target_id_len"]["wch_dmi_7f"]
 TARGET_ID_SCHEMES = set(reg.WIRE_RVSWD.enum["target_id_scheme"].values()) | set(reg.WIRE_SWD.enum["target_id_scheme"].values())
+_I2C, _SPI = reg.FIXTURE_I2C_TARGET, reg.FIXTURE_SPI_TARGET
+I2C_MODE, I2C_FEATURES, SPI_FEATURES = _I2C.enum["mode"], _I2C.enum["features"], _SPI.enum["features"]
+TARGET_ROLES = {"oep.fixture.gpio": {1}, "oep.fixture.uart": {1, 2}, _I2C.name: set(_I2C.enum["role"].values()),
+                _SPI.name: set(_SPI.enum["role"].values())}   # the plan roles each fixture takes
 UART_FORMAT_MASK = 0x1F                                    # the defined format bits (fixture §2)
 UART_CONFIGURED = _UART.enum["uart_configured"]            # status's configured byte: default / session / item / item_fallback
 _T_SCAN, _T_ATTACH, _T_DETACH, _T_ATTACH_ANSWER = (reg.WIRE_RVSWD.tlv[k] for k in ("scan", "attach", "detach", "attach_answer"))
@@ -212,6 +223,7 @@ class FakeTarget:
     # run(pc, regs) -> (stopped, dpc, elapsed_us); default: halts 0x10 past the start
     run_hook: Callable | None = None
     unstoppable: bool = False                          # run: the limit passes and the hart cannot be halted (stopped 2)
+    reset_line: int | None = None                      # the channel wired to its reset (None: any reset channel resets it)
 
     def dmstatus(self) -> int:
         return 0x82 | ((0x300 if self.halted else 0xC00)) | (0xC0000 if self.havereset else 0)
@@ -223,6 +235,33 @@ class FakeTarget:
         return self.dmi.get(address, 0)
 
 
+@dataclass
+class I2cState:
+    """One oep.fixture.i2c-target (fixture §3): what configure made, the frames waiting for read_rx, the tx slots."""
+    state: int = 0                       # 0 not configured, 1 running
+    address: int = 0
+    mode: int = 0
+    armed: int = 0                       # mode 1: the length arm_rx waits for (0 = not armed)
+    queue: list = field(default_factory=list)   # (frame, ns)
+    rx_frames: int = 0
+    errors: int = 0
+    slots: int = 0                       # preload_tx's running count (u8, wraps)
+    tx: list = field(default_factory=list)      # preloaded, unread
+    stretch_us: int = 0
+
+
+@dataclass
+class SpiState:
+    """One oep.fixture.spi-target (fixture §4): what configure made, the armed transaction, the finished ones."""
+    state: int = 0
+    mode: int = 0
+    bit_order: int = 0
+    armed: tuple[int, bytes] | None = None      # (length, MISO bytes) of the one transaction it waits for
+    queue: list = field(default_factory=list)   # (bits, MOSI bytes, ns)
+    transactions: int = 0
+    errors: int = 0
+
+
 @dataclass
 class Stream:
     """A position stream (common §1): bytes from position `base`, marks with serials; a console stream's users
@@ -362,6 +401,8 @@ class Endpoint:
         self.fns = {name: fn for fn, name in sorted(self.names.items(), reverse=True)}   # first fn of each name
         self.static = {o.fn: o.tlvs for o in probe.offered}
         self.static_labels: dict[int, str] = {}
+        # channels the probe can only read (a test sets them): an idle of mode 3 / 4 there is unsupported (probe.config §1)
+        self.input_only: set[int] = set()
         self.transports: list[int] = []
         self.max_op_ms = reg.LIMITS["max_op_ms_reference"]
         self.plan_roles: int | None = None
@@ -418,6 +459,14 @@ class Endpoint:
                              for fn, name in self.names.items() if name == "oep.fixture.uart"}
         self.uart_max_hz = {fn: next((struct.unpack_from("<I", t, 2)[0] for t in self.static[fn] if t[0] == catalog.MAX_CLOCK_HZ),
                                      3_000_000) for fn, name in self.names.items() if name == "oep.fixture.uart"}
+        def own(fn: int, tag: int, fmt: str, default: int) -> int:
+            return next((struct.unpack_from("<" + fmt, t, 2)[0] for t in self.static[fn] if t[0] == tag), default)
+        # the fixture targets' declarations (fixture §3 / §4): max_length, features, queue_depth, max_stretch_us
+        # (i2c-target only; 0 when not declared)
+        self.target_decl = {fn: (own(fn, catalog.MAX_LENGTH, "H", 1), own(fn, catalog.FEATURES, "I", 0),
+                                 own(fn, _I2C.tlv["describe"]["queue_depth"], "B", 1),
+                                 own(fn, _I2C.tlv["describe"]["max_stretch_us"], "I", 0) if name == _I2C.name else 0)
+                            for fn, name in self.names.items() if name in (_I2C.name, _SPI.name)}
         cfg_fn = self.fns.get("oep.probe.config")
         cfg = {t[0]: t[2:2 + t[1]] for t in self.static.get(cfg_fn, ())}
         self.slots_max = cfg[CFG_DESCRIBE["slots_max"]][0] if CFG_DESCRIBE["slots_max"] in cfg else 0
@@ -430,6 +479,9 @@ class Endpoint:
         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
+        # the lines outside (a test hook): gpio_world(channel, mode) -> the level an input mode reads (None: the
+        # default - gpio_inputs, a pull-up 1); reads see the world as the modes set it (gpio_modes)
+        self.gpio_world: Callable[[int, int], int | None] | None = None
         self._boot()
 
     def _boot(self) -> None:
@@ -469,6 +521,8 @@ class Endpoint:
         self.uart_clock_hz = 80_000_000                # the UARTs' divider clock (a test lowers it: the item's fallback)
         self.uart_session_cfg: set[int] = set()        # fns a session's configure set (it beats the uart item)
         self.uart_tx: dict[int, bytearray] = {}        # what a serial port's raw bytes sent out on a fixture UART
+        self.i2c: dict[int, I2cState] = {fn: I2cState() for fn, n in self.names.items() if n == _I2C.name}
+        self.spi: dict[int, SpiState] = {fn: SpiState() for fn, n in self.names.items() if n == _SPI.name}
         self.config: dict[tuple[int, int], bytes | list[bytes]] = {}   # (item tag, key) -> value (plan: list)
         self.saved: dict | None = getattr(self, "saved", None)
         self.saved_ids: dict[int, tuple] = getattr(self, "saved_ids", {})   # saved fn -> (name, instance, revision)
@@ -822,6 +876,8 @@ class Endpoint:
             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 req.fn in self.i2c and req.op == _I2C.op["stretch"] and not self.target_decl[req.fn][1] & I2C_FEATURES["stretch"]:
+            return m.REJECTED, m.UNKNOWN_OPERATION, b""            # stretch is features bit1's (fixture §3)
         if not self._lock_free(req.fn, req.op):
             refused = self._check(req.session)
             if refused:
@@ -1047,6 +1103,7 @@ class Endpoint:
             named = {fn for fn, _, _ in got}
             if any(fn not in self.names for fn in named):
                 raise Reject(m.UNKNOWN_FUNCTION)
+            self._check_target_roles(got)                          # malformed before held_by_settings (core §4.3)
             if named & self.plan_from_config:                       # the settings' plan is the settings' (core §8)
                 raise unavailable("held_by_settings", holder_fn=min(named & self.plan_from_config),
                                   holder_kind="settings_plan")
@@ -1054,7 +1111,7 @@ class Endpoint:
             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)
+            self._replace_plans(named, got)
             for fn in named:
                 self._uart_plan_changed(fn)
             return m.COMPLETED, m.SUCCESS, b""
@@ -1072,8 +1129,19 @@ class Endpoint:
         their analog function, cutting their digital input and output (oep-if-capture §1.2), as on this library's ESP32s."""
         return fn in self.captures and not self.captures[fn].analog
 
+    def _check_target_roles(self, got: list[tuple[int, int, int]]) -> None:
+        """An i2c-target / spi-target plan holds each of its roles exactly once, on distinct channels (fixture §3 /
+        §4): a missing role, a role twice or two roles on one channel -> malformed. A role the fn does not define is
+        left to the declaration check (unsupported)."""
+        for fn in {f for f, _, _ in got if f in self.i2c or f in self.spi}:
+            roles = TARGET_ROLES[self.names[fn]]
+            mine = [(role, ch) for f, role, ch in got if f == fn and role in roles]
+            if sorted(r for r, _ in mine) != sorted(roles) or len({ch for _, ch in mine}) != len(mine):
+                raise Reject(m.MALFORMED)
+
     def _check_plan(self, got: list[tuple[int, int, int]]) -> None:
         """plan_apply's all-or-nothing check: the roles each fn has, and no pin another fn (or a slot) holds."""
+        self._check_target_roles(got)
         named = {fn for fn, _, _ in got}
         others = {a for a in self.plan if a[0] not in named}
         kept = {a for a in others if not self._listens(a[0])}
@@ -1105,17 +1173,31 @@ class Endpoint:
                 if role not in self._declared_roles(fn, ch):
                     raise not_declared(ch)
                 continue
-            roles = {"oep.fixture.gpio": {1}, "oep.fixture.uart": {1, 2}}.get(self.names.get(fn, ""), set())
+            roles = TARGET_ROLES.get(self.names.get(fn, ""), set())
             if role not in roles or ch not in self._declared_channels(fn):
                 raise not_declared(ch)
+            if fn in self.i2c or fn in self.spi:                   # role_channels binds the roles it lists (core §7.4)
+                listed = self._listed_roles(fn)
+                if role in listed and role not in self._declared_roles(fn, ch):
+                    raise not_declared(ch)
             if any(k[2] == ch for k in kept) or ch in slot_pins:
                 raise held(ch, next((k[0] for k in kept if k[2] == ch), None))
+        for fn in {f for f, _, _ in got if f in self.i2c or f in self.spi}:
+            groups = [set(catalog.unpack_channel_group(t[2:2 + t[1]])[1]) for t in self.static[fn]
+                      if t[0] == catalog.CHANNEL_GROUP]
+            mine = {(role, ch) for f, role, ch in got if f == fn}
+            if groups and mine not in groups:                      # one channel_group exactly (core §7.4)
+                raise not_declared(min(ch for _, ch in mine))
 
     def _declared_roles(self, fn: int, channel: int) -> set[int]:
         """The roles fn's describe offers on `channel` (role_channels)."""
         return {t[2] for t in self.static[fn] if t[0] == catalog.ROLE_CHANNELS
                 and channel in catalog.bitmap_to_channels(struct.unpack_from("<H", t, 3)[0], t[5:2 + t[1]])}
 
+    def _listed_roles(self, fn: int) -> set[int]:
+        """The roles fn's role_channels name (the only ones it binds, core §7.4)."""
+        return {t[2] for t in self.static[fn] if t[0] == catalog.ROLE_CHANNELS}
+
     def _declared_channels(self, fn: int) -> set[int]:
         """Every channel fn's describe offers in any role (role_channels and channel_group)."""
         out = set()
@@ -1126,6 +1208,24 @@ class Endpoint:
                 out.update(c for _, c in catalog.unpack_channel_group(t[2:2 + t[1]])[1])
         return out
 
+    def _replace_plans(self, fns: set[int], got) -> None:
+        """The plans of `fns` become `got` as one change (core §8): a channel leaving goes to its idle state, one in
+        both the old and the new plan of a gpio keeps its state and drive, and a new gpio line keeps the state it was
+        in - an output idle keeps driving - until the first set (fixture §1); the idle modes 0-4 are the gpio modes of
+        the same numbers."""
+        old = {a for a in self.plan if a[0] in fns}
+        kept = {ch for f, _, ch in old if self.names.get(f) == "oep.fixture.gpio"} & \
+               {ch for f, _, ch in got if self.names.get(f) == "oep.fixture.gpio"}
+        released = {a[2] for a in old} - {a[2] for a in got}
+        for ch in {a[2] for a in old} - kept:
+            self.gpio_modes.pop(ch, None)
+        self.plan = {a for a in self.plan if a[0] not in fns}
+        self._park(released)
+        self.plan |= set(got)
+        for fn, _, ch in got:
+            if ch not in kept and self.names.get(fn) == "oep.fixture.gpio" and self.parked.get(ch, 0):
+                self.gpio_modes[ch] = self.parked[ch]
+
     def _drop_plan(self, fn: int) -> None:
         released = set()
         for a in [a for a in self.plan if a[0] == fn]:
@@ -1139,7 +1239,12 @@ class Endpoint:
     # ---- oep.fixture.uart's stream: made by the plan, gone with it (fixture §2) ---------------------
     def _uart_plan_changed(self, fn: int) -> None:
         """fn's plan moved: a fixture UART with RX or TX gets its stream (carrying on from where the last one ended,
-        common §1.1) and the settings' uart item unless a session's configure holds; one without loses it."""
+        common §1.1) and the settings' uart item unless a session's configure holds; one without loses it. A fixture
+        I2C / SPI target goes back to not configured (state 0): its configure is made on the plan's pins."""
+        if fn in self.i2c:
+            self.i2c[fn] = I2cState()
+        if fn in self.spi:
+            self.spi[fn] = SpiState()
         if self.names.get(fn) != "oep.fixture.uart":
             return
         planned = any(a[0] == fn for a in self.plan)
@@ -1395,7 +1500,10 @@ class Endpoint:
             for n, s in self.slots.items():                        # a new connection for an evicted slot: a new cue
                 if s.wire_fn == fn and s.pair == pair:
                     self.slot_rt[n].evicted = False
-            if reset is not None:                                  # the reset line held, then let go: a host reset
+            if reset is not None and tg.reset_line not in (None, channel):
+                if method == 1:                                    # a line that resets nothing: halted where it ran
+                    tg.halted, tg.dpc = True, tg.reset_vector + 0x2f8
+            elif reset is not None:                                # the reset line held, then let go: a host reset
                 tg.halted = method == 1
                 tg.dpc = tg.reset_vector if method == 1 else tg.reset_vector + 0x200
                 self._host_reset(cid, MARK_RESET["attach_reset"])
@@ -1848,7 +1956,9 @@ class Endpoint:
             levels = []
             for ch in chans:
                 mode = self.gpio_modes.get(ch, 0)
-                levels.append({1: 1, 3: 0, 4: 1, 5: 0, 6: 1}.get(mode, self.gpio_inputs.get(ch, 0)))
+                outside = self.gpio_world(ch, mode) if self.gpio_world and mode in (0, 1, 2, 6, 7) else None
+                levels.append(outside if outside is not None else
+                              {1: 1, 3: 0, 4: 1, 5: 0, 6: 1}.get(mode, self.gpio_inputs.get(ch, 0)))
             return self._answer(bytes([len(levels)]) + bytes(levels), ignored)   # n(u8) n x level (fixture §1)
         return m.REJECTED, m.UNKNOWN_OPERATION, b""
 
@@ -1889,6 +1999,194 @@ class Endpoint:
         """Bytes arrive on fixture UART `fn`'s RX."""
         self.uarts[fn].data += data
 
+    # ---- oep.fixture.i2c-target (fixture §3) ------------------------------------------------------
+    def _i2c_op(self, fn: int, op: int, t: Take) -> tuple[int, int, bytes]:
+        st, (max_length, features, depth, max_stretch) = self.i2c[fn], self.target_decl[fn]
+        ops = _I2C.op
+        planned = any(a[0] == fn for a in self.plan)
+        if op == ops["configure"]:                                 # core §4.3's order: malformed, unsupported, unavailable
+            address, mode = t.take("BB")
+            _, ignored = t.tail()
+            if address > 0x7F or mode not in I2C_MODE.values():
+                raise Reject(m.MALFORMED)
+            if mode == I2C_MODE["preloaded_tx"] and not features & I2C_FEATURES["preloaded_tx"]:
+                raise unsupported_fixed()                          # mode 3 without features bit0
+            if not planned:
+                raise unavailable("wrong_state")                   # before the plan (cause 6)
+            self.i2c[fn] = I2cState(state=1, address=address, mode=mode, stretch_us=st.stretch_us)   # made anew
+            return self._answer(b"", ignored)
+        if op == ops["arm_rx"]:
+            length = t.take("H")
+            _, ignored = t.tail()
+            if length == 0:
+                raise Reject(m.MALFORMED)
+            if length > max_length:
+                raise unsupported_fixed()
+            if st.state == 0 or st.mode != I2C_MODE["fixed_rx"]:
+                raise unavailable("wrong_state")                   # mode 1 only
+            st.armed = length                                      # an earlier wait is dropped for this one
+            return self._answer(b"", ignored)
+        if op == ops["read_rx"]:
+            _, ignored = t.tail()
+            if st.state == 0:
+                raise unavailable("wrong_state")                   # cause 6
+            if not st.queue:
+                return self._answer(struct.pack("<BH", 0, 0), ignored)
+            frame, ns = st.queue.pop(0)
+            return self._answer(struct.pack("<BH", min(len(st.queue), 255), len(frame)) + frame
+                                + m.tlv(_I2C.tlv["read_rx_answer"]["ns"], struct.pack("<Q", ns)), ignored)
+        if op == ops["preload_tx"]:
+            count = t.take("H")
+            data = t.bytes(count)
+            _, ignored = t.tail()
+            if count == 0:
+                raise Reject(m.MALFORMED)
+            if count > max_length:
+                raise unsupported_fixed()
+            if st.state == 0 or st.mode != I2C_MODE["preloaded_tx"]:
+                raise unavailable("wrong_state")                   # mode 3 only
+            if len(st.tx) >= depth:
+                raise unavailable("limit")                         # every slot holds an unread preload
+            st.tx.append(data)
+            st.slots = (st.slots + 1) & 0xFF
+            return self._answer(bytes([st.slots]), ignored)
+        if op == ops["status"]:                                    # lock-free
+            _, ignored = t.tail()
+            return self._answer(struct.pack("<BBBBIBI", st.state, st.mode, int(st.armed > 0), min(len(st.queue), 255),
+                                            st.rx_frames, len(st.tx) if st.mode == I2C_MODE["preloaded_tx"] else 0,
+                                            st.errors), ignored)
+        if op == ops["reset"]:
+            _, ignored = t.tail()
+            if st.state == 0:
+                raise unavailable("wrong_state")
+            self.i2c[fn] = I2cState(state=1, address=st.address, mode=st.mode, stretch_us=st.stretch_us)
+            return self._answer(b"", ignored)
+        if op == ops["stretch"] and features & I2C_FEATURES["stretch"]:
+            us = t.take("I")
+            _, ignored = t.tail()
+            if us > max_stretch:
+                raise unsupported_fixed()                          # past describe's max_stretch_us
+            st.stretch_us = us                                     # any state; configure / reset keep it
+            return self._answer(b"", ignored)
+        return m.REJECTED, m.UNKNOWN_OPERATION, b""
+
+    def _i2c_frame(self, st: I2cState, frame: bytes, depth: int) -> None:
+        if len(st.queue) >= depth:
+            st.errors += 1                                         # the queue overflows: the new frame goes
+            return
+        st.queue.append((bytes(frame), self.now_ns()))
+        st.rx_frames += 1
+
+    def i2c_write(self, fn: int, data: bytes, address: int | None = None) -> bool:
+        """TEST HOOK: a bus controller writes `data` to i2c-target `fn` in one transaction (START, address + W, data,
+        STOP). -> whether the target ACKed its address (configured, and `address` None or its own). An address-only
+        write (empty data) counts nothing in any mode. Mode 1: the armed length exactly is a frame and the wait goes on
+        (armed until the next arm_rx / reset / configure / plan release); another length is a receive error; no wait
+        -> ACKed, dropped, an error. Mode 2: the first byte is the length of the rest, the rest a frame (a length that
+        does not match is a receive error). Mode 3 takes no writes: ACKed, dropped, an error."""
+        st, (max_length, _, depth, _) = self.i2c[fn], self.target_decl[fn]
+        if st.state == 0 or (address is not None and address != st.address):
+            return False
+        if not data:
+            pass                                                   # address only: nothing counts
+        elif st.mode == I2C_MODE["fixed_rx"] and st.armed:
+            if len(data) == st.armed:
+                self._i2c_frame(st, data, depth)
+            else:
+                st.errors += 1
+        elif st.mode == I2C_MODE["framed_rx"] and 0 < data[0] == len(data) - 1 <= max_length:
+            self._i2c_frame(st, data[1:], depth)
+        else:
+            st.errors += 1
+        return True
+
+    def i2c_read(self, fn: int, n: int, address: int | None = None) -> bytes | None:
+        """TEST HOOK: a bus controller reads n bytes from i2c-target `fn` in one transaction. -> the bytes, or None
+        when the address is not ACKed. Mode 3 answers from the oldest preloaded slot (cut or padded with 0xFF to n:
+        the next read starts at the next slot); an empty slot list, mode 1 and mode 2 answer 0xFF."""
+        st = self.i2c[fn]
+        if st.state == 0 or (address is not None and address != st.address):
+            return None
+        if st.mode == I2C_MODE["preloaded_tx"] and st.tx:
+            slot = st.tx.pop(0)
+            return (slot + b"\xff" * n)[:n]
+        return b"\xff" * n
+
+    # ---- oep.fixture.spi-target (fixture §4) ------------------------------------------------------
+    def _spi_op(self, fn: int, op: int, t: Take) -> tuple[int, int, bytes]:
+        st, (max_length, features, _, _) = self.spi[fn], self.target_decl[fn]
+        ops = _SPI.op
+        if op == ops["configure"]:
+            mode, order = t.take("BB")
+            _, ignored = t.tail()
+            if mode > 3 or order > 1:
+                raise Reject(m.MALFORMED)
+            if order == 1 and not features & SPI_FEATURES["lsb_first"]:
+                raise unsupported_fixed()
+            if not any(a[0] == fn for a in self.plan):
+                raise unavailable("wrong_state")                   # before the plan (cause 6)
+            self.spi[fn] = SpiState(state=1, mode=mode, bit_order=order)
+            return self._answer(b"", ignored)
+        if op == ops["arm"]:
+            length, count = t.take("HH")
+            tx = t.bytes(count)
+            _, ignored = t.tail()
+            if length == 0 or count > length:
+                raise Reject(m.MALFORMED)
+            if length > max_length:
+                raise unsupported_fixed()
+            if st.state == 0 or st.armed is not None:
+                raise unavailable("wrong_state")                   # not configured, or one is armed already
+            st.armed = (length, tx)
+            return self._answer(b"", ignored)
+        if op == ops["read_rx"]:
+            _, ignored = t.tail()
+            if st.state == 0:
+                raise unavailable("wrong_state")                   # cause 6
+            if not st.queue:
+                return self._answer(struct.pack("<BIH", 0, 0, 0), ignored)
+            bits, data, ns = st.queue.pop(0)
+            return self._answer(struct.pack("<BIH", min(len(st.queue), 255), bits, len(data)) + data
+                                + m.tlv(_SPI.tlv["read_rx_answer"]["ns"], struct.pack("<Q", ns)), ignored)
+        if op == ops["status"]:                                    # lock-free
+            _, ignored = t.tail()
+            return self._answer(struct.pack("<BBBBBII", st.state, st.mode, st.bit_order, int(st.armed is not None),
+                                            min(len(st.queue), 255), st.transactions, st.errors), ignored)
+        if op == ops["reset"]:
+            _, ignored = t.tail()
+            if st.state == 0:
+                raise unavailable("wrong_state")
+            self.spi[fn] = SpiState(state=1, mode=st.mode, bit_order=st.bit_order)
+            return self._answer(b"", ignored)
+        return m.REJECTED, m.UNKNOWN_OPERATION, b""
+
+    def spi_transfer(self, fn: int, mosi: bytes, bits: int | None = None) -> bytes:
+        """TEST HOOK: a bus controller runs one transaction on spi-target `fn` (CS low, `bits` clocks - 8 a MOSI byte
+        by default - CS high). -> the MISO bytes: the armed tx, 0 past it and when not armed. Armed: the MOSI bytes
+        (bits / 8 rounded up) up to the armed length (more is an error) and the bits are queued, the wait ends; a full
+        queue drops them (an error). Not armed: MOSI dropped, an error. Every transaction of a configured target
+        counts; a target not configured sees nothing. 0 bits (CS edges without SCK) is no transaction: nothing counts,
+        an arm keeps waiting."""
+        st, (_, _, depth, _) = self.spi[fn], self.target_decl[fn]
+        n = len(mosi)
+        bits = 8 * n if bits is None else bits
+        if st.state == 0 or bits == 0:
+            return bytes(n)
+        st.transactions += 1
+        if st.armed is None:
+            st.errors += 1
+            return bytes(n)
+        length, tx = st.armed
+        st.armed = None
+        got = (bits + 7) // 8
+        if got > length:
+            st.errors += 1                                         # past the armed length: dropped
+        if len(st.queue) >= depth:
+            st.errors += 1
+        else:
+            st.queue.append((bits, bytes(mosi[:min(got, length)]), self.now_ns()))
+        return (tx + bytes(n))[:n]
+
     # ---- oep.probe.config -----------------------------------------------------------------------
     def _config_op(self, fn: int, op: int, t: Take) -> tuple[int, int, bytes]:
         if op == _CFG.op["get"]:
@@ -2113,8 +2411,10 @@ class Endpoint:
                 if key not in self.names or key == m.CORE_FN:
                     raise Reject(m.UNKNOWN_FUNCTION if key else m.MALFORMED)
             elif tag == ITEM["idle"]:
-                if len(value) != 3 or value[2] > 2:
+                if len(value) != 3 or value[2] > IDLE_MODE["output_high"]:
                     raise Reject(m.MALFORMED)
+                if value[2] in (IDLE_MODE["output_low"], IDLE_MODE["output_high"]) and key in self.input_only:
+                    raise unsupported_fixed(m.tlv(_UNA["channel"], struct.pack("<H", key)))   # cannot drive it (§1)
             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)))
@@ -2146,10 +2446,13 @@ class Endpoint:
         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
+        # idle before the plans (probe.config §2: idle, plan, uart, the at-boot attach): at boot every free channel,
+        # later the ones whose idle changed (or enabled again); a gpio plan then takes a line in that state
+        self._park(self._all_channels() if boot else repark)
         for fn in old_plan_fns - set(plans):                       # are not parked when the same set disables them
             self._drop_plan(fn)
         for fn, assigned in plans.items():
-            self.plan = {a for a in self.plan if a[0] != fn} | set(assigned)
+            self._replace_plans({fn}, assigned)
             self.plan_from_config.add(fn)
             self._uart_plan_changed(fn)
         for fn in self.uarts:                                      # the uart item (or its going) on the planned UARTs no session set
@@ -2167,8 +2470,6 @@ 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
@@ -2509,4 +2810,4 @@ class Endpoint:
 SIMS = {"oep.wire.rvswd": "wire", "oep.wire.swio": "wire", "oep.target.riscv-dm": "dm",
         "oep.target.console": "console", "oep.fixture.gpio": "gpio", "oep.fixture.uart": "uart",
         "oep.probe.config": "config_op", "oep.fixture.logic": "capture", "oep.fixture.analog": "capture",
-        "oep.fixture.capture-group": "group"}
+        "oep.fixture.capture-group": "group", "oep.fixture.i2c-target": "i2c_op", "oep.fixture.spi-target": "spi_op"}