200G and 400G: The PCS with FEC Inside

At 200G and 400G the FEC is no longer an add-on under the PCS. See one stream become two codewords, and how their symbols are woven onto 8 or 16 lanes.

You Will Be Able To

  • Follow a block through the transmit side of the Clause 119 PCS.
  • Deal a stream of symbols into the two messages A and B.
  • Place the symbols of two codewords on 8 or 16 PCS lanes.
  • Explain how the marker group puts a whole marker on each lane.
Lesson
P11.33
Time
40 min
Runs on
Your browser
Check
5 questions

Two codewords, eight lanes. On every lane the symbols alternate between A and B.

PCS laneFirst six symbols on the lane
200GBASE-R lane 0A0, B4, A8, B12, A16, B20
200GBASE-R lane 1B0, A4, B8, A12, B16, A20
200GBASE-R lane 2A1, B5, A9, B13, A17, B21
200GBASE-R lane 7B3, A7, B11, A15, B19, A23

Bench run of a private model. A4 is symbol 4 of codeword A, counted in sending order from 0.

FEC Moves into the PCS

A 100G link may add RS-FEC as a sublayer under its PCS. At 200G and 400G the PCS itself holds the encoder (119.2.4.6).

The Transmit Side of the 200G and 400G PCSOne stream of blocks goes in. Two codewords come out, woven onto 8 or 16 lanes.
  • Datapath
  • Channel / handshake
  • Data
The transmit side of the 200G and 400G PCSOne stream of blocks goes in. Two codewords come out, woven onto 8 or 16 lanes. datapath Encode 64B/66B blocks datapath Transcode four blocks to 257bits datapath Scramble x^58, whole 257-bitblocks datapath Insert markers a group, notscrambled datapath Pre-FECdistribution symbols in turn to Aand B datapath Two RS encoders RS(544,514), A andB datapath Symboldistribution A and B interleaved channel PCS lanes 8 or 16 66 bits257 bits257 bits40 blocks2 x 514 symbols2 x 544 symbolsone symbol a lane
  1. datapath Encode64B/66B blocks
    • 66 bits → Transcode
  2. datapath Transcodefour blocks to 257 bits
    • 257 bits → Scramble
  3. datapath Scramblex^58, whole 257-bit blocks
    • 257 bits → Insert markers
  4. datapath Insert markersa group, not scrambled
    • 40 blocks → Pre-FEC distribution
  5. datapath Pre-FEC distributionsymbols in turn to A and B
    • 2 x 514 symbols → Two RS encoders
  6. datapath Two RS encodersRS(544,514), A and B
    • 2 x 544 symbols → Symbol distribution
  7. datapath Symbol distributionA and B interleaved
    • one symbol a lane → PCS lanes
  8. channel PCS lanes8 or 16
  1. Blocks

    Encode and transcode as P11.22 and P11.30 showed. Then the whole 257-bit block is scrambled.

  2. Markers

    Now and then a marker group takes the place of the first blocks. It is not scrambled.

  3. Two messages

    Forty blocks are 1,028 symbols. They go to messages A and B in turn.

  4. Lanes

    Both codewords are dealt to the lanes, one symbol at a time, A and B alternating.

Read the diagram as text
  • Encode: 64B/66B blocks
  • Transcode: four blocks to 257 bits
  • Scramble: x^58, whole 257-bit blocks
  • Insert markers: a group, not scrambled
  • Pre-FEC distribution: symbols in turn to A and B
  • Two RS encoders: RS(544,514), A and B
  • Symbol distribution: A and B interleaved
  • PCS lanes: 8 or 16
  • Encode → Transcode: 66 bits
  • Transcode → Scramble: 257 bits
  • Scramble → Insert markers: 257 bits
  • Insert markers → Pre-FEC distribution: 40 blocks
  • Pre-FEC distribution → Two RS encoders: 2 x 514 symbols
  • Two RS encoders → Symbol distribution: 2 x 544 symbols
  • Symbol distribution → PCS lanes: one symbol a lane

After IEEE Std 802.3-2022 Figures 119-10 and 119-11 (redrawn).

100GBASE-R200GBASE-R and 400GBASE-R
FECa sublayer of its own (Clause 91)inside the PCS, always RS(544,514)
Scrambleron 66-bit blocks, before transcodingon 257-bit blocks, after transcoding
Codewordsone at a time, on 4 FEC lanestwo at a time, interleaved
PCS lanes208 and 16
Marker of a lane66 bits, with BIP120 bits, no BIP

IEEE Std 802.3-2022 82.2, 91.5.2, 119.2.4. The marker row for 200G and 400G is read from Figure 119-4.

The transcoder is the one of P11.30 without the header XOR. The scrambler makes that step needless (119.2.4.2).

The line carries more bits than the MAC sends. For 200G the bench works out 212.5 Gb/s: 26.5625 Gb/s on each lane.

One Stream, Two Messages

The next step works on 10,280 bits at a time: forty 257-bit blocks, markers included when a group is due.

Cut into 10-bit symbols, that is 1,028 symbols.

The pre-FEC distribution deals them out in turn: one to message A, one to message B (119.2.4.5).

MessageStream symbols it getsSymbols
A0, 2, 4, 6, 8, ...514
B1, 3, 5, 7, 9, ...514

Bench run of a private model on a stream whose symbol i holds the number i. Symbol 0 is sent first.

Each message has 514 symbols. Each goes through its own RS(544,514) encoder and gains 30 parity symbols.

The first symbol of the stream is the first symbol into encoder A. In the standard's names it is mA<513>.

The standard gives the reason for two codewords: better error correction. P11.32 measured it.

Two Codewords, 8 or 16 Lanes

The symbol distribution deals both codewords to the lanes, one 10-bit symbol at a time (119.2.4.7).

A pair of lanes takes one symbol of A and one of B. On the next round the pair swaps.

PCS typeLaneFirst six symbols
200GBASE-R0A0, B4, A8, B12, A16, B20
200GBASE-R1B0, A4, B8, A12, B16, A20
200GBASE-R2A1, B5, A9, B13, A17, B21
200GBASE-R7B3, A7, B11, A15, B19, A23
400GBASE-R0A0, B8, A16, B24, A32, B40
400GBASE-R1B0, A8, B16, A24, B32, A40
400GBASE-R15B7, A15, B23, A31, B39, A47

Bench run of a private model. In the standard's names, A0 is cA<543> (Figures 119-10 and 119-11).

So along a lane the symbols alternate: A, B, A, B. The neighbouring lane starts with B.

Along a lane the symbol number steps by 4 on 200G and by 8 on 400G. The codeword changes every time.

So a 200G lane carries every eighth symbol of each codeword. A 400G lane carries every sixteenth.

Bit 0 of each symbol goes first.

Markers That Survive the Shuffle

The receiver must find each lane before it can decode anything. So each lane needs a whole marker.

A marker is 120 bits: a common part, a part unique to the lane, and three pad octets (119.2.4.4).

The pad octets also differ from lane to lane. The receiver ignores them.

The common part is the same on all lanes. Two unique parts differ in at least 12 of 48 bits, by the bench's count.

PCS typeMarkersPadStatusGroupOne group every
200GBASE-R8 x 120 bits65 bits3 bits1,028 bits: 4 blocks4,096 codewords
400GBASE-R16 x 120 bits133 bits3 bits2,056 bits: 8 blocks8,192 codewords

IEEE Std 802.3-2022 119.2.4.4. The sums are bench arithmetic.

The markers of all lanes are sent as one group. It opens a pair of messages, in place of the first blocks.

Row k of the group holds symbol k of every marker, one row after another.

In every odd row, each pair of markers swaps places.

Row of the groupSymbol 0Symbol 1Symbol 2Symbol 3Symbol 4Symbol 5Symbol 6Symbol 7
Row 0: symbol 0 of each markeram_0 to Aam_1 to Bam_2 to Aam_3 to Bam_4 to Aam_5 to Bam_6 to Aam_7 to B
Row 1: symbol 1 of each markeram_1 to Aam_0 to Bam_3 to Aam_2 to Bam_5 to Aam_4 to Bam_7 to Aam_6 to B
Row 2: symbol 2 of each markeram_0 to Aam_1 to Bam_2 to Aam_3 to Bam_4 to Aam_5 to Bam_6 to Aam_7 to B
Row 3: symbol 3 of each markeram_1 to Aam_0 to Bam_3 to Aam_2 to Bam_5 to Aam_4 to Bam_7 to Aam_6 to B

Bench run of a private model, 200GBASE-R, first 4 of 12 rows. "am_1 to B": this group symbol is from the marker of lane 1 and goes to message B. Our own table, after Figure 119-5. The 400G group has 16 symbols a row and the same swap.

Follow marker 0. Its symbols go to A, B, A, B: the pattern of lane 0 in the table before.

So the split and the dealing put each marker back together on its lane. The stated aim is intact markers.

Check against Annex 119A200GBASE-R400GBASE-R
Marker group built from the marker tableequalequal
Codewords A and B after the split and the encoderboth equalboth equal
First two parity symbols of A106, 275916, 586
Lanes that start with their own marker8 of 816 of 16

Bench run of private models on the example block of Annex 119A of IEEE Std 802.3-2022.

The pad is PRBS9 filler. The three status bits carry the FEC degrade signal of P11.32 to the far end.

The group is not scrambled and not transcoded.

The Receive Side

The receiver undoes the steps in reverse order (119.2.5).

StepWhat it uses
Marker lock on each lanethe common part of the marker
Deskew and reorderthe unique part gives the PCS lane number
De-interleavethe alternating pattern gives back codewords A and B
Decodeeach codeword corrects up to 15 symbols
Post-FEC interleavethe two messages become one stream again
Remove markers, descramble, transcodethe status bits are read on the way

IEEE Std 802.3-2022 119.2.5.1 to 119.2.5.7.

Marker lock runs before any correction. The standard notes that it works on a high error rate (119.2.5.1).

The receiver must absorb 180 ns of skew between lanes.

If a codeword is not corrected, both codewords of the pair are given up, as P11.32 showed.

Try It

eth_am119 holds the marker octets of both PCS types.

The first 32 bits of marker 0 are printed in sending order. The standard prints the same 32 bits.

The common part is equal on every lane. It holds as many ones as zeros, and so does the unique part.

The pad is a PRBS9 sequence. The standard lets it start anywhere but at zero.

With FEC degrade, tx_am_sf<2:0> is 100: bit 2 is set. Bit 0 is sent first.

The readable library stops here. The split and the dealing are the practice problem.

Print am.am(1) for both PCS types. Predict whether they are equal.

RUNIcarus Verilog · in your browser
Edit the code, then run it
Expected: 200GBASE-R am_0, first 32 bits sent: 01011001 01010010 01100100 10100000 8 markers; common part equal on 8; ones in the common and unique parts: 48 to 48 of 96; two unique parts differ in at least 16 of 48 bits 400GBASE-R am_0, first 32 bits sent: 01011001 01010010 01100100 01101101 16 markers; common part equal on 16; ones in the common and unique parts: 48 to 48 of 96; two unique parts differ in at least 12 of 48 bits pad, first 24 bits from the start value 001: 000000001000010001100001 status field with no degrade: 000; with FEC degrade: 100
Read 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_pcs119.sv
`timescale 1ns/1ns
// eth_pcs119.sv: readable parts of the 200GBASE-R and 400GBASE-R PCS (Clause 119) (read-only).

// eth_am119: the alignment markers (119.2.4.4, Figure 119-4, Tables 119-1 and 119-2) and what goes with them.
// Bit 0 of a marker is the first bit sent.
//   g400            0: 200GBASE-R, 8 PCS lanes. 1: 400GBASE-R, 16 PCS lanes
//   lanes()         8 or 16
//   am(x)           the 120-bit marker of PCS lane x: CM0 CM1 CM2 UP0 CM3 CM4 CM5 UP1 UM0 UM1 UM2 UP2 UM3 UM4 UM5,
//                   one octet each, each octet sent lowest bit first
//   common(m)       the 48 bits that are the same on every lane (CM0 to CM5)
//   unique_part(m)  the 48 bits that name the lane (UM0 to UM5)
//   pad_seed(s), pad_bit()   the PRBS9 generator of the pad, x^9 + x^5 + 1. The standard only asks that it
//                   free-runs and never starts at zero.
//   status(deg, far)         tx_am_sf<2:0> without an extender sublayer: bit 2 is FEC_degraded_SER or
//                   rx_local_degraded
module eth_am119;
  bit g400;
  reg [8:0] prbs = 9'h001;
  function automatic int lanes(); return g400 ? 16 : 8; endfunction
  function automatic [119:0] am(input int x);
    if (g400)
      case (x)
      0: return 120'hc8efe26f37101d9d9b565b6264a9a;
      1: return 120'h8121a5987ede5a67d9b56504264a9a;
      2: return 120'ha90cc10156f33efed9b56546264a9a;
      3: return 120'h2f7f797bd0808684d9b5655a264a9a;
      4: return 120'hdaed5e6f2512a19d9b565e1264a9a;
      5: return 120'h2eb0edb1d14f124ed9b565f2264a9a;
      6: return 120'h5e63bd11a19c42eed9b5653d264a9a;
      7: return 120'ha48929cd5b76d632d9b56522264a9a;
      8: return 120'h8a8c1e607573e19fd9b56560264a9a;
      9: return 120'hc33b8e5d3cc471a2d9b5656b264a9a;
      10: return 120'h27146afbd8eb9504d9b565fa264a9a;
      11: return 120'hc799dd8e38662271d9b5656c264a9a;
      12: return 120'h6a095da495f6a25bd9b56518264a9a;
      13: return 120'h3c68ce33c39731ccd9b56514264a9a;
      14: return 120'h5904354ea6fbcab1d9b565d0264a9a;
      15: return 120'h864559a979baa656d9b565b4264a9a;
      default: return 120'd0;
      endcase
    else
      case (x)
      0: return 120'h733f4c298cc0b3d6d9b56505264a9a;
      1: return 120'h8121a5987ede5a67d9b56504264a9a;
      2: return 120'ha90cc10156f33efed9b56546264a9a;
      3: return 120'h2f7f797bd0808684d9b5655a264a9a;
      4: return 120'hdaed5e6f2512a19d9b565e1264a9a;
      5: return 120'h2eb0edb1d14f124ed9b565f2264a9a;
      6: return 120'h5e63bd11a19c42eed9b5653d264a9a;
      7: return 120'ha48929cd5b76d632d9b56522264a9a;
      default: return 120'd0;
      endcase
  endfunction
  function automatic [47:0] common(input [119:0] m); return {m[55:32], m[23:0]}; endfunction
  function automatic [47:0] unique_part(input [119:0] m); return {m[119:96], m[87:64]}; endfunction
  function automatic void pad_seed(input [8:0] s); prbs = (s == 9'd0) ? 9'h001 : s; endfunction
  function automatic bit pad_bit();
    bit o;
    o = prbs[8];
    prbs = {prbs[7:0], prbs[8] ^ prbs[4]};
    return o;
  endfunction
  function automatic [2:0] status(input bit deg, input bit far); return {deg | far, 2'b00}; endfunction
endmodule

Check Yourself

Predict the outputThe bench counts the 400G lanes whose whole marker equals that of lane 0. Then it adds the 200G lanes whose common part equals that of lane 0. What does it print?
`timescale 1ns/1ns
module tb;
  eth_am119 am(); int n;
  initial begin
    am.g400 = 1; n = 0;
    for (int x = 0; x < am.lanes(); x++) if (am.am(x) == am.am(0)) n++;
    am.g400 = 0;
    for (int x = 0; x < am.lanes(); x++) if (am.common(am.am(x)) == am.common(am.am(0))) n++;
    $display("%0d", n);
    $finish;
  end
endmodule
Read 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_pcs119.sv
`timescale 1ns/1ns
// eth_pcs119.sv: readable parts of the 200GBASE-R and 400GBASE-R PCS (Clause 119) (read-only).

// eth_am119: the alignment markers (119.2.4.4, Figure 119-4, Tables 119-1 and 119-2) and what goes with them.
// Bit 0 of a marker is the first bit sent.
//   g400            0: 200GBASE-R, 8 PCS lanes. 1: 400GBASE-R, 16 PCS lanes
//   lanes()         8 or 16
//   am(x)           the 120-bit marker of PCS lane x: CM0 CM1 CM2 UP0 CM3 CM4 CM5 UP1 UM0 UM1 UM2 UP2 UM3 UM4 UM5,
//                   one octet each, each octet sent lowest bit first
//   common(m)       the 48 bits that are the same on every lane (CM0 to CM5)
//   unique_part(m)  the 48 bits that name the lane (UM0 to UM5)
//   pad_seed(s), pad_bit()   the PRBS9 generator of the pad, x^9 + x^5 + 1. The standard only asks that it
//                   free-runs and never starts at zero.
//   status(deg, far)         tx_am_sf<2:0> without an extender sublayer: bit 2 is FEC_degraded_SER or
//                   rx_local_degraded
module eth_am119;
  bit g400;
  reg [8:0] prbs = 9'h001;
  function automatic int lanes(); return g400 ? 16 : 8; endfunction
  function automatic [119:0] am(input int x);
    if (g400)
      case (x)
      0: return 120'hc8efe26f37101d9d9b565b6264a9a;
      1: return 120'h8121a5987ede5a67d9b56504264a9a;
      2: return 120'ha90cc10156f33efed9b56546264a9a;
      3: return 120'h2f7f797bd0808684d9b5655a264a9a;
      4: return 120'hdaed5e6f2512a19d9b565e1264a9a;
      5: return 120'h2eb0edb1d14f124ed9b565f2264a9a;
      6: return 120'h5e63bd11a19c42eed9b5653d264a9a;
      7: return 120'ha48929cd5b76d632d9b56522264a9a;
      8: return 120'h8a8c1e607573e19fd9b56560264a9a;
      9: return 120'hc33b8e5d3cc471a2d9b5656b264a9a;
      10: return 120'h27146afbd8eb9504d9b565fa264a9a;
      11: return 120'hc799dd8e38662271d9b5656c264a9a;
      12: return 120'h6a095da495f6a25bd9b56518264a9a;
      13: return 120'h3c68ce33c39731ccd9b56514264a9a;
      14: return 120'h5904354ea6fbcab1d9b565d0264a9a;
      15: return 120'h864559a979baa656d9b565b4264a9a;
      default: return 120'd0;
      endcase
    else
      case (x)
      0: return 120'h733f4c298cc0b3d6d9b56505264a9a;
      1: return 120'h8121a5987ede5a67d9b56504264a9a;
      2: return 120'ha90cc10156f33efed9b56546264a9a;
      3: return 120'h2f7f797bd0808684d9b5655a264a9a;
      4: return 120'hdaed5e6f2512a19d9b565e1264a9a;
      5: return 120'h2eb0edb1d14f124ed9b565f2264a9a;
      6: return 120'h5e63bd11a19c42eed9b5653d264a9a;
      7: return 120'ha48929cd5b76d632d9b56522264a9a;
      default: return 120'd0;
      endcase
  endfunction
  function automatic [47:0] common(input [119:0] m); return {m[55:32], m[23:0]}; endfunction
  function automatic [47:0] unique_part(input [119:0] m); return {m[119:96], m[87:64]}; endfunction
  function automatic void pad_seed(input [8:0] s); prbs = (s == 9'd0) ? 9'h001 : s; endfunction
  function automatic bit pad_bit();
    bit o;
    o = prbs[8];
    prbs = {prbs[7:0], prbs[8] ^ prbs[4]};
    return o;
  endfunction
  function automatic [2:0] status(input bit deg, input bit far); return {deg | far, 2'b00}; endfunction
endmodule
ConceptHow many PCS lanes does a 400GBASE-R PCS have?
ConceptWhich code does the Clause 119 PCS use?
ConceptForty 257-bit blocks enter the pre-FEC distribution. How many symbols does message A get?
ConceptWhy is the marker group laid out in a special order before the split?

Common Mistakes

Wrong Give the first half of the stream to codeword A and the second half to B.

The split is a round robin of symbols. Each message gets every other symbol.

Fix Even stream symbols to A, odd ones to B.

Wrong Put codeword A on the even lanes and codeword B on the odd lanes.

A burst on one lane would then hit one codeword only.

Fix Swap the pair of lanes on every round, so the symbols alternate along each lane.

Wrong Scramble or transcode the marker group.

The receiver searches the raw lanes for the marker pattern, before FEC.

Fix Insert the group after the scrambler, as it is.

Wrong Search each lane for its own unique marker first.

Lanes may arrive in any order.

Fix Lock on the common part, then read the lane number from the unique part.

Remember

  • The 200G and 400G PCS holds the FEC: encode, transcode, scramble, insert markers, split, two RS(544,514) encoders, deal.
  • Pre-FEC distribution deals 1,028 symbols in turn to messages A and B.
  • Symbol distribution puts both codewords on 8 or 16 lanes. Along a lane the symbols alternate between A and B.
  • A marker is 120 bits: common part, unique part, pad octets. The group is 1,028 or 2,056 bits with a PRBS9 pad and 3 status bits.
  • The group is laid out so that each lane carries its own whole marker. The receiver locks on the common part and reads the lane from the unique part.

Practice

Report a problem with this page