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 Paths
  • Concept Map
  • How to Read the Diagrams
  • Part 0: What Is a Protocol?10
  • Part 1: Timing and Clocking11
  • Part 2: Encoding and Framing12
  • Part 3: Handshakes13
  • Part 4: Flow Control17
  • Part 5: Transactions19
  • Part 6: Concurrency and Performance17
  • Part 7: Ordering13
  • Part 8: Sharing and Arbitration12
  • Part 9: Deadlock and Liveness13
  • Part 10: Reliability and Recovery20
  • Part 11: Bring-Up and Link Management10
    • Reset Semantics
    • Reset Sequencing Across Interfaces
    • Presence and Hot-Plug
    • Link Training
    • Capability Negotiation
    • Enumeration and Discovery
    • Link State Machines
    • Versioning and Compatibility
    • Protocols Compared: Bring-Up and Link Management
    • Drills: Bring-Up and Link Management
  • Part 12: Power8
  • Part 13: Shared State and Coherence9
  • Part 14: Security and Isolation7
  • Part 15: Specifying and Verifying11
  • Part 16: Protocols Dissected17
  • Part 17: Capstones5
  • Part 18: Interview Preparation6
Loading lesson

‹Part 11: Bring-Up and Link Management
  1. Topics
  2. First Principles of Hardware Protocols
  3. Part 11: Bring-Up and Link Management
  4. Reset Sequencing Across Interfaces

Part 11 · Bring-Up and Link Management · Senior (S)

Reset Sequencing Across Interfaces

When two connected blocks leave reset at different times, the order matters. What breaks when the requester starts first, what breaks when the target does, and the handshake or rule that makes start-up safe either way.

On this page

    Note

    Level: Senior (S) · Answers: How do the two sides agree at start-up?

    Before this: Reset Semantics

    A DMA engine and the memory controller it talks to are released from reset by different parts of the chip's power-up sequence. On most boards the memory controller comes out first. On one board revision, with a slower clock oscillator, the DMA engine comes out first, sends its first descriptor fetch into a memory controller still in reset, and waits for an answer that never comes. Nothing in either block is wrong. The order is.

    When connected blocks leave reset at different times, what can go wrong, and how is start-up made safe?

    The obvious answer, and why it breaks

    The obvious answer is to release everything at once. On a real chip that is rarely possible: blocks sit in different clock and power domains, resets are synchronised separately into each domain (taking different numbers of cycles), and some blocks must wait for a PLL, a memory calibration or firmware. Release times differ by design. Start-up must be correct for every order the hardware can produce.

    The idea: each order has its own failure

    Order

    What can go wrong

    Typical symptom

    Requester out first

    It sends requests into a target still in reset, which drops or ignores them

    Requester hangs waiting for responses (lesson 11.1)

    Target out first

    It drives its outputs (ready, responses, credits) to a requester still in reset, which may misinterpret them; or it starts with stale assumptions

    Spurious transfers or credits counted before the requester is ready

    Reset asserted on one side mid-operation

    State on the two sides disagrees

    Lost requests, wrong credit counts

    The requester sends nothing until the target signals it is ready; whichever leaves reset first, the first request always finds a working target.

    Making start-up order-independent

    • Explicit readiness: the target signals that it is ready (a link-up indication, a credit initialisation, a ready bit), and the requester sends nothing until it sees it. Credit-based links get this for free: no credits, no requests (lesson 4.4).

    • Defined outputs in reset: every block drives safe, inactive values while in reset, so a partner that starts earlier sees "nothing happening" rather than garbage.

    • Synchronised reset release per domain: each domain's reset is released synchronously to its own clock, so no flop sees a reset edge too close to a clock edge (the CDC and RDC course covers reset-domain crossings).

    • Documented sequence: where order cannot be made irrelevant, the power-up sequence is specified and checked.

    How real protocols chose

    Protocol

    Start-up rule

    PCI Express

    No transactions until the link has trained to L0 and flow-control credits are initialised; the order in which the two devices leave reset does not matter.

    AXI

    Valid signals are low during reset; a manager may start once both sides are out of reset, and many systems add a readiness signal or a fixed release order.

    DCLink

    Capability negotiation (step 10) and credit initialisation (step 3) must complete before any packet is sent.

    What breaks

    The opening board (illustrative) exposed an order nobody had tested: with the slower oscillator, the memory controller's reset release lagged by a few microseconds. The fix was to hold the DMA engine until the memory controller asserted a calibration-done signal, an explicit readiness handshake, rather than relying on the usual order.

    Why this matters

    Senior lens. List every pair of connected blocks whose resets are released independently, and for each, ask what happens if either side starts first and if either side resets alone. Prefer designs where readiness is explicit (link up, credits granted, a ready flag), so that order does not matter, and verify start-up with both orders and with random delays between releases.

    Interview

    Asked: "Master out of reset before slave: what breaks?"

    Weak answer: Nothing, the slave will catch up.

    Strong answer: The master can issue requests into a slave that's still in reset, which ignores or drops them, so the master waits for responses that never come and hangs. The reverse order has its own risks: the slave driving outputs at a master still in reset. The fix is to make start-up order-independent: the slave signals readiness, link up, initial credits or a ready flag, and the master sends nothing until it sees it; both sides drive inactive values in reset; and each domain's reset is released synchronously to its own clock.

    Follow-ups: (1) How do credit-based links avoid this? (2) Why can't all blocks just leave reset together?

    Check yourself Why does a credit-based link not care which side leaves reset first?

    The sender has no credits until the receiver has come out of reset and granted them, so it cannot send anything early.

    Check yourself Name two reasons blocks on one chip leave reset at different times.

    Different clock domains synchronise reset release separately, and some blocks wait for PLL lock, memory calibration or firmware.

    Key takeaways

    • Connected blocks often leave reset at different times; each order has its own failure.

    • Make start-up order-independent with explicit readiness, inactive outputs in reset, and synchronised release per domain.

    • Verify start-up with both orders and with random delays between releases.

    Keep going

    Next: Lesson 11.3, Presence and Hot-Plug. Knowing the other side exists, and surviving when it suddenly does not.

    Related topics

    • Part 11 overview: Bring-Up and Link Management

    • CDC and RDC course: The Reset-Release Bug

    Previous

    163 / 234

    Next: Presence and Hot-Plug

    Up next

    Up nextPresence and Hot-Plug

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Link Training
    • Capability Negotiation
    • Enumeration and Discovery