Management Counters and Status
A port counts its frames, its bad blocks and its corrected codewords. Some status bits hold bad news until someone reads them. See what each read returns.
You Will Be Able To
- Name the counters a received frame moves, and the frames that move none.
- Explain latching-low and latching-high status bits.
- Tell counters that wrap from counters that stop and clear when read.
- Read a 32-bit FEC counter through two 16-bit registers.
- Lesson
- P11.40
- Time
- 45 min
- Runs on
- Your browser
- Check
- 5 questions
A link drops for a millisecond at night. By morning it is up again.
The port remembers. In the bench, the first read after the drop still says "down".
- Cycle 0
All is well. Register 3.1 reads 0004h: the link bit is 1.
- Cycle 1
Block lock is lost. Nobody reads anything.
- Cycle 2
Block lock is back. The fault is over.
- Cycle 3
Register 3.32 shows the present state: the link is up.
- Cycle 4
Register 3.1 still says "down". The bit kept the bad news for this read.
- Cycle 5
The second read gives the present state: up. The fault bit is still 1.
- Cycle 6
The fault itself is latched in register 3.8. This read returns it and lets it go.
- Cycle 7
Now register 3.1 is clean again.
Bench run of a private model of the statistics block (p1140.latch). The bits are 3.1.2, 3.32.12, 3.1.7 and 3.8.10. The model leaves out the device-present and ability bits of registers 3.1 and 3.8.
Where the Numbers Live
- Datapath
- Control / FSM
- Neutral
- Storage
- Manager
- Structure
- Transaction / TLM
- MAC
The MAC gives every frame a status and updates its counters. They have names in Clause 30.
- MAC Control
The sublayer above counts control frames a second time, in counters of its own.
- PCS
The PCS keeps status bits and two small error counters in MDIO device 3.
- FEC
The decoder counts codewords and symbols in MDIO device 1.
- Station
One management station reads all of them and works out what happened.
Read the diagram as text
- MAC: frames sent and received
- MAC Control: control and PAUSE frames
- PCS: link status, bad blocks
- FEC: codewords, symbols
- Attributes: Clause 30 names
- MDIO registers: Clause 45 addresses
- Station: reads and compares
- MAC → Attributes: 5.2.4
- MAC Control → Attributes: 30.3.3
- PCS → MDIO registers: device 3
- FEC → MDIO registers: device 1
- Attributes → Station: get
- MDIO registers → Station: read
Our own drawing after IEEE Std 802.3-2022 30.1, 30.3 and 45.2. A teaching model: no real PHY pairs this PCS with this FEC.
Every layer of a port keeps numbers about itself.
Clause 30 gives each one a name, such as aFramesReceivedOK. These names are called attributes.
For the MAC, Clause 5 says in code when each counter moves (5.2.4).
For a PHY, Clause 45 says where each number sits: a register of an MDIO device (P11.16).
This lesson uses a teaching model of a port. It puts a 10GBASE-R PCS (Clause 49) beside a four-lane Clause 91 RS-FEC.
No real PHY has this pair: Clause 91 belongs to 100GBASE-R (P11.32).
The model shows both kinds of register in one place.
One Frame, One Status, Several Counters
P11.8 gave every received frame one status. The counters follow from it (5.2.4.3).
| Received frame | Counters that move |
|---|---|
| Good, 64 octets, for this station | aFramesReceivedOK, aOctetsReceivedOK + 46 |
| Good, 1,518 octets, broadcast | aFramesReceivedOK, aOctetsReceivedOK + 1,500, aBroadcastFramesReceivedOK |
| Good, 100 octets, a listed group address | aFramesReceivedOK, aOctetsReceivedOK + 82, aMulticastFramesReceivedOK |
| 300 octets, bad FCS | aFrameCheckSequenceErrors |
| 1,519 octets, good FCS | aFrameTooLongErrors |
| 1,519 octets, bad FCS | aFrameTooLongErrors |
| Length 100, but 200 data octets | aInRangeLengthErrors |
| Length/Type 1,510 | aOutOfRangeLengthField |
Bench run of a private model (p1140.frames). Each counter moves by 1 unless a number is given. The updates are those of 5.2.4.3.
A good frame moves at least two counters: one for frames, one for octets.
The octet counter adds the data and pad octets only. That is the frame without its 18 octets of header and FCS.
A broadcast or a group address moves a third counter.
A bad frame moves one error counter and nothing else. Its octets are not counted.
A frame can be too long and have a bad FCS. It still moves one counter only: aFrameTooLongErrors.
On this port a frame never has extra bits. So aAlignmentErrors cannot move (30.3.1.1.7).
Frames That Move Nothing
Two kinds of frame get no status at all. So no counter moves.
| Received frame | Normal mode | Promiscuous mode |
|---|---|---|
| 100 octets, for another station | none | aFramesReceivedOK, aOctetsReceivedOK + 82 |
| The same, with a bad FCS | none | aFrameCheckSequenceErrors |
| 60 octets, for this station | none | none |
Bench run of a private model (p1140.frames).
The first kind is a frame for another station. The address is tested before the size, the FCS and the length (4.2.9).
Promiscuous mode switches the address test off. Then such frames count like your own (30.3.1.1.16).
The second kind is a fragment: fewer than 64 octets. The MAC drops it as the rest of a collision (4.2.4.2.2).
MAC Control Counts a Second Time
A PAUSE frame is an ordinary frame to the MAC (P11.10). Its type is 8808h.
The MAC counts it like any good frame. Then the MAC Control sublayer counts it again (30.3.3, 30.3.4).
| Frame | MAC counters | MAC Control counters |
|---|---|---|
| Received: a PAUSE frame | aFramesReceivedOK, aOctetsReceivedOK + 46, aMulticastFramesReceivedOK | aMACControlFramesReceived, aPAUSEMACCtrlFramesReceived |
| Received: a PFC frame | aFramesReceivedOK, aOctetsReceivedOK + 46, aMulticastFramesReceivedOK | aMACControlFramesReceived, aUnsupportedOpcodesReceived |
| Received: a PAUSE frame, bad FCS | aFrameCheckSequenceErrors | none |
| Sent: a PAUSE frame | aFramesTransmittedOK, aOctetsTransmittedOK + 46, aMulticastFramesXmittedOK | aMACControlFramesTransmitted, aPAUSEMACCtrlFramesTransmitted |
Bench run of a private model (p1140.frames). This model port supports the PAUSE opcode only.
So one received PAUSE frame moves 5 counters.
Its one legal address is a group address (31B.3.1), so it also counts as multicast.
A control frame with an opcode the device does not support moves aUnsupportedOpcodesReceived (30.3.3.5).
How Long Does a Counter Last?
A MAC counter is 32 bits wide in the code of 5.2.4.4. At the top it wraps to zero and counts on.
A read changes nothing. Clause 30 calls it a nonresettable counter.
At 10 Gb/s a port can receive 14,880,952 short frames a second. A 32-bit frame counter then wraps after 288.6 s.
The octet counter is faster. With long frames it wraps after 3.52 s, and at 100 Gb/s after 0.352 s.
So the station must read often and subtract. The difference is right if the counter wrapped at most once.
With 64 bits, the octet counter at 100 Gb/s lasts 48 years. Real designs often use wider counters.
In the bench an 8-bit counter shows the wrap: after 255 frames it reads 255, after 256 it reads 0.
Status Bits That Remember
A status bit shows a state. But a station reads it only now and then, and a short fault could slip by.
So some bits are latching (45.2).
A latching low bit goes to 0 when the bad state occurs. It stays 0 until it has been read.
A latching high bit does the same with 1.
After the read, the bit takes the present state.
| Bit | Name | Kind | It follows |
|---|---|---|---|
| 3.32.12 | receive link status | live | block lock and no high BER |
| 3.1.2 | PCS receive link status | latching low | bit 3.32.12 |
| 3.8.10 | receive fault | latching high | the inverse of that status |
| 3.1.7 | fault | a mirror | bits 3.8.11 and 3.8.10 |
| 3.33.15 | latched block lock | latching low | bit 3.32.0 |
| 3.33.14 | latched high BER | latching high | bit 3.32.1 |
IEEE Std 802.3-2022 45.2.3.2, 45.2.3.7, 45.2.3.15, 45.2.3.16 and 49.2.14.1, for a 10GBASE-R PCS.
Bit 3.1.7 is different. It has no memory of its own: it reads as the fault bits of register 3.8 would.
So reading register 3.1 does not clear it. Reading register 3.8 does.
When the Fault Stays
After a read, a latched bit does not go back to "good". It goes to the present state.
| Event | Value read | Link bit 3.1.2 | Latched block lock 3.33.15 |
|---|---|---|---|
| Block lock is lost and stays lost | |||
| read 3.1 | 0080h | 0 | |
| read 3.1 | 0080h | 0 | |
| read 3.33 | 0000h | 0 | |
| read 3.33 | 0000h | 0 | |
| Block lock is back | |||
| read 3.1 | 0080h | 0 | |
| read 3.1 | 0084h | 1 | |
| read 3.33 | 0000h | 0 | |
| read 3.33 | 8000h | 1 |
Bench run of a private model (p1140.latch), after the timeline at the top of the page.
Here block lock stays lost. Every read of register 3.1 returns 0 in bit 2.
Then the lock comes back. The next read still returns 0: the bit holds the bad state from before.
Only the read after that returns 1.
Counters That Stop, and Clear When Read
The PCS has two small counters in register 3.33 (49.2.14.2).
The BER counter has 6 bits. It counts the bad sync headers that the BER monitor of P11.24 sees.
The errored blocks counter has 8 bits. It counts blocks that the receiver had to turn into errors.
They stop at the top, in a PCS without the wider counters of registers 3.44 and 3.45.
A read of register 3.33 sets both back to zero.
| Counter | Width | At the top | When read | Clause |
|---|---|---|---|---|
| MAC counters | 32 bits | wrap to zero | nothing changes | 5.2.4.4, 30.3.1 |
| BER counter, 3.33.13:8 | 6 bits | stop at 63 | cleared | 49.2.14.2 |
| Errored blocks, 3.33.7:0 | 8 bits | stop at 255 | cleared | 49.2.14.2 |
| FEC counters, 1.202 to 1.217 | 32 bits | stop at all ones | cleared | 45.2.1.118 |
IEEE Std 802.3-2022. The MAC width is that of the counter procedures of 5.2.4.4.
In the bench, 260 errored blocks leave the counter at 255. The next read returns 0.
One read of register 3.33 clears all of it: both counters and both latched bits.
A 32-Bit Counter in Two Registers
P11.32 showed what the RS-FEC decoder counts: corrected codewords, uncorrected codewords, and symbol errors on each lane.
Each of these counters has 32 bits. An MDIO register has 16. So each counter is read as two registers (45.2.1.118).
The station reads the lower register first.
It returns the lower half, holds the upper half, and clears the counter.
A read of the upper register then returns the held half.
In the bench the counter stands at 196,613. Register 1.202 reads 0005h.
Then 131,073 more codewords are corrected. Register 1.203 still reads 0003h.
So the two halves belong to the same instant, and nothing is counted twice.
These counters stop at all ones. They count only while the FEC lanes are aligned (91.6.16).
What a Checker Must Remember
To verify a statistics block, you predict every value it returns. That needs a second copy of its state.
Reads come in three kinds. A MAC attribute changes nothing when read.
A PCS register clears its counters, and its latched bits take the present state.
A lower FEC register clears its counter and loads the held half.
So the order of reads matters, and a check at the end of a run is not enough.
Try It
eth_mgmt_view is the station's side. It names the fields of the values it reads.
Register 3.32 is live: 1001h is block lock, no high BER, link up.
Register 3.1 with 0080h has bit 2 low and bit 7 high: the link was down at some time.
Register 3.33 with 4305h packs four things: two latched bits, a BER count of 3 and 5 errored blocks.
frames_per_s adds 20 octets to each frame: preamble, SFD and gap. That gives 14,880,952 short frames a second.
wrap_s divides the size of the counter by that rate.
The task good is a small tally. It counts three frames that are known to be good.
The octets grow by 46, 1,500 and 46. The third frame is a PAUSE frame, so three more counters move.
Which frame is good at all is not in the readable library. That is the practice problem.
Change the rate to 25 Gb/s. Predict the wrap time of the octet counter.
3.32 = 1001: block lock 1, high BER 0, receive link 1 3.1 = 0004: receive link up, fault 0 3.1 = 0080: receive link down or was down, fault 1 3.8 = 0400: receive fault seen 3.33 = 4305: block lock was lost, high BER was seen, BER count 3, errored blocks 5 10 Gb/s, frames of 64 octets: 14880952 frames a second a 32-bit frame counter wraps after 288.6 s 10 Gb/s, frames of 1518 octets: 1219115735 data octets a second a 32-bit octet counter wraps after 3.52 s at 100 Gb/s it wraps after 0.352 s a 64-bit octet counter at 100 Gb/s lasts 48 years three good frames: frames 3, octets 1592, multicast 1, MAC Control 1, PAUSE 1Read included file: hs_pkg.sv
`timescale 1ns/1ns
// hs_pkg.sv: shared pure functions, and the bench random generator (read-only).
package hs_pkg;
// xorshift32 (Marsaglia 2003): a linear generator over GF(2), period 2^32 - 1. A zero state is
// replaced by 1, because zero maps to itself.
function automatic [31:0] xs32(input [31:0] s);
reg [31:0] x;
x = (s == 32'd0) ? 32'd1 : s;
x = x ^ (x << 13); x = x ^ (x >> 17); x = x ^ (x << 5);
return x;
endfunction
// A Fibonacci PRBS generator x^n + x^m + 1 (PRBS7: 7,6; PRBS9: 9,5; PRBS15: 15,14; PRBS23: 23,18;
// PRBS31: 31,28). The output bit is s[n-1]; the next state shifts the feedback into bit 0.
function automatic [31:0] prbs_next(input [31:0] s, input int n, input int m);
reg fb;
fb = s[n-1] ^ s[m-1];
return ((s << 1) | {31'd0, fb}) & ((n == 32) ? 32'hffffffff : ((32'd1 << n) - 32'd1));
endfunction
function automatic int ones(input [63:0] v);
int n; n = 0;
for (int i = 0; i < 64; i++) n += v[i];
return n;
endfunction
// GF(16) with x^4 + x + 1, and GF(1024) with x^10 + x^3 + 1: shift-and-add multiply, no tables.
function automatic [3:0] gf16_mul(input [3:0] a, input [3:0] b);
reg [3:0] p, x; p = 4'd0; x = a;
for (int i = 0; i < 4; i++) begin
if (b[i]) p = p ^ x;
x = x[3] ? ({x[2:0], 1'b0} ^ 4'b0011) : {x[2:0], 1'b0};
end
return p;
endfunction
function automatic [3:0] gf16_pow(input int e); // alpha^e, alpha = x
reg [3:0] p; int k; p = 4'd1; k = e % 15; if (k < 0) k += 15;
for (int i = 0; i < k; i++) p = gf16_mul(p, 4'd2);
return p;
endfunction
function automatic int gf16_log(input [3:0] a); // -1 for 0
reg [3:0] p; p = 4'd1;
if (a == 4'd0) return -1;
for (int i = 0; i < 15; i++) begin if (p == a) return i; p = gf16_mul(p, 4'd2); end
return -1;
endfunction
function automatic [9:0] gf1024_mul(input [9:0] a, input [9:0] b);
reg [9:0] p, x; p = 10'd0; x = a;
for (int i = 0; i < 10; i++) begin
if (b[i]) p = p ^ x;
x = x[9] ? ({x[8:0], 1'b0} ^ 10'b0000001001) : {x[8:0], 1'b0};
end
return p;
endfunction
function automatic [9:0] gf1024_pow(input int e);
reg [9:0] p; int k; p = 10'd1; k = e % 1023; if (k < 0) k += 1023;
for (int i = 0; i < k; i++) p = gf1024_mul(p, 10'd2);
return p;
endfunction
endpackage
// hs_rng: the bench's random numbers. Same seed, same numbers, on every engine.
module hs_rng;
int unsigned s = 32'h2545f491;
function automatic void seed(input int unsigned v); s = (v == 0) ? 32'd1 : v; endfunction
function automatic int unsigned next(); s = hs_pkg::xs32(s); return s; endfunction
function automatic int below(input int n); s = hs_pkg::xs32(s); return (n <= 0) ? 0 : int'(s % n); endfunction
function automatic bit bit1(); s = hs_pkg::xs32(s); return s[16]; endfunction
function automatic bit chance_ppm(input int ppm); s = hs_pkg::xs32(s); return (s % 1000000) < ppm; endfunction
function automatic [7:0] byte8(); s = hs_pkg::xs32(s); return s[23:16]; endfunction
endmodule
Read included file: hs_code.sv
`timescale 1ns/1ns
// hs_code.sv: line codes, CRCs and scramblers (read-only).
// ---------------------------------------------------------------------------------------------
// hs_8b10b: 8b/10b encoder and decoder with running disparity and the 12 K codes.
// code[9:0] = {a,b,c,d,e,i,f,g,h,j}; bit a (code[9]) goes on the wire first. rd: 0 = RD-, 1 = RD+.
// encode(d, k, rd_in) -> {rd_out, code[9:0]} (11 bits)
// decode(code, rd_in) -> {rd_out, disp_err, code_err, k, d[7:0]} (12 bits)
// enc(d, k) / dec(code): the same, with the running disparity kept in rd_tx / rd_rx
// A K request for a byte that is not one of the 12 K codes is encoded as data and counted in bad_k.
// Decoder: code_err = the code is in neither column of the table; disp_err = it is a valid code
// only in the other column. rd_out follows the sub-block rule on the received bits.
// Faults: no_rd (always the RD- column), a7_never (never the alternate D.x.A7),
// keep_rd_on_unbalanced (the 4b sub-block is chosen with the disparity from before the 6b one),
// no_balanced_flip (D.07 and D.x.3 keep their RD- form at RD+), dec_no_disp_check.
module hs_8b10b;
bit no_rd = 0, a7_never = 0, keep_rd_on_unbalanced = 0, no_balanced_flip = 0, dec_no_disp_check = 0;
bit trace = 0;
bit rd_tx = 0, rd_rx = 0;
int bad_k = 0, symbols = 0, code_errs = 0, disp_errs = 0;
bit last_k = 0, last_code_err = 0, last_disp_err = 0;
bit valid_m [0:1023]; bit valid_p [0:1023]; bit [8:0] kd [0:1023]; bit built = 0;
function automatic [5:0] t6(input [4:0] x); // 5b/6b, RD- column, abcdei
case (x)
5'd0: return 6'b100111; 5'd1: return 6'b011101; 5'd2: return 6'b101101; 5'd3: return 6'b110001;
5'd4: return 6'b110101; 5'd5: return 6'b101001; 5'd6: return 6'b011001; 5'd7: return 6'b111000;
5'd8: return 6'b111001; 5'd9: return 6'b100101; 5'd10: return 6'b010101; 5'd11: return 6'b110100;
5'd12: return 6'b001101; 5'd13: return 6'b101100; 5'd14: return 6'b011100; 5'd15: return 6'b010111;
5'd16: return 6'b011011; 5'd17: return 6'b100011; 5'd18: return 6'b010011; 5'd19: return 6'b110010;
5'd20: return 6'b001011; 5'd21: return 6'b101010; 5'd22: return 6'b011010; 5'd23: return 6'b111010;
5'd24: return 6'b110011; 5'd25: return 6'b100110; 5'd26: return 6'b010110; 5'd27: return 6'b110110;
5'd28: return 6'b001110; 5'd29: return 6'b101110; 5'd30: return 6'b011110; default: return 6'b101011;
endcase
endfunction
function automatic [3:0] t4d(input [2:0] y); // 3b/4b data, RD- column, fghj (y = 7 is P7)
case (y)
3'd0: return 4'b1011; 3'd1: return 4'b1001; 3'd2: return 4'b0101; 3'd3: return 4'b1100;
3'd4: return 4'b1101; 3'd5: return 4'b1010; 3'd6: return 4'b0110; default: return 4'b1110;
endcase
endfunction
function automatic [3:0] t4k(input [2:0] y); // 3b/4b for K codes, RD- form before the flip
case (y)
3'd0: return 4'b1011; 3'd1: return 4'b0110; 3'd2: return 4'b1010; 3'd3: return 4'b1100;
3'd4: return 4'b1101; 3'd5: return 4'b0101; 3'd6: return 4'b1001; default: return 4'b0111;
endcase
endfunction
function automatic bit k_ok(input [7:0] d);
return d[4:0] == 5'd28 || d == 8'hf7 || d == 8'hfb || d == 8'hfd || d == 8'hfe;
endfunction
function automatic int n6(input [5:0] v); return v[0] + v[1] + v[2] + v[3] + v[4] + v[5]; endfunction
function automatic int n4(input [3:0] v); return v[0] + v[1] + v[2] + v[3]; endfunction
// running disparity at the end of a sub-block (more ones: +; more zeros: -; 000111 and 0011: +; 111000 and 1100: -)
function automatic bit rd6(input [5:0] v, input bit rd);
return (n6(v) > 3) ? 1'b1 : (n6(v) < 3) ? 1'b0 : (v == 6'b000111) ? 1'b1 : (v == 6'b111000) ? 1'b0 : rd;
endfunction
function automatic bit rd4(input [3:0] v, input bit rd);
return (n4(v) > 2) ? 1'b1 : (n4(v) < 2) ? 1'b0 : (v == 4'b0011) ? 1'b1 : (v == 4'b1100) ? 1'b0 : rd;
endfunction
// faults: [0] no_rd [1] a7_never [2] keep_rd_on_unbalanced [3] no_balanced_flip
function automatic [10:0] core(input [7:0] d, input bit k, input bit rd_in, input [3:0] f);
reg [5:0] six; reg [3:0] four; reg rd0, r6, rd1, a7, kk; reg [4:0] x; reg [2:0] y; int o6, o4;
x = d[4:0]; y = d[7:5]; kk = k && k_ok(d); rd0 = f[0] ? 1'b0 : rd_in;
six = (kk && x == 5'd28) ? 6'b001111 : t6(x); o6 = n6(six);
if (rd0 && (o6 != 3 || (six == 6'b111000 && !f[3]))) begin six = ~six; o6 = 6 - o6; end
r6 = (o6 > 3) ? 1'b1 : (o6 < 3) ? 1'b0 : (six == 6'b000111) ? 1'b1 : (six == 6'b111000) ? 1'b0 : rd0;
rd1 = f[2] ? rd0 : r6;
if (kk) begin
four = t4k(y); if (rd1) four = ~four;
end else begin
a7 = (y == 3'd7) && !f[1] && ((!rd1 && (x == 5'd17 || x == 5'd18 || x == 5'd20)) || (rd1 && (x == 5'd11 || x == 5'd13 || x == 5'd14)));
four = a7 ? 4'b0111 : t4d(y);
if (rd1 && (n4(four) != 2 || (four == 4'b1100 && !f[3]))) four = ~four;
end
o4 = n4(four);
return {(o4 > 2) ? 1'b1 : (o4 < 2) ? 1'b0 : (four == 4'b0011) ? 1'b1 : (four == 4'b1100) ? 1'b0 : r6, six, four};
endfunction
function automatic [10:0] encode(input [7:0] d, input bit k, input bit rd_in);
if (k && !k_ok(d)) bad_k++;
return core(d, k, rd_in, {no_balanced_flip, keep_rd_on_unbalanced, a7_never, no_rd});
endfunction
function automatic void build();
reg [10:0] c;
for (int i = 0; i < 1024; i++) begin valid_m[i] = 0; valid_p[i] = 0; kd[i] = 9'd0; end
for (int i = 0; i < 268; i++) begin
reg [7:0] d; reg k;
if (i < 256) begin d = i[7:0]; k = 0; end
else begin k = 1; d = (i < 264) ? {3'(i - 256), 5'd28} : (i == 264) ? 8'hf7 : (i == 265) ? 8'hfb : (i == 266) ? 8'hfd : 8'hfe; end
c = core(d, k, 1'b0, 4'd0); valid_m[c[9:0]] = 1; kd[c[9:0]] = {k, d};
c = core(d, k, 1'b1, 4'd0); valid_p[c[9:0]] = 1; kd[c[9:0]] = {k, d};
end
built = 1;
endfunction
function automatic [11:0] decode(input [9:0] code, input bit rd_in);
reg here, there, ce, de, r;
if (!built) build();
here = rd_in ? valid_p[code] : valid_m[code];
there = rd_in ? valid_m[code] : valid_p[code];
ce = !(here || there); de = !ce && !here && !dec_no_disp_check;
r = rd4(code[3:0], rd6(code[9:4], rd_in));
return {r, de, ce, ce ? 9'd0 : kd[code]};
endfunction
function automatic [9:0] enc(input [7:0] d, input bit k);
reg [10:0] r; r = encode(d, k, rd_tx); rd_tx = r[10];
if (trace) $display("s%0d TX %s%0d.%0d code=%b rd=%s", symbols, (k && k_ok(d)) ? "K" : "D", d[4:0], d[7:5], r[9:0], r[10] ? "+" : "-");
symbols++;
return r[9:0];
endfunction
function automatic [8:0] dec(input [9:0] code);
reg [11:0] r; r = decode(code, rd_rx); rd_rx = r[11];
last_disp_err = r[10]; last_code_err = r[9]; last_k = r[8];
if (r[9]) code_errs++; if (r[10]) disp_errs++;
if (trace && (r[9] || r[10])) $display("RX %b %s", code, r[9] ? "code error" : "disparity error");
return r[8:0];
endfunction
function automatic bit comma7(input [6:0] w); return w == 7'b0011111 || w == 7'b1100000; endfunction
endmodule
// ---------------------------------------------------------------------------------------------
// hs_crc: a CRC of 1 to 32 bits with any polynomial, seed, bit order and final inversion.
// The register shifts left; the polynomial omits the x^width term. The field is sent register bit
// width-1 first (USB 2.0, USB 3.2 and Ethernet all send it this way).
// use_crc32(), use_crc16_usb2(), use_crc5_usb2(), use_crc16_usb3(): parameter sets
// reset(), crc_bit(b), crc_byte(v), crc_bits(v, n), field(), field_bit(i), check_value(), crc_residue_ok()
// Faults: msb_first (bytes enter MSB first), no_invert (the field is not complemented), seed_zero.
module hs_crc;
int width = 32;
bit [31:0] poly = 32'h04c11db7, seed = 32'hffffffff, residue = 32'hc704dd7b;
bit lsb_first = 1, invert = 1;
bit msb_first = 0, no_invert = 0, seed_zero = 0;
bit [31:0] r = 32'hffffffff;
function automatic [31:0] mask(); return (width >= 32) ? 32'hffffffff : ((32'd1 << width) - 32'd1); endfunction
function automatic void reset(); r = seed_zero ? 32'd0 : (seed & mask()); endfunction
function automatic void set(input int w, input [31:0] p, input [31:0] s, input [31:0] res, input bit lsb, input bit inv);
width = w; poly = p; seed = s; residue = res; lsb_first = lsb; invert = inv; reset();
endfunction
function automatic void use_crc32(); set(32, 32'h04c11db7, 32'hffffffff, 32'hc704dd7b, 1, 1); endfunction
function automatic void use_crc16_usb2(); set(16, 32'h8005, 32'hffff, 32'h800d, 1, 1); endfunction
function automatic void use_crc5_usb2(); set(5, 32'h05, 32'h1f, 32'h0c, 1, 1); endfunction
function automatic void use_crc16_usb3(); set(16, 32'h100b, 32'hffff, 32'hf6aa, 1, 1); endfunction
function automatic void crc_bit(input bit b);
reg fb; fb = b ^ r[width - 1];
r = ((r << 1) ^ (fb ? poly : 32'd0)) & mask();
endfunction
function automatic void crc_byte(input [7:0] v);
for (int i = 0; i < 8; i++) crc_bit(v[(lsb_first ^ msb_first) ? i : 7 - i]);
endfunction
function automatic void crc_bits(input [31:0] v, input int n); // n bits of v, bit 0 first
for (int i = 0; i < n; i++) crc_bit(v[i]);
endfunction
function automatic [31:0] field(); return (invert && !no_invert) ? (~r & mask()) : r; endfunction
function automatic bit field_bit(input int i); reg [31:0] f; f = field(); return f[width - 1 - i]; endfunction
// the usual published "check" number: the field with its first-sent bit read as bit 0
function automatic [31:0] check_value();
reg [31:0] f, o; f = field(); o = 32'd0;
for (int i = 0; i < width; i++) o[i] = f[width - 1 - i];
return lsb_first ? o : f;
endfunction
function automatic bit crc_residue_ok(); return r == (residue & mask()); endfunction
endmodule
// ---------------------------------------------------------------------------------------------
// hs_scr: additive (frame-synchronous) and multiplicative (self-synchronising) scramblers.
// poly holds the coefficients: bit k is x^k; the +1 term is always used (taps() sets bit 0); len is the degree.
// Additive: a Galois LFSR. The key bit is s[len-1]; each step shifts left and adds the low terms of
// the polynomial when the key bit is 1. The data never enters the register.
// Multiplicative: the line bit is the data bit XOR the register bits at the polynomial's terms;
// the scrambler shifts its own output in, the descrambler shifts the received line bit in.
// scr_add(len, poly, seed), scr_mul(len, poly), use_usb3_gen1(), use_x58(), use_x23_usb3() (see its note)
// scr_bit(b), dscr_bit(b), scr_byte(v), dscr_byte(v) (bit 0 first), scr_reset(), scr_hold() (a skip
// symbol: no step), scr_unscrambled() (a symbol sent in the clear: 8 steps, data untouched)
// Faults: advance_on_skip (scr_hold steps the LFSR 8 times), no_reset (scr_reset does nothing),
// wrong_tap (the lowest term x^k becomes x^(k+1)), seed_zero (scr_reset loads 0).
module hs_scr;
bit mult = 0; int len = 16;
bit [63:0] poly = 64'h10039, seed = 64'hffff;
bit advance_on_skip = 0, no_reset = 0, wrong_tap = 0, seed_zero = 0;
bit [63:0] s = 64'hffff;
int steps = 0;
function automatic [63:0] lmask(); return (len >= 64) ? 64'hffffffffffffffff : ((64'd1 << len) - 64'd1); endfunction
function automatic [63:0] taps();
reg [63:0] p; int k; p = poly | 64'd1; k = 1;
if (wrong_tap) begin
while (k < len && !p[k]) k++;
if (k < len) begin p[k] = 1'b0; p[k + 1] = 1'b1; end
end
return p;
endfunction
function automatic void load(); s = (seed_zero ? 64'd0 : seed) & lmask(); endfunction
function automatic void scr_add(input int n, input [63:0] p, input [63:0] sd); mult = 0; len = n; poly = p; seed = sd; s = sd & lmask(); endfunction
function automatic void scr_mul(input int n, input [63:0] p); mult = 1; len = n; poly = p; seed = 64'd0; s = 64'd0; endfunction
function automatic void use_usb3_gen1(); scr_add(16, 64'h10039, 64'hffff); endfunction // x^16 + x^5 + x^4 + x^3 + 1, seed FFFFh
function automatic void use_x58(); scr_mul(58, (64'd1 << 58) | (64'd1 << 39) | 64'd1); endfunction // x^58 + x^39 + 1
// USB 3.2 Gen 2 (§6.3.2.3) polynomial x^23 + x^21 + x^16 + x^8 + x^5 + x^2 + 1 with seed 1DBFBCh. Only the
// polynomial and seed are the specification's: the register form here is this library's Galois form, and
// the reset and bypass rules of §6.3.2.3 are not modelled, so do not quote its key stream as USB's.
function automatic void use_x23_usb3(); scr_add(23, (64'd1 << 23) | (64'd1 << 21) | (64'd1 << 16) | (64'd1 << 8) | (64'd1 << 5) | (64'd1 << 2) | 64'd1, 64'h1dbfbc); endfunction
function automatic void scr_reset(); if (!no_reset) load(); endfunction
function automatic bit key(); return s[len - 1]; endfunction
function automatic void step();
reg kb; kb = s[len - 1];
s = ((s << 1) & lmask()) ^ (kb ? (taps() & lmask()) : 64'd0);
steps++;
endfunction
// the XOR of the register bits at the polynomial's terms x^1..x^len (bit k-1 of the register for x^k)
function automatic bit fbx(input [63:0] st); return ^(st & (taps() >> 1) & lmask()); endfunction
function automatic bit scr_bit(input bit b);
reg o;
if (!mult) begin o = b ^ s[len - 1]; step(); end
else begin o = b ^ fbx(s); s = ((s << 1) | {63'd0, o}) & lmask(); steps++; end
return o;
endfunction
function automatic bit dscr_bit(input bit b);
reg o;
if (!mult) begin o = b ^ s[len - 1]; step(); end
else begin o = b ^ fbx(s); s = ((s << 1) | {63'd0, b}) & lmask(); steps++; end
return o;
endfunction
function automatic [7:0] scr_byte(input [7:0] v);
reg [7:0] o; for (int i = 0; i < 8; i++) o[i] = scr_bit(v[i]); return o;
endfunction
function automatic [7:0] dscr_byte(input [7:0] v);
reg [7:0] o; for (int i = 0; i < 8; i++) o[i] = dscr_bit(v[i]); return o;
endfunction
// a skip symbol passes unscrambled and the LFSR holds
function automatic void scr_hold(); if (advance_on_skip && !mult) for (int i = 0; i < 8; i++) step(); endfunction
// another symbol that is sent unscrambled (a K code other than COM and SKP): the LFSR still steps 8 times
function automatic void scr_unscrambled(); if (!mult) for (int i = 0; i < 8; i++) step(); endfunction
endmodule
Read included file: eth_mgmt.sv
`timescale 1ns/1ns
// eth_mgmt.sv: what a management station reads (read-only). A bench model.
// eth_mgmt_view: the fields of four PCS registers, and how long a counter lasts.
// status1(r) register 3.1: the latched receive link status and the fault bit (Table 45-235)
// status2(r) register 3.8: the latched receive fault
// baser1(r) register 3.32: the live block lock, high BER and receive link status
// baser2(r) register 3.33: two latched bits and two counters (Table 45-245)
// frames_per_s(rate, octets) frames of this size in one second: each takes its octets, 8 of preamble
// and SFD, and 12 of gap
// wrap_s(bits, per_second) seconds until a counter of that width wraps
module eth_mgmt_view;
function automatic string status1(input [15:0] r);
string link;
if (r[2]) link = "up"; else link = "down or was down";
return $sformatf("3.1 = %h: receive link %s, fault %0d", r, link, r[7]);
endfunction
function automatic string status2(input [15:0] r);
string f;
if (r[10]) f = "seen"; else f = "none";
return $sformatf("3.8 = %h: receive fault %s", r, f);
endfunction
function automatic string baser1(input [15:0] r);
return $sformatf("3.32 = %h: block lock %0d, high BER %0d, receive link %0d", r, r[0], r[1], r[12]);
endfunction
function automatic string baser2(input [15:0] r);
string lock, ber;
if (r[15]) lock = "held"; else lock = "was lost";
if (r[14]) ber = "was seen"; else ber = "not seen";
return $sformatf("3.33 = %h: block lock %s, high BER %s, BER count %0d, errored blocks %0d", r, lock, ber, r[13:8], r[7:0]);
endfunction
function automatic real frames_per_s(input real rate, input int octets);
return rate / (8.0 * (octets + 20));
endfunction
function automatic real wrap_s(input int bits, input real per_second);
return (2.0 ** bits) / per_second;
endfunction
endmodule
Check Yourself
Common Mistakes
Wrong Count an FCS error for every damaged frame on the wire.
A frame for another station gets no status, so it moves no counter.
Fix Count only frames that pass the address test, or all frames in promiscuous mode.
Wrong Read register 3.1 once and report "link down".
Bit 3.1.2 is latching low. The first read tells the past.
Fix Read twice, or read the live bit 3.32.12.
Wrong Treat a reading of 255 errored blocks as exactly 255.
The counter stops at all ones.
Fix Report "255 or more", and read more often.
Wrong Read the upper FEC register first.
It returns the half held at an earlier read of the lower register.
Fix Read the lower register, then the upper one.
Remember
- A received frame gets one status. A good frame moves several counters, a bad one moves one, and some move none.
- A PAUSE frame is counted by the MAC and again by the MAC Control sublayer.
- MAC counters are 32 bits, wrap, and are not changed by a read.
- A latched bit holds the bad state until it is read. Then it takes the present state.
- PCS and FEC counters stop at all ones and clear when read. A 32-bit FEC counter is read lower register first.