Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutRoadmapCareersInternshipsFAQContactPrivacyTerms
Skip to lesson

Course contents

  • How to Use This Course
  • The NanoSoC Tour
  • Reading Path
  • SoC Glossary10
  • SoC Metrics Reference
  • SoC Cheatsheet
  • What SoC Integration Is12
  • Architecture and Budgets21
  • Memory Maps and Address Decode26
  • Interconnect and Bus Fabrics26
  • Clock and Reset Architecture24
    • Clock Sources and PLLs
    • Dividers, Muxes and Glitch-Free Switching
    • Clock Gating Architecture
    • Clock Domain Planning
    • Top-Level Crossings
      • The Ten Crossings
      • Choosing a Mechanism per Crossing
      • Crossing Review Checklist
    • Always-On Domain, Wake Policy and a Timer Extension
    • Reset Sources and Reset Tree
    • Reset Sequencing and Release
  • Power Architecture21
  • Interrupts, DMA and Peripherals15
  • Memories, Boot and Security21
  • IP Integration and Handoff21
  • Top-Level Verification and Bring-up21
  • Package, Pads and I/O18
  • Chip Signoff and Tapeout18
  • SoC Interview Prep16
  • Capstone: Integrate NanoSoC14
Loading lesson

←Top-Level Crossings
  1. Topics
  2. SoC Design
  3. Clock and Reset Architecture
  4. Top-Level Crossings
  5. The Ten Crossings
On this page

    Part 5 of 14, lesson 13 of 24Part 5 of 14/Clock and Reset Architecture/Lesson 13 of 24All levels

    The Ten Crossings

    All ten NanoSoC crossing groups: from, to, signals, mechanism and type, with the interrupt path worked in nanoseconds.

    Why it matters

    A crossing missing from the inventory is a crossing with no synchroniser, no constraint and no test. The inventory is therefore the most safety-critical table in clock planning: ten rows that every tool and every test derives from. This lesson writes all ten with their mechanisms, then works the interrupt path end to end in nanoseconds so the table carries at least one latency the reader can feel. Its one job is the inventory; choosing mechanisms for new crossings is next.

    The core idea

    The ten groups fall into four kinds. The AXI bridge crosses X1 and X2 carry whole channels through 4-deep dual-clock FIFOs with gray-coded pointers. The APB bridge crosses X3 and X4 carry address, data and response through a request-and-acknowledge handshake that holds data stable. The single-bit groups X5 to X8 and X10 cross as levels through two-flop synchronisers: interrupt lines, reset releases, lock flags and power sequencing. Group X9 is the outside world: GPIO, UART receive and SPI data synchronised per input before use. The table is quoted from the NanoSoC specification:

    #

    From

    To

    Signals

    Mechanism

    X1

    clk_cpu

    clk_sys

    AXI AW, W, AR requests

    Dual-clock FIFO per channel, 4 deep

    X2

    clk_sys

    clk_cpu

    AXI B, R responses

    Dual-clock FIFO per channel, 4 deep

    X3

    clk_sys

    clk_per

    APB request: address, data, control

    Req toggle synchronised, data held stable

    X4

    clk_per

    clk_sys

    APB response: read data, error, ack

    Ack toggle synchronised, data held stable

    X5

    clk_sys

    clk_per

    irq_dma, irq_sbr

    2-flop level synchroniser in the controller

    X6

    clk_per

    clk_cpu

    irq_cpu controller output

    2-flop level synchroniser at the CPU

    X7

    clk_per

    clk_sys

    Reset release, pll_lock, clock enables

    Per-domain sync release; 2-flop for lock

    X8

    clk_per

    clk_cpu

    Reset release

    Per-domain sync release

    X9

    Pads

    clk_per

    GPIO, UART RX, SPI MISO

    2-flop synchroniser per input

    X10

    clk_per

    clk_sys

    pwr_up_done, pgood

    2-flop synchroniser

    Worked latency: the interrupt path

    The X5 plus X6 chain has a quoted latency in the NanoSoC specification, best 135.4 ns and worst 182.3 ns, and the script recomputes both from the synchroniser depths so the numbers are never quoted on faith:

    example.py
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    T_CPU, T_PER = 1e9 / 192e6, 1e9 / 24e6  # 5.2083 ns, 41.6667 ns
    # Best case: 2-flop sync into clk_per, 1 controller register, 2-flop into cpu.
    best = 2 * T_PER + 1 * T_PER + 2 * T_CPU
    assert abs(best - 135.4167) < 0.01, best
    # Worst case adds one cycle of alignment at each synchroniser input.
    worst = best + T_PER + T_CPU
    assert abs(worst - 182.2917) < 0.01, worst
    # In cpu cycles: 26 best, 35 worst, matching the NanoSoC specification.
    assert round(best / T_CPU) == 26, best / T_CPU
    assert round(worst / T_CPU) == 35, worst / T_CPU
    print("PASS: irq path 135.4 ns best (26 cpu cycles), 182.3 ns worst (35)")

    What the review looks for

    • The ten rows above, current, with no eleventh signal found by the CDC tool unlisted.

    • Each row names the synchroniser or FIFO instance that implements it, not just the mechanism class.

    • Level inputs state their minimum hold: at least 2 destination cycles, 83.3 ns into clk_per.

    Verify and debug

    Run the structural CDC check against this table: every crossing the tool finds must match a row, and every row must match circuitry. Sweep the clock ratios in simulation with CDC stimulus (ratio and phase sweeps) and confirm no pulse shorter than the hold requirement crosses X5 or X6. A missed interrupt that correlates with ratio or temperature points at hold time, not at the controller.

    Lost interrupt across the domain: a one-cycle pulse from a fast domain is not seen by the slow domain. Symptom: occasional missed event. Caught by CDC lint and by pulse tests with ratio sweeps. Fixed with a level held past the hold time plus a handshake, or a sticky status bit cleared by software, which is how the DMA interrupt works: a level held until cleared.

    If asked to bound an interrupt latency, walk the chain aloud the way the script does: sync, controller, sync, then entry and prologue on the CPU. The whiteboard rubric scores the stages and the worst-case alignment separately.

    Check yourself Why must irq_dma be a level held until cleared rather than a pulse?

    The X5 synchroniser needs the value stable for at least 2 clk_per cycles. The rule is a level of at least 2 clk_per (83.3 ns): a pulse under 41.7 ns, one clk_per, can be missed completely, and anything under 83.3 ns is not guaranteed to give a clean sample after the first flop. The DMA holds irq high until software clears DONE or ERR, so the level is always long enough.

    Related topics

    • Next: Choosing a Mechanism per Crossing

    • CDC and RDC: Async FIFO CDC

    • CDC and RDC: Handshake Protocols Across Domains

    Previous

    103 / 289

    Next: Choosing a Mechanism per Crossing

    Up next

    Up nextChoosing a Mechanism per Crossing

    Sign in to save progress

    Practice this lessonPrevious lessonReport an error

    See also

    • Crossing Review Checklist