AMBA AXI · Module 10

AXI4-Lite Verification Checklist

The consolidated must-check list for verifying an AXI4-Lite slave — protocol compliance (handshake, subset, responses, WSTRB) plus register semantics (map, access types, reset, decode) — and the UVM-style testbench that checks them.

This chapter closes Module 10 with a consolidated checklist for verifying an AXI4-Lite slave. AXI4-Lite verification splits into two parts: a small protocol-compliance layer (the handshake, the subset restrictions, response codes, byte strobes) and a larger register-semantics layer (the register map, access types from Chapter 10.4, reset values, address decode). A correct Lite slave must pass both. We'll lay out the checklist by category, show the UVM-style testbench that implements it, and emphasize where the verification effort actually concentrates — the register semantics, not the (modest) protocol.

1. The Checklist Categories

Verifying an AXI4-Lite slave means covering these categories:

Handshake compliance — VALID/READY rules on all five channels: once VALID is asserted, payload stays stable until READY; VALID must not depend combinationally on READY (no handshake deadlock).
Subset restrictions — assert it's genuinely Lite: single-beat only (no bursts), in-order (no AxID reordering), fixed full-width data, no exclusive access — flag any out-of-subset traffic as illegal.
Response codes — OKAY for valid accesses, SLVERR for illegal ones (write to read-only, reserved offset), DECERR for unmapped addresses (default slave).
Byte strobes — WSTRB honored: only strobed bytes written, neighbors preserved.
Register semantics — every register's access type (RW/RO/W1C/W1S/RC/self-clearing, Chapter 10.4) behaves exactly as specified, with correct reset values and reserved-bit behavior.
Address decode — the right register is selected; unmapped offsets error; any aliasing/wrap behavior matches the spec.

Figure 1 — the AXI4-Lite verification checklist categories. Handshake compliance, subset restrictions (single-beat/in-order/fixed-width/no-exclusive), response codes, WSTRB byte writes, register semantics (access types, reset, reserved), and address decode. A correct Lite slave must satisfy every category.

2. Protocol Is Small, Register Semantics Is the Bulk

A key planning insight: for AXI4-Lite, the protocol part is small and largely reusable, while the register-semantics part is where most of the work and most of the bugs are.

Protocol (small): single-beat handshakes, three response codes, WSTRB, and the subset assertions. There's no burst arithmetic, no 4 KB rule, no outstanding/out-of-order scoreboard, no ID ordering, no exclusive monitor — most of Modules 6–9 simply doesn't apply. A standard AXI4-Lite VIP/protocol checker covers this layer almost for free.
Register semantics (the bulk): every register's access type, reset value, reserved bits, byte-field behavior, and decode — replicated across potentially hundreds of registers, each with hardware/software interactions (W1C races, self-clearing, RC side effects). This is design-specific, large, and where subtle bugs live.

So plan the effort accordingly: lean on a VIP for protocol compliance, and invest in a thorough register model for the semantics. The transactions are trivial; the meaning of each register is the hard part.

Figure 2 — where the verification effort goes. The protocol layer (handshake, responses, WSTRB, subset) is small and VIP-covered — most of full-AXI's burst/outstanding/ordering verification doesn't apply. The register-semantics layer (access types, reset, decode across all registers) is the bulk of the work and the locus of bugs. Plan effort toward the register model.

3. The Testbench Structure

A UVM-style environment for an AXI4-Lite slave has the standard components, sized for the single-transaction nature:

Driver / sequencer — issues AXI4-Lite reads and writes (single-beat) from sequences; a register abstraction layer (RAL) lets tests read/write by register name rather than raw address.
Monitor — observes the bus, reconstructs transactions, and feeds the checker/scoreboard and coverage.
Protocol checker / VIP — continuously asserts the handshake, subset, and response-code rules.
Scoreboard / register model — a model of the register map encoding each register's access type, reset, and reserved bits; it predicts the result of every access and checks reads/writes against it (the RAL provides this model).
Coverage — functional coverage of registers, access types, WSTRB patterns, error responses, and reset.

The register model (RAL) is the centerpiece: it both drives by-name access and predicts expected behavior, so it checks register semantics systematically across the whole map.

Figure 3 — the AXI4-Lite testbench. A driver/sequencer (with a register abstraction layer for by-name access) issues single-beat transactions; a monitor observes them; a protocol checker/VIP asserts the handshake/subset/response rules; a register-model scoreboard predicts and checks register semantics; coverage measures the map and access types. The register model is the centerpiece.

4. The Sign-Off Flow

Verification sign-off for a Lite slave runs in a clear order:

Figure 4 — the sign-off flow. First confirm protocol compliance (handshake, subset, responses) — VIP-driven and quick. Then verify register semantics across the whole map (access types, reset, reserved, decode) via the register model. Then close functional coverage (every register, access type, WSTRB pattern, error). Sign off when all three are clean.

5. Common Misconceptions

Myths to unlearn

"Verifying AXI4-Lite is as hard as full AXI." It's much smaller on the protocol side — no burst/outstanding/ordering/exclusive verification. The work is in the register semantics, not the bus.
"If the handshake works, the slave is verified." No — handshake compliance is necessary but small. The bulk is register-map semantics (access types, reset, decode), which handshake testing doesn't touch.
"A protocol checker covers everything." It covers protocol (handshake, subset, responses) — not register meaning (W1C behavior, reset values, RO enforcement). You need a register model for that.
"You don't need to test error responses." You do — writes to read-only registers (SLVERR), unmapped addresses (DECERR), and reserved offsets are common bug sites and must be covered.
"Reset values don't need verification." They do — a wrong reset value is a real, software-visible bug. Check every register's reset/default.
"Byte writes are an edge case you can skip." No — WSTRB byte-field writes are common and a frequent corruption source; cover each field/strobe pattern.

6. Debugging Insight

🔍 Debugging insight — use the checklist categories to localize

When a Lite slave misbehaves, the checklist categories localize the bug fast:

Transaction hangs or signals glitch? Handshake — check VALID/READY stability and that VALID doesn't depend on READY. A protocol checker pinpoints it.
Wrong register accessed / unmapped works or mapped fails? Address decode — verify the offset→register mapping and that unmapped offsets return DECERR.
A register doesn't behave as documented (can't clear a flag, RO writable)? Register semantics — the access type is mis-implemented (W1C as RW, RO not enforced). Check against the register model.
A byte-field write corrupts neighbors? WSTRB — the slave isn't honoring strobes per byte.
A burst/ID slips through and breaks things? Subset — something violated the Lite subset; the checker should have flagged it.
Wrong value right after reset? Reset — a wrong default value; check the register's reset spec.

The triage maps one-to-one onto the checklist: hang→handshake, wrong-register→decode, wrong-behavior→semantics, field-corruption→WSTRB, illegal-traffic→subset, post-reset→reset. The checklist is the debug taxonomy.

7. Verification Insight

✅ Verification insight — register model + VIP, coverage across the whole map

The efficient strategy pairs a standard AXI4-Lite VIP/protocol checker (for the small, reusable protocol layer — handshake, subset assertions, response codes) with a thorough register model / RAL (for the large, design-specific semantics layer). The register model encodes every register's access type, reset value, and reserved bits, and auto-generates much of the checking: built-in register tests (reset value check, RW read-after-write, RO write-no-effect, W1C/W1S behavior) exercise the map systematically, while custom sequences cover hardware/software interactions (W1C races, self-clearing, RC side effects) the generic tests don't capture.

Coverage must span the whole map: every register read and written, every access type's specific behavior, all WSTRB patterns on writable fields, error responses (SLVERR for RO/reserved, DECERR for unmapped), reset/default values, and the interrupt sequence end-to-end (Chapter 10.4). The highest-value, easy-to-miss items are the negative cases (RO writes, unmapped accesses, reserved bits) and the W1C race — both classic register-block bugs. Because the protocol layer is small and VIP-covered, sign-off hinges on register-semantics coverage closure: when every register's documented behavior is exercised and checked against the model, and the protocol checker is clean, the Lite slave is verified. This checklist is the practical endpoint of the AXI4-Lite module.

8. Interview Questions

9. Summary

Verifying an AXI4-Lite slave is a two-part problem: a small protocol-compliance layer (handshake VALID/READY stability, the single-beat/in-order/fixed-width/no-exclusive subset, response codes OKAY/SLVERR/DECERR, and WSTRB byte writes) and a larger register-semantics layer (every register's access type from Chapter 10.4, reset values, reserved bits, and address decode). The protocol layer is small and largely VIP-covered — none of full-AXI's burst/outstanding/ordering/exclusive verification applies — so the effort and the bugs concentrate in the register semantics, best handled with a register model (RAL) that both drives by-name access and predicts expected behavior.

The testbench is the standard UVM set (driver+RAL, monitor, protocol checker, register-model scoreboard, coverage), and sign-off runs protocol compliance → register semantics → coverage closure. The checklist doubles as a debug taxonomy (hang→handshake, wrong-register→decode, wrong-behavior→semantics, field-corruption→WSTRB, illegal-traffic→subset, post-reset→reset). The highest-value, easy-to-miss checks are the negative cases (RO writes, unmapped, reserved) and the W1C race. A clean protocol checker plus closed register-semantics coverage is genuine sign-off because Lite's contract decomposes exactly into transport + typed registers. This completes Module 10 (AXI4-Lite); next, Module 11 turns to a different variant entirely — AXI4-Stream, the streaming, non-address-mapped protocol.

10. What Comes Next

You've finished AXI4-Lite; Module 11 turns to the streaming variant:

11.1 — The AXI4-Stream Mental Model (coming next) — stream-vs-memory-mapped thinking: AXI4-Stream moves data with no addresses, a different paradigm from everything so far.

Previous: 10.4 — Common CSR Design Patterns. Related: 10.2 — Register Access with AXI4-Lite and 8.6 — Verification Challenges for the contrast with full-AXI verification. For the broader protocol catalog, see the AMBA family overview doc.