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
    • Error Models
    • Parity
    • Hamming Distance
    • CRC
    • ECC and SECDED
    • Forward Error Correction
    • Error Responses
    • Poison and Containment
    • ACK and NAK
    • Sequence Numbers
    • Replay Buffers
    • Go-Back-N or Selective Repeat
    • Idempotency and Safe Replay
    • Link-Level or End-to-End Protection
    • Error Classes and Reporting
    • Recovery and Degradation
    • Interface Protection and Safety
    • The Reliability Budget
    • Protocols Compared: Reliability and Recovery
    • Drills: Reliability and Recovery
  • Part 11: Bring-Up and Link Management10
  • 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 10: Reliability and Recovery
  1. Topics
  2. First Principles of Hardware Protocols
  3. Part 10: Reliability and Recovery
  4. Error Responses

Part 10 · Reliability and Recovery · Working (W)

Error Responses

When a transaction fails, the requester must be told, and told what kind of failure it was. Target errors and decode errors, who generates each, how errors travel back through bridges, and what requesters do with them.

On this page

    Note

    Level: Working (W) · Answers: What if bits go wrong?

    Before this: The Request/Response Model, Address Maps and Decoding

    A driver reads a status register and gets an error. Is the device broken, or was the address wrong? The fix for one is to reset the device; the fix for the other is to correct the driver. If both failures come back as the same "error", software can only guess. Protocols separate the two because the response to each is different.

    What kinds of failure should a response report, who reports each, and how do they get back to the requester?

    The obvious answer, and why it breaks

    The obvious response status is a single bit: worked, or did not. It is enough to stop a requester using bad data, but not enough to tell anyone what to do next. Was there nothing at that address (a software bug)? Was the target there but unable to do it (a device problem, or an access it does not allow)? Did the data get corrupted on the way (a hardware fault)? Each points to a different fix.

    The idea: distinguish who failed

    Error

    Means

    Generated by

    Usual fix

    Decode error

    No target owns this address

    The interconnect's default target (lesson 5.3)

    Software bug or bad pointer

    Target (slave) error

    The target exists but could not do the access: illegal access, internal fault, unsupported size, powered down

    The target itself

    Driver or device fault; may need a reset

    Data integrity error

    The data was corrupted (an uncorrectable ECC error, a failed end-to-end check)

    Whoever detects it: a memory controller, a receiver

    Hardware fault; contain it (lesson 10.8)

    Timeout

    No answer arrived in time

    The requester or an interconnect monitor (lesson 9.9)

    Target hung or lost; reset it

    A bridge must map each error to the closest equivalent on the other side; turning an error into success hides the fault.

    Propagating errors

    • Each hop translates. A bridge maps the far side's error codes to the near side's closest equivalent (lesson 5.17). Where there is no equivalent, it uses the more severe one, never success.

    • Bursts and split transactions combine. One response for a whole burst must report an error if any beat failed; a read with data per beat can mark each beat.

    • Posted writes cannot report back (lesson 5.7): their errors must be logged and signalled elsewhere (lesson 10.15).

    • Requesters must act on errors. A processor typically turns a bus error into an exception at the faulting instruction; a DMA engine stops and reports in a status register.

    How real protocols chose

    Protocol

    Error responses

    AXI

    SLVERR (the target could not complete the access) and DECERR (no target at the address, usually from the interconnect's default target); read data carries a response per beat, a write gets one for the whole burst.

    APB

    PSLVERR (from APB3) marks a failed transfer.

    PCI Express

    Completions carry a status (for example Unsupported Request, Completer Abort); errors on posted requests are reported through error messages and logs.

    What breaks

    A bridge (illustrative) translated every downstream error into the upstream protocol's "OK", because its designer could not decide which error code to use. For two years, failed peripheral accesses looked like successes, returning zeros. When a sensor's interface failed in the field, the system read zeros for its temperature and kept running hot. Mapping every downstream error to a target error would have made the failure visible on the first read.

    Why this matters

    Senior lens. Trace every error a target can produce all the way to software: through every bridge and converter, through burst and split-response merging, and for posted writes through error logging. At each hop, check it is translated, never dropped or turned into success. Then check what software does with it; a precise exception or a logged error with an address is the goal.

    Interview

    Asked: "SLVERR vs DECERR: who generates each?"

    Weak answer: The slave generates both.

    Strong answer: DECERR means no target exists at that address, so no target can generate it: the interconnect's default target, the error responder in the decoder, returns it. SLVERR comes from a real target that received the access but couldn't complete it: an illegal access, an unsupported size, an internal fault or a powered-down block. Separating them tells software whether it has a bad address, a software bug, or a device problem. A bridge in between must translate both, never turn them into OKAY.

    Follow-ups: (1) How does a burst report an error on one beat? (2) How are errors on posted writes reported?

    Check yourself A processor writes to an address in a hole in the memory map. Which error, from whom?

    A decode error, from the interconnect's default target.

    Check yourself A bridge has no exact equivalent on the near side for an error code from the far side. What should it return?

    The closest, or more severe, error, never success.

    Key takeaways

    • Responses distinguish decode errors (no target), target errors (target could not do it), data errors and timeouts.

    • Decode errors come from the interconnect's default target; target errors from the target itself.

    • Every hop must translate errors, bursts must merge them, and posted writes must log them.

    Keep going

    Next: Lesson 10.8, Poison and Containment. Marking bad data instead of dropping it, so one error does not spread.

    Related topics

    • Part 10 overview: Reliability and Recovery

    Previous

    148 / 234

    Next: Poison and Containment

    Up next

    Up nextPoison and Containment

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Error Models
    • Parity
    • Hamming Distance