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

AboutContactPrivacyTerms
Skip to lesson

Course contents

  • How to Use This Course
  • Reading Path
  • CDC/RDC Glossary
  • CDC/RDC Metrics Reference
  • CDC/RDC Interview Prep
  • CDC/RDC Signoff Cheatsheet
  • Clock Domains and Failure Modes8
  • Metastability and Synchronizers16
  • CDC Protocols and Handshakes16
  • Reconvergence and Gray Coding16
  • Reset Domain Crossing16
  • Architecture and Design Rules16
    • CDC-Aware Partitioning
    • Clock Gating and Muxing
    • Interface and IP Rules
      • IP and Macro Boundaries
      • Async Interfaces: Config and Status
      • Documenting Crossings
      • Interface Checklists
    • Quasi-Static Signals and Configuration
  • CDC Signoff Methodology24
  • RDC Signoff16
  • Debug and Case Studies11
  • CDC and RDC Interview Prep30
  • Capstone: Sign Off a Multi-clock Peripheral4
Loading lesson

‹Interface and IP Rules
  1. Topics
  2. CDC & RDC
  3. Architecture and Design Rules
  4. Interface and IP Rules
  5. Async Interfaces: Config and Status

Part 6 · Architecture and Design Rules · Intermediate

Async Interfaces: Config and Status

Configuration and status registers that cross domains; handshake, shadow register, and qualified capture patterns and when each fits.

On this page

    Almost every block has the same two crossings: configuration flowing in from software (slow, infrequent, must never tear) and status flowing out (flags, counters, event reports). Three standard patterns cover both directions; picking the wrong one is behind a large share of control-path CDC bugs.

    The three patterns

    Pattern

    How it works

    Fits

    Costs

    Handshake

    Hold the value stable, cross a request, capture on arrival, return an acknowledge.

    Any multi-bit value that can change at any time; the general answer.

    Round-trip latency on every update.

    Shadow register with load pulse

    Software writes a shadow copy freely, then a single synced load pulse copies it to the live register at once.

    Configuration written in bursts, applied atomically.

    Double the flops; the load pulse itself needs a pulse-crossing structure.

    Qualified capture

    The destination samples the bus only when the source guarantees it is stable (idle, held, or version-guarded).

    Quasi-static signals that provably do not change while in use (see the quasi-static topic).

    The proof obligation: stability must be guaranteed, not hoped for.

    design.sv
    1
    2
    3
    4
    5
    6
    // snippet
    // shadow register with a load pulse: the live register updates atomically
    always_ff @(posedge clk_cfg) begin
      if (wr_en)   shadow <= wr_data;      // software writes freely
      if (load_q)  live   <= shadow;       // one synced pulse copies everything at once
    end

    The snippet shows the destination side: ordinary software writes land in shadow, and a single synchronised load_q pulse commits the whole word to live in one cycle. Nothing the datapath uses ever sees a half-written value.

    Status in the other direction

    Status kind

    Crossing

    Single independent flags (idle, error latched)

    One two-flop synchroniser per flag; they have no timing relationship to keep.

    A counter or event count

    Gray code if it only increments; handshake or FIFO if software reads must not skip values.

    A multi-bit measurement sampled with a “ready” strobe

    Hold the measurement, cross the strobe as an event, capture on arrival: the same handshake shape as configuration.

    What the review looks for

    For every configuration register: which pattern, and where the stability or acknowledge guarantee is written. For every status path: what software observes if it reads mid-update, and why that observation is acceptable. “Software retries” is not an answer unless the retry protocol is specified with the register.

    Common pitfall

    Clear-on-read status crossed as a level. The read pulse in one domain clears the flag while the other domain is still synchronising it, and the event vanishes. Cross the event as a pulse or handshake and do the clear-on-read bookkeeping in one domain only.

    Interview

    “How do you pass a 32-bit configuration from a CPU clock to a fast datapath clock?” Hold it stable, handshake or load-pulse it across, capture it whole. Then volunteer the status direction unasked: flags by synchroniser, events by handshake, counters by Gray or FIFO.

    Check yourself A 16-bit threshold is memory-mapped in the CPU domain and read directly by comparators in the datapath domain. Software updates it rarely. What is the risk, and which pattern fixes it?

    The datapath can sample the bus mid-update and compare against a torn value. A shadow register with a load pulse fixes it: software writes the shadow, one synced pulse commits the live copy atomically.

    Related topics

    • Documenting Crossings

    • RTL: CDC handshakes

    Previous

    88 / 179

    Next: Documenting Crossings

    Up next

    Up nextDocumenting Crossings

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Interface Checklists