FEC in Service: Bursts, Interleaving and Counters
A link with FEC makes errors all day and reports them in counters. See which bursts a decoder repairs, what it does with the rest, and how to read its counters.
You Will Be Able To
- Count a burst in symbols and say whether a codeword will be corrected.
- Explain what bit multiplexing and interleaving do to a burst.
- Describe how an uncorrected codeword is shown to the PCS.
- Read the corrected, uncorrected and symbol error counters, hi_ser and FEC degrade.
- Lesson
- P11.32
- Time
- 40 min
- Runs on
- Your browser
- Check
- 5 questions
One codeword, one burst. Seventy wrong bits are repaired. Sixty-two, placed badly, are not.
| Wrong bits in a row on one FEC lane | First wrong bit of the lane | Symbols touched | What the decoder did |
|---|---|---|---|
| 1 | 200 | 1 | Corrected |
| 10 | 200 | 1 | Corrected |
| 10 | 205 | 2 | Corrected |
| 70 | 200 | 7 | Corrected |
| 71 | 200 | 8 | Not corrected |
| 61 | 209 | 7 | Corrected |
| 62 | 209 | 8 | Not corrected |
Bench run of a private decoder on the RS(528,514) codeword of Annex 91A. Every bit of the burst is wrong. A symbol is ten lane bits, the first from bit 0.
What the Decoder Owes the Link
P11.31 built the codeword. This lesson is about the receiving side.
A decoder must correct any t wrong symbols in a codeword: 7 for RS(528,514), 15 for RS(544,514) (91.5.3.3).
It must also be able to say that a codeword was not corrected.
- Neutral
- Result
- Structure
- Data
- Control
- Bits to symbols
A symbol with one wrong bit is a wrong symbol. So is one with ten.
- Corrected
Up to t wrong symbols: the codeword is repaired. One codeword counter and the lane symbol counters go up.
- Uncorrected
More than t: the other codeword counter goes up, and the blocks are marked for the PCS.
Read the diagram as text
- Wrong bits: a burst on a lane
- Wrong symbols: ten bits each
- One codeword: how many are wrong?
- Corrected: 1 to t wrong symbols
- Uncorrected: more than t
- Wrong bits → Wrong symbols: any wrong bit
- Wrong symbols → One codeword: count
- One codeword → Corrected: at most t
- One codeword → Uncorrected: more than t
Our drawing of 91.5.3.3 and 91.6.16 to 91.6.19. A decoder may, rarely, miss the lower branch.
Beyond t a decoder can miss the problem. It may "correct" to a different valid codeword. That explanation is ours.
The standard gives a number for a codeword with t + 1 errors that is not flagged as uncorrected.
Its probability is not expected to exceed 10^-6. The same holds for t + 2 errors and more (91.5.3.3).
For the 200G and 400G PCS the figure is 10^-16 (119.2.5.3).
A Burst Is Counted in Symbols
A symbol is ten bits in a row on one FEC lane. One wrong bit spoils it, and so do ten.
So what matters is how many symbols a burst touches. That depends on where it starts.
In the table above, 61 wrong bits touch 7 symbols. One more bit, from the same start, touches 8.
The bench tried 20 starts in a row. All 20 bursts of 61 bits were corrected, and 18 of the 62-bit ones.
A burst of 61 bits can never touch 8 symbols of one lane. That count is ours, not the standard's.
A Burst Across Lanes
Some PHYs have fewer lanes than the RS-FEC has FEC lanes. A PMA then multiplexes FEC lanes bit by bit (135.5.2).
Take all four on one lane. A burst there is dealt to all four FEC lanes, a quarter of its bits to each.
All four lanes belong to the same codeword. So the symbols add up.
| Wrong bits in a row on the shared lane | Symbols touched | What the decoder did |
|---|---|---|
| 40 | 4 | Corrected |
| 41 | 5 | Corrected |
| 120 | 12 | Corrected |
| 121 | 13 | Corrected |
| 87 | 15 | Corrected |
| 88 | 16 | Not corrected |
Bench run with RS(544,514), t = 15. Every bit of the burst is wrong. Counted in bits, not PAM4 symbols (P11.35). Bench choice: bit w of the shared lane belongs to FEC lane w mod 4. The symbol boundaries of the four lanes line up. The last two bursts start one bit before a boundary.
On one FEC lane, a burst of up to 141 bits never touches more than 15 symbols.
On the shared lane the bench finds 87 bits. Each lane can lose a symbol at both ends of its share.
That holds however the lanes are aligned. Of 1,000 alignments tried, 88 bits exceed 15 symbols at 4.
Two Codewords Interleaved
The 200G and 400G PCS goes the other way. It builds two codewords at a time, A and B.
On every PCS lane their symbols alternate (119.2.4.7). The stated aim is better error correction (119.2.4.5).
A burst on a lane is then shared between two codewords, and each can correct 15 symbols.
| Wrong bits in a row on one PCS lane | One codeword alone | Two codewords interleaved: A | B |
|---|---|---|---|
| 141 | 15 symbols corrected | 8 symbols corrected | 7 symbols corrected |
| 142 | Not corrected | 8 symbols corrected | 8 symbols corrected |
| 291 | Not corrected | 15 symbols corrected | 15 symbols corrected |
| 292 | Not corrected | Not corrected | 15 symbols corrected |
Bench run with RS(544,514). Every bit of the burst is wrong. Counted in bits, not PAM4 symbols (P11.35). Each burst starts one bit before a symbol boundary, the worst place. "One codeword alone" is a bench construction for comparison.
So one lane now survives a burst of 291 bits. P11.33 builds this pipeline.
The price: if either is not corrected, every block of both becomes an error block (119.2.5.3).
That holds unless error indication is bypassed.
Telling the PCS
The 100G RS-FEC sits under a PCS that knows nothing of codewords. So the decoder spoils sync headers (91.5.3.3).
In an uncorrected codeword it sets the header of some 66-bit blocks to 11, which is invalid.
It marks the first block of every other 257-bit block: the 1st, 3rd, 5th and so on.
It also marks the first block of the 6th, and the last block of the 20th.
That is 12 of 80 blocks. The example finds at most 7 unmarked blocks in a row.
The standard states the effect: the PCS discards every frame of 64 octets or more in that codeword.
| Mode | Corrects | Marks blocks for the PCS | Note |
|---|---|---|---|
| Normal | yes | when a codeword is not corrected | required |
| Bypass correction | no | when a codeword has any error | optional; forbidden for some PHYs |
| Bypass indication | yes | no | optional; the hi_ser monitor runs in its place |
IEEE Std 802.3-2022 91.5.3.3. Both bypass options exist to cut delay. Bypass correction wins if both are set.
The Counters
Management reads three kinds of FEC counter from the RS-FEC (91.6.16, 91.6.17, 91.6.19).
| Counter | Counts once for | Size |
|---|---|---|
| FEC_corrected_cw_counter | each codeword that had errors and was corrected | 32 bits |
| FEC_uncorrected_cw_counter | each codeword with errors that was not corrected | 32 bits |
| FEC_symbol_error_counter_i | each 10-bit symbol corrected on FEC lane i | 32 bits a lane |
IEEE Std 802.3-2022 91.6.16, 91.6.17, 91.6.19. All count only while the FEC lanes are aligned.
| Codeword received | Corrected codewords | Uncorrected codewords | Symbol errors, FEC lanes 0 to 3 |
|---|---|---|---|
| A clean codeword | 0 | 0 | 0, 0, 0, 0 |
| 25 wrong bits on FEC lane 2 | 1 | 0 | 0, 0, 3, 0 |
| 7 wrong bits in 7 symbols | 2 | 0 | 2, 2, 5, 1 |
| 8 wrong bits in 8 symbols | 2 | 1 | 2, 2, 5, 1 |
Bench run: four codewords in a row through the private decoder. The counters are shown after each one.
The last row adds nothing to the lane counters. They count symbols corrected (91.6.19, 119.3.4), and none was.
The register text says "detected", but it points back to 91.6.19 for the definition (45.2.1.121).
A clean codeword changes no counter. The registers clear when read, and stop at all ones (45.2.1.118).
BASE-R FEC of P11.29 has the same pair for its blocks: corrected and uncorrected (74.8.4).
Watching the Trend: hi_ser and FEC Degrade
With error marking bypassed, bad codewords would reach the PCS unmarked. So a monitor watches the trend (91.5.3.3).
It counts symbol errors over blocks of 8,192 codewords. More than K in a block sets hi_ser.
| Code and sublayer | K | Clause |
|---|---|---|
| RS(528,514), 100GBASE-R RS-FEC | 417 | 91.5.3.3 |
| RS(544,514), 100GBASE-R RS-FEC | 6,380 | 91.5.3.3 |
| RS(544,514), 200G and 400G PCS | 5,560 | 119.2.5.3 |
More than K symbol errors in one block of 8,192 codewords sets hi_ser.
The 100G RS-FEC then spoils every sync header for 60 ms to 75 ms. The PCS sees hi_ber and stops receiving.
In the 200G and 400G PCS, hi_ser itself is held that long (119.2.5.3).
FEC degrade is an optional early warning (116.6). Management sets an interval and two thresholds.
In Clause 91 it exists for 100GBASE-CR2, -KR2, -SR2, -DR, -FR1 and -LR1 only (91.5.3.3.1).
All of them use RS(544,514). The 200G and 400G PCS can have it too (119.2.5.3).
An uncorrectable codeword adds 16 to its count. The bit clears when an interval ends below the lower threshold.
| Symbol errors in the block | Uncorrectable codewords | hi_ser | Degraded |
|---|---|---|---|
| 164 | 0 | clear | clear |
| 274 | 0 | clear | set |
| 137 | 0 | clear | set |
| 82 | 0 | clear | clear |
| 6380 | 0 | clear | set |
| 6381 | 0 | set | set |
| 90 | 7 | clear | set |
Bench run of the example: blocks of 8,192 codewords in a row, K = 6,380 for RS(544,514). The degrade thresholds 200 and 100 are bench values. The bench ends hi_ser before the last row.
A 200G or 400G PCS sends the warning to the far end, in three status bits of its marker group (119.2.4.4).
Try It
eth_fec_mark answers one question: is block b of an uncorrected codeword marked?
The first lines list the marked blocks and the longest run without one, over two codewords in a row.
eth_fec_watch gets one call for each codeword. feed sends one block of 8,192 codewords.
At 274 symbol errors the degraded bit sets. At 137 it stays: that is not below 100.
At 6,381 hi_ser sets. The bench then ends it, as the timer would.
In the last line, 7 uncorrectable codewords add 112 to the 90, for the degraded count only.
The hi_ser count takes the 90 as given. That is a bench choice: the standard is silent here.
The Reed-Solomon decoder itself is private. Its results reach this page as tables.
Change the last line to feed(90, 6). Predict the degraded bit first.
blocks marked 11: 0 8 16 20 24 32 40 48 56 64 72 79 12 of 80 blocks marked; longest run of unmarked blocks: 7 164 symbol errors, 0 uncorrectable codewords: hi_ser 0, degraded 0 274 symbol errors, 0 uncorrectable codewords: hi_ser 0, degraded 1 137 symbol errors, 0 uncorrectable codewords: hi_ser 0, degraded 1 82 symbol errors, 0 uncorrectable codewords: hi_ser 0, degraded 0 6380 symbol errors, 0 uncorrectable codewords: hi_ser 0, degraded 1 6381 symbol errors, 0 uncorrectable codewords: hi_ser 1, degraded 1 90 symbol errors, 7 uncorrectable codewords: hi_ser 0, degraded 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_fecsvc.sv
`timescale 1ns/1ns
// eth_fecsvc.sv: readable models of what an RS-FEC decoder reports (read-only).
// eth_fec_mark: how a Clause 91 decoder tells the PCS that a codeword was not corrected (91.5.3.3).
// A codeword is 20 blocks of 257 bits, so 80 blocks of 66 bits after the transcoder. Blocks are numbered from 0.
// marked(b) 1 if 66-bit block b of the codeword gets the sync header 11
module eth_fec_mark;
function automatic bit marked(input int b);
int x, j;
x = b / 4; // which 257-bit block, 0 to 19
j = b % 4; // which of its four 66-bit blocks
if (j == 0 && x % 2 == 0) return 1; // the first block of the 1st, 3rd, 5th ... 257-bit block
if (j == 0 && x == 5) return 1; // the first block of the 6th
if (j == 3 && x == 19) return 1; // the last block of the 20th
return 0;
endfunction
endmodule
// eth_fec_watch: the two optional monitors that count symbol errors over many codewords.
// The bench calls cw() once per codeword with what the decoder found.
// k, window the hi_ser monitor (91.5.3.3, 119.2.5.3): more than k symbol errors in one block of
// window codewords sets hi_ser. The standard's block is 8,192 codewords.
// timer_done() ends hi_ser. Clause 119 holds hi_ser for 60 ms to 75 ms; Clause 91 spoils the sync
// headers that long. This model does not count time.
// interval, activate, deactivate the FEC degraded SER monitor (91.5.3.3.1, 119.2.5.3)
// cw(syms, uncorrectable) one codeword: syms symbol errors detected; an uncorrectable codeword adds 16 to the
// degraded count
// hi_ser, hi_ser_events, degraded
// Bench choice: the hi_ser count takes syms as given, also for an uncorrectable codeword.
module eth_fec_watch;
int k = 417, window = 8192;
int interval = 8192, activate = 100, deactivate = 50;
bit hi_ser, degraded; int hi_ser_events;
int in_window, win_syms, in_interval, int_syms;
function automatic void reset();
hi_ser = 0; degraded = 0; hi_ser_events = 0; in_window = 0; win_syms = 0; in_interval = 0; int_syms = 0;
endfunction
function automatic void timer_done(); hi_ser = 0; endfunction
function automatic void cw(input int syms, input bit uncorrectable);
win_syms += syms; in_window++;
if (in_window == window) begin
if (win_syms > k) begin hi_ser = 1; hi_ser_events++; end
in_window = 0; win_syms = 0;
end
int_syms += syms + (uncorrectable ? 16 : 0); in_interval++;
if (int_syms > activate) degraded = 1;
if (in_interval == interval) begin
if (int_syms < deactivate) degraded = 0;
in_interval = 0; int_syms = 0;
end
endfunction
endmodule
Check Yourself
Common Mistakes
Wrong Compare the number of wrong bits with t.
The code corrects symbols. Seventy wrong bits can sit in 7 symbols.
Fix Count the symbols that hold at least one wrong bit, in each codeword.
Wrong Expect four FEC lanes to share out a burst between codewords.
All four FEC lanes of a 100G RS-FEC carry the same codeword.
Fix Only the 200G and 400G PCS interleaves two codewords on a lane.
Wrong Read a rising corrected-codeword counter as a broken link.
Correcting is the normal work of the FEC. Frames are lost only when codewords stay uncorrected.
Fix Watch the uncorrected counter for loss, and the symbol error counters for the trend.
Wrong Bypass error marking and watch nothing.
An uncorrected codeword then reaches the PCS without a mark.
Fix With marking bypassed, the hi_ser monitor must run (91.5.3.3).
Remember
- A decoder must correct any t wrong symbols in a codeword, 7 or 15, and be able to report an uncorrected one.
- A burst is counted in symbols. On one FEC lane, 61 wrong bits in a row never exceed 7 symbols.
- Bit multiplexing spreads a burst over the FEC lanes of one codeword. Interleaving shares it between two codewords.
- A 100G RS-FEC marks an uncorrected codeword with sync headers of 11. The 200G and 400G PCS makes every block of both codewords an error block.
- Counters: corrected codewords, uncorrected codewords, and corrected symbols for each lane. hi_ser and FEC degrade watch the symbol error count over many codewords.