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.
- Manager
- Subordinate
Check bit n covers byte n. Lane 1 is the second bit from the right.
- Cycle 0
Setup: every byte of 11223344 has an even number of ones, so every check bit is 1.
- 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.
- 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.
| Rule | Meaning |
|---|---|
| Odd parity | A payload byte and its check bit hold an odd number of ones together. |
| At most 8 bits per check bit | Check bit n covers payload bits 8n+7 to 8n; a partial top byte gets the last check bit. |
| Critical controls get one bit | The check bit is simply the inverse of the signal, such as PSELxCHK = !PSELx. |
| Driven in every Check Enable cycle | Every bit, even of a byte the strobes say is unused. |
| Missing signals are LOW | If 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 signal | Covers | Must be right when |
|---|---|---|
| PADDRCHK | PADDR, one bit per byte | PSEL |
| PCTRLCHK | PPROT, PWRITE and PNSE, one bit | PSEL |
| PSELxCHK | PSELx, one per completer | PRESETn |
| PENABLECHK | PENABLE | PSEL |
| PWDATACHK, PSTRBCHK | PWDATA per byte; PSTRB in one bit | PSEL and PWRITE |
| PREADYCHK | PREADY | PSEL and PENABLE |
| PRDATACHK | PRDATA per byte | PSEL, PENABLE, PREADY and not PWRITE |
| PSLVERRCHK | PSLVERR | PSEL, PENABLE and PREADY |
| PWAKEUPCHK | PWAKEUP | PRESETn |
| PAUSERCHK, PWUSERCHK | the request user signals | PSEL; PSEL and PWRITE |
| PRUSERCHK, PBUSERCHK | the response user signals | as 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
Is APB5 parity odd or even?
Odd: a byte and its check bit always hold an odd number of ones together.
What is PSELxCHK?
The inverse of PSELx, one per completer, which must be right whenever PRESETn is high.
Can parity catch two flipped bits?
Only if they sit in different check groups. Two flips in one byte cancel out.
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.
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 notesRead 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
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.
assign chk[n] = ^pwdata[8*n +: 8];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.