OCuLink Riser for the Supermicro AIOM Slot

#!/usr/bin/env python3
"""High-speed routing for the OCP NIC 3.0 SFF -> 4x OCuLink riser.

Board frame: x across the card (0..76), y from the faceplate edge (0) to the gold-finger edge (115), KiCad y-down.
Layers: L1=F.Cu, L2=In1 GND, L3=In2, L4=In3 GND, L5=In4, L6=B.Cu GND (and the A-side fingers).

Each differential pair is a centreline of nodes (x, y, layer). Consecutive nodes on one layer are a trace; a layer
change is a via pair placed across the direction of travel. The n trace is the left offset (west when heading north),
p the right one; that holds the whole way because every path is an octilinear S-shape.

Lane reversal (OCuLink ports face the faceplate, so each port sees its lanes in the opposite order to the fingers):
  stage A (just past the via row): lanes 0<->1 and 2<->3 cross; lane 0 on L1, lane 1 on L3, lane 3 on L1, lane 2 on L5
  lane 3 drops L1 -> L5 in band M
  stage B (before the connector): block {1,0} (L3, L1) crosses block {3,2} (both L5)
"""
import math, json, os, sys
sys.path.insert(0, os.path.dirname(__file__))
from footprints import ocp_pin_x

F = 38.0 - 0.258          # datum F: H (card centre line, x=38) minus 0.258 (SFF-TA-1002 Fig 5-39, OCP Detail A)
EDGE_Y = 115.0
PAD_TOP = EDGE_Y - 3.00   # inner end of every gold finger
CX = [16.1 + 14.6 * k for k in range(4)]   # OCuLink port centres (pitch 14.6, inside the 59.1 mm faceplate zone)

# 85 ohm differential, JLC06161H-3313 (design/zsolve.py, 2D field solve)
PAIR = {"L1": (0.163, 0.15), "L6": (0.163, 0.15), "L3": (0.131, 0.15), "L5": (0.121, 0.15)}
KLAY = {"L1": "F.Cu", "L3": "In2.Cu", "L5": "In4.Cu", "L6": "B.Cu"}
VIA_P = 0.70               # signal via pair pitch
VIA_D, VIA_H = 0.40, 0.20  # transition vias
VIP_D, VIP_H = 0.25, 0.15  # via-in-pad at the OCuLink pads (JLC 6L: filled and capped by default)


def pitch(layer):
    w, s = PAIR[layer]
    return w + s


class Pair:
    def __init__(self, name, nnet, pnet, kind):
        self.name, self.nnet, self.pnet, self.kind = name, nnet, pnet, kind
        self.nodes = []          # (x, y, layer)
        self.start = None        # ((xn, yn), (xp, yp), layer)  pad ends
        self.end = None          # ((xn, yn), (xp, yp), layer, via_in_pad)
        self.tracks = []         # (layer, net, x1, y1, x2, y2, w)
        self.vias = []           # (x, y, net, d, h)

    def add(self, x, y, layer):
        self.nodes.append((round(x, 4), round(y, 4), layer))
        return self


def unit(dx, dy):
    L = math.hypot(dx, dy)
    return (dx / L, dy / L)


def left(d):
    return (d[1], -d[0])


def offset_polyline(pts, off):
    """Mitred offset of an octilinear polyline (left side positive)."""
    out = []
    n = len(pts)
    for i in range(n):
        if i == 0:
            d = unit(pts[1][0] - pts[0][0], pts[1][1] - pts[0][1]); l = left(d)
            out.append((pts[0][0] + l[0] * off, pts[0][1] + l[1] * off))
        elif i == n - 1:
            d = unit(pts[-1][0] - pts[-2][0], pts[-1][1] - pts[-2][1]); l = left(d)
            out.append((pts[-1][0] + l[0] * off, pts[-1][1] + l[1] * off))
        else:
            d1 = unit(pts[i][0] - pts[i - 1][0], pts[i][1] - pts[i - 1][1])
            d2 = unit(pts[i + 1][0] - pts[i][0], pts[i + 1][1] - pts[i][1])
            l1, l2 = left(d1), left(d2)
            bis = (l1[0] + l2[0], l1[1] + l2[1])
            bl = math.hypot(*bis)
            if bl < 1e-9:
                raise ValueError("reversal in path")
            bis = (bis[0] / bl, bis[1] / bl)
            cosh = bis[0] * l1[0] + bis[1] * l1[1]
            k = off / cosh
            out.append((pts[i][0] + bis[0] * k, pts[i][1] + bis[1] * k))
    return out


def build(pair):
    """Turn a pair's centreline nodes into n/p tracks and vias."""
    nodes = []
    for nd in pair.nodes:
        if nodes and abs(nd[0] - nodes[-1][0]) < 1e-6 and abs(nd[1] - nodes[-1][1]) < 1e-6 and nd[2] == nodes[-1][2]:
            continue
        nodes.append(nd)
    # drop collinear middle points on the same layer
    clean = [nodes[0]]
    for i in range(1, len(nodes) - 1):
        a, b, c = clean[-1], nodes[i], nodes[i + 1]
        if a[2] == b[2] == c[2]:
            cr = (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0])
            dot = (b[0] - a[0]) * (c[0] - b[0]) + (b[1] - a[1]) * (c[1] - b[1])
            if abs(cr) < 1e-9 and dot > 0:
                continue
        clean.append(b)
    clean.append(nodes[-1])
    nodes = clean
    pair.nodes = nodes
    # split into runs per layer
    runs = []
    cur = [nodes[0]]
    for nd in nodes[1:]:
        if nd[2] == cur[-1][2]:
            cur.append(nd)
        else:
            runs.append(cur)
            cur = [nd]
    runs.append(cur)
    vias = []  # positions between runs: last node of run i == first node xy of run i+1
    for i in range(len(runs) - 1):
        a = runs[i][-1]; b = runs[i + 1][0]
        assert abs(a[0] - b[0]) < 1e-6 and abs(a[1] - b[1]) < 1e-6, (pair.name, a, b)
    for ri, run in enumerate(runs):
        layer = run[0][2]
        p = pitch(layer); w = PAIR[layer][0]
        pts = [(x, y) for (x, y, _) in run]
        # entry and exit fans to via pitch
        fan_in = ri > 0
        fan_out = ri < len(runs) - 1
        for sign, net in ((+1, pair.nnet), (-1, pair.pnet)):
            off = sign * p / 2
            line = offset_polyline(pts, off)
            if fan_in:
                d = unit(pts[1][0] - pts[0][0], pts[1][1] - pts[0][1]); l = left(d)
                vx, vy = pts[0][0] + l[0] * sign * VIA_P / 2, pts[0][1] + l[1] * sign * VIA_P / 2
                f = (VIA_P - p) / 2
                line[0] = (line[0][0] + d[0] * f, line[0][1] + d[1] * f)
                line.insert(0, (vx, vy))
            if fan_out:
                d = unit(pts[-1][0] - pts[-2][0], pts[-1][1] - pts[-2][1]); l = left(d)
                vx, vy = pts[-1][0] + l[0] * sign * VIA_P / 2, pts[-1][1] + l[1] * sign * VIA_P / 2
                f = (VIA_P - p) / 2
                line[-1] = (line[-1][0] - d[0] * f, line[-1][1] - d[1] * f)
                line.append((vx, vy))
            # pad ends
            if ri == 0 and pair.start is not None:
                padpt = pair.start[0] if sign > 0 else pair.start[1]
                line = pad_join(padpt, line, at_start=True, p=p)
            if ri == len(runs) - 1 and pair.end is not None:
                padpt = pair.end[0] if sign > 0 else pair.end[1]
                line = pad_join(padpt, line, at_start=False, p=p)
            for (x1, y1), (x2, y2) in zip(line, line[1:]):
                if math.hypot(x2 - x1, y2 - y1) > 1e-6:
                    pair.tracks.append((layer, net, x1, y1, x2, y2, w))
        if fan_out:
            d = unit(pts[-1][0] - pts[-2][0], pts[-1][1] - pts[-2][1]); l = left(d)
            for sign, net in ((+1, pair.nnet), (-1, pair.pnet)):
                pair.vias.append((pts[-1][0] + l[0] * sign * VIA_P / 2, pts[-1][1] + l[1] * sign * VIA_P / 2, net, VIA_D, VIA_H))
    if pair.end is not None and pair.end[3]:
        for (pt, net) in ((pair.end[0], pair.nnet), (pair.end[1], pair.pnet)):
            pair.vias.append((pt[0], pt[1], net, VIP_D, VIP_H))
    return pair


def pad_join(padpt, line, at_start, p):
    """Join a trace end to a pad point with a 45 degree jog (pads are on the pair's axis line)."""
    if at_start:
        q = line[0]
        dx, dy = q[0] - padpt[0], q[1] - padpt[1]
        # go straight along the major axis, then 45 degrees
        if abs(dx) < 1e-6:
            return [padpt] + line
        s = 1 if dy > 0 else -1
        mid = (padpt[0], q[1] - s * abs(dx))
        return [padpt, mid] + line
    else:
        q = line[-1]
        dx, dy = padpt[0] - q[0], padpt[1] - q[1]
        if abs(dx) < 1e-6:
            return line + [padpt]
        s = 1 if dy > 0 else -1
        mid = (padpt[0], q[1] + s * abs(dx)) if abs(dy) > abs(dx) else None
        # move diagonally first, then straight onto the pad
        mid = (q[0] + dx, q[1] + s * abs(dx))
        return line + [mid, padpt]


# ------------------------------------------------------------------------------------------ geometry plan
PX = ocp_pin_x()


def finger(pin):
    return (F + PX[pin], PAD_TOP)


Y_FAN0 = 107.6      # fan diagonals start (clear of the key slots, which end at y = 108.0)
Y_VIA = 97.6        # transition via row
Y_SA0 = 96.9        # stage A start
LANE_PITCH = 2.8
WITHIN = 0.7        # P/R offset from the lane cell centre after the via row
# lane cell centres at the via row
XC = []
x = 21.0
for k in range(4):
    row = []
    for l in range(4):
        row.append(x + l * LANE_PITCH)
    XC.append(row)
    x = row[-1] + LANE_PITCH + 1.5

# which side of its cell each pair sits on after the via row (P first, R second), per lane index in port
#   b0: P west / R east, b1: R west / P east, b2: P west / R east, b3: R west / P east
SIDE = {0: (-1, +1), 1: (+1, -1), 2: (-1, +1), 3: (+1, -1)}
# layer of each bundle in band S and at the connector
LAYER_S = {0: "L1", 1: "L3", 2: "L5", 3: "L1"}
LAYER_C = {0: "L1", 1: "L3", 2: "L5", 3: "L5"}

# connector-end pair centres relative to the port centre, and how each pair ends
#   P pairs land on B-row pads, R pairs pass the B row through a gap and land on A-row pads
CONN = {
    # lane: (P centre, R gap x, R pad centre)
    0: (4.0, 4.0, 3.5),
    1: (2.5, 1.0, 2.0),
    2: (-2.0, -0.5, -2.5),
    3: (-3.5, -5.15, -4.0),
}
Y_BROW, Y_AROW = 7.37, 5.18
Y_STRIP = 6.27          # between the A and B rows, where R pairs turn to their A pads
Y_NB_END = 13.0         # stage B finished: pairs at their connector x
Y_NB = 19.5             # stage B starts (block swap, 45 degree)


def lane_pins(lane):
    starts = [17, 20, 23, 26, 30, 33, 36, 39, 44, 47, 50, 53, 56, 59, 62, 65]
    s = starts[lane]
    return f"{s}", f"{s+1}"


# band M straight-section positions relative to the port centre (before the band-M2 shift back west)
#   order W->E: R1, P1, P0, R0 | crossing-via gap | R3, P3, P2, R2
XEND = {("R", 1): 1.0, ("P", 1): 2.5, ("P", 0): 4.0, ("R", 0): 5.2,
        ("R", 3): -5.15, ("P", 3): -3.5, ("P", 2): -2.0, ("R", 2): -0.5}
D_SWAP = 6.0
def xm_rel(kind, l):
    x = XEND[(kind, l)]
    return x - D_SWAP if l in (0, 1) else x + D_SWAP

S_EAST = 6.0            # band M corridors sit this far east of their connectors
Y_SW = 93.4             # lane 3 drops L1 -> L5 here
Y_M0 = 92.6             # band M diagonals start
Y_M2 = 36.0             # band M2: shift back west by S_EAST
Y_NB = Y_NB_END + D_SWAP


def plan_lane(k, l):
    """(P pair, R pair) for port k, port-lane l, finger to OCuLink pad."""
    lane = 4 * k + l
    n, p = lane_pins(lane)
    P = Pair(f"P{k}{l}", f"PETn{lane}", f"PETp{lane}", "PET")
    R = Pair(f"R{k}{l}", f"PERn{lane}", f"PERp{lane}", "PER")
    cx = CX[k]
    xc_f = F + PX["B" + n] + 0.3
    sP, sR = SIDE[l]
    partner = {0: 1, 1: 0, 2: 3, 3: 2}[l]
    for pr, kind, s_side, startlayer in ((P, "P", sP, "L1"), (R, "R", sR, "L6")):
        xv = XC[k][l] + s_side * WITHIN
        xa = XC[k][partner] + s_side * WITHIN
        xm = cx + S_EAST + xm_rel(kind, l)
        xn = cx + xm_rel(kind, l)
        xe = cx + XEND[(kind, l)]
        pin_n = ("B" if kind == "P" else "A") + n
        pin_p = ("B" if kind == "P" else "A") + p
        pr.start = (finger(pin_n), finger(pin_p), startlayer)
        pc = pitch(startlayer)
        y0 = PAD_TOP - 0.25 - (0.6 - pc) / 2
        pr.add(xc_f, y0, startlayer)
        pr.add(xc_f, Y_FAN0, startlayer)
        pr.add(xv, Y_FAN0 - abs(xv - xc_f), startlayer)
        lay = LAYER_S[l]
        pr.add(xv, Y_VIA, startlayer)
        if lay != startlayer:
            pr.add(xv, Y_VIA, lay)
        pr.add(xv, Y_SA0, lay)
        pr.add(xa, Y_SA0 - abs(xa - xv), lay)
        if l == 3:                      # lane 3 drops to L5 for stage B
            pr.add(xa, Y_SW, lay)
            pr.add(xa, Y_SW, "L5")
            lay = "L5"
        pr.add(xa, Y_M0, lay)
        pr.add(xm, Y_M0 - abs(xm - xa), lay)
        for (tx, ty) in TUNE.get(pr.name, []):
            pr.add(tx, ty, lay)
        pr.add(xm, Y_M2, lay)
        pr.add(xn, Y_M2 - abs(xn - xm), lay)
        pr.add(xn, Y_NB, lay)
        pr.add(xe, Y_NB_END, lay)
        connector_end(pr, kind, l, cx, lay)
    return P, R


def connector_end(pr, kind, l, cx, lay):
    xe = cx + XEND[(kind, l)]
    if kind == "P":
        pads = (cx + 5.25 - 0.5 * (b_pin(l, "n") - 1), cx + 5.25 - 0.5 * (b_pin(l, "p") - 1))
        xc = (pads[0] + pads[1]) / 2
        assert abs(xc - xe) < 1e-6, (pr.name, xc, xe)
        pr.add(xe, Y_BROW + 0.45, lay)
        pr.end = ((pads[0], Y_BROW), (pads[1], Y_BROW), lay, lay != "L1")
        return
    # R pairs: L1 (lane 0) drops to L3 first, then the B-row gap, the strip, the A pads
    if lay == "L1":
        yv = 11.6
        pr.add(xe, yv, "L1")
        pr.add(xe, yv, "L3")
        lay = "L3"
        xg = cx + CONN[l][1]
        pr.add(xe, yv - 0.6, lay)
        pr.add(xg, yv - 0.6 - abs(xg - xe), lay)
    xg = cx + CONN[l][1]
    xa = cx + CONN[l][2]
    pads = (cx + 4.75 - 0.5 * (a_pin(l, "n") - 1), cx + 4.75 - 0.5 * (a_pin(l, "p") - 1))
    assert abs((pads[0] + pads[1]) / 2 - xa) < 1e-6, (pr.name, pads, xa)
    c = min(0.3, abs(xa - xg) / 2)
    sgn = 1 if xa > xg else -1
    pr.add(xg, Y_STRIP + c, lay)
    pr.add(xg + sgn * c, Y_STRIP, lay)
    pr.add(xa - sgn * c, Y_STRIP, lay)
    pr.add(xa, Y_STRIP - c, lay)
    pr.add(xa, Y_AROW + 0.42, lay)
    pr.end = ((pads[0], Y_AROW), (pads[1], Y_AROW), lay, True)


def b_pin(l, pol):
    return {0: {"p": 3, "n": 4}, 1: {"p": 6, "n": 7}, 2: {"p": 15, "n": 16}, 3: {"p": 18, "n": 19}}[l][pol]


def a_pin(l, pol):
    return {0: {"p": 3, "n": 4}, 1: {"p": 6, "n": 7}, 2: {"p": 15, "n": 16}, 3: {"p": 18, "n": 19}}[l][pol]


TUNE = {}   # pair name -> centreline points inserted in band M (filled by tune())

# band-M tuning windows and direction (away from same-layer neighbours)
TUNE_DIR = {("P", 0): -1, ("R", 0): +1, ("R", 1): -1, ("P", 1): +1,
            ("R", 3): -1, ("P", 3): +1, ("P", 2): -1, ("R", 2): +1}
# y windows (top, bottom) so that P3 (east bumps) and P2 (west bumps) never bulge at the same height
TUNE_WIN = {("P", 0): (56.0, 38.0), ("R", 0): (56.0, 38.0), ("R", 1): (77.0, 58.0), ("P", 1): (77.0, 58.0),
            ("R", 3): (77.0, 58.0), ("P", 3): (77.0, 67.6), ("P", 2): (67.0, 58.0), ("R", 2): (77.0, 58.0)}


def accordion(x0, ytop, side, amp, n, g=1.1, c=0.4):
    """Centreline points of n accordion periods heading north from (x0, ytop) (y decreasing)."""
    pts = []
    y = ytop
    x1 = x0 + side * amp
    for i in range(n):
        y1 = y; y2 = y - g; y3 = y - 2 * g
        pts += [(x0, y1 + c), (x0 + side * c, y1), (x1 - side * c, y1), (x1, y1 - c),
                (x1, y2 + c), (x1 - side * c, y2), (x0 + side * c, y2), (x0, y2 - c)]
        y = y3
    return pts


def bumps(x0, ytop, side, amp, n, flat=0.4, gap=0.5):
    pts = []
    y = ytop
    for i in range(n):
        pts += [(x0, y), (x0 + side * amp, y - amp), (x0 + side * amp, y - amp - flat), (x0, y - 2 * amp - flat)]
        y = y - 2 * amp - flat - gap
    return pts


def tune(iterations=4, tol_ps=0.3):
    """Delay-match each port's TX lanes and RX lanes (by ps, including via barrels)."""
    import delay
    TUNE.clear()
    for it in range(iterations):
        pairs = [build(pp) for k in range(4) for l in range(4) for pp in plan_lane(k, l)]
        byname = {pp.name: pp for pp in pairs}
        changed = False
        for k in range(4):
            for kind in "PR":
                grp = [byname[f"{kind}{k}{l}"] for l in range(4)]
                d = {pp.name: delay.pair_delay(pp) for pp in grp}
                tgt = max(d.values())
                for pp in grp:
                    l = int(pp.name[2])
                    need_ps = tgt - d[pp.name]
                    if need_ps < tol_ps:
                        continue
                    lay = "L5" if l == 3 else LAYER_S[l]
                    need_mm = need_ps / delay.per_mm(lay)
                    cur = TUNE.get(pp.name)
                    xm = CX[k] + S_EAST + xm_rel(kind, l)
                    ytop, ybot = TUNE_WIN[(kind, l)]
                    side = TUNE_DIR[(kind, l)]
                    # current extra length of the existing tuning, then add the shortfall
                    have = getattr(tune, "extra", {}).get(pp.name, 0.0)
                    want = have + need_mm
                    if l == 0:
                        n = max(1, math.ceil(want / 4.6))
                        amp = want / (2 * n) + 0.234   # chamfer correction: 4 corners x 0.586c / (2 per period)
                        pts = accordion(xm, ytop, side, amp, n)
                    else:
                        n = max(1, math.ceil(want / 0.45))
                        amp = want / (0.828 * n)
                        pts = bumps(xm, ytop, side, amp, n)
                    if pts[-1][1] < ybot:
                        raise SystemExit(f"tuning for {pp.name} overruns its window: {pts[-1][1]:.1f} < {ybot}")
                    TUNE[pp.name] = pts
                    tune.extra = getattr(tune, "extra", {})
                    tune.extra[pp.name] = want
                    changed = True
        if not changed:
            break
    return TUNE


def all_lanes():
    out = []
    for k in range(4):
        for l in range(4):
            P, R = plan_lane(k, l)
            out += [build(P), build(R)]
    return out


# ------------------------------------------------------------------------------------------ refclks and the band-M bus
Y_BUS = {"PERST1": 80.0, "REFCLK2": 81.5, "PERST2": 83.0, "REFCLK3": 84.5, "PERST3": 86.0, "REFCLK1": 87.5}
X_CORR_VIA = lambda k: CX[k] + S_EAST + 0.025          # in the R0-R3 gap of corridor k (band M)
G_CONT, G_PERST, G_REF = 12.35, 13.15, 14.4            # positions in gap (k-1, k), relative to cx[k-1] (band M)
Y_REF_TURN, Y_PERST_TURN = 12.3, 10.9
BUS_START_X = 16.0                                      # PERST bus lines start here (L1 -> L5 via)


def corner_path(pts_xy, layer, c=0.3):
    """Expand a rectilinear list of points into chamfered octilinear nodes (45 degree chamfer c)."""
    out = [pts_xy[0]]
    for i in range(1, len(pts_xy) - 1):
        a, b, cc = pts_xy[i - 1], pts_xy[i], pts_xy[i + 1]
        d1 = unit(b[0] - a[0], b[1] - a[1]); d2 = unit(cc[0] - b[0], cc[1] - b[1])
        if abs(d1[0] * d2[1] - d1[1] * d2[0]) < 1e-9:
            out.append(b); continue
        out.append((b[0] - d1[0] * c, b[1] - d1[1] * c))
        out.append((b[0] + d2[0] * c, b[1] + d2[1] * c))
    out.append(pts_xy[-1])
    return out


def bus_route(k_from, k_to, y, first_layer="L5"):
    """Waypoint list (x, y, layer) for a bus line that starts west of corridor k_from on L5 and exits into
    gap (k_to - 1, k_to). Each corridor: L5 under its west half, a via in the R0-R3 gap, L3 over its east half;
    each gap passed through: back to L5."""
    nodes = []
    for k in range(k_from, k_to):
        xv = X_CORR_VIA(k)
        nodes.append((xv, y, "L5"))
        nodes.append((xv, y, "L3"))
        if k < k_to - 1:
            xg = CX[k] + G_CONT
            nodes.append((xg, y, "L3"))
            nodes.append((xg, y, "L5"))
    return nodes


def refclk(k):
    """REFCLK k from its gold fingers to OCuLink port k (A12 p / A13 n)."""
    P = Pair(f"CLK{k}", f"REFCLKn{k}", f"REFCLKp{k}", "REFCLK")
    if k in (0, 1):
        pins = ("B14", "B15") if k == 0 else ("A14", "A15")
    else:
        pins = ("OCP_B11", "OCP_B12") if k == 2 else ("OCP_A11", "OCP_A12")
    lay0 = "L1" if pins[0].startswith(("B", "OCP_B")) else "L6"
    P.start = (finger(pins[0]), finger(pins[1]), lay0)
    xc_f = F + PX[pins[0]] + 0.3
    y0 = PAD_TOP - 0.25 - (0.6 - pitch(lay0)) / 2
    P.add(xc_f, y0, lay0)
    cx = CX[k]
    if k == 0:
        P.add(xc_f, 107.9, "L1"); P.add(19.1, 107.9 - (xc_f - 19.1), "L1"); P.add(19.1, 97.0, "L1")
        P.add(19.1, 97.0, "L3"); P.add(19.1, 96.3, "L3"); P.add(3.6, 96.3 - 15.5, "L3")
        for (x, y) in corner_path([(3.6, 80.8), (3.6, Y_REF_TURN), (cx - 0.5, Y_REF_TURN), (cx - 0.5, Y_REF_TURN - 0.8)], "L3")[1:]:
            P.add(x, y, "L3")
        lay = "L3"
    else:
        yb = Y_BUS[f"REFCLK{k}"]
        if k == 1:
            P.add(xc_f, 108.4, "L6"); P.add(17.6, 108.4 - (xc_f - 17.6), "L6"); P.add(17.6, 98.0, "L6")
            P.add(17.6, 98.0, "L5"); xs = 17.6
        elif k == 2:
            P.add(xc_f, 107.9, "L1"); P.add(12.6, 107.9 - (xc_f - 12.6), "L1"); P.add(12.6, 106.5, "L1")
            P.add(12.6, 106.5, "L5"); xs = 12.6
        else:
            P.add(xc_f, 107.9, "L6"); P.add(14.6, 107.9 - (14.6 - xc_f), "L6"); P.add(14.6, 106.5, "L6")
            P.add(14.6, 106.5, "L5"); xs = 14.6
        for (x, y) in corner_path([(xs, 106.0 if k > 1 else 97.6), (xs, yb), (X_CORR_VIA(0), yb)], "L5")[1:]:
            P.add(x, y, "L5")
        for nd in bus_route(0, k, yb)[1:]:
            P.add(*nd)
        g = CX[k - 1] + G_REF
        lay = "L3"
        pts = corner_path([(P.nodes[-1][0], yb), (g, yb), (g, Y_M2)], "L3")
        for (x, y) in pts[1:]:
            P.add(x, y, lay)
        P.add(g - S_EAST, Y_M2 - S_EAST, lay)
        for (x, y) in corner_path([(g - S_EAST, Y_M2 - S_EAST), (g - S_EAST, Y_REF_TURN), (cx - 0.5, Y_REF_TURN), (cx - 0.5, Y_REF_TURN - 0.8)], lay)[1:]:
            P.add(x, y, lay)
    # B-row gap B11/B14, strip, A12/A13
    xg, xa = cx - 0.5, cx - 1.0
    c = 0.25
    P.add(xg, Y_STRIP + c, lay); P.add(xg - c, Y_STRIP, lay); P.add(xa + c, Y_STRIP, lay); P.add(xa, Y_STRIP - c, lay)
    P.add(xa, Y_AROW + 0.42, lay)
    P.end = ((cx + 4.75 - 0.5 * 12, Y_AROW), (cx + 4.75 - 0.5 * 11, Y_AROW), lay, True)
    return build(P)


class Line:
    """A single-ended route: nodes (x, y, layer); a layer change places one via."""
    def __init__(self, name, net, w=0.15):
        self.name, self.net, self.w = name, net, w
        self.nodes, self.tracks, self.vias = [], [], []

    def add(self, x, y, layer):
        self.nodes.append((round(x, 4), round(y, 4), layer)); return self

    def build(self):
        for a, b in zip(self.nodes, self.nodes[1:]):
            if a[2] != b[2]:
                assert abs(a[0] - b[0]) < 1e-6 and abs(a[1] - b[1]) < 1e-6
                self.vias.append((a[0], a[1], self.net, VIA_D, VIA_H))
            elif math.hypot(b[0] - a[0], b[1] - a[1]) > 1e-6:
                self.tracks.append((a[2], self.net, a[0], a[1], b[0], b[1], self.w))
        return self


def perst_bus(k):
    """PORTk_PERST# from its bus start via (fed from U4 through R1x by the maze router) to the B12 pad of port k."""
    L = Line(f"PERST{k}", f"PORT{k}_PERST#")
    y = Y_BUS[f"PERST{k}"]
    cx = CX[k]
    L.add(BUS_START_X, y, "L1"); L.add(BUS_START_X, y, "L5")
    for nd in bus_route(0, k, y):
        L.add(*nd)
    g = CX[k - 1] + G_PERST
    L.add(g, y, "L3"); L.add(g, y, "L1")
    for (x, yy) in corner_path([(g, y), (g, Y_M2), (g - S_EAST, Y_M2 - S_EAST), (g - S_EAST, Y_PERST_TURN),
                                (cx - 0.25, Y_PERST_TURN), (cx - 0.25, Y_BROW)], "L1", c=0.3)[1:]:
        L.add(x, yy, "L1")
    return L.build()


def all_routes():
    tune()
    pairs = all_lanes() + [refclk(k) for k in range(4)]
    lines = [perst_bus(k) for k in (1, 2, 3)]
    return pairs, lines


if __name__ == "__main__":
    pairs = all_lanes()
    print(len(pairs), "pairs", sum(len(p.tracks) for p in pairs), "tracks", sum(len(p.vias) for p in pairs), "vias")