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 lane | First six symbols on the lane |
|---|---|
| 200GBASE-R lane 0 | A0, B4, A8, B12, A16, B20 |
| 200GBASE-R lane 1 | B0, A4, B8, A12, B16, A20 |
| 200GBASE-R lane 2 | A1, B5, A9, B13, A17, B21 |
| 200GBASE-R lane 7 | B3, 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).
- Datapath
- Channel / handshake
- Data
- Blocks
Encode and transcode as P11.22 and P11.30 showed. Then the whole 257-bit block is scrambled.
- Markers
Now and then a marker group takes the place of the first blocks. It is not scrambled.
- Two messages
Forty blocks are 1,028 symbols. They go to messages A and B in turn.
- 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-R | 200GBASE-R and 400GBASE-R | |
|---|---|---|
| FEC | a sublayer of its own (Clause 91) | inside the PCS, always RS(544,514) |
| Scrambler | on 66-bit blocks, before transcoding | on 257-bit blocks, after transcoding |
| Codewords | one at a time, on 4 FEC lanes | two at a time, interleaved |
| PCS lanes | 20 | 8 and 16 |
| Marker of a lane | 66 bits, with BIP | 120 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).
| Message | Stream symbols it gets | Symbols |
|---|---|---|
| A | 0, 2, 4, 6, 8, ... | 514 |
| B | 1, 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 type | Lane | First six symbols |
|---|---|---|
| 200GBASE-R | 0 | A0, B4, A8, B12, A16, B20 |
| 200GBASE-R | 1 | B0, A4, B8, A12, B16, A20 |
| 200GBASE-R | 2 | A1, B5, A9, B13, A17, B21 |
| 200GBASE-R | 7 | B3, A7, B11, A15, B19, A23 |
| 400GBASE-R | 0 | A0, B8, A16, B24, A32, B40 |
| 400GBASE-R | 1 | B0, A8, B16, A24, B32, A40 |
| 400GBASE-R | 15 | B7, 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 type | Markers | Pad | Status | Group | One group every |
|---|---|---|---|---|---|
| 200GBASE-R | 8 x 120 bits | 65 bits | 3 bits | 1,028 bits: 4 blocks | 4,096 codewords |
| 400GBASE-R | 16 x 120 bits | 133 bits | 3 bits | 2,056 bits: 8 blocks | 8,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 group | Symbol 0 | Symbol 1 | Symbol 2 | Symbol 3 | Symbol 4 | Symbol 5 | Symbol 6 | Symbol 7 |
|---|---|---|---|---|---|---|---|---|
| Row 0: symbol 0 of each marker | am_0 to A | am_1 to B | am_2 to A | am_3 to B | am_4 to A | am_5 to B | am_6 to A | am_7 to B |
| Row 1: symbol 1 of each marker | am_1 to A | am_0 to B | am_3 to A | am_2 to B | am_5 to A | am_4 to B | am_7 to A | am_6 to B |
| Row 2: symbol 2 of each marker | am_0 to A | am_1 to B | am_2 to A | am_3 to B | am_4 to A | am_5 to B | am_6 to A | am_7 to B |
| Row 3: symbol 3 of each marker | am_1 to A | am_0 to B | am_3 to A | am_2 to B | am_5 to A | am_4 to B | am_7 to A | am_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 119A | 200GBASE-R | 400GBASE-R |
|---|---|---|
| Marker group built from the marker table | equal | equal |
| Codewords A and B after the split and the encoder | both equal | both equal |
| First two parity symbols of A | 106, 275 | 916, 586 |
| Lanes that start with their own marker | 8 of 8 | 16 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).
| Step | What it uses |
|---|---|
| Marker lock on each lane | the common part of the marker |
| Deskew and reorder | the unique part gives the PCS lane number |
| De-interleave | the alternating pattern gives back codewords A and B |
| Decode | each codeword corrects up to 15 symbols |
| Post-FEC interleave | the two messages become one stream again |
| Remove markers, descramble, transcode | the 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.
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: 100Read 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
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.