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
  • Part 12: Power8
    • Idle Detection
    • Link Power States
    • Break-Even Time
    • Low-Power Handshakes
    • Quiescing and Draining
    • Wake Signalling
    • Protocols Compared: Power
    • Drills: Power
  • 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 12: Power
  1. Topics
  2. First Principles of Hardware Protocols
  3. Part 12: Power
  4. Link Power States

Part 12 · Power · Working (W)

Link Power States

Links offer a ladder of low-power states, from a light idle that wakes in nanoseconds to near-off states that need retraining. What each rung turns off, what it costs to leave, and the difference between link states and device states.

On this page

    Note

    Level: Working (W) · Answers: How do we save power without losing data?

    Before this: Idle Detection

    A laptop's wireless card is idle for 100 microseconds between packets, and for whole seconds while the user reads. One low-power state cannot suit both. A light state that wakes almost instantly saves a little in the short gaps; a deep state that turns off the clocks and the receiver saves much more but takes far longer to leave, so it only suits the long ones. Every serious link offers several states, arranged as a ladder.

    What low-power states can a link offer, and what does each one cost to leave?

    The obvious answer, and why it breaks

    The obvious design has two states, on and off. "Off" saves the most, but leaving it means powering up, relocking clock recovery and retraining (lesson 11.4): far too slow for a gap between packets. A single light state wakes quickly but leaves too much running during long idle periods. The answer is a ladder: each step down turns off more, saves more, and takes longer to come back.

    The idea: each rung turns off more

    Rung

    What is turned off

    Power

    Exit latency

    Suits

    Active

    Nothing

    Full

    —

    Traffic

    Light idle

    Transmitter drives a quiet level; clock recovery kept locked

    Somewhat lower

    Nanoseconds to around a microsecond

    Gaps between packets

    Deeper idle

    Transmitters and receivers off; PLLs may stay on

    Much lower

    Microseconds; may need a short retrain

    Gaps between bursts

    Deepest idle

    Reference clock and most analogue circuits off

    Very low

    Tens of microseconds or more

    Long idle periods

    Off

    Power removed

    Zero

    Full power-up, training and enumeration

    Unused devices

    A light state returns directly to active; a deep state turns off enough that waking it passes through retraining, which is where its longer exit latency comes from.

    Link states and device states are different

    A device power state says how much of the device is working (fully on, with clocks gated, or powered off with its context lost). A link power state says what the wires are doing. They are related but separate: a fully working device can let its link sleep between packets, and a device being put to sleep must first take its link down in an orderly way (lessons 12.4 and 12.5).

    How real protocols chose

    Protocol

    States

    PCI Express

    Device states D0 to D3hot and D3cold; link states L0, L0s, L1 (with substates L1.1 and L1.2), L2 and L3. ASPM moves an idle link into L0s or L1 while the device stays in D0; each state's exit latency is reported and checked by software before it is enabled.

    USB 3.x

    U0 active, U1 and U2 progressively deeper with longer exit latency, U3 suspend.

    Energy-Efficient Ethernet

    Low Power Idle with periodic refresh signals.

    DCLink

    One sleep state, entered by the step 11 handshake.

    What breaks

    A platform (illustrative) enabled the deepest link substate on every device to pass a battery-life test. An audio device, whose buffer covered only a short time, could not tolerate the exit latency: each wake took longer than its buffer lasted, and playback crackled. The fix was to respect each device's reported latency tolerance and keep that link in a lighter state (lesson 12.6).

    Why this matters

    Senior lens. For each low-power state, record what it turns off, its entry and exit latency, its power, and who decides to enter it (hardware timer or software). Then check every device's latency tolerance against every state you enable. Power states that pass battery tests but break latency-sensitive devices are a common late-stage bug.

    Interview

    Asked: "Why does a link have several low-power states?"

    Weak answer: For different power levels.

    Strong answer: Because power saved and exit latency trade off. A light state keeps clock recovery locked and wakes in nanoseconds, so it can be used in short gaps but saves little; deeper states turn off receivers, PLLs or the reference clock and save much more, but leaving them needs relocking or retraining, which takes microseconds or more. A ladder lets the link use the light state in short gaps and the deep ones in long idle periods. PCIe has L0s and L1 with substates under ASPM, and each state's exit latency is checked against what the device can tolerate before it's enabled.

    Follow-ups: (1) What is the difference between a link state and a device state? (2) Why must exit latency be checked against the device?

    Check yourself Why does leaving a deep state take longer than leaving a light one?

    More is turned off: receivers, PLLs or clocks must restart and the link must relock or retrain before data can flow.

    Check yourself Can a device be fully working while its link is in a low-power state?

    Yes: a working device's link can sleep between packets (in PCIe, ASPM moves the link to L0s or L1 while the device stays in D0).

    Key takeaways

    • Links offer a ladder of states: each deeper rung saves more power and takes longer to leave.

    • Deep states are left through relocking or retraining, which sets their exit latency.

    • Link states and device states are separate; check exit latency against each device's tolerance.

    Keep going

    Next: Lesson 12.3, Break-Even Time. When sleeping costs more than it saves: the break-even time, modelled.

    Related topics

    • Part 12 overview: Power

    Previous

    173 / 234

    Next: Break-Even Time

    Up next

    Up nextBreak-Even Time

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Low-Power Handshakes
    • Quiescing and Draining
    • Wake Signalling