Esp32 Reset Domain Crossing

Clock domain crossing (CDC) gets most of the attention in verification discussions, but reset domain crossing (RDC) is the sibling problem that's arguably more dangerous on a chip with this many independent power domains, because a reset glitch doesn't just corrupt one data sample — it can leave an entire block stuck in an undefined state that persists until the next full reset. Every one of this chip's power domains (digital core, RF, I/O, RTC) that can be independently powered down also needs its own reset signal, and the moment a signal has to cross between two domains that reset at different times, on different events, or asynchronously relative to each other, the same class of metastability problem CDC solves for clocks shows up again for resets — except now the failure mode is a block that boots into the wrong state rather than a single bad data sample.

Reset sources
Power-on reset, brown-out reset, watchdog reset, software reset
Reset assertion and de-assertion discipline
Asynchronous assert
Reset takes effect immediately, no clock dependency
Synchronous de-assert
Release re-synchronized to the local clock before logic resumes
Reset domain crossing (RDC)
Signal crosses reset domains
A block held in reset drives a signal into a block that isn't
RDC synchronizer / isolation cell
Forces a known-safe value until the receiving domain is valid
Every domain boots into a known, verified state
No block ever samples a signal from a domain still mid-reset

Asynchronous assert, synchronous de-assert is the specific discipline that closes most reset-related bugs, and it's asymmetric on purpose — the two edges of a reset signal have genuinely different risk profiles. Reset has to assert immediately and unconditionally the instant a brown-out or watchdog event fires, with no dependency on a clock that might itself be unstable or absent during the fault that triggered the reset in the first place; but releasing reset has to be re-synchronized to the local clock edge before logic starts running, because releasing reset asynchronously risks some flip-flops coming out of reset on one clock edge and others on the next, leaving the block internally inconsistent for a cycle — getting this asymmetry backwards is one of the most common reset-related bugs in real silicon.

Reset Domain Crossing — The CDC Problem's Dangerous Sibling async assert, sync de-assert — and isolation at every domain boundary Asymmetric reset discipline RESET asserts — immediate, async RESET releases — re-synced to clock clock edges — release aligns to one of these Domain A — still in reset Internal state undefined Output signal value meaningless RDC isolation forces a known-safe value through Domain B — active Never samples a meaningless mid-reset value from Domain A Without isolation, Domain B can latch garbage the instant Domain A starts resetting RDC bugs don't corrupt one sample — they boot a whole block into the wrong state

RDC isolation cells have to do their job during the exact window a CDC synchronizer can't help with, because a signal that's mid-reset on one side isn't an ordinary clock-timing problem — it's a signal with no defined value at all. A standard CDC synchronizer assumes the signal it's resynchronizing is a valid, settled logic value that just needs to cross a clock boundary safely; a signal coming out of a block that's actively being reset has no such guarantee, since the driving flip-flops themselves may be in an undefined or transitioning state during reset assertion — which is why RDC isolation is its own distinct verification category, inserting a forced known-safe value at the domain boundary specifically for the window where the source domain's own output can't be trusted at all, rather than treating reset crossings as just another flavor of ordinary CDC.

Combined CDC-and-RDC verification — a signal that crosses both a clock boundary and a reset boundary at the same point in the design — is the specific case that static CDC-only or RDC-only checking tools can miss entirely, which is why dedicated CDC/RDC sign-off tools exist as their own category separate from standard timing analysis. A signal leaving one power domain's clock and reset regime and entering another simultaneously has to satisfy both disciplines at once: proper synchronization against the destination clock, and proper isolation against the source's reset state — a verification flow that only checks one or the other can report a clean pass while missing a real bug that only manifests when both domains interact during a specific power-sequencing event, which is exactly the scenario a chip with independently-switchable domains needs to exercise deliberately rather than hope never occurs in the field.

Clock and reset domain crossing together are the verification category that decides whether independently power-gateable domains — the exact architecture this chip relies on for its deep-sleep power numbers — actually wake up correctly every single time, rather than occasionally booting into an undefined state that no amount of correct digital logic design elsewhere on the die can prevent.

Take esp32 reset domain crossing further

Ask the copilot about this term, or have our engineers assess it against your process.