Parity Protection on APB5

Compute the odd parity of any APB5 signal group and know in which cycles each check signal must be right. Then predict which single-bit faults parity catches.

You Will Be Able To

  • Compute an odd parity check bit for a byte, and for a single critical control.
  • Name the Check Enable term of each APB5 check signal.
  • Predict whether a one-bit fault on a given wire in a given cycle is reported.
  • List what a completer may do when it detects a parity error.
Lesson
P3.14
Time
30 min
Runs on
Your browser
Check
5 questions

In a safety chip, a long APB route crossed the die to a motor controller. A single bit of a speed register flipped on the way, once, and the controller took the wrong value. Nothing on the wires broke a protocol rule. APB5 parity exists for exactly this: one check bit per byte, recomputed at the receiver.

One Upset on PWDATA, Caught by PWDATACHKEdges 3 to 5 of the example. The requester sends 11223344 with PWDATACHK 1111. In the completion cycle bit 9 flips on the wire.
  • Manager
  • Subordinate
PWDATAPWDATACHKRequestermakes PWDATACHKCompleterrecomputes and compares
PWDATA→ CompleterPWDATACHK→ CompleterRequestermakes PWDATACHKCompleterrecomputes and compares

Check bit n covers byte n. Lane 1 is the second bit from the right.

012clkpselpenablepwritepwdata_sent1122334400000000pwdata_seen112233441122314400000000pwdatachk1111recomputed111111011111
Scroll horizontally ↔
  1. Cycle 0

    Setup: every byte of 11223344 has an even number of ones, so every check bit is 1.

  2. Cycle 1

    Completion: byte 1 arrives as 31 instead of 33. It has three ones now, so the completer computes 0 for lane 1 and reports PWDATACHK.

  3. Cycle 2

    The next transfer is a read. PWDATACHK no longer has to be right, and nobody checks it.

The data still landed wrong. Parity detects; what to do next is the system's choice.

One Odd Bit per Byte

Parity on APB5 detects a single flipped wire between two components. Each component protects data inside itself in its own way; parity covers the short hop between them.

RuleMeaning
Odd parityA payload byte and its check bit hold an odd number of ones together.
At most 8 bits per check bitCheck bit n covers payload bits 8n+7 to 8n; a partial top byte gets the last check bit.
Critical controls get one bitThe check bit is simply the inverse of the signal, such as PSELxCHK = !PSELx.
Driven in every Check Enable cycleEvery bit, even of a byte the strobes say is unused.
Missing signals are LOWIf no signal of a group exists, the check signal is left out.

IHI 0024E 5.3. Check signals exist only on APB5, when Check_Type is Odd_Parity_Byte_All.

Two flipped bits in the same byte cancel out and go unseen. Two flips in different groups are each caught by their own check bit.

Fourteen Check Signals, Each with Its Own Cycles

A check signal only has to be right while its Check Enable term is true. A receiver that checks outside those cycles reports errors that are not there.

Check signalCoversMust be right when
PADDRCHKPADDR, one bit per bytePSEL
PCTRLCHKPPROT, PWRITE and PNSE, one bitPSEL
PSELxCHKPSELx, one per completerPRESETn
PENABLECHKPENABLEPSEL
PWDATACHK, PSTRBCHKPWDATA per byte; PSTRB in one bitPSEL and PWRITE
PREADYCHKPREADYPSEL and PENABLE
PRDATACHKPRDATA per bytePSEL, PENABLE, PREADY and not PWRITE
PSLVERRCHKPSLVERRPSEL, PENABLE and PREADY
PWAKEUPCHKPWAKEUPPRESETn
PAUSERCHK, PWUSERCHKthe request user signalsPSEL; PSEL and PWRITE
PRUSERCHK, PBUSERCHKthe response user signalsas PRDATACHK; as PSLVERRCHK

IHI 0024E 5.5, Table 5-1. PCTRLCHK covers up to five bits with a single check bit.

The example's link makes and checks the first nine. The spot below asks which single flip none of them can see.

When a Check Fails

The specification does not say what a component must do on a parity error. A flipped bit can be harmless, slow, corrupting, a security hole or a deadlock, depending on the wire. A completer may end or pass on the transfer, and fix or pass on the bad check bit. It may update its memory or not, and raise an error another way, such as an interrupt.

The bench only reports. The example's dump shows why that is not enough on its own. The completer stored 31 in byte 1 while the error was logged.

Asked in interviews: APB5 parity
  1. Is APB5 parity odd or even?

    Odd: a byte and its check bit always hold an odd number of ones together.

  2. What is PSELxCHK?

    The inverse of PSELx, one per completer, which must be right whenever PRESETn is high.

  3. Can parity catch two flipped bits?

    Only if they sit in different check groups. Two flips in one byte cancel out.

  4. What must a completer do on a parity error?

    The specification leaves it open: terminate or pass on, correct or propagate, update or not, and possibly signal an interrupt.

Try It

The completer's check fires at edge 4, the completion edge of the write, where bit 9 arrived flipped. The requester's log still says OKAY and shows the data it sent. The read and the dump show what really landed.

Add link.check_on = 0; for the twin: the same corrupted byte, and parity: 0 check errors. Then try link.flip_sig = 2; link.flip_edge = 10;: a PSEL flip while the bus is idle, which PSELCHK reports because its enable is PRESETn.

RUNIcarus Verilog · in your browser
Edit the code, then run it
Expected: parity e4: PWDATACHK does not match e3-e4 WRITE 0x0010 data=0x11223344 strb=1111 waits=0 OKAY e5-e6 READ 0x0010 data=0x11223144 waits=0 OKAY e7-e8 WRITE 0x0100 data=0x000000ff strb=1111 waits=0 OKAY 0x0010 44 31 22 11 regs: CTRL=0x000000ff STATUS=0 WCOUNT=2 parity: 1 check errors checker: 2 writes, 1 reads, 0 wait edges, 0 rules broken, 0 notes
Read included file: apb_periph.sv
`timescale 1ns/1ns
// apb_periph.sv: an APB4 completer (read-only). Offsets are paddr[11:0]:
//   0x000-0x0ff  RAM, 256 bytes, written lane by lane under PSTRB
//   0x100 CTRL   read/write, byte-strobed
//   0x104 STATUS read-only: the number of words in the FIFO
//   0x108 WCOUNT read-only: counts completed writes (a zero-strobe write counts too)
//   0x10c FIFO   a write pushes PWDATA, a read pops the oldest word (0 when empty)
//   0x110 ID     read-only, 0x41504234 ("APB4")
// With err_on (the default) the completer answers PSLVERR for an unmapped offset, an unaligned
// PADDR, a write to a read-only register and, with priv_ctrl, an unprivileged access to CTRL;
// a transfer that gets PSLVERR changes nothing here (IHI 0024E 3.4 allows either choice).
// Switches (set from the stimulus):
//   waits           wait states in every access (PREADY low for that many access cycles)
//   ready_in_setup  drive PREADY high outside the access phase (a don't-care: the spec allows it)
//   hang            never raise PREADY
//   err_on, priv_ctrl
// Broken twins:
//   act_every_cycle acts at every edge PSEL is high, not once at completion
//   late_rdata      PRDATA registered at completion, so it arrives one cycle late
//   err_early       PSLVERR during setup and wait cycles, low at completion
//   ignore_strobes  writes every lane of a RAM word or CTRL
//   ignore_psel     decodes PADDR and acts in access cycles without looking at its PSEL
module apb_periph #(parameter NAME = "p0") (
  input  logic        pclk,
  input  logic        presetn,
  input  logic        psel,
  input  logic        penable,
  input  logic        pwrite,
  input  logic [31:0] paddr,
  input  logic [31:0] pwdata,
  input  logic [3:0]  pstrb,
  input  logic [2:0]  pprot,
  output logic        pready,
  output logic [31:0] prdata,
  output logic        pslverr);
  int waits = 0;
  bit ready_in_setup = 0, hang = 0, err_on = 1, priv_ctrl = 0, trace = 0;
  bit act_every_cycle = 0, late_rdata = 0, err_early = 0, ignore_strobes = 0, ignore_psel = 0;

  logic [7:0]  mem [0:255];
  logic [31:0] ctrl = 0, wcount = 0;
  logic [31:0] fifo [0:15];
  int          fhead = 0, fcount = 0;
  int          wcnt = 0;                  // wait cycles spent in this access
  logic [31:0] prdata_q = 0;
  initial for (int i = 0; i < 256; i++) mem[i] = 0;

  localparam int RAM = 0, CTRL = 1, STATUS = 2, WCOUNT = 3, FIFO = 4, ID = 5, NONE = 6;
  function automatic int region(input logic [11:0] a);
    if (a < 12'h100) region = RAM;
    else if (a[11:2] == 10'h040) region = CTRL;
    else if (a[11:2] == 10'h041) region = STATUS;
    else if (a[11:2] == 10'h042) region = WCOUNT;
    else if (a[11:2] == 10'h043) region = FIFO;
    else if (a[11:2] == 10'h044) region = ID;
    else region = NONE;
  endfunction
  function automatic bit bad(input logic wr, input logic [11:0] a, input logic [2:0] prot);
    int r;
    r = region(a);
    bad = (r == NONE) || (a[1:0] != 0) || (wr && (r == STATUS || r == WCOUNT || r == ID))
          || (priv_ctrl && r == CTRL && !prot[0]);
  endfunction
  function automatic logic [31:0] value(input logic [11:0] a);
    case (region(a))
      RAM:     value = {mem[{a[7:2], 2'd3}], mem[{a[7:2], 2'd2}], mem[{a[7:2], 2'd1}], mem[{a[7:2], 2'd0}]};
      CTRL:    value = ctrl;
      STATUS:  value = fcount;
      WCOUNT:  value = wcount;
      FIFO:    value = fcount > 0 ? fifo[fhead] : 32'h0;
      ID:      value = 32'h41504234;
      default: value = 32'h0;
    endcase
  endfunction

  wire sel    = ignore_psel ? 1'b1 : (psel === 1'b1);
  wire access = sel && (penable === 1'b1);
  wire err    = err_on && bad(pwrite, paddr[11:0], pprot);
  assign pready  = hang ? 1'b0 : (!access ? (ready_in_setup ? 1'b1 : 1'b0) : (wcnt >= waits));
  wire done   = access && pready;
  assign pslverr = err_early ? (sel && !done && err) : (done && err);
  // The read value is taken at the setup edge (PSEL 1, PENABLE 0) and held on PRDATA until the next
  // read, the way most register blocks do it (the bus multiplexor decides who is heard);
  // late_rdata registers it at completion instead.
  logic [31:0] rdata_r = 0;
  always @(posedge pclk) if (sel && penable !== 1'b1 && pwrite === 1'b0) rdata_r <= value(paddr[11:0]);
  assign prdata  = late_rdata ? prdata_q : rdata_r;
  wire act    = act_every_cycle ? sel : done;

  always @(posedge pclk or negedge presetn) begin
    if (!presetn) begin
      ctrl <= 0; wcount <= 0; wcnt <= 0;
    end else begin
      wcnt <= (access && !pready) ? wcnt + 1 : 0;
      if (done && !pwrite) prdata_q <= value(paddr[11:0]);
      if (act && !err) begin
        if (pwrite) begin
          wcount <= wcount + 1;
          case (region(paddr[11:0]))
            RAM:  for (int l = 0; l < 4; l++) if (pstrb[l] || ignore_strobes) mem[{paddr[7:2], 2'b00} + l] <= pwdata[8*l +: 8];
            CTRL: for (int l = 0; l < 4; l++) if (pstrb[l] || ignore_strobes) ctrl[8*l +: 8] <= pwdata[8*l +: 8];
            FIFO: if (fcount < 16) begin fifo[(fhead + fcount) % 16] <= pwdata; fcount <= fcount + 1; end
            default: ;
          endcase
          if (trace) $display("  %0s e%0d: write 0x%03h <= 0x%08h strb=%b", NAME, ($time - 5) / 10, paddr[11:0], pwdata, pstrb);
        end else begin
          if (region(paddr[11:0]) == FIFO && fcount > 0) begin fhead <= (fhead + 1) % 16; fcount <= fcount - 1; end
          if (trace) $display("  %0s e%0d: read 0x%03h -> 0x%08h", NAME, ($time - 5) / 10, paddr[11:0], value(paddr[11:0]));
        end
      end else if (act && trace) $display("  %0s e%0d: error, %0s 0x%03h ignored", NAME, ($time - 5) / 10, pwrite ? "write" : "read", paddr[11:0]);
    end
  end
endmodule
Read included file: apb_checker.sv
`timescale 1ns/1ns
// apb_checker.sv: the rules of an APB interface, checked at every rising edge (read-only).
//   reset        PSEL is 1 while PRESETn is low;
//   known        PSEL is x, or a control signal, a strobed write byte or PREADY in access is x;
//   setup        PENABLE is 1 without a setup cycle (PSEL 1, PENABLE 0) before it;
//   setup_len    a setup cycle not followed by an access cycle;
//   stable       PSEL, PADDR, PWRITE, PPROT, PSTRB or the write data changed inside a transfer,
//                or PSEL or PENABLE dropped before PREADY;
//   enable_drop  PENABLE still 1 in the cycle after a completed transfer;
//   strb_read    PSTRB not zero during a read;
//   onehot       more than one PSELx at once;
//   timeout      no PREADY after TIMEOUT wait cycles (a liveness watchdog, not a protocol rule).
// A NOTE (not a broken rule): PSLVERR is 1 outside the completion cycle, which the spec allows
// and recommends against (IHI 0024E 3.4).
module apb_checker #(parameter int NSEL = 1, parameter int TIMEOUT = 16) (
  input logic            pclk,
  input logic            presetn,
  input logic [NSEL-1:0] psel,
  input logic            penable,
  input logic            pwrite,
  input logic [31:0]     paddr,
  input logic [31:0]     pwdata,
  input logic [3:0]      pstrb,
  input logic [2:0]      pprot,
  input logic            pready,
  input logic            pslverr);
  int broken = 0, notes = 0, writes = 0, reads = 0, waits = 0, edge_n = -1, stall = 0;
  logic            p_any = 0, p_en = 0, p_rdy = 0, p_wr = 0;
  logic [NSEL-1:0] p_sel = 0;
  logic [31:0]     p_addr = 0, p_wdata = 0;
  logic [3:0]      p_strb = 0;
  logic [2:0]      p_prot = 0;
  task automatic report(input string rule, input string msg);
    broken++;
    $display("RULE %0s broken at edge %0d: %0s", rule, edge_n, msg);
  endtask
  task automatic note(input string rule, input string msg);
    notes++;
    $display("NOTE %0s at edge %0d: %0s", rule, edge_n, msg);
  endtask
  always @(posedge pclk) begin
    logic any, en, rdy, bytes_x;
    edge_n = edge_n + 1;
    any = (|psel) === 1'b1; en = (penable === 1'b1); rdy = (pready === 1'b1);
    if (presetn !== 1'b1) begin
      if (any) report("reset", "PSEL is 1 while PRESETn is low");
      any = 0; en = 0;
    end else begin
      bytes_x = 0;
      for (int l = 0; l < 4; l++) if (pstrb[l] === 1'b1 && (^pwdata[8*l +: 8]) === 1'bx) bytes_x = 1;
      if ((^psel) === 1'bx) report("known", "PSEL is x");
      else if (any && (^{paddr, pwrite, penable, pstrb, pprot}) === 1'bx) report("known", "a control signal is x while PSEL is 1");
      else if (any && pwrite === 1'b1 && bytes_x) report("known", "a strobed byte of PWDATA is x");
      else if (any && en && pready === 1'bx) report("known", "PREADY is x in an access cycle");
      if (any && en && !(p_any && (!p_en || !p_rdy)))
        report("setup", "PENABLE is 1 without a setup cycle (PSEL 1, PENABLE 0) before it");
      if (p_any && !p_en && !(any && en))
        report("setup_len", "the setup cycle was not followed by an access cycle");
      if (p_any && (!p_en || !p_rdy) && any) begin
        if (psel !== p_sel) report("stable", $sformatf("PSEL changed from %b to %b inside a transfer", p_sel, psel));
        if (paddr !== p_addr) report("stable", $sformatf("PADDR changed from 0x%0h to 0x%0h inside a transfer", p_addr, paddr));
        if (pwrite !== p_wr) report("stable", "PWRITE changed inside a transfer");
        if (pprot !== p_prot) report("stable", "PPROT changed inside a transfer");
        if (pstrb !== p_strb) report("stable", "PSTRB changed inside a transfer");
        if (p_wr && pwdata !== p_wdata) report("stable", $sformatf("PWDATA changed from 0x%0h to 0x%0h inside a transfer", p_wdata, pwdata));
        if (p_en && !en) report("stable", "PENABLE dropped before PREADY");
      end
      if (p_any && p_en && !p_rdy && !any) report("stable", "PSEL dropped before PREADY");
      if (p_any && p_en && p_rdy && en) report("enable_drop", "PENABLE is still 1 in the cycle after a completed transfer");
      if (any && pwrite === 1'b0 && pstrb !== 4'b0000) report("strb_read", $sformatf("PSTRB is %b during a read", pstrb));
      if ($countones(psel) > 1) report("onehot", $sformatf("PSELx is %b: two completers selected", psel));
      if (any && en && rdy) begin
        if (pwrite === 1'b1) writes++; else reads++;
        stall = 0;
      end else if (any && en) begin
        waits++; stall++;
        if (stall == TIMEOUT) report("timeout", $sformatf("no PREADY after %0d wait cycles", TIMEOUT));
      end
      if (pslverr === 1'b1 && !(any && en && rdy))
        note("pslverr", "PSLVERR is 1 outside the completion cycle (ignored by the requester; recommended LOW)");
    end
    p_any = any; p_en = en; p_rdy = rdy; p_sel = psel; p_addr = paddr; p_wr = (pwrite === 1'b1);
    p_wdata = pwdata; p_strb = pstrb; p_prot = pprot;
  end
  final $display("checker: %0d writes, %0d reads, %0d wait edges, %0d rules broken, %0d notes", writes, reads, waits, broken, notes);
endmodule
Read included file: apb_tasks.svh
// apb_tasks.svh: the requester side of the bench, as tasks for the stimulus (read-only).
// apb_write(addr, data, strb, prot) and apb_read(addr, prot) run one transfer and leave the bus
// IDLE; q_write / q_read queue transfers and apb_run() sends the queue back to back with PSEL held
// high (ACCESS goes straight to SETUP). Each transfer prints one log line at its completion edge:
//   e3-e4 WRITE 0x0100 data=0x11223344 strb=1111 waits=0 OKAY
// (setup edge - completion edge). The result of a read is in prdata_q and pslverr_q; the results
// of a queue are in rdv[i] and errv[i]. `cycle` counts rising edges from 0.
int cycle = -1;
always @(posedge pclk) cycle = cycle + 1;
bit quiet = 0;
// Requester bugs, for the broken twins:
bit move_in_wait = 0;   // PADDR moves by 4 in the first wait cycle
bit enable_stuck = 0;   // PENABLE stays 1 into the next queued transfer (no setup cycle)
bit strb_on_read = 0;   // PSTRB = 1111 on reads
bit skip_setup   = 0;   // PSEL and PENABLE rise together
int give_up      = 24;  // the bench stops waiting after this many wait cycles
// APB5 wake-up (IHI 0024E 3.7), off by default: with wake_lead >= 0 the requester raises PWAKEUP
// wake_lead cycles before PSEL of a transfer that starts from IDLE, and lowers it after the last
// transfer of a run completes. Broken twin: wake_drop_in_wait lowers PWAKEUP in the first wait cycle.
// The wake-up request is wake_req; a bench built with wake copies it onto PWAKEUP.
int wake_lead    = -1;
bit wake_drop_in_wait = 0;
logic wake_req = 0;

logic [31:0] prdata_q = 0;
logic        pslverr_q = 0;
int          waits_q = 0;
bit          stuck_now = 0;
bit          q_wr [0:63];
logic [31:0] q_addr [0:63], q_data [0:63], rdv [0:63];
logic [3:0]  q_strb [0:63];
logic [2:0]  q_prot [0:63];
bit          errv [0:63];
int          qn = 0;

// A text waveform for the trace blocks: one line per rising edge with the values sampled there.
bit watch = 0;
int wave_edge = -1;
always @(posedge pclk) begin
  wave_edge = wave_edge + 1;
`ifdef APB_DECODER
  if (watch) $display("wave e%0d: psel=%b pselx=%b penable=%b pwrite=%b paddr=%h pwdata=%h pstrb=%b pready=%b prdata=%h pslverr=%b",
                      wave_edge, psel, pselx, penable, pwrite, paddr, pwdata, pstrb, pready, prdata, pslverr);
`else
  if (watch) $display("wave e%0d: psel=%b penable=%b pwrite=%b paddr=%h pwdata=%h pstrb=%b pready=%b prdata=%h pslverr=%b",
                      wave_edge, psel, penable, pwrite, paddr, pwdata, pstrb, pready, prdata, pslverr);
`endif
end

// One transfer: SETUP for one cycle, then ACCESS until PREADY. last = 0 keeps PSEL high for the
// next transfer.
task automatic apb_xfer(input bit wr, input logic [31:0] addr, input logic [31:0] data, input logic [3:0] strb,
                        input logic [2:0] prot, input bit last);
  int s_edge, w;
  if (wake_lead >= 0 && !psel) begin
    if (!wake_req) begin wake_req = 1; repeat (wake_lead) begin @(posedge pclk); #1; end end
  end
  paddr = addr; pwrite = wr; pwdata = wr ? data : 32'h0;
  pstrb = wr ? strb : (strb_on_read ? 4'hf : 4'h0);
  pprot = prot; psel = 1;
  s_edge = cycle + 1;
  if (skip_setup || stuck_now) penable = 1;
  else begin
    penable = 0;
    @(posedge pclk); #1 penable = 1;
  end
  stuck_now = 0;
  w = 0;
  @(posedge pclk);
  while (pready !== 1'b1 && w < give_up) begin
    w++;
    #1 if (move_in_wait && w == 1) paddr = addr + 4;
    if (wake_drop_in_wait && w == 1) wake_req = 0;
    @(posedge pclk);
  end
  prdata_q = prdata; pslverr_q = (pslverr === 1'b1); waits_q = w;
  #1;
  if (!quiet) begin
    if (w >= give_up) $display("e%0d-e%0d %0s 0x%04h no PREADY after %0d wait cycles, the bench gives up", s_edge, cycle, wr ? "WRITE" : "READ ", addr[15:0], w);
    else if (wr) $display("e%0d-e%0d WRITE 0x%04h data=0x%08h strb=%b waits=%0d %0s", s_edge, cycle, addr[15:0], data, strb, w, pslverr_q ? "PSLVERR" : "OKAY");
    else $display("e%0d-e%0d READ  0x%04h data=0x%08h waits=%0d %0s", s_edge, cycle, addr[15:0], prdata_q, w, pslverr_q ? "PSLVERR" : "OKAY");
  end
  if (last) begin
    psel = 0; penable = 0; pwrite = 0; pstrb = 0;
    if (wake_lead >= 0) wake_req = 0;
  end else begin
    penable = enable_stuck ? 1 : 0;
    stuck_now = enable_stuck;
  end
endtask

task automatic apb_write(input logic [31:0] addr, input logic [31:0] data, input logic [3:0] strb = 4'hf, input logic [2:0] prot = 3'b000);
  apb_xfer(1, addr, data, strb, prot, 1);
endtask
task automatic apb_read(input logic [31:0] addr, input logic [2:0] prot = 3'b000);
  apb_xfer(0, addr, 0, 0, prot, 1);
endtask

// The queue: transfers sent back to back by apb_run().
task automatic q_write(input logic [31:0] addr, input logic [31:0] data, input logic [3:0] strb = 4'hf, input logic [2:0] prot = 3'b000);
  q_wr[qn] = 1; q_addr[qn] = addr; q_data[qn] = data; q_strb[qn] = strb; q_prot[qn] = prot; qn++;
endtask
task automatic q_read(input logic [31:0] addr, input logic [2:0] prot = 3'b000);
  q_wr[qn] = 0; q_addr[qn] = addr; q_data[qn] = 0; q_strb[qn] = 0; q_prot[qn] = prot; qn++;
endtask
task automatic apb_run();
  for (int i = 0; i < qn; i++) begin
    apb_xfer(q_wr[i], q_addr[i], q_data[i], q_strb[i], q_prot[i], i == qn - 1);
    rdv[i] = prdata_q; errv[i] = pslverr_q;
  end
  qn = 0;
endtask

task automatic idle(input int n);
  repeat (n) @(posedge pclk);
  #1;
endtask

// The completer's RAM, by bus address (the decoder bench picks the completer from bits 13:12).
function automatic logic [7:0] ram_byte(input int unsigned a);
`ifdef APB_DECODER
  case (a[13:12]) 2'd1: ram_byte = p1.mem[a[7:0]]; 2'd2: ram_byte = p2.mem[a[7:0]]; default: ram_byte = p0.mem[a[7:0]]; endcase
`else
  ram_byte = p0.mem[a[7:0]];
`endif
endfunction
// dump(addr, n): n bytes from addr, one 32-bit word per group, lane 0 (the lowest address) first.
task automatic dump(input int unsigned addr, input int n);
  string s;
  for (int a = addr & ~3; a < addr + n; a += 4) begin
    if ((a - (addr & ~3)) % 16 == 0) begin
      if (a != (addr & ~3)) $display("%0s", s);
      s = $sformatf("0x%04h  ", a[15:0]);
    end
    s = {s, $sformatf(" %h %h %h %h ", ram_byte(a), ram_byte(a + 1), ram_byte(a + 2), ram_byte(a + 3))};
  end
  $display("%0s", s);
endtask
// fifo_fill(n, first): put n words first, first+1, ... in completer 0's FIFO before the run.
task automatic fifo_fill(input int n, input logic [31:0] first);
  for (int i = 0; i < n; i++) p0.fifo[(p0.fhead + p0.fcount + i) % 16] = first + i;
  p0.fcount = p0.fcount + n;
endtask
// regs(): completer 0's registers as one line.
task automatic regs();
  $display("regs: CTRL=0x%08h STATUS=%0d WCOUNT=%0d", p0.ctrl, p0.fcount, p0.wcount);
endtask
Read included file: amba_parity.sv
`timescale 1ns/1ns
// amba_parity.sv: odd parity, one check bit per byte of payload (read-only).
// Check bit n covers payload bits [8n+7:8n]; when W is not a multiple of 8, the top check bit covers
// the bits that are left. Odd parity means the payload byte and its check bit hold an odd number of
// ones together, so a check bit is the inverse of the XOR of its byte. For a 1-bit payload (a critical
// control signal) that makes the check bit simply the inverse of the signal.
module amba_parity #(parameter int W = 8) (
  input  logic [W-1:0]         d,
  output logic [(W+7)/8-1:0]   chk
);
  for (genvar n = 0; n < (W + 7) / 8; n++) begin : g_byte
    localparam int HI = (8 * n + 7 < W) ? 8 * n + 7 : W - 1;
    assign chk[n] = ~(^d[HI:8 * n]);
  end
endmodule

// amba_parity_check: err is 1 when en is 1 and any check bit disagrees with its payload byte.
// A check signal only has to be right in cycles where its Check Enable term is true, so en carries it.
module amba_parity_check #(parameter int W = 8) (
  input  logic [W-1:0]         d,
  input  logic [(W+7)/8-1:0]   chk,
  input  logic                 en,
  output logic                 err
);
  logic [(W+7)/8-1:0] want;
  amba_parity #(.W(W)) gen (.d(d), .chk(want));
  assign err = en && (want !== chk);
endmodule
Read included file: apb_parity_link.sv
`timescale 1ns/1ns
// apb_parity_link.sv: the wires between the requester and completer p0, with check signals (read-only).
// Each source makes the check signals of what it drives (amba_parity: odd parity per byte, a single
// inverted bit for a critical control). Each receiver recomputes them from what arrived and compares,
// but only in cycles where the signal's Check Enable term (Table 5-1) is true.
// Switches: flip_sig and flip_bit pick one wire bit; flip_edge is the edge whose sampled value is
// flipped (one cycle only); check_on = 0 turns both receivers' checks off (the twin); quiet = 1
// counts errors without printing them.
//   flip_sig: 0 PADDR, 1 PWRITE, 2 PSEL, 3 PENABLE, 4 PWDATA, 5 PSTRB, 6 PREADY, 7 PRDATA, 8 PSLVERR
// A detected error is printed and counted; what to do next is left to the system (5.4).
module apb_parity_link (
  input  logic        pclk, presetn,
  input  logic        psel, penable, pwrite,          // from the requester
  input  logic [31:0] paddr, pwdata,
  input  logic [3:0]  pstrb,
  input  logic [2:0]  pprot,
  output logic        psel_c, penable_c, pwrite_c,    // to the completer, as they arrive
  output logic [31:0] paddr_c, pwdata_c,
  output logic [3:0]  pstrb_c,
  output logic [2:0]  pprot_c,
  input  logic        pready_c, pslverr_c,            // from the completer
  input  logic [31:0] prdata_c,
  output logic        pready, pslverr,                // to the requester, as they arrive
  output logic [31:0] prdata);
  int flip_sig = -1, flip_bit = 0, flip_edge = -1;
  bit check_on = 1, quiet = 0;
  int errors = 0, cycle = -1;
  always @(posedge pclk) cycle = cycle + 1;
  wire        flip  = (cycle + 1 == flip_edge);
  wire [31:0] fmask = 32'h1 << flip_bit;
  // ---- the source side makes the check signals from the clean values ----
  logic [3:0] paddrchk, pwdatachk, prdatachk;
  logic       pselchk, penablechk, pstrbchk, preadychk, pslverrchk;
  amba_parity #(32) g_addr (.d(paddr), .chk(paddrchk));
  amba_parity #(1)  g_sel  (.d(psel), .chk(pselchk));
  amba_parity #(1)  g_en   (.d(penable), .chk(penablechk));
  amba_parity #(32) g_wd   (.d(pwdata), .chk(pwdatachk));
  amba_parity #(4)  g_st   (.d(pstrb), .chk(pstrbchk));
  amba_parity #(1)  g_rdy  (.d(pready_c), .chk(preadychk));
  amba_parity #(32) g_rd   (.d(prdata_c), .chk(prdatachk));
  amba_parity #(1)  g_err  (.d(pslverr_c), .chk(pslverrchk));
  // PCTRLCHK is one bit over PPROT, PWRITE and PNSE (absent here, so assumed LOW).
  logic pctrl_tx;
  assign pctrl_tx = ~(^{pprot, pwrite});
  // ---- the wires, with the injected fault ----
  assign paddr_c   = paddr ^ ((flip && flip_sig == 0) ? fmask : 32'h0);
  assign pwrite_c  = pwrite ^ (|((flip && flip_sig == 1) ? fmask : 32'h0));
  assign psel_c    = psel ^ (|((flip && flip_sig == 2) ? fmask : 32'h0));
  assign penable_c = penable ^ (|((flip && flip_sig == 3) ? fmask : 32'h0));
  assign pwdata_c  = pwdata ^ ((flip && flip_sig == 4) ? fmask : 32'h0);
  assign pstrb_c   = pstrb ^ 4'(((flip && flip_sig == 5) ? fmask : 32'h0));
  assign pprot_c   = pprot;
  assign pready    = pready_c ^ (|((flip && flip_sig == 6) ? fmask : 32'h0));
  assign prdata    = prdata_c ^ ((flip && flip_sig == 7) ? fmask : 32'h0);
  assign pslverr   = pslverr_c ^ (|((flip && flip_sig == 8) ? fmask : 32'h0));
  // what each receiver recomputes from the values that arrived
  logic [3:0] paddr_r, pwdata_r, prdata_r;
  amba_parity #(32) r_addr (.d(paddr_c), .chk(paddr_r));
  amba_parity #(32) r_wd   (.d(pwdata_c), .chk(pwdata_r));
  amba_parity #(32) r_rd   (.d(prdata), .chk(prdata_r));
  // ---- the receivers ----
  task automatic bad(input string name);
    errors++;
    if (!quiet) $display("parity e%0d: %0s does not match", cycle, name);
  endtask
  always @(posedge pclk) if (check_on) begin
    // the completer checks the request
    if (presetn && (~psel_c) !== pselchk) bad("PSELCHK");
    if (psel_c) begin
      if (~(^{pprot_c, pwrite_c}) !== pctrl_tx) bad("PCTRLCHK");
      if (paddr_r !== paddrchk) bad("PADDRCHK");
      if ((~penable_c) !== penablechk) bad("PENABLECHK");
      if (pwrite_c) begin
        if (pwdata_r !== pwdatachk) bad("PWDATACHK");
        if (~(^pstrb_c) !== pstrbchk) bad("PSTRBCHK");
      end
    end
    // the requester checks the response
    if (psel && penable && (~pready) !== preadychk) bad("PREADYCHK");
    if (psel && penable && pready_c) begin
      if ((~pslverr) !== pslverrchk) bad("PSLVERRCHK");
      if (!pwrite && prdata_r !== prdatachk) bad("PRDATACHK");
    end
  end
  final if (!quiet) $display("parity: %0d check errors", errors);
endmodule

Check Yourself

Predict the outputPRDATA bit 31 flips on the wire in the completion cycle of the read. The link counts quietly. The program prints the data the requester took and the error count. What is the line?
`timescale 1ns/1ps
module tb;
  logic pclk = 0, presetn = 0;
  always #5 pclk = ~pclk;                 // rising edges at 5, 15, 25, ...
  logic        psel = 0, penable = 0, pwrite = 0, pwakeup = 0;
  logic [31:0] paddr = 0, pwdata = 0;
  logic [3:0]  pstrb = 0;
  logic [2:0]  pprot = 0;
  logic        pready, pslverr;
  logic [31:0] prdata;
  logic        psel_c, penable_c, pwrite_c, pready_c, pslverr_c;
  logic [31:0] paddr_c, pwdata_c, prdata_c;
  logic [3:0]  pstrb_c;
  logic [2:0]  pprot_c;
  apb_parity_link link (.pclk(pclk), .presetn(presetn), .psel(psel), .penable(penable), .pwrite(pwrite), .paddr(paddr), .pwdata(pwdata),
                        .pstrb(pstrb), .pprot(pprot), .psel_c(psel_c), .penable_c(penable_c), .pwrite_c(pwrite_c), .paddr_c(paddr_c),
                        .pwdata_c(pwdata_c), .pstrb_c(pstrb_c), .pprot_c(pprot_c), .pready_c(pready_c), .pslverr_c(pslverr_c),
                        .prdata_c(prdata_c), .pready(pready), .pslverr(pslverr), .prdata(prdata));
  apb_periph p0 (.pclk(pclk), .presetn(presetn), .psel(psel_c), .penable(penable_c), .pwrite(pwrite_c), .paddr(paddr_c),
                .pwdata(pwdata_c), .pstrb(pstrb_c), .pprot(pprot_c), .pready(pready_c), .prdata(prdata_c), .pslverr(pslverr_c));
  `include "apb_tasks.svh"

  initial begin

    repeat (2) @(posedge pclk); #1 presetn = 1;   // reset released after edge 1
    @(posedge pclk); #1;                          // the first transfer may start after edge 2
    quiet = 1; link.quiet = 1; link.flip_sig = 7; link.flip_bit = 31; link.flip_edge = 6;
    apb_write(32'h010, 32'h11223344);
    apb_read(32'h010);
    $display("read %h, %0d check error", prdata_q, link.errors);
    repeat (3) @(posedge pclk);
    $finish;
  end
endmodule
Read included file: apb_periph.sv
`timescale 1ns/1ns
// apb_periph.sv: an APB4 completer (read-only). Offsets are paddr[11:0]:
//   0x000-0x0ff  RAM, 256 bytes, written lane by lane under PSTRB
//   0x100 CTRL   read/write, byte-strobed
//   0x104 STATUS read-only: the number of words in the FIFO
//   0x108 WCOUNT read-only: counts completed writes (a zero-strobe write counts too)
//   0x10c FIFO   a write pushes PWDATA, a read pops the oldest word (0 when empty)
//   0x110 ID     read-only, 0x41504234 ("APB4")
// With err_on (the default) the completer answers PSLVERR for an unmapped offset, an unaligned
// PADDR, a write to a read-only register and, with priv_ctrl, an unprivileged access to CTRL;
// a transfer that gets PSLVERR changes nothing here (IHI 0024E 3.4 allows either choice).
// Switches (set from the stimulus):
//   waits           wait states in every access (PREADY low for that many access cycles)
//   ready_in_setup  drive PREADY high outside the access phase (a don't-care: the spec allows it)
//   hang            never raise PREADY
//   err_on, priv_ctrl
// Broken twins:
//   act_every_cycle acts at every edge PSEL is high, not once at completion
//   late_rdata      PRDATA registered at completion, so it arrives one cycle late
//   err_early       PSLVERR during setup and wait cycles, low at completion
//   ignore_strobes  writes every lane of a RAM word or CTRL
//   ignore_psel     decodes PADDR and acts in access cycles without looking at its PSEL
module apb_periph #(parameter NAME = "p0") (
  input  logic        pclk,
  input  logic        presetn,
  input  logic        psel,
  input  logic        penable,
  input  logic        pwrite,
  input  logic [31:0] paddr,
  input  logic [31:0] pwdata,
  input  logic [3:0]  pstrb,
  input  logic [2:0]  pprot,
  output logic        pready,
  output logic [31:0] prdata,
  output logic        pslverr);
  int waits = 0;
  bit ready_in_setup = 0, hang = 0, err_on = 1, priv_ctrl = 0, trace = 0;
  bit act_every_cycle = 0, late_rdata = 0, err_early = 0, ignore_strobes = 0, ignore_psel = 0;

  logic [7:0]  mem [0:255];
  logic [31:0] ctrl = 0, wcount = 0;
  logic [31:0] fifo [0:15];
  int          fhead = 0, fcount = 0;
  int          wcnt = 0;                  // wait cycles spent in this access
  logic [31:0] prdata_q = 0;
  initial for (int i = 0; i < 256; i++) mem[i] = 0;

  localparam int RAM = 0, CTRL = 1, STATUS = 2, WCOUNT = 3, FIFO = 4, ID = 5, NONE = 6;
  function automatic int region(input logic [11:0] a);
    if (a < 12'h100) region = RAM;
    else if (a[11:2] == 10'h040) region = CTRL;
    else if (a[11:2] == 10'h041) region = STATUS;
    else if (a[11:2] == 10'h042) region = WCOUNT;
    else if (a[11:2] == 10'h043) region = FIFO;
    else if (a[11:2] == 10'h044) region = ID;
    else region = NONE;
  endfunction
  function automatic bit bad(input logic wr, input logic [11:0] a, input logic [2:0] prot);
    int r;
    r = region(a);
    bad = (r == NONE) || (a[1:0] != 0) || (wr && (r == STATUS || r == WCOUNT || r == ID))
          || (priv_ctrl && r == CTRL && !prot[0]);
  endfunction
  function automatic logic [31:0] value(input logic [11:0] a);
    case (region(a))
      RAM:     value = {mem[{a[7:2], 2'd3}], mem[{a[7:2], 2'd2}], mem[{a[7:2], 2'd1}], mem[{a[7:2], 2'd0}]};
      CTRL:    value = ctrl;
      STATUS:  value = fcount;
      WCOUNT:  value = wcount;
      FIFO:    value = fcount > 0 ? fifo[fhead] : 32'h0;
      ID:      value = 32'h41504234;
      default: value = 32'h0;
    endcase
  endfunction

  wire sel    = ignore_psel ? 1'b1 : (psel === 1'b1);
  wire access = sel && (penable === 1'b1);
  wire err    = err_on && bad(pwrite, paddr[11:0], pprot);
  assign pready  = hang ? 1'b0 : (!access ? (ready_in_setup ? 1'b1 : 1'b0) : (wcnt >= waits));
  wire done   = access && pready;
  assign pslverr = err_early ? (sel && !done && err) : (done && err);
  // The read value is taken at the setup edge (PSEL 1, PENABLE 0) and held on PRDATA until the next
  // read, the way most register blocks do it (the bus multiplexor decides who is heard);
  // late_rdata registers it at completion instead.
  logic [31:0] rdata_r = 0;
  always @(posedge pclk) if (sel && penable !== 1'b1 && pwrite === 1'b0) rdata_r <= value(paddr[11:0]);
  assign prdata  = late_rdata ? prdata_q : rdata_r;
  wire act    = act_every_cycle ? sel : done;

  always @(posedge pclk or negedge presetn) begin
    if (!presetn) begin
      ctrl <= 0; wcount <= 0; wcnt <= 0;
    end else begin
      wcnt <= (access && !pready) ? wcnt + 1 : 0;
      if (done && !pwrite) prdata_q <= value(paddr[11:0]);
      if (act && !err) begin
        if (pwrite) begin
          wcount <= wcount + 1;
          case (region(paddr[11:0]))
            RAM:  for (int l = 0; l < 4; l++) if (pstrb[l] || ignore_strobes) mem[{paddr[7:2], 2'b00} + l] <= pwdata[8*l +: 8];
            CTRL: for (int l = 0; l < 4; l++) if (pstrb[l] || ignore_strobes) ctrl[8*l +: 8] <= pwdata[8*l +: 8];
            FIFO: if (fcount < 16) begin fifo[(fhead + fcount) % 16] <= pwdata; fcount <= fcount + 1; end
            default: ;
          endcase
          if (trace) $display("  %0s e%0d: write 0x%03h <= 0x%08h strb=%b", NAME, ($time - 5) / 10, paddr[11:0], pwdata, pstrb);
        end else begin
          if (region(paddr[11:0]) == FIFO && fcount > 0) begin fhead <= (fhead + 1) % 16; fcount <= fcount - 1; end
          if (trace) $display("  %0s e%0d: read 0x%03h -> 0x%08h", NAME, ($time - 5) / 10, paddr[11:0], value(paddr[11:0]));
        end
      end else if (act && trace) $display("  %0s e%0d: error, %0s 0x%03h ignored", NAME, ($time - 5) / 10, pwrite ? "write" : "read", paddr[11:0]);
    end
  end
endmodule
Read included file: apb_checker.sv
`timescale 1ns/1ns
// apb_checker.sv: the rules of an APB interface, checked at every rising edge (read-only).
//   reset        PSEL is 1 while PRESETn is low;
//   known        PSEL is x, or a control signal, a strobed write byte or PREADY in access is x;
//   setup        PENABLE is 1 without a setup cycle (PSEL 1, PENABLE 0) before it;
//   setup_len    a setup cycle not followed by an access cycle;
//   stable       PSEL, PADDR, PWRITE, PPROT, PSTRB or the write data changed inside a transfer,
//                or PSEL or PENABLE dropped before PREADY;
//   enable_drop  PENABLE still 1 in the cycle after a completed transfer;
//   strb_read    PSTRB not zero during a read;
//   onehot       more than one PSELx at once;
//   timeout      no PREADY after TIMEOUT wait cycles (a liveness watchdog, not a protocol rule).
// A NOTE (not a broken rule): PSLVERR is 1 outside the completion cycle, which the spec allows
// and recommends against (IHI 0024E 3.4).
module apb_checker #(parameter int NSEL = 1, parameter int TIMEOUT = 16) (
  input logic            pclk,
  input logic            presetn,
  input logic [NSEL-1:0] psel,
  input logic            penable,
  input logic            pwrite,
  input logic [31:0]     paddr,
  input logic [31:0]     pwdata,
  input logic [3:0]      pstrb,
  input logic [2:0]      pprot,
  input logic            pready,
  input logic            pslverr);
  int broken = 0, notes = 0, writes = 0, reads = 0, waits = 0, edge_n = -1, stall = 0;
  logic            p_any = 0, p_en = 0, p_rdy = 0, p_wr = 0;
  logic [NSEL-1:0] p_sel = 0;
  logic [31:0]     p_addr = 0, p_wdata = 0;
  logic [3:0]      p_strb = 0;
  logic [2:0]      p_prot = 0;
  task automatic report(input string rule, input string msg);
    broken++;
    $display("RULE %0s broken at edge %0d: %0s", rule, edge_n, msg);
  endtask
  task automatic note(input string rule, input string msg);
    notes++;
    $display("NOTE %0s at edge %0d: %0s", rule, edge_n, msg);
  endtask
  always @(posedge pclk) begin
    logic any, en, rdy, bytes_x;
    edge_n = edge_n + 1;
    any = (|psel) === 1'b1; en = (penable === 1'b1); rdy = (pready === 1'b1);
    if (presetn !== 1'b1) begin
      if (any) report("reset", "PSEL is 1 while PRESETn is low");
      any = 0; en = 0;
    end else begin
      bytes_x = 0;
      for (int l = 0; l < 4; l++) if (pstrb[l] === 1'b1 && (^pwdata[8*l +: 8]) === 1'bx) bytes_x = 1;
      if ((^psel) === 1'bx) report("known", "PSEL is x");
      else if (any && (^{paddr, pwrite, penable, pstrb, pprot}) === 1'bx) report("known", "a control signal is x while PSEL is 1");
      else if (any && pwrite === 1'b1 && bytes_x) report("known", "a strobed byte of PWDATA is x");
      else if (any && en && pready === 1'bx) report("known", "PREADY is x in an access cycle");
      if (any && en && !(p_any && (!p_en || !p_rdy)))
        report("setup", "PENABLE is 1 without a setup cycle (PSEL 1, PENABLE 0) before it");
      if (p_any && !p_en && !(any && en))
        report("setup_len", "the setup cycle was not followed by an access cycle");
      if (p_any && (!p_en || !p_rdy) && any) begin
        if (psel !== p_sel) report("stable", $sformatf("PSEL changed from %b to %b inside a transfer", p_sel, psel));
        if (paddr !== p_addr) report("stable", $sformatf("PADDR changed from 0x%0h to 0x%0h inside a transfer", p_addr, paddr));
        if (pwrite !== p_wr) report("stable", "PWRITE changed inside a transfer");
        if (pprot !== p_prot) report("stable", "PPROT changed inside a transfer");
        if (pstrb !== p_strb) report("stable", "PSTRB changed inside a transfer");
        if (p_wr && pwdata !== p_wdata) report("stable", $sformatf("PWDATA changed from 0x%0h to 0x%0h inside a transfer", p_wdata, pwdata));
        if (p_en && !en) report("stable", "PENABLE dropped before PREADY");
      end
      if (p_any && p_en && !p_rdy && !any) report("stable", "PSEL dropped before PREADY");
      if (p_any && p_en && p_rdy && en) report("enable_drop", "PENABLE is still 1 in the cycle after a completed transfer");
      if (any && pwrite === 1'b0 && pstrb !== 4'b0000) report("strb_read", $sformatf("PSTRB is %b during a read", pstrb));
      if ($countones(psel) > 1) report("onehot", $sformatf("PSELx is %b: two completers selected", psel));
      if (any && en && rdy) begin
        if (pwrite === 1'b1) writes++; else reads++;
        stall = 0;
      end else if (any && en) begin
        waits++; stall++;
        if (stall == TIMEOUT) report("timeout", $sformatf("no PREADY after %0d wait cycles", TIMEOUT));
      end
      if (pslverr === 1'b1 && !(any && en && rdy))
        note("pslverr", "PSLVERR is 1 outside the completion cycle (ignored by the requester; recommended LOW)");
    end
    p_any = any; p_en = en; p_rdy = rdy; p_sel = psel; p_addr = paddr; p_wr = (pwrite === 1'b1);
    p_wdata = pwdata; p_strb = pstrb; p_prot = pprot;
  end
  final $display("checker: %0d writes, %0d reads, %0d wait edges, %0d rules broken, %0d notes", writes, reads, waits, broken, notes);
endmodule
Read included file: apb_tasks.svh
// apb_tasks.svh: the requester side of the bench, as tasks for the stimulus (read-only).
// apb_write(addr, data, strb, prot) and apb_read(addr, prot) run one transfer and leave the bus
// IDLE; q_write / q_read queue transfers and apb_run() sends the queue back to back with PSEL held
// high (ACCESS goes straight to SETUP). Each transfer prints one log line at its completion edge:
//   e3-e4 WRITE 0x0100 data=0x11223344 strb=1111 waits=0 OKAY
// (setup edge - completion edge). The result of a read is in prdata_q and pslverr_q; the results
// of a queue are in rdv[i] and errv[i]. `cycle` counts rising edges from 0.
int cycle = -1;
always @(posedge pclk) cycle = cycle + 1;
bit quiet = 0;
// Requester bugs, for the broken twins:
bit move_in_wait = 0;   // PADDR moves by 4 in the first wait cycle
bit enable_stuck = 0;   // PENABLE stays 1 into the next queued transfer (no setup cycle)
bit strb_on_read = 0;   // PSTRB = 1111 on reads
bit skip_setup   = 0;   // PSEL and PENABLE rise together
int give_up      = 24;  // the bench stops waiting after this many wait cycles
// APB5 wake-up (IHI 0024E 3.7), off by default: with wake_lead >= 0 the requester raises PWAKEUP
// wake_lead cycles before PSEL of a transfer that starts from IDLE, and lowers it after the last
// transfer of a run completes. Broken twin: wake_drop_in_wait lowers PWAKEUP in the first wait cycle.
// The wake-up request is wake_req; a bench built with wake copies it onto PWAKEUP.
int wake_lead    = -1;
bit wake_drop_in_wait = 0;
logic wake_req = 0;

logic [31:0] prdata_q = 0;
logic        pslverr_q = 0;
int          waits_q = 0;
bit          stuck_now = 0;
bit          q_wr [0:63];
logic [31:0] q_addr [0:63], q_data [0:63], rdv [0:63];
logic [3:0]  q_strb [0:63];
logic [2:0]  q_prot [0:63];
bit          errv [0:63];
int          qn = 0;

// A text waveform for the trace blocks: one line per rising edge with the values sampled there.
bit watch = 0;
int wave_edge = -1;
always @(posedge pclk) begin
  wave_edge = wave_edge + 1;
`ifdef APB_DECODER
  if (watch) $display("wave e%0d: psel=%b pselx=%b penable=%b pwrite=%b paddr=%h pwdata=%h pstrb=%b pready=%b prdata=%h pslverr=%b",
                      wave_edge, psel, pselx, penable, pwrite, paddr, pwdata, pstrb, pready, prdata, pslverr);
`else
  if (watch) $display("wave e%0d: psel=%b penable=%b pwrite=%b paddr=%h pwdata=%h pstrb=%b pready=%b prdata=%h pslverr=%b",
                      wave_edge, psel, penable, pwrite, paddr, pwdata, pstrb, pready, prdata, pslverr);
`endif
end

// One transfer: SETUP for one cycle, then ACCESS until PREADY. last = 0 keeps PSEL high for the
// next transfer.
task automatic apb_xfer(input bit wr, input logic [31:0] addr, input logic [31:0] data, input logic [3:0] strb,
                        input logic [2:0] prot, input bit last);
  int s_edge, w;
  if (wake_lead >= 0 && !psel) begin
    if (!wake_req) begin wake_req = 1; repeat (wake_lead) begin @(posedge pclk); #1; end end
  end
  paddr = addr; pwrite = wr; pwdata = wr ? data : 32'h0;
  pstrb = wr ? strb : (strb_on_read ? 4'hf : 4'h0);
  pprot = prot; psel = 1;
  s_edge = cycle + 1;
  if (skip_setup || stuck_now) penable = 1;
  else begin
    penable = 0;
    @(posedge pclk); #1 penable = 1;
  end
  stuck_now = 0;
  w = 0;
  @(posedge pclk);
  while (pready !== 1'b1 && w < give_up) begin
    w++;
    #1 if (move_in_wait && w == 1) paddr = addr + 4;
    if (wake_drop_in_wait && w == 1) wake_req = 0;
    @(posedge pclk);
  end
  prdata_q = prdata; pslverr_q = (pslverr === 1'b1); waits_q = w;
  #1;
  if (!quiet) begin
    if (w >= give_up) $display("e%0d-e%0d %0s 0x%04h no PREADY after %0d wait cycles, the bench gives up", s_edge, cycle, wr ? "WRITE" : "READ ", addr[15:0], w);
    else if (wr) $display("e%0d-e%0d WRITE 0x%04h data=0x%08h strb=%b waits=%0d %0s", s_edge, cycle, addr[15:0], data, strb, w, pslverr_q ? "PSLVERR" : "OKAY");
    else $display("e%0d-e%0d READ  0x%04h data=0x%08h waits=%0d %0s", s_edge, cycle, addr[15:0], prdata_q, w, pslverr_q ? "PSLVERR" : "OKAY");
  end
  if (last) begin
    psel = 0; penable = 0; pwrite = 0; pstrb = 0;
    if (wake_lead >= 0) wake_req = 0;
  end else begin
    penable = enable_stuck ? 1 : 0;
    stuck_now = enable_stuck;
  end
endtask

task automatic apb_write(input logic [31:0] addr, input logic [31:0] data, input logic [3:0] strb = 4'hf, input logic [2:0] prot = 3'b000);
  apb_xfer(1, addr, data, strb, prot, 1);
endtask
task automatic apb_read(input logic [31:0] addr, input logic [2:0] prot = 3'b000);
  apb_xfer(0, addr, 0, 0, prot, 1);
endtask

// The queue: transfers sent back to back by apb_run().
task automatic q_write(input logic [31:0] addr, input logic [31:0] data, input logic [3:0] strb = 4'hf, input logic [2:0] prot = 3'b000);
  q_wr[qn] = 1; q_addr[qn] = addr; q_data[qn] = data; q_strb[qn] = strb; q_prot[qn] = prot; qn++;
endtask
task automatic q_read(input logic [31:0] addr, input logic [2:0] prot = 3'b000);
  q_wr[qn] = 0; q_addr[qn] = addr; q_data[qn] = 0; q_strb[qn] = 0; q_prot[qn] = prot; qn++;
endtask
task automatic apb_run();
  for (int i = 0; i < qn; i++) begin
    apb_xfer(q_wr[i], q_addr[i], q_data[i], q_strb[i], q_prot[i], i == qn - 1);
    rdv[i] = prdata_q; errv[i] = pslverr_q;
  end
  qn = 0;
endtask

task automatic idle(input int n);
  repeat (n) @(posedge pclk);
  #1;
endtask

// The completer's RAM, by bus address (the decoder bench picks the completer from bits 13:12).
function automatic logic [7:0] ram_byte(input int unsigned a);
`ifdef APB_DECODER
  case (a[13:12]) 2'd1: ram_byte = p1.mem[a[7:0]]; 2'd2: ram_byte = p2.mem[a[7:0]]; default: ram_byte = p0.mem[a[7:0]]; endcase
`else
  ram_byte = p0.mem[a[7:0]];
`endif
endfunction
// dump(addr, n): n bytes from addr, one 32-bit word per group, lane 0 (the lowest address) first.
task automatic dump(input int unsigned addr, input int n);
  string s;
  for (int a = addr & ~3; a < addr + n; a += 4) begin
    if ((a - (addr & ~3)) % 16 == 0) begin
      if (a != (addr & ~3)) $display("%0s", s);
      s = $sformatf("0x%04h  ", a[15:0]);
    end
    s = {s, $sformatf(" %h %h %h %h ", ram_byte(a), ram_byte(a + 1), ram_byte(a + 2), ram_byte(a + 3))};
  end
  $display("%0s", s);
endtask
// fifo_fill(n, first): put n words first, first+1, ... in completer 0's FIFO before the run.
task automatic fifo_fill(input int n, input logic [31:0] first);
  for (int i = 0; i < n; i++) p0.fifo[(p0.fhead + p0.fcount + i) % 16] = first + i;
  p0.fcount = p0.fcount + n;
endtask
// regs(): completer 0's registers as one line.
task automatic regs();
  $display("regs: CTRL=0x%08h STATUS=%0d WCOUNT=%0d", p0.ctrl, p0.fcount, p0.wcount);
endtask
Read included file: amba_parity.sv
`timescale 1ns/1ns
// amba_parity.sv: odd parity, one check bit per byte of payload (read-only).
// Check bit n covers payload bits [8n+7:8n]; when W is not a multiple of 8, the top check bit covers
// the bits that are left. Odd parity means the payload byte and its check bit hold an odd number of
// ones together, so a check bit is the inverse of the XOR of its byte. For a 1-bit payload (a critical
// control signal) that makes the check bit simply the inverse of the signal.
module amba_parity #(parameter int W = 8) (
  input  logic [W-1:0]         d,
  output logic [(W+7)/8-1:0]   chk
);
  for (genvar n = 0; n < (W + 7) / 8; n++) begin : g_byte
    localparam int HI = (8 * n + 7 < W) ? 8 * n + 7 : W - 1;
    assign chk[n] = ~(^d[HI:8 * n]);
  end
endmodule

// amba_parity_check: err is 1 when en is 1 and any check bit disagrees with its payload byte.
// A check signal only has to be right in cycles where its Check Enable term is true, so en carries it.
module amba_parity_check #(parameter int W = 8) (
  input  logic [W-1:0]         d,
  input  logic [(W+7)/8-1:0]   chk,
  input  logic                 en,
  output logic                 err
);
  logic [(W+7)/8-1:0] want;
  amba_parity #(.W(W)) gen (.d(d), .chk(want));
  assign err = en && (want !== chk);
endmodule
Read included file: apb_parity_link.sv
`timescale 1ns/1ns
// apb_parity_link.sv: the wires between the requester and completer p0, with check signals (read-only).
// Each source makes the check signals of what it drives (amba_parity: odd parity per byte, a single
// inverted bit for a critical control). Each receiver recomputes them from what arrived and compares,
// but only in cycles where the signal's Check Enable term (Table 5-1) is true.
// Switches: flip_sig and flip_bit pick one wire bit; flip_edge is the edge whose sampled value is
// flipped (one cycle only); check_on = 0 turns both receivers' checks off (the twin); quiet = 1
// counts errors without printing them.
//   flip_sig: 0 PADDR, 1 PWRITE, 2 PSEL, 3 PENABLE, 4 PWDATA, 5 PSTRB, 6 PREADY, 7 PRDATA, 8 PSLVERR
// A detected error is printed and counted; what to do next is left to the system (5.4).
module apb_parity_link (
  input  logic        pclk, presetn,
  input  logic        psel, penable, pwrite,          // from the requester
  input  logic [31:0] paddr, pwdata,
  input  logic [3:0]  pstrb,
  input  logic [2:0]  pprot,
  output logic        psel_c, penable_c, pwrite_c,    // to the completer, as they arrive
  output logic [31:0] paddr_c, pwdata_c,
  output logic [3:0]  pstrb_c,
  output logic [2:0]  pprot_c,
  input  logic        pready_c, pslverr_c,            // from the completer
  input  logic [31:0] prdata_c,
  output logic        pready, pslverr,                // to the requester, as they arrive
  output logic [31:0] prdata);
  int flip_sig = -1, flip_bit = 0, flip_edge = -1;
  bit check_on = 1, quiet = 0;
  int errors = 0, cycle = -1;
  always @(posedge pclk) cycle = cycle + 1;
  wire        flip  = (cycle + 1 == flip_edge);
  wire [31:0] fmask = 32'h1 << flip_bit;
  // ---- the source side makes the check signals from the clean values ----
  logic [3:0] paddrchk, pwdatachk, prdatachk;
  logic       pselchk, penablechk, pstrbchk, preadychk, pslverrchk;
  amba_parity #(32) g_addr (.d(paddr), .chk(paddrchk));
  amba_parity #(1)  g_sel  (.d(psel), .chk(pselchk));
  amba_parity #(1)  g_en   (.d(penable), .chk(penablechk));
  amba_parity #(32) g_wd   (.d(pwdata), .chk(pwdatachk));
  amba_parity #(4)  g_st   (.d(pstrb), .chk(pstrbchk));
  amba_parity #(1)  g_rdy  (.d(pready_c), .chk(preadychk));
  amba_parity #(32) g_rd   (.d(prdata_c), .chk(prdatachk));
  amba_parity #(1)  g_err  (.d(pslverr_c), .chk(pslverrchk));
  // PCTRLCHK is one bit over PPROT, PWRITE and PNSE (absent here, so assumed LOW).
  logic pctrl_tx;
  assign pctrl_tx = ~(^{pprot, pwrite});
  // ---- the wires, with the injected fault ----
  assign paddr_c   = paddr ^ ((flip && flip_sig == 0) ? fmask : 32'h0);
  assign pwrite_c  = pwrite ^ (|((flip && flip_sig == 1) ? fmask : 32'h0));
  assign psel_c    = psel ^ (|((flip && flip_sig == 2) ? fmask : 32'h0));
  assign penable_c = penable ^ (|((flip && flip_sig == 3) ? fmask : 32'h0));
  assign pwdata_c  = pwdata ^ ((flip && flip_sig == 4) ? fmask : 32'h0);
  assign pstrb_c   = pstrb ^ 4'(((flip && flip_sig == 5) ? fmask : 32'h0));
  assign pprot_c   = pprot;
  assign pready    = pready_c ^ (|((flip && flip_sig == 6) ? fmask : 32'h0));
  assign prdata    = prdata_c ^ ((flip && flip_sig == 7) ? fmask : 32'h0);
  assign pslverr   = pslverr_c ^ (|((flip && flip_sig == 8) ? fmask : 32'h0));
  // what each receiver recomputes from the values that arrived
  logic [3:0] paddr_r, pwdata_r, prdata_r;
  amba_parity #(32) r_addr (.d(paddr_c), .chk(paddr_r));
  amba_parity #(32) r_wd   (.d(pwdata_c), .chk(pwdata_r));
  amba_parity #(32) r_rd   (.d(prdata), .chk(prdata_r));
  // ---- the receivers ----
  task automatic bad(input string name);
    errors++;
    if (!quiet) $display("parity e%0d: %0s does not match", cycle, name);
  endtask
  always @(posedge pclk) if (check_on) begin
    // the completer checks the request
    if (presetn && (~psel_c) !== pselchk) bad("PSELCHK");
    if (psel_c) begin
      if (~(^{pprot_c, pwrite_c}) !== pctrl_tx) bad("PCTRLCHK");
      if (paddr_r !== paddrchk) bad("PADDRCHK");
      if ((~penable_c) !== penablechk) bad("PENABLECHK");
      if (pwrite_c) begin
        if (pwdata_r !== pwdatachk) bad("PWDATACHK");
        if (~(^pstrb_c) !== pstrbchk) bad("PSTRBCHK");
      end
    end
    // the requester checks the response
    if (psel && penable && (~pready) !== preadychk) bad("PREADYCHK");
    if (psel && penable && pready_c) begin
      if ((~pslverr) !== pslverrchk) bad("PSLVERRCHK");
      if (!pwrite && prdata_r !== prdatachk) bad("PRDATACHK");
    end
  end
  final if (!quiet) $display("parity: %0d check errors", errors);
endmodule
Spot the bugEach option flips one wire bit for one cycle. Then a write of 0x010 runs at edges 3 and 4, and a read of it at edges 5 and 6. Which flip goes unreported?
Read included file: apb_periph.sv
`timescale 1ns/1ns
// apb_periph.sv: an APB4 completer (read-only). Offsets are paddr[11:0]:
//   0x000-0x0ff  RAM, 256 bytes, written lane by lane under PSTRB
//   0x100 CTRL   read/write, byte-strobed
//   0x104 STATUS read-only: the number of words in the FIFO
//   0x108 WCOUNT read-only: counts completed writes (a zero-strobe write counts too)
//   0x10c FIFO   a write pushes PWDATA, a read pops the oldest word (0 when empty)
//   0x110 ID     read-only, 0x41504234 ("APB4")
// With err_on (the default) the completer answers PSLVERR for an unmapped offset, an unaligned
// PADDR, a write to a read-only register and, with priv_ctrl, an unprivileged access to CTRL;
// a transfer that gets PSLVERR changes nothing here (IHI 0024E 3.4 allows either choice).
// Switches (set from the stimulus):
//   waits           wait states in every access (PREADY low for that many access cycles)
//   ready_in_setup  drive PREADY high outside the access phase (a don't-care: the spec allows it)
//   hang            never raise PREADY
//   err_on, priv_ctrl
// Broken twins:
//   act_every_cycle acts at every edge PSEL is high, not once at completion
//   late_rdata      PRDATA registered at completion, so it arrives one cycle late
//   err_early       PSLVERR during setup and wait cycles, low at completion
//   ignore_strobes  writes every lane of a RAM word or CTRL
//   ignore_psel     decodes PADDR and acts in access cycles without looking at its PSEL
module apb_periph #(parameter NAME = "p0") (
  input  logic        pclk,
  input  logic        presetn,
  input  logic        psel,
  input  logic        penable,
  input  logic        pwrite,
  input  logic [31:0] paddr,
  input  logic [31:0] pwdata,
  input  logic [3:0]  pstrb,
  input  logic [2:0]  pprot,
  output logic        pready,
  output logic [31:0] prdata,
  output logic        pslverr);
  int waits = 0;
  bit ready_in_setup = 0, hang = 0, err_on = 1, priv_ctrl = 0, trace = 0;
  bit act_every_cycle = 0, late_rdata = 0, err_early = 0, ignore_strobes = 0, ignore_psel = 0;

  logic [7:0]  mem [0:255];
  logic [31:0] ctrl = 0, wcount = 0;
  logic [31:0] fifo [0:15];
  int          fhead = 0, fcount = 0;
  int          wcnt = 0;                  // wait cycles spent in this access
  logic [31:0] prdata_q = 0;
  initial for (int i = 0; i < 256; i++) mem[i] = 0;

  localparam int RAM = 0, CTRL = 1, STATUS = 2, WCOUNT = 3, FIFO = 4, ID = 5, NONE = 6;
  function automatic int region(input logic [11:0] a);
    if (a < 12'h100) region = RAM;
    else if (a[11:2] == 10'h040) region = CTRL;
    else if (a[11:2] == 10'h041) region = STATUS;
    else if (a[11:2] == 10'h042) region = WCOUNT;
    else if (a[11:2] == 10'h043) region = FIFO;
    else if (a[11:2] == 10'h044) region = ID;
    else region = NONE;
  endfunction
  function automatic bit bad(input logic wr, input logic [11:0] a, input logic [2:0] prot);
    int r;
    r = region(a);
    bad = (r == NONE) || (a[1:0] != 0) || (wr && (r == STATUS || r == WCOUNT || r == ID))
          || (priv_ctrl && r == CTRL && !prot[0]);
  endfunction
  function automatic logic [31:0] value(input logic [11:0] a);
    case (region(a))
      RAM:     value = {mem[{a[7:2], 2'd3}], mem[{a[7:2], 2'd2}], mem[{a[7:2], 2'd1}], mem[{a[7:2], 2'd0}]};
      CTRL:    value = ctrl;
      STATUS:  value = fcount;
      WCOUNT:  value = wcount;
      FIFO:    value = fcount > 0 ? fifo[fhead] : 32'h0;
      ID:      value = 32'h41504234;
      default: value = 32'h0;
    endcase
  endfunction

  wire sel    = ignore_psel ? 1'b1 : (psel === 1'b1);
  wire access = sel && (penable === 1'b1);
  wire err    = err_on && bad(pwrite, paddr[11:0], pprot);
  assign pready  = hang ? 1'b0 : (!access ? (ready_in_setup ? 1'b1 : 1'b0) : (wcnt >= waits));
  wire done   = access && pready;
  assign pslverr = err_early ? (sel && !done && err) : (done && err);
  // The read value is taken at the setup edge (PSEL 1, PENABLE 0) and held on PRDATA until the next
  // read, the way most register blocks do it (the bus multiplexor decides who is heard);
  // late_rdata registers it at completion instead.
  logic [31:0] rdata_r = 0;
  always @(posedge pclk) if (sel && penable !== 1'b1 && pwrite === 1'b0) rdata_r <= value(paddr[11:0]);
  assign prdata  = late_rdata ? prdata_q : rdata_r;
  wire act    = act_every_cycle ? sel : done;

  always @(posedge pclk or negedge presetn) begin
    if (!presetn) begin
      ctrl <= 0; wcount <= 0; wcnt <= 0;
    end else begin
      wcnt <= (access && !pready) ? wcnt + 1 : 0;
      if (done && !pwrite) prdata_q <= value(paddr[11:0]);
      if (act && !err) begin
        if (pwrite) begin
          wcount <= wcount + 1;
          case (region(paddr[11:0]))
            RAM:  for (int l = 0; l < 4; l++) if (pstrb[l] || ignore_strobes) mem[{paddr[7:2], 2'b00} + l] <= pwdata[8*l +: 8];
            CTRL: for (int l = 0; l < 4; l++) if (pstrb[l] || ignore_strobes) ctrl[8*l +: 8] <= pwdata[8*l +: 8];
            FIFO: if (fcount < 16) begin fifo[(fhead + fcount) % 16] <= pwdata; fcount <= fcount + 1; end
            default: ;
          endcase
          if (trace) $display("  %0s e%0d: write 0x%03h <= 0x%08h strb=%b", NAME, ($time - 5) / 10, paddr[11:0], pwdata, pstrb);
        end else begin
          if (region(paddr[11:0]) == FIFO && fcount > 0) begin fhead <= (fhead + 1) % 16; fcount <= fcount - 1; end
          if (trace) $display("  %0s e%0d: read 0x%03h -> 0x%08h", NAME, ($time - 5) / 10, paddr[11:0], value(paddr[11:0]));
        end
      end else if (act && trace) $display("  %0s e%0d: error, %0s 0x%03h ignored", NAME, ($time - 5) / 10, pwrite ? "write" : "read", paddr[11:0]);
    end
  end
endmodule
Read included file: apb_checker.sv
`timescale 1ns/1ns
// apb_checker.sv: the rules of an APB interface, checked at every rising edge (read-only).
//   reset        PSEL is 1 while PRESETn is low;
//   known        PSEL is x, or a control signal, a strobed write byte or PREADY in access is x;
//   setup        PENABLE is 1 without a setup cycle (PSEL 1, PENABLE 0) before it;
//   setup_len    a setup cycle not followed by an access cycle;
//   stable       PSEL, PADDR, PWRITE, PPROT, PSTRB or the write data changed inside a transfer,
//                or PSEL or PENABLE dropped before PREADY;
//   enable_drop  PENABLE still 1 in the cycle after a completed transfer;
//   strb_read    PSTRB not zero during a read;
//   onehot       more than one PSELx at once;
//   timeout      no PREADY after TIMEOUT wait cycles (a liveness watchdog, not a protocol rule).
// A NOTE (not a broken rule): PSLVERR is 1 outside the completion cycle, which the spec allows
// and recommends against (IHI 0024E 3.4).
module apb_checker #(parameter int NSEL = 1, parameter int TIMEOUT = 16) (
  input logic            pclk,
  input logic            presetn,
  input logic [NSEL-1:0] psel,
  input logic            penable,
  input logic            pwrite,
  input logic [31:0]     paddr,
  input logic [31:0]     pwdata,
  input logic [3:0]      pstrb,
  input logic [2:0]      pprot,
  input logic            pready,
  input logic            pslverr);
  int broken = 0, notes = 0, writes = 0, reads = 0, waits = 0, edge_n = -1, stall = 0;
  logic            p_any = 0, p_en = 0, p_rdy = 0, p_wr = 0;
  logic [NSEL-1:0] p_sel = 0;
  logic [31:0]     p_addr = 0, p_wdata = 0;
  logic [3:0]      p_strb = 0;
  logic [2:0]      p_prot = 0;
  task automatic report(input string rule, input string msg);
    broken++;
    $display("RULE %0s broken at edge %0d: %0s", rule, edge_n, msg);
  endtask
  task automatic note(input string rule, input string msg);
    notes++;
    $display("NOTE %0s at edge %0d: %0s", rule, edge_n, msg);
  endtask
  always @(posedge pclk) begin
    logic any, en, rdy, bytes_x;
    edge_n = edge_n + 1;
    any = (|psel) === 1'b1; en = (penable === 1'b1); rdy = (pready === 1'b1);
    if (presetn !== 1'b1) begin
      if (any) report("reset", "PSEL is 1 while PRESETn is low");
      any = 0; en = 0;
    end else begin
      bytes_x = 0;
      for (int l = 0; l < 4; l++) if (pstrb[l] === 1'b1 && (^pwdata[8*l +: 8]) === 1'bx) bytes_x = 1;
      if ((^psel) === 1'bx) report("known", "PSEL is x");
      else if (any && (^{paddr, pwrite, penable, pstrb, pprot}) === 1'bx) report("known", "a control signal is x while PSEL is 1");
      else if (any && pwrite === 1'b1 && bytes_x) report("known", "a strobed byte of PWDATA is x");
      else if (any && en && pready === 1'bx) report("known", "PREADY is x in an access cycle");
      if (any && en && !(p_any && (!p_en || !p_rdy)))
        report("setup", "PENABLE is 1 without a setup cycle (PSEL 1, PENABLE 0) before it");
      if (p_any && !p_en && !(any && en))
        report("setup_len", "the setup cycle was not followed by an access cycle");
      if (p_any && (!p_en || !p_rdy) && any) begin
        if (psel !== p_sel) report("stable", $sformatf("PSEL changed from %b to %b inside a transfer", p_sel, psel));
        if (paddr !== p_addr) report("stable", $sformatf("PADDR changed from 0x%0h to 0x%0h inside a transfer", p_addr, paddr));
        if (pwrite !== p_wr) report("stable", "PWRITE changed inside a transfer");
        if (pprot !== p_prot) report("stable", "PPROT changed inside a transfer");
        if (pstrb !== p_strb) report("stable", "PSTRB changed inside a transfer");
        if (p_wr && pwdata !== p_wdata) report("stable", $sformatf("PWDATA changed from 0x%0h to 0x%0h inside a transfer", p_wdata, pwdata));
        if (p_en && !en) report("stable", "PENABLE dropped before PREADY");
      end
      if (p_any && p_en && !p_rdy && !any) report("stable", "PSEL dropped before PREADY");
      if (p_any && p_en && p_rdy && en) report("enable_drop", "PENABLE is still 1 in the cycle after a completed transfer");
      if (any && pwrite === 1'b0 && pstrb !== 4'b0000) report("strb_read", $sformatf("PSTRB is %b during a read", pstrb));
      if ($countones(psel) > 1) report("onehot", $sformatf("PSELx is %b: two completers selected", psel));
      if (any && en && rdy) begin
        if (pwrite === 1'b1) writes++; else reads++;
        stall = 0;
      end else if (any && en) begin
        waits++; stall++;
        if (stall == TIMEOUT) report("timeout", $sformatf("no PREADY after %0d wait cycles", TIMEOUT));
      end
      if (pslverr === 1'b1 && !(any && en && rdy))
        note("pslverr", "PSLVERR is 1 outside the completion cycle (ignored by the requester; recommended LOW)");
    end
    p_any = any; p_en = en; p_rdy = rdy; p_sel = psel; p_addr = paddr; p_wr = (pwrite === 1'b1);
    p_wdata = pwdata; p_strb = pstrb; p_prot = pprot;
  end
  final $display("checker: %0d writes, %0d reads, %0d wait edges, %0d rules broken, %0d notes", writes, reads, waits, broken, notes);
endmodule
Read included file: apb_tasks.svh
// apb_tasks.svh: the requester side of the bench, as tasks for the stimulus (read-only).
// apb_write(addr, data, strb, prot) and apb_read(addr, prot) run one transfer and leave the bus
// IDLE; q_write / q_read queue transfers and apb_run() sends the queue back to back with PSEL held
// high (ACCESS goes straight to SETUP). Each transfer prints one log line at its completion edge:
//   e3-e4 WRITE 0x0100 data=0x11223344 strb=1111 waits=0 OKAY
// (setup edge - completion edge). The result of a read is in prdata_q and pslverr_q; the results
// of a queue are in rdv[i] and errv[i]. `cycle` counts rising edges from 0.
int cycle = -1;
always @(posedge pclk) cycle = cycle + 1;
bit quiet = 0;
// Requester bugs, for the broken twins:
bit move_in_wait = 0;   // PADDR moves by 4 in the first wait cycle
bit enable_stuck = 0;   // PENABLE stays 1 into the next queued transfer (no setup cycle)
bit strb_on_read = 0;   // PSTRB = 1111 on reads
bit skip_setup   = 0;   // PSEL and PENABLE rise together
int give_up      = 24;  // the bench stops waiting after this many wait cycles
// APB5 wake-up (IHI 0024E 3.7), off by default: with wake_lead >= 0 the requester raises PWAKEUP
// wake_lead cycles before PSEL of a transfer that starts from IDLE, and lowers it after the last
// transfer of a run completes. Broken twin: wake_drop_in_wait lowers PWAKEUP in the first wait cycle.
// The wake-up request is wake_req; a bench built with wake copies it onto PWAKEUP.
int wake_lead    = -1;
bit wake_drop_in_wait = 0;
logic wake_req = 0;

logic [31:0] prdata_q = 0;
logic        pslverr_q = 0;
int          waits_q = 0;
bit          stuck_now = 0;
bit          q_wr [0:63];
logic [31:0] q_addr [0:63], q_data [0:63], rdv [0:63];
logic [3:0]  q_strb [0:63];
logic [2:0]  q_prot [0:63];
bit          errv [0:63];
int          qn = 0;

// A text waveform for the trace blocks: one line per rising edge with the values sampled there.
bit watch = 0;
int wave_edge = -1;
always @(posedge pclk) begin
  wave_edge = wave_edge + 1;
`ifdef APB_DECODER
  if (watch) $display("wave e%0d: psel=%b pselx=%b penable=%b pwrite=%b paddr=%h pwdata=%h pstrb=%b pready=%b prdata=%h pslverr=%b",
                      wave_edge, psel, pselx, penable, pwrite, paddr, pwdata, pstrb, pready, prdata, pslverr);
`else
  if (watch) $display("wave e%0d: psel=%b penable=%b pwrite=%b paddr=%h pwdata=%h pstrb=%b pready=%b prdata=%h pslverr=%b",
                      wave_edge, psel, penable, pwrite, paddr, pwdata, pstrb, pready, prdata, pslverr);
`endif
end

// One transfer: SETUP for one cycle, then ACCESS until PREADY. last = 0 keeps PSEL high for the
// next transfer.
task automatic apb_xfer(input bit wr, input logic [31:0] addr, input logic [31:0] data, input logic [3:0] strb,
                        input logic [2:0] prot, input bit last);
  int s_edge, w;
  if (wake_lead >= 0 && !psel) begin
    if (!wake_req) begin wake_req = 1; repeat (wake_lead) begin @(posedge pclk); #1; end end
  end
  paddr = addr; pwrite = wr; pwdata = wr ? data : 32'h0;
  pstrb = wr ? strb : (strb_on_read ? 4'hf : 4'h0);
  pprot = prot; psel = 1;
  s_edge = cycle + 1;
  if (skip_setup || stuck_now) penable = 1;
  else begin
    penable = 0;
    @(posedge pclk); #1 penable = 1;
  end
  stuck_now = 0;
  w = 0;
  @(posedge pclk);
  while (pready !== 1'b1 && w < give_up) begin
    w++;
    #1 if (move_in_wait && w == 1) paddr = addr + 4;
    if (wake_drop_in_wait && w == 1) wake_req = 0;
    @(posedge pclk);
  end
  prdata_q = prdata; pslverr_q = (pslverr === 1'b1); waits_q = w;
  #1;
  if (!quiet) begin
    if (w >= give_up) $display("e%0d-e%0d %0s 0x%04h no PREADY after %0d wait cycles, the bench gives up", s_edge, cycle, wr ? "WRITE" : "READ ", addr[15:0], w);
    else if (wr) $display("e%0d-e%0d WRITE 0x%04h data=0x%08h strb=%b waits=%0d %0s", s_edge, cycle, addr[15:0], data, strb, w, pslverr_q ? "PSLVERR" : "OKAY");
    else $display("e%0d-e%0d READ  0x%04h data=0x%08h waits=%0d %0s", s_edge, cycle, addr[15:0], prdata_q, w, pslverr_q ? "PSLVERR" : "OKAY");
  end
  if (last) begin
    psel = 0; penable = 0; pwrite = 0; pstrb = 0;
    if (wake_lead >= 0) wake_req = 0;
  end else begin
    penable = enable_stuck ? 1 : 0;
    stuck_now = enable_stuck;
  end
endtask

task automatic apb_write(input logic [31:0] addr, input logic [31:0] data, input logic [3:0] strb = 4'hf, input logic [2:0] prot = 3'b000);
  apb_xfer(1, addr, data, strb, prot, 1);
endtask
task automatic apb_read(input logic [31:0] addr, input logic [2:0] prot = 3'b000);
  apb_xfer(0, addr, 0, 0, prot, 1);
endtask

// The queue: transfers sent back to back by apb_run().
task automatic q_write(input logic [31:0] addr, input logic [31:0] data, input logic [3:0] strb = 4'hf, input logic [2:0] prot = 3'b000);
  q_wr[qn] = 1; q_addr[qn] = addr; q_data[qn] = data; q_strb[qn] = strb; q_prot[qn] = prot; qn++;
endtask
task automatic q_read(input logic [31:0] addr, input logic [2:0] prot = 3'b000);
  q_wr[qn] = 0; q_addr[qn] = addr; q_data[qn] = 0; q_strb[qn] = 0; q_prot[qn] = prot; qn++;
endtask
task automatic apb_run();
  for (int i = 0; i < qn; i++) begin
    apb_xfer(q_wr[i], q_addr[i], q_data[i], q_strb[i], q_prot[i], i == qn - 1);
    rdv[i] = prdata_q; errv[i] = pslverr_q;
  end
  qn = 0;
endtask

task automatic idle(input int n);
  repeat (n) @(posedge pclk);
  #1;
endtask

// The completer's RAM, by bus address (the decoder bench picks the completer from bits 13:12).
function automatic logic [7:0] ram_byte(input int unsigned a);
`ifdef APB_DECODER
  case (a[13:12]) 2'd1: ram_byte = p1.mem[a[7:0]]; 2'd2: ram_byte = p2.mem[a[7:0]]; default: ram_byte = p0.mem[a[7:0]]; endcase
`else
  ram_byte = p0.mem[a[7:0]];
`endif
endfunction
// dump(addr, n): n bytes from addr, one 32-bit word per group, lane 0 (the lowest address) first.
task automatic dump(input int unsigned addr, input int n);
  string s;
  for (int a = addr & ~3; a < addr + n; a += 4) begin
    if ((a - (addr & ~3)) % 16 == 0) begin
      if (a != (addr & ~3)) $display("%0s", s);
      s = $sformatf("0x%04h  ", a[15:0]);
    end
    s = {s, $sformatf(" %h %h %h %h ", ram_byte(a), ram_byte(a + 1), ram_byte(a + 2), ram_byte(a + 3))};
  end
  $display("%0s", s);
endtask
// fifo_fill(n, first): put n words first, first+1, ... in completer 0's FIFO before the run.
task automatic fifo_fill(input int n, input logic [31:0] first);
  for (int i = 0; i < n; i++) p0.fifo[(p0.fhead + p0.fcount + i) % 16] = first + i;
  p0.fcount = p0.fcount + n;
endtask
// regs(): completer 0's registers as one line.
task automatic regs();
  $display("regs: CTRL=0x%08h STATUS=%0d WCOUNT=%0d", p0.ctrl, p0.fcount, p0.wcount);
endtask
Read included file: amba_parity.sv
`timescale 1ns/1ns
// amba_parity.sv: odd parity, one check bit per byte of payload (read-only).
// Check bit n covers payload bits [8n+7:8n]; when W is not a multiple of 8, the top check bit covers
// the bits that are left. Odd parity means the payload byte and its check bit hold an odd number of
// ones together, so a check bit is the inverse of the XOR of its byte. For a 1-bit payload (a critical
// control signal) that makes the check bit simply the inverse of the signal.
module amba_parity #(parameter int W = 8) (
  input  logic [W-1:0]         d,
  output logic [(W+7)/8-1:0]   chk
);
  for (genvar n = 0; n < (W + 7) / 8; n++) begin : g_byte
    localparam int HI = (8 * n + 7 < W) ? 8 * n + 7 : W - 1;
    assign chk[n] = ~(^d[HI:8 * n]);
  end
endmodule

// amba_parity_check: err is 1 when en is 1 and any check bit disagrees with its payload byte.
// A check signal only has to be right in cycles where its Check Enable term is true, so en carries it.
module amba_parity_check #(parameter int W = 8) (
  input  logic [W-1:0]         d,
  input  logic [(W+7)/8-1:0]   chk,
  input  logic                 en,
  output logic                 err
);
  logic [(W+7)/8-1:0] want;
  amba_parity #(.W(W)) gen (.d(d), .chk(want));
  assign err = en && (want !== chk);
endmodule
Read included file: apb_parity_link.sv
`timescale 1ns/1ns
// apb_parity_link.sv: the wires between the requester and completer p0, with check signals (read-only).
// Each source makes the check signals of what it drives (amba_parity: odd parity per byte, a single
// inverted bit for a critical control). Each receiver recomputes them from what arrived and compares,
// but only in cycles where the signal's Check Enable term (Table 5-1) is true.
// Switches: flip_sig and flip_bit pick one wire bit; flip_edge is the edge whose sampled value is
// flipped (one cycle only); check_on = 0 turns both receivers' checks off (the twin); quiet = 1
// counts errors without printing them.
//   flip_sig: 0 PADDR, 1 PWRITE, 2 PSEL, 3 PENABLE, 4 PWDATA, 5 PSTRB, 6 PREADY, 7 PRDATA, 8 PSLVERR
// A detected error is printed and counted; what to do next is left to the system (5.4).
module apb_parity_link (
  input  logic        pclk, presetn,
  input  logic        psel, penable, pwrite,          // from the requester
  input  logic [31:0] paddr, pwdata,
  input  logic [3:0]  pstrb,
  input  logic [2:0]  pprot,
  output logic        psel_c, penable_c, pwrite_c,    // to the completer, as they arrive
  output logic [31:0] paddr_c, pwdata_c,
  output logic [3:0]  pstrb_c,
  output logic [2:0]  pprot_c,
  input  logic        pready_c, pslverr_c,            // from the completer
  input  logic [31:0] prdata_c,
  output logic        pready, pslverr,                // to the requester, as they arrive
  output logic [31:0] prdata);
  int flip_sig = -1, flip_bit = 0, flip_edge = -1;
  bit check_on = 1, quiet = 0;
  int errors = 0, cycle = -1;
  always @(posedge pclk) cycle = cycle + 1;
  wire        flip  = (cycle + 1 == flip_edge);
  wire [31:0] fmask = 32'h1 << flip_bit;
  // ---- the source side makes the check signals from the clean values ----
  logic [3:0] paddrchk, pwdatachk, prdatachk;
  logic       pselchk, penablechk, pstrbchk, preadychk, pslverrchk;
  amba_parity #(32) g_addr (.d(paddr), .chk(paddrchk));
  amba_parity #(1)  g_sel  (.d(psel), .chk(pselchk));
  amba_parity #(1)  g_en   (.d(penable), .chk(penablechk));
  amba_parity #(32) g_wd   (.d(pwdata), .chk(pwdatachk));
  amba_parity #(4)  g_st   (.d(pstrb), .chk(pstrbchk));
  amba_parity #(1)  g_rdy  (.d(pready_c), .chk(preadychk));
  amba_parity #(32) g_rd   (.d(prdata_c), .chk(prdatachk));
  amba_parity #(1)  g_err  (.d(pslverr_c), .chk(pslverrchk));
  // PCTRLCHK is one bit over PPROT, PWRITE and PNSE (absent here, so assumed LOW).
  logic pctrl_tx;
  assign pctrl_tx = ~(^{pprot, pwrite});
  // ---- the wires, with the injected fault ----
  assign paddr_c   = paddr ^ ((flip && flip_sig == 0) ? fmask : 32'h0);
  assign pwrite_c  = pwrite ^ (|((flip && flip_sig == 1) ? fmask : 32'h0));
  assign psel_c    = psel ^ (|((flip && flip_sig == 2) ? fmask : 32'h0));
  assign penable_c = penable ^ (|((flip && flip_sig == 3) ? fmask : 32'h0));
  assign pwdata_c  = pwdata ^ ((flip && flip_sig == 4) ? fmask : 32'h0);
  assign pstrb_c   = pstrb ^ 4'(((flip && flip_sig == 5) ? fmask : 32'h0));
  assign pprot_c   = pprot;
  assign pready    = pready_c ^ (|((flip && flip_sig == 6) ? fmask : 32'h0));
  assign prdata    = prdata_c ^ ((flip && flip_sig == 7) ? fmask : 32'h0);
  assign pslverr   = pslverr_c ^ (|((flip && flip_sig == 8) ? fmask : 32'h0));
  // what each receiver recomputes from the values that arrived
  logic [3:0] paddr_r, pwdata_r, prdata_r;
  amba_parity #(32) r_addr (.d(paddr_c), .chk(paddr_r));
  amba_parity #(32) r_wd   (.d(pwdata_c), .chk(pwdata_r));
  amba_parity #(32) r_rd   (.d(prdata), .chk(prdata_r));
  // ---- the receivers ----
  task automatic bad(input string name);
    errors++;
    if (!quiet) $display("parity e%0d: %0s does not match", cycle, name);
  endtask
  always @(posedge pclk) if (check_on) begin
    // the completer checks the request
    if (presetn && (~psel_c) !== pselchk) bad("PSELCHK");
    if (psel_c) begin
      if (~(^{pprot_c, pwrite_c}) !== pctrl_tx) bad("PCTRLCHK");
      if (paddr_r !== paddrchk) bad("PADDRCHK");
      if ((~penable_c) !== penablechk) bad("PENABLECHK");
      if (pwrite_c) begin
        if (pwdata_r !== pwdatachk) bad("PWDATACHK");
        if (~(^pstrb_c) !== pstrbchk) bad("PSTRBCHK");
      end
    end
    // the requester checks the response
    if (psel && penable && (~pready) !== preadychk) bad("PREADYCHK");
    if (psel && penable && pready_c) begin
      if ((~pslverr) !== pslverrchk) bad("PSLVERRCHK");
      if (!pwrite && prdata_r !== prdatachk) bad("PRDATACHK");
    end
  end
  final if (!quiet) $display("parity: %0d check errors", errors);
endmodule
ConceptWhich signals does PCTRLCHK cover?
ConceptA write has PSTRB 0001: only byte 0 of PWDATA is valid. What must PWDATACHK carry for bytes 1 to 3?
ConceptA completer detects a PWDATACHK error. What does the APB specification require it to do?

Common Mistakes

Wrong Use even parity because most parity examples do.

APB5 check signals use odd parity, so an even-parity receiver reports every correct byte as wrong.

Fix Make each check bit the inverse of the XOR of its byte.

Before
assign chk[n] = ^pwdata[8*n +: 8];
After
assign chk[n] = ~^pwdata[8*n +: 8];

Wrong Check PWDATACHK in every cycle where PSEL is high.

During reads PWDATACHK has no rule, so the checker reports errors that are not there.

Fix Check each signal only under its Check Enable term: PSEL and PWRITE for PWDATACHK.

Wrong Compute PWDATACHK only over the strobed bytes.

Every bit of PWDATACHK must be correct, including bytes the strobes leave out.

Fix Compute one check bit for every byte of PWDATA on every write.

Remember

  • APB5 parity is odd, with one check bit per byte, and a single inverted bit for critical controls.
  • A check signal must be right only while its Check Enable term is true.
  • PSELxCHK and PWAKEUPCHK are checked whenever PRESETn is high, not only during transfers.
  • One flip per group is caught; two flips in one byte are not.
  • What to do on an error is the system's choice; detection alone does not repair the data.

Practice

Report a problem with this page