256B/257B Transcoding
Reed-Solomon FEC needs 140 bits of parity for every 80 blocks. See how a transcoder finds them by packing four 66-bit blocks into 257 bits.
You Will Be Able To
- Explain why four 66-bit blocks are sent as 257 bits.
- Lay out a 257-bit block for any mix of data and control blocks.
- Say which nibble is left out, and how the receiver gets it back.
- Tell the Clause 91 transcoder from the Clause 119 one.
- Lesson
- P11.30
- Time
- 35 min
- Runs on
- Your browser
- Check
- 5 questions
Four groups of four blocks. Each one fits in 257 bits, and each one comes back whole.
| Four blocks of 66 bits | First five bits of the 257 | What pays for them |
|---|---|---|
| Data, data, data, data | 1, then payload | Nothing: 1 + 256 bits |
| Control, data, data, data | 00111 | Four bits of block 0 |
| Data, data, data, control | 01110 | Four bits of block 3 |
| Control, control, control, control | 00000 | Four bits of block 0 |
Bench run of a private model of the transcoder. Every group came back unchanged from the receive side.
Seven Bits Saved in Every Four Blocks
BASE-R FEC saved one bit per block (P11.29). Reed-Solomon FEC needs more room than that.
Its transcoder takes four 66-bit blocks at a time: 264 bits. It sends 257 bits (91.5.2.5).
The eight sync bits shrink to one bit, or to five.
- Neutral
- Datapath
- Data
- Save seven bits
Four blocks of 66 bits are 264 bits. The transcoder sends 257.
- Twenty times
Twenty transcoded blocks are 5,140 bits: exactly 514 symbols of 10 bits.
- Spend them
The 140 saved bits hold 14 parity symbols. The codeword is as long as the 80 blocks were.
Read the diagram as text
- PCS blocks: 80 blocks of 66 bits
- Transcode: four blocks to 257 bits
- Message: 20 blocks of 257 bits
- Reed-Solomon: 14 parity symbols of 10 bits
- Codeword: 528 symbols
- PCS blocks → Transcode: 5,280 bits
- Transcode → Message: 5,140 bits
- Message → Reed-Solomon: 514 symbols
- Reed-Solomon → Codeword: 5,280 bits
Bench arithmetic for RS(528,514). The code itself is the next lesson.
Twenty transcoded blocks are 5,140 bits. That is 514 symbols of 10 bits, with no bit left over.
Add 14 parity symbols and you get 5,280 bits. Eighty blocks of 66 bits are 5,280 bits too.
So the RS(528,514) code of 100GBASE-R costs no extra bit rate. That sum is ours; the sizes are the standard's (91.5.2.7).
Four Data Blocks
The common case is four data blocks. Each has sync bits 0 then 1.
The transcoder sends a single 1 in place of all eight sync bits (91.5.2.5 a).
The four payloads follow, block 0 first: 1 + 256 = 257 bits.
Nothing is lost. The receiver sees the 1 and writes sync bits 0 then 1 in front of every payload (91.5.3.5 b1).
| Group | Bit 0 | Bits 1 to 4 | From bit 5 |
|---|---|---|---|
| Four data blocks | 1 | payload already | the rest of the 256 payload bits |
| Control, data, data, data | 0 | 0111 | 4 + 56 bits of block 0, then blocks 1 to 3 |
| Data, data, data, control | 0 | 1110 | blocks 0 to 2, then 4 + 56 bits of block 3 |
| Control, control, control, control | 0 | 0000 | 4 + 56 bits of block 0, then blocks 1 to 3 |
After IEEE Std 802.3-2022 Figure 91-3 (redrawn as a table). The flags are bench values. "4 + 56" is a 64-bit payload without its second nibble.
A Control Block in the Group
With a control block in the group, one bit is not enough. The receiver must know which blocks are control blocks.
So bit 0 is 0, and four flags follow. Flag j is the second sync bit of block j: 1 for data, 0 for control.
That makes five header bits, four more than before. The count must stay at 257: 1 + 4 + 252.
So four payload bits must go. The transcoder takes them from the first control block in the group.
It leaves out payload bits 4 to 7 of that block: the second nibble of its block type field (91.5.2.5 e1).
| Group, block 0 first | First five bits | Nibble left out of | Back unchanged |
|---|---|---|---|
| DDDD | 1 and four payload bits | none | yes |
| CDDD | 00111 | block 0 | yes |
| DCDD | 01011 | block 1 | yes |
| CCDD | 00011 | block 0 | yes |
| DDCD | 01101 | block 2 | yes |
| CDCD | 00101 | block 0 | yes |
| DCCD | 01001 | block 1 | yes |
| CCCD | 00001 | block 0 | yes |
| DDDC | 01110 | block 3 | yes |
| CDDC | 00110 | block 0 | yes |
| DCDC | 01010 | block 1 | yes |
| CCDC | 00010 | block 0 | yes |
| DDCC | 01100 | block 2 | yes |
| CDCC | 00100 | block 0 | yes |
| DCCC | 01000 | block 1 | yes |
| CCCC | 00000 | block 0 | yes |
Bench run of a private model: all 16 mixes of data (D) and control (C) blocks, before the XOR. "Back" is through the Clause 91 receive transcoder.
Read one row. In DCDD the flags are 1, 0, 1, 1 and block 1 gives up the nibble.
In CCDD both first blocks are control blocks. Only block 0, the first, gives up a nibble.
Why That Nibble Can Go
A block type field is eight bits, but only 11 values are in use (Figure 82-5).
Either nibble alone names the block type. The standard says so in 91.5.3.5.
| Nibble sent first | Nibble sent second | Block type field |
|---|---|---|
| 1 | E | E1h |
| 2 | D | D2h |
| 4 | B | B4h |
| 7 | 8 | 87h |
| 8 | 7 | 78h |
| 9 | 9 | 99h |
| A | A | AAh |
| B | 4 | 4Bh |
| C | C | CCh |
| E | 1 | 1Eh |
| F | F | FFh |
Bench run of the example: the 11 block type fields of IEEE Std 802.3-2022 Figure 82-5, split into their two nibbles.
The field is sent lowest bit first. So the low nibble goes first, and the transcoder keeps it.
The receiver looks the other nibble up. The example below runs that lookup, eth_xc_type, on all 16 values.
Five first nibbles name no block type. For those the receiver sets the sync header of that block to 11 (91.5.3.5 i2).
The bench tried all 15 wrong values of one first nibble. 5 gave sync 11; 10 gave another block type.
So this check catches some errors, not all. The Reed-Solomon code is what protects the bits.
One more step applies in Clause 91. The 66-bit blocks arrive scrambled, so the nibble is scrambled too.
The receiver descrambles the first nibble with bits of the block before it. Then it looks up, and scrambles the result again (91.5.3.5 e2, a4).
An Invalid Sync Header
A sync header of 00 or 11 is invalid. The transcoder must still send 257 bits, and the error must not get lost.
It sends bit 0 as 0 and all four flags as 1 (91.5.2.5 a2, b2). No valid group looks like that.
A valid group with bit 0 at 0 has a control block. So at least one of its flags is 0.
The four bits are taken from block 0 here, whatever block 0 is.
| Group | First five bits | Nibble left out of | Sync bits the receiver rebuilds |
|---|---|---|---|
| Data blocks, except block 2 with sync 11 | 01111 | block 0 | 00 11 00 11 |
| Control, data, data, control; block 1 with sync 00 | 01111 | block 0 | 00 11 00 11 |
| Control, data, data, data; all valid | 00111 | block 0 | 10 01 01 01 |
Bench run of a private model, before the XOR. Sync bits are shown in sending order, block 0 first.
The receiver cannot tell which block was bad. It gives all four blocks an invalid sync header: 00, 11, 00, 11 (91.5.3.5 d3, e3).
The PCS above then treats all four as errors.
The XOR of the First Five Bits, and Clause 119
Clause 91 adds one last step. The first five bits are XORed with bits 8 to 12 of the same block (91.5.2.5 a3).
The receiver has bits 8 to 12 unchanged, so it does the same XOR to undo it.
| Group of four idle blocks | First five bits before the XOR | First five bits sent |
|---|---|---|
| Annex 91A, group 1 | 00000 | 00101 |
| Annex 91A, group 2 | 00000 | 11110 |
| Annex 91A, group 3 | 00000 | 01111 |
| Annex 91A, group 4 | 00000 | 00110 |
| Annex 91A, group 5 | 00000 | 00100 |
| Annex 91A, group 6 | 00000 | 10010 |
Bench run of a private model on the first six groups of Annex 91A. The bits sent equal the annex's table.
An idle link sends groups of four control blocks. Without the XOR, each would start with 00000.
Bits 8 to 12 are payload bits, scrambled by the PCS. So the XOR makes the header bits look random.
The standard gives no reason for this step. That reading is ours.
The XOR applies to every group, a group of four data blocks included.
| PHY family | Clause | Transcoder | XOR of the first five bits |
|---|---|---|---|
| 100GBASE-R with RS-FEC | 91.5.2.5 | defined here | yes |
| 25GBASE-R with RS-FEC | 108.5.2.3 | the process of 91.5.2.5 | yes |
| 50GBASE-R | 134.5.2.5 | identical to 91.5.2.5 | yes |
| 200GBASE-R and 400GBASE-R | 119.2.4.2 | the same layout | no: the whole block is scrambled next |
IEEE Std 802.3-2022, the clauses named.
The 200G and 400G PCS of Clause 119 works in another order. It transcodes first and scrambles the whole 257-bit block after.
So it needs no XOR, and its nibble is never scrambled. Its receiver looks the nibble up directly (119.2.5.7).
Try It
The bench asks the receive side's lookup about every first nibble, 0 to F.
second returns the nibble that was left out. It returns 0 when no block type starts with that nibble.
Eleven first nibbles name a block type. All eleven are different, and so are the eleven second nibbles.
No block type has the second nibble 0. So 0 is free to mean "not found".
The readable library holds this lookup only. The transmit transcoder is the practice problem.
Print type_at(k) for k from 0 to 10. Check that no two block types share a nibble in the same place.
first nibble 0: no block type first nibble 1: second nibble e, block type e1 first nibble 2: second nibble d, block type d2 first nibble 3: no block type first nibble 4: second nibble b, block type b4 first nibble 5: no block type first nibble 6: no block type first nibble 7: second nibble 8, block type 87 first nibble 8: second nibble 7, block type 78 first nibble 9: second nibble 9, block type 99 first nibble a: second nibble a, block type aa first nibble b: second nibble 4, block type 4b first nibble c: second nibble c, block type cc first nibble d: no block type first nibble e: second nibble 1, block type 1e first nibble f: second nibble f, block type ff 11 of 16 first nibbles name a block typeRead 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_rsfec.sv
`timescale 1ns/1ns
// eth_rsfec.sv: readable models for RS-FEC (read-only).
// eth_xc_type: the block type field as a 256B/257B receive transcoder sees it (91.5.3.5 f2, 119.2.5.7; Figure 82-5).
// A block type field is sent lowest bit first, so its low nibble is the nibble sent first.
// type_at(k) block type field k of Figure 82-5, k = 0 to 10
// second(g) the nibble sent second, worked out from the nibble sent first; 0 when no block type starts with g
module eth_xc_type;
function automatic [7:0] type_at(input int k);
case (k)
0: return 8'h1e; 1: return 8'h78; 2: return 8'h4b; 3: return 8'h87;
4: return 8'h99; 5: return 8'haa; 6: return 8'hb4; 7: return 8'hcc;
8: return 8'hd2; 9: return 8'he1; default: return 8'hff;
endcase
endfunction
function automatic [3:0] second(input [3:0] g);
reg [7:0] t;
for (int k = 0; k < 11; k++) begin
t = type_at(k);
if (t[3:0] == g) return t[7:4];
end
return 4'h0;
endfunction
endmodule
// eth_rs_lanes: alignment marker mapping (91.5.2.6, Figure 91-4) and symbol distribution (91.5.2.8) of the
// 100GBASE-R RS-FEC, which has four FEC lanes. Bit 0 of a vector is sent first.
// am[x] the 66-bit alignment marker of PCS lane x as the PCS sent it; tab[x] the one from the table.
// The bench sets both, x = 0 to 19.
// payload(x) amp_tx_x, 64 bits: the fixed bytes from the table, the two BIP bytes from am[x].
// PCS lanes 0 to 3 all get the fixed bytes of lane 0.
// map(pad) am_txmapped, 1285 bits: the 20 payloads laid out so that each FEC lane carries five whole ones
// deal(cw, n) deals the n symbols of a codeword to the lanes, one 10-bit symbol at a time; lane[i] then holds
// the bits of FEC lane i in sending order
// valid(b) is b a marker payload of PCS lane 0? Twelve nibbles of the 48 fixed bits are compared, and up to
// three may differ (amp_valid of 91.5.4.2.1)
// Twin: no_map (the 20 payloads go into the message one after another).
module eth_rs_lanes;
bit no_map = 0;
reg [65:0] am [0:19]; reg [65:0] tab [0:19];
reg [1359:0] lane [0:3];
function automatic [63:0] payload(input int x);
int y;
y = (x <= 3) ? 0 : x;
return {am[x][65:58], tab[y][57:34], am[x][33:26], tab[y][25:2]};
endfunction
function automatic [1284:0] map(input [4:0] pad);
reg [1284:0] o; reg [319:0] row [0:3];
o = 1285'd0;
for (int i = 0; i < 4; i++) for (int j = 0; j < 5; j++) row[i][64 * j +: 64] = payload(i + 4 * j);
if (no_map) for (int x = 0; x < 20; x++) o[64 * x +: 64] = payload(x);
else for (int i = 0; i < 4; i++) for (int k = 0; k < 32; k++) o[10 * (i + 4 * k) +: 10] = row[i][10 * k +: 10];
o[1284:1280] = pad;
return o;
endfunction
function automatic void deal(input [5439:0] cw, input int n);
for (int i = 0; i < 4; i++) lane[i] = 1360'd0;
for (int s = 0; s < n; s++) lane[s % 4][10 * (s / 4) +: 10] = cw[10 * s +: 10];
endfunction
function automatic bit valid(input [63:0] b);
reg [63:0] want; int miss;
want = {8'd0, tab[0][57:34], 8'd0, tab[0][25:2]}; miss = 0;
for (int n = 0; n < 16; n++)
if (n != 6 && n != 7 && n != 14 && n != 15 && b[4 * n +: 4] != want[4 * n +: 4]) miss++;
return miss <= 3;
endfunction
endmodule
// eth_rs_lock: alignment marker lock of one FEC lane (Figure 91-8) and the restart rule, on scripted results.
// amp(valid) one call per candidate marker position, a marker period apart once the first one is found.
// Out of lock: two valid payloads in a row give the lock; an invalid one slips.
// In lock (the optional states of the figure): five invalid payloads in a row ask for a restart.
// cw(bad) one call per codeword: three uncorrected codewords in a row ask for a restart
// Course simplification: the codeword rule is the 3_BAD state of Figure 91-9. In the standard it runs on all four
// lanes together, once they are locked and deskewed, and a restart clears every lane. Here it is folded into one lane.
// locked, slips, restarts
module eth_rs_lock;
bit locked, first_seen; int slips, bad_cnt, cw_bad_cnt, restarts;
function automatic void reset(); locked = 0; first_seen = 0; slips = 0; bad_cnt = 0; cw_bad_cnt = 0; restarts = 0; endfunction
function automatic void restart(); restarts++; locked = 0; first_seen = 0; bad_cnt = 0; cw_bad_cnt = 0; endfunction
function automatic void amp(input bit valid);
if (!locked) begin
if (valid && first_seen) begin locked = 1; bad_cnt = 0; end
else if (valid) first_seen = 1;
else begin first_seen = 0; slips++; end
end else if (valid) bad_cnt = 0;
else begin
bad_cnt++;
if (bad_cnt == 5) restart();
end
endfunction
function automatic void cw(input bit bad);
if (!bad) cw_bad_cnt = 0;
else begin
cw_bad_cnt++;
if (cw_bad_cnt == 3) restart();
end
endfunction
endmodule
Check Yourself
Common Mistakes
Wrong Leave the nibble out of every control block.
Only four bits are needed. A second missing nibble would make the block 253 bits long.
Fix Leave out one nibble: the second nibble of the first control block in the group.
Wrong Leave out the first nibble of the block type field.
The receiver looks up from the nibble sent first. That is the low nibble of the field.
Fix Keep payload bits 0 to 3 and leave out bits 4 to 7.
Wrong Skip the XOR for a group of four data blocks.
The receiver undoes the XOR before it reads bit 0. It cannot know the group type first.
Fix In Clause 91, XOR the first five bits of every block with bits 8 to 12.
Wrong Send an invalid sync header on as a data or control flag.
The receiver would rebuild a valid header, and the error would be hidden from the PCS.
Fix Send bit 0 as 0 and all four flags as 1.
Remember
- Four 66-bit blocks become one 257-bit block. Twenty of those are 514 symbols of 10 bits.
- Four data blocks: a 1, then 256 payload bits.
- Any control block: a 0, four flags, and 252 payload bits. The first control block gives up the second nibble of its block type.
- The receiver looks the nibble up from the other one. A nibble with no block type gives sync 11.
- An invalid sync header gives 0 and the flags 1111. Clause 91 XORs the first five bits with bits 8 to 12; Clause 119 does not.