PCS: 64b/66b Block Encoding

Ten gigabit Ethernet packs eight XGMII characters into one 66-bit block. Learn the two sync headers, the fifteen block types and the 7-bit control codes.

You Will Be Able To

  • Split a 66-bit block into its sync header, block type field and payload.
  • Pick the block type from the pattern of control characters.
  • Place data octets, C codes and O codes in the payload.
  • Tell a valid block from an invalid one.
Lesson
P11.22
Time
35 min
Runs on
Your browser
Check
5 questions

The XGMII marks each octet with a control flag: eight flags beside every 64 data bits. The 64b/66b code does the same job with two bits.

The Control Pattern Selects the Block TypeThe example stream, eight characters at a time: idle, three fault patterns, then the 64-octet frame of P11.17.
01234567891011121314charactersI I I I / I I I IQ D D D / I I I II I I I / Q D D DQ D D D / Q D D DS D D D / D D D DD D D D / D D D DT I I I / I I I II I I I / I I I Isync header100110block type1Eh4Bh2Dh55h78hnone87h1Eh
Scroll horizontally ↔
  1. Cycle 0

    Eight idles. The sync header 10 says control. Type 1Eh says all eight are control characters.

  2. Cycle 1

    An ordered set fills the first four characters. That pattern has its own type, 4Bh.

  3. Cycle 2

    The same set in the last four characters is a different pattern: 2Dh.

  4. Cycle 4

    Start in character 0, then seven octets: 78h. The type field stands in for the Start.

  5. Cycle 5

    Eight data octets. The sync header 01 is enough. There is no type field.

  6. Cycle 13

    Terminate in character 0: 87h. The seven idles after it travel as 7-bit codes.

Bench run of the example. I idle, Q sequence ordered set, S Start, T Terminate, D data.

Eight Characters, One Block

The 10GBASE-R PCS (Clause 49) sits under the XGMII of P11.17. It takes two XGMII transfers at a time: eight characters (49.2.4.1).

It sends them as a block of 66 bits. The first two bits are the sync header. The other 64 are the payload (49.2.4.3).

From the XGMII to the LineTwo transfers become one block. Only the payload is scrambled.
  • Channel / handshake
  • Datapath
  • Neutral
  • Data
From the XGMII to the lineTwo transfers become one block. Only the payload is scrambled. channel XGMII two transfers: eightcharacters, eightflags datapath Encoder this lesson neutral Sync header 2 bits: 01 data, 10control neutral Payload 64 bits datapath Scrambler P10.5 neutral 66-bit block header first, thenthe payload 72 bitsnot scrambled
  1. channel XGMIItwo transfers: eight characters, eight flags
    • 72 bits → Encoder
  2. datapath Encoderthis lesson
    • Sync header
    • Payload
  3. neutral Sync header2 bits: 01 data, 10 control
    • not scrambled → 66-bit block
  4. neutral Payload64 bits
    • Scrambler
  5. datapath ScramblerP10.5
    • 66-bit block
  6. neutral 66-bit blockheader first, then the payload
  1. Collect

    Two XGMII transfers give eight characters. Each has an octet and a control flag.

  2. Encode

    The encoder writes a sync header and 64 payload bits. The flags are gone.

  3. Scramble

    The payload goes through the scrambler. The sync header goes around it.

  4. Send

    The header leaves first. Its two bits always differ, so every block has a transition there.

Read the diagram as text
  • XGMII: two transfers: eight characters, eight flags
  • Encoder: this lesson
  • Sync header: 2 bits: 01 data, 10 control
  • Payload: 64 bits
  • Scrambler: P10.5
  • 66-bit block: header first, then the payload
  • XGMII → Encoder: 72 bits
  • Encoder → Sync header
  • Encoder → Payload
  • Payload → Scrambler
  • Sync header → 66-bit block: not scrambled
  • Scrambler → 66-bit block

After IEEE Std 802.3-2022 Figure 49-5 (redrawn; the gearbox below the scrambler is left out).

Sync header 01 means eight data octets. Sync header 10 means a control block. The values 00 and 11 are never sent.

Binary values here are written first bit first. So for 01 the first bit on the line is 0.

PCSMAC rateOn the lineBlocks a second
10GBASE-R (Clause 49)10 Gb/s10.3125 Gb/s156.25 million
25GBASE-R (Clause 107)25 Gb/s25.78125 Gb/s390.625 million

Bench arithmetic: 66 bits for every 64. The sync header adds 3.125 percent; 8b/10b added 25.

The payload is then scrambled, and the sync header is not (P10.5). The receiver finds the block boundary from that header (P10.4).

The Block Type Field

A control block starts with an 8-bit block type field. It tells the receiver which characters are control characters.

TypeFirst four charactersLast fourPayload after the type field
none (sync 01)D D D DD D D Deight octets, 64 bits
1EhC C C CC C C Ceight C codes
2DhC C C CO D D Dfour C codes, an O code, three octets
33hC C C CS D D Dfour C codes, four spare bits, three octets
66hO D D DS D D Dthree octets, an O code, four spare bits, three octets
55hO D D DO D D Dthree octets, two O codes, three octets
78hS D D DD D D Dseven octets
4BhO D D DC C C Cthree octets, an O code, four C codes
87h to FFhT in character kk octets, spare bits, then 7 - k C codes

After IEEE Std 802.3-2022 Figure 49-7 (redrawn as a list). C is a control character with a C code, O an ordered set, S Start, T Terminate.

Start may be character 0 or character 4 only. An ordered set may start there too (49.2.4.8, 49.2.4.10). That is lane 0 of each transfer.

The type field stands in for Start and Terminate. Neither needs a code of its own in the payload.

Hex values are sent lowest bit first. Type 1Eh went out as 01111000 in the example run.

The fifteen type values differ from each other in at least 4 bits. The bench tried all 540 one-bit and two-bit errors in a type field. None gave another type.

Control Codes and O Codes

On the XGMII a control character is an octet plus a flag. In a block it shrinks to a 7-bit C code (49.2.4.4).

CharacterXGMII codeIn a block
Idle07hC code 00h
Low power idle06hC code 06h (P11.39)
ErrorFEhC code 1Eh
Six reserved characters1Ch, 3Ch, 7Ch, BCh, DCh, F7hC codes 2Dh, 33h, 4Bh, 55h, 66h, 78h
StartFBhthe block type field
TerminateFDhthe block type field
Sequence ordered set9Chthe block type field and O code 0h

IEEE Std 802.3-2022 Table 49-1. The C codes are what the bench function c_code returns. One more set, for Fibre Channel, uses O code Fh.

Eight C codes take 56 bits. That is exactly the room left after the type field.

An ordered set keeps its three data octets. Its first character becomes a 4-bit O code: 0h for the sequence set of P11.19.

In the example, block 1 holds a local fault set and four idles. It went out as 10 11010010 and then the payload.

Data octets go into the payload unchanged, lowest bit first.

Where Terminate Lands

A frame may have any length. So Terminate may be any of the eight characters, and each position has its own type (49.2.4.9).

Frame octetsTerminate is characterBlock typeOctets in the blockC codesSpare bits
64087h077
65199h166
662AAh255
673B4h344
684CCh433
695D2h522
706E1h611
717FFh700

Bench runs with a private encoder. Start was character 0 of its block each time. Spare bits are sent as zero.

The octets before Terminate fill the payload from its start. The C codes after it fill the payload from its end. The bits between them are spare.

Spare bits are sent as zero. A receiver ignores them (49.2.4.3).

A Frame, Encoded and Decoded

The bench encoded the 64-octet frame of P11.17 with idle around it. It made 12 blocks: 792 bits on the line.

A private decoder turned them back into characters. Every block matched what was sent, and 64 frame octets reached the far XGMII.

Now break the encoder. Twin wrong_block_type sends the Terminate type of the next position.

Frame sentClean encoderWith wrong_block_type
64 octets64 octets arrive65 octets arrive
65 octets65 octets arrive66 octets arrive
66 octets66 octets arrive67 octets arrive
67 octets67 octets arrive68 octets arrive
68 octets68 octets arrive69 octets arrive
69 octets69 octets arrive70 octets arrive
70 octets70 octets arrive71 octets arrive
71 octets71 octets arrivethe block is rejected; no Terminate arrives

Bench runs with the private encoder and decoder. The faulty encoder sends the Terminate type of the next position.

The receiver trusts the type field. So it takes one spare octet as frame data, and the frame check sequence no longer fits.

The readable eth_66 has a twin of the same name. It swaps types 2Dh and 4Bh, so a fault set lands in the wrong half.

Valid and Invalid Blocks

A received block is checked before it is used (49.2.4.6). A bad sync header, an unused type or an unknown code makes it invalid.

The decoder receivesVerdict
an idle blocktaken
sync header 00error: eight Error characters go to the XGMII
sync header 11error: eight Error characters go to the XGMII
block type 00herror: eight Error characters go to the XGMII
block type 1Fh, one bit from 1Eherror: eight Error characters go to the XGMII
C code 01h in an idle blockerror: eight Error characters go to the XGMII
the error code 1Eh once in an idle blockerror: eight Error characters go to the XGMII
the LPI code 06h, PCS without EEEerror: eight Error characters go to the XGMII
six spare bits of a 99h block settaken
the error code 1Eh after a Terminatetaken
O code 5h in a 4Bh blockerror: eight Error characters go to the XGMII

Bench runs with a private decoder that has no EEE support. The rules are 49.2.4.6 and the block classes of 49.2.13.2.3.

An invalid block is not passed on in part. The receiver hands the XGMII eight Error characters in its place (49.2.4.11).

Two rows may surprise. One error code inside an idle block spoils the whole block. After a Terminate the same code is accepted.

That follows the block classes of 49.2.13.2.3, which P11.23 puts to work.

The Same Code at Other Rates

The 25GBASE-R PCS is the Clause 49 PCS with three changes (107.1.2). None of them touches the block formats.

Its interface to the layer below is one bit wide. It adds one test pattern. And its error monitor uses other limits (P11.24).

The 25GMII above it carries the same characters as the XGMII, on a faster clock (P11.18). So this lesson holds at 25 Gb/s as it stands.

The 5GBASE-R PCS reuses Clause 49 too, apart from its error monitor (129.1.2).

From 40 Gb/s up, Start sits in character 0 only. That PCS drops types 2Dh, 33h, 66h and 55h (82.2.3.3).

Clause 49 also names a gearbox. It fits 66-bit blocks onto a 16-bit interface (49.2.7). P10.4 built one.

Try It

The bench lays idle, three fault patterns and one frame on the XGMII. It prints each group of eight characters with its sync header and type.

Read block 1 as sent. After the sync header comes 4Bh, lowest bit first. The only 1 in the payload is the last octet of the fault set.

Add e.wrong_block_type = 1; before the loop. Blocks 1 and 2 change from 4Bh and 2Dh to 2Dh and 4Bh.

RUNIcarus Verilog · in your browser
Edit the code, then run it
Expected: block 0: I I I I / I I I I sync 10, type 1e (laid out by eth_66) block 1: Q D D D / I I I I sync 10, type 4b (laid out by eth_66) block 2: I I I I / Q D D D sync 10, type 2d (laid out by eth_66) block 3: Q D D D / Q D D D sync 10, type 55 (laid out by eth_66) block 4: S D D D / D D D D sync 10, type 78 block 5: D D D D / D D D D sync 01, eight data octets block 6: D D D D / D D D D sync 01, eight data octets block 7: D D D D / D D D D sync 01, eight data octets block 8: D D D D / D D D D sync 01, eight data octets block 9: D D D D / D D D D sync 01, eight data octets block 10: D D D D / D D D D sync 01, eight data octets block 11: D D D D / D D D D sync 01, eight data octets block 12: D D D D / D D D D sync 01, eight data octets block 13: T I I I / I I I I sync 10, type 87 block 14: I I I I / I I I I sync 10, type 1e (laid out by eth_66) block 0 as sent: 10 01111000 00000000000000000000000000000000000000000000000000000000 block 1 as sent: 10 11010010 00000000000000001000000000000000000000000000000000000000
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_mac.sv
`timescale 1ns/1ns
// eth_frame: one MAC frame as octets, its packet as wire bits, and a bit-serial receiver.
//   pay[i]                         client data, set by the bench before build()
//   build(da, sa, lt, len)         destination, source, Length/Type, len data octets, then the FCS -> oct[0..n-1].
//                                  It adds no pad: give it 46 data octets or more. (Padding is P11.2.1's task; the
//                                  pages show the padding MAC's frames as measured tables.)
//   wire_bits(), wire_bit(i)       the packet in transmit order: preamble, SFD, frame
//   rx_start(), rx_bit(b), rx_end()  hunt for the SFD, collect octets, then parse()
//   parse()                        da, sa, lt, is_length, is_type, data_len, fcs_rx, fcs_calc, fcs_ok
// Faults: fcs_msb_first, fcs_no_invert, fcs_covers_preamble, sfd_wrong, msb_first_octets.
module eth_frame;
  localparam int MIN_FRAME = 64, MAX_BASIC = 1518, MAX_QTAG = 1522, MAX_ENVELOPE = 2000;
  bit fcs_msb_first = 0, fcs_no_invert = 0, fcs_covers_preamble = 0, sfd_wrong = 0, msb_first_octets = 0;
  hs_crc crc();
  bit [7:0] pay [0:2047];
  bit [7:0] oct [0:2047];
  int n = 0;
  bit [47:0] da = 0, sa = 0; bit [15:0] lt = 0;
  bit is_length = 0, is_type = 0, fcs_ok = 0;
  int data_len = 0;
  bit [31:0] fcs_rx = 0, fcs_calc = 0;
  // receiver state
  bit in_frame = 0; bit [7:0] hist = 0, cur = 0; int nb = 0, excess = 0, sfd_at = -1, bits_seen = 0;

  // The FCS of oct[0..len-1] as four octets: the first octet sent is in [7:0].
  function automatic [31:0] fcs_of(input int len);
    crc.use_crc32(); crc.msb_first = fcs_msb_first; crc.no_invert = fcs_no_invert; crc.reset();
    if (fcs_covers_preamble) begin
      for (int i = 0; i < 7; i++) crc.crc_byte(8'h55);
      crc.crc_byte(8'hd5);
    end
    for (int i = 0; i < len; i++) crc.crc_byte(oct[i]);
    return crc.check_value();
  endfunction

  function automatic void build(input [47:0] d, input [47:0] s, input [15:0] t, input int len);
    int k; reg [31:0] f;
    k = 0;
    for (int i = 0; i < 6; i++) begin oct[k] = d[47 - 8*i -: 8]; k++; end
    for (int i = 0; i < 6; i++) begin oct[k] = s[47 - 8*i -: 8]; k++; end
    oct[k] = t[15:8]; k++;
    oct[k] = t[7:0]; k++;
    for (int i = 0; i < len; i++) begin oct[k] = pay[i]; k++; end
    f = fcs_of(k);
    for (int i = 0; i < 4; i++) begin oct[k] = f[8*i +: 8]; k++; end
    n = k; excess = 0;
    parse();
  endfunction

  function automatic void parse();
    da = 0; sa = 0; lt = 0; is_length = 0; is_type = 0; fcs_ok = 0; data_len = 0; fcs_rx = 0; fcs_calc = 0;
    if (n >= 14) begin
      da = {oct[0], oct[1], oct[2], oct[3], oct[4], oct[5]};
      sa = {oct[6], oct[7], oct[8], oct[9], oct[10], oct[11]};
      lt = {oct[12], oct[13]};
      is_length = (lt <= 16'd1500);
      is_type = (lt >= 16'd1536);
    end
    if (n >= 18) begin
      fcs_rx = {oct[n-1], oct[n-2], oct[n-3], oct[n-4]};
      fcs_calc = fcs_of(n - 4);
      fcs_ok = (fcs_rx == fcs_calc);
      data_len = is_length ? int'(lt) : n - 18;
    end
  endfunction

  function automatic int wire_bits(); return 8 * (8 + n); endfunction
  function automatic bit wire_bit(input int i);
    int o, b; reg [7:0] v;
    o = i / 8; b = i % 8;
    if (o < 7) v = 8'h55;
    else if (o == 7) v = sfd_wrong ? 8'h55 : 8'hd5;
    else v = oct[o - 8];
    return msb_first_octets ? v[7 - b] : v[b];
  endfunction

  function automatic void rx_start();
    in_frame = 0; hist = 0; cur = 0; nb = 0; n = 0; excess = 0; sfd_at = -1; bits_seen = 0;
  endfunction
  function automatic void rx_bit(input bit b);
    bits_seen++;
    if (!in_frame) begin
      hist = {hist[6:0], b};                      // the oldest bit is hist[7]
      if (hist == 8'b10101011) begin in_frame = 1; sfd_at = bits_seen; end
    end else begin
      if (msb_first_octets) cur[7 - nb] = b; else cur[nb] = b;
      nb++;
      if (nb == 8) begin oct[n] = cur; n++; nb = 0; end
    end
  endfunction
  function automatic void rx_end(); excess = nb; parse(); endfunction
endmodule
// eth_axis: a MAC client bus in the style of AXI4-Stream (IHI 0051B 2.2 handshake, 2.5 TKEEP, 2.6 TLAST, 2.9 TUSER),
// 64 bits wide. Byte 0 of a beat is tdata[7:0] and is first in the frame (AXI4-Stream 2.4.1). Bench conventions,
// not AXI4-Stream's or 802.3's: tkeep is all ones except on the last beat, where it covers bytes 0 to k-1; one tuser
// bit (transfer-based, 2.9.1), read on the last beat only, marks a bad frame (receive) or asks the MAC to abort it
// (transmit).
//   load(n)                  beats for octets oct[0..n-1]: bd[], bk[], bl[], nbeats; bv[] = valid per cycle, ncyc
//   tx_cycles()              the transmit MAC: one beat per cycle once a frame has started. Returns 0 sent,
//                            1 underrun (tvalid fell inside the frame), 2 aborted by tuser. sent_octets, fail_cycle.
// Fault: tvalid_gap (load() leaves cycle 3 of the frame empty: the client was late with a beat).
module eth_axis;
  bit tvalid_gap = 0;
  bit [7:0] oct [0:2047];
  bit [63:0] bd [0:300]; bit [7:0] bk [0:300]; bit bl [0:300]; bit bu [0:300];
  int nbeats = 0;
  bit bv [0:301]; int bix [0:301]; int ncyc = 0;
  int sent_octets = 0, fail_cycle = -1;
  function automatic void load(input int n);
    int b, k;
    nbeats = (n + 7) / 8;
    for (b = 0; b < nbeats; b++) begin
      bd[b] = 64'd0; bk[b] = 8'd0; bl[b] = (b == nbeats - 1); bu[b] = 0;
      for (k = 0; k < 8; k++) if (8*b + k < n) begin bd[b][8*k +: 8] = oct[8*b + k]; bk[b][k] = 1'b1; end
    end
    ncyc = 0;
    for (b = 0; b < nbeats; b++) begin
      if (tvalid_gap && b == 3) begin bv[ncyc] = 0; bix[ncyc] = -1; ncyc++; end
      bv[ncyc] = 1; bix[ncyc] = b; ncyc++;
    end
  endfunction
  function automatic int tx_cycles();
    bit started; started = 0; sent_octets = 0; fail_cycle = -1;
    for (int c = 0; c < ncyc; c++) begin
      if (!bv[c]) begin
        if (started) begin fail_cycle = c; return 1; end
      end else begin
        started = 1;
        if (bl[bix[c]] && bu[bix[c]]) begin fail_cycle = c; return 2; end
        for (int k = 0; k < 8; k++) if (bk[bix[c]][k]) sent_octets++;
      end
    end
    return 0;
  endfunction
endmodule

// eth_pause: the PAUSE function of MAC Control (Annex 31B) at the station that receives PAUSE frames, in octet
// times (one octet time is 8 bit times; a pause quantum is 512 bit times = 64 octet times, 31B.2).
//   reset(), rx_pause(t, q)  a valid PAUSE frame with pause_time q ended at time t: the timer restarts (31B.3.3)
//   may_start(t)             1 when a new data frame may start at time t. A frame already started is never cut
//                            (31B.3.7). react is the bench's reaction time: frames may still start until t + react.
//   paused_until             the time the timer runs out
//   pause_octets(q, o[])     not here: build a PAUSE frame with eth_frame (DA 01-80-C2-00-00-01, 8808h, 0001h, q)
// Faults: pause_ignored, pause_adds_not_overrides (a new frame adds to the timer, and zero does not cancel),
//         slow_reaction (react = 70 quanta, over the 60 allowed at 10 Gb/s), timer_in_bits (q counts bit times).
module eth_pause;
  localparam int QUANTUM = 64;                     // octet times
  bit pause_ignored = 0, pause_adds_not_overrides = 0, slow_reaction = 0, timer_in_bits = 0;
  int react = 0, t_rx = -1, paused_until = 0;
  function automatic void reset(); t_rx = -1; paused_until = 0; endfunction
  function automatic void rx_pause(input int t, input int q);
    int len;
    if (pause_ignored) return;
    len = timer_in_bits ? (q + 7) / 8 : q * QUANTUM;
    if (pause_adds_not_overrides && paused_until > t) paused_until = paused_until + len;
    else paused_until = t + len;
    t_rx = t;
  endfunction
  function automatic bit may_start(input int t);
    int r;
    r = slow_reaction ? 70 * QUANTUM : react;
    if (t_rx < 0) return 1;
    if (t < t_rx + r) return 1;
    return t >= paused_until;
  endfunction
endmodule

// eth_pfc: priority-based flow control (Annex 31D). The frame is 802.3's; holding a priority's queue is the MAC
// Control client's job (IEEE 802.1Q, not held), so the eight timers here are a bench client, in octet times.
//   build(f_oct[], pev, times[])   not here: the bench writes opcode 01-01, the vector and eight times into eth_frame
//   reset(), rx(t, pev, tm[0..7])  for each e[n] = 1 (bit n of the vector's low octet), priority n stops until
//                                  t + 64 * time[n] (hold_end[n]); e[n] = 0 leaves priority n alone; time[n] = 0 releases it
//   blocked(n, t)                  1 while priority n is held
// Fault: pfc_wrong_priority (reads e[n] from bit 7 - n).
module eth_pfc;
  bit pfc_wrong_priority = 0;
  int hold_end [0:7];
  function automatic void reset(); for (int i = 0; i < 8; i++) hold_end[i] = 0; endfunction
  function automatic void rx(input int t, input [15:0] pev, input [127:0] tm);   // tm[16*n +: 16] = time[n]
    bit e;
    for (int n = 0; n < 8; n++) begin
      e = pfc_wrong_priority ? pev[7 - n] : pev[n];
      if (e) hold_end[n] = t + 64 * int'(tm[16*n +: 16]);
    end
  endfunction
  function automatic bit blocked(input int n, input int t); return t < hold_end[n]; endfunction
endmodule

// eth_csma_tx: one half-duplex transmitter (4.2.3.2), one call of tick() per octet time.
//   reset(), load(frame_octets)   a frame of frame_octets (DA to FCS) waits to be sent; it is padded to min_frame
//   tick(carrier)                 carrier: another station's signal is on the wire here now. Returns 1 when the
//                                 station puts an octet (packet or jam) on the wire.
//   plan[i]                       the wait, in slots, after collision i + 1. The bench sets it (default 0). This
//                                 readable station draws nothing and has no attempt limit.
//   state  0 idle, 1 defer, 2 send, 3 jam, 4 backoff, 5 sent (as far as the sender knows)
//   pkt, sent, quiet, left, attempts, late, last_start, last_r
// min_frame is 64 octets; a bench may lower it to show why it is 64. Fault: no_backoff (every wait is 0 slots).
// Deference is a bench simplification: the 12-octet quiet count restarts on any carrier, own or received, and the
// station never starts while carrier is present. 4.2.8 restarts only the first part of the gap, and then transmits
// whatever the carrier.
module eth_csma_tx;
  localparam int SLOT = 64, JAM = 4, GAP = 12, PRE = 8;   // octet times
  bit no_backoff = 0;
  int min_frame = 64;
  int plan [0:63];
  int state = 0, pkt = 0, sent = 0, quiet = GAP, left = 0, attempts = 0, late = 0, last_start = -1, last_r = 0, now = 0;
  function automatic void reset();
    state = 0; pkt = 0; sent = 0; quiet = GAP; left = 0; attempts = 0; late = 0; last_start = -1; last_r = 0; now = 0;
  endfunction
  function automatic void load(input int frame_octets);
    pkt = PRE + frame_octets;
    if (frame_octets < min_frame) pkt = PRE + min_frame;
    state = 1; attempts = 0; sent = 0; late = 0;
  endfunction
  function automatic bit tick(input bit carrier);
    bit on;
    on = 0;
    if (state == 1 && !carrier && quiet >= GAP) begin state = 2; sent = 0; last_start = now; end
    if (state == 2 && carrier) begin
      attempts++; if (sent > SLOT) late++;
      state = 3; left = JAM;
    end
    case (state)
      2: begin sent++; on = 1; if (sent == pkt) state = 5; end
      3: begin
           on = 1; left--;
           if (left == 0) begin
             last_r = no_backoff ? 0 : plan[(attempts - 1) % 64];
             left = SLOT * last_r;
             state = (left == 0) ? 1 : 4;
           end
         end
      4: begin left--; if (left == 0) state = 1; end
      default: ;
    endcase
    quiet = (carrier || on) ? 0 : ((quiet < GAP) ? quiet + 1 : GAP);
    now++;
    return on;
  endfunction
endmodule

// eth_csma: two eth_csma_tx stations, A and B, at the two ends of a wire with a one-way delay of d octet times.
//   run(fa, ready_a, fb, ready_b, tmax)   each station loads its frame (fa, fb octets) at its ready time
//   on_a[t], on_b[t]          what each station put on the wire at time t
//   ev_t[], ev_who[] (0 A, 1 B), ev_kind[], ev_v[], n_ev   the event log:
//     kind 0 starts attempt v; 1 sees a collision after v octets; 2 jam over, backs off v slots;
//     3 last octet sent (v = octets); 4 gives up after v attempts
//   delivered(i)              1 when station i's last attempt reached the far end with no overlap there
//   a.plan[], b.plan[], a.no_backoff, b.no_backoff, a.min_frame, b.min_frame: the stations' settings
module eth_csma;
  eth_csma_tx a(); eth_csma_tx b();
  int d = 10, n_ev = 0, tend = 0;
  bit on_a [0:16383]; bit on_b [0:16383];
  int ev_t [0:255]; int ev_who [0:255]; int ev_kind [0:255]; int ev_v [0:255];
  function automatic void log_ev(input int t, input int who, input int kind, input int v);
    if (n_ev < 256) begin ev_t[n_ev] = t; ev_who[n_ev] = who; ev_kind[n_ev] = kind; ev_v[n_ev] = v; n_ev++; end
  endfunction
  function automatic void note(input int t, input int who, input int s0, input int s1, input int sent0, input int att, input int r, input int sent1);
    if (s0 != 2 && s1 == 2) log_ev(t, who, 0, att + 1);
    if (s0 == 2 && (s1 == 3 || s1 == 4)) log_ev(t, who, 1, sent0);
    if (s0 == 3 && (s1 == 4 || s1 == 1)) log_ev(t, who, 2, r);
    if (s0 != 5 && s1 == 5) log_ev(t, who, 3, sent1);
    if (s0 != 6 && s1 == 6) log_ev(t, who, 4, att);
  endfunction
  function automatic void run(input int fa, input int ready_a, input int fb, input int ready_b, input int tmax);
    bit ca, cb; int sa, sb, xa, xb;
    a.reset(); b.reset(); n_ev = 0; tend = tmax;
    for (int t = 0; t < tmax; t++) begin
      if (t == ready_a) a.load(fa);
      if (t == ready_b) b.load(fb);
      ca = (t >= d) ? on_b[t - d] : 1'b0;
      cb = (t >= d) ? on_a[t - d] : 1'b0;
      sa = a.state; sb = b.state; xa = a.sent; xb = b.sent;
      on_a[t] = a.tick(ca);
      on_b[t] = b.tick(cb);
      note(t, 0, sa, a.state, xa, a.attempts, a.last_r, a.sent);
      note(t, 1, sb, b.state, xb, b.attempts, b.last_r, b.sent);
    end
  endfunction
  function automatic bit delivered(input int i);
    int s, p, u;
    if (i == 0 && a.state != 5) return 0;
    if (i == 1 && b.state != 5) return 0;
    s = (i == 0) ? a.last_start : b.last_start;
    p = (i == 0) ? a.pkt : b.pkt;
    for (int t = s; t < s + p; t++) begin
      u = t + d;
      if (u < tend && ((i == 0) ? on_b[u] : on_a[u])) return 0;
    end
    return 1;
  endfunction
endmodule

// eth_gap: how long the gap before the next Start is on a 4-lane XGMII, where Start must sit on lane 0
// (46.3.1.4). A gap counts every character from the Terminate to the last idle before Start. A packet is
// 8 + n characters (Start, six preamble octets, SFD, an n-octet frame) and starts on lane 0.
//   reset()                     DIC = 0 (the count is reset only at initialisation)
//   method                      0 deficit idle count, 1 always insert (both allowed by 46.3.1.4)
//   next_gap(n, mac_gap)        the gap after an n-octet frame when the MAC asks for mac_gap (12 or more)
//   deleted, inserted, dic      what the last call did, and the count after it
// Faults: ipg_min_only (always deletes, ignoring the bound), dic_max4 (bounds the count at 4, not 3),
//         start_any_lane (no alignment: the gap is always mac_gap).
module eth_gap;
  bit ipg_min_only = 0, dic_max4 = 0, start_any_lane = 0;
  int method = 0, dic = 0, deleted = 0, inserted = 0;
  function automatic void reset(); dic = 0; deleted = 0; inserted = 0; endfunction
  function automatic int next_gap(input int n, input int mac_gap);
    int m, top;
    deleted = 0; inserted = 0;
    m = (n + mac_gap) % 4;                       // lanes past lane 0 the next Start would land on
    if (start_any_lane || m == 0) return mac_gap;
    top = dic_max4 ? 4 : 3;
    if (method == 0 && (ipg_min_only || dic + m <= top)) begin deleted = m; dic = dic + m; end
    else begin inserted = 4 - m; if (method == 0) dic = dic - (4 - m); end
    return mac_gap - deleted + inserted;
  endfunction
endmodule
Read included file: eth_xgmii.sv
`timescale 1ns/1ns
// eth_rs: the packet as XGMII characters (9 bits: control flag and octet), four lanes per column, and the
// 66-bit block each pair of columns becomes.
//   clear(), put(c, d), idle(k)
//   lanes            4 for the XGMII and 25GMII (default), 8 for the 64-bit interfaces (XLGMII to 800GMII, P11.18)
//   start_packet()   adds idle until lane 0, then Start (FBh), six preamble octets and the SFD
//   end_packet()     Terminate (FDh)
//   columns(), lane_of(i)   columns of lanes characters; the lane of character i
//   block_info(g)    {valid, sync[1:0], type[7:0]} for characters 8g to 8g+7 (pad the tail with idle first)
// Fault: start_any_lane (Start is not aligned to lane 0).
module eth_rs;
  bit start_any_lane = 0;
  int lanes = 4;
  bit [8:0] ch [0:4095];
  int nch = 0;
  function automatic void clear(); nch = 0; endfunction
  function automatic void put(input bit c, input [7:0] d); ch[nch] = {c, d}; nch++; endfunction
  function automatic void idle(input int k); for (int i = 0; i < k; i++) put(1'b1, 8'h07); endfunction
  function automatic void start_packet();
    if (!start_any_lane) while (nch % lanes != 0) put(1'b1, 8'h07);
    put(1'b1, 8'hfb);
    for (int i = 0; i < 6; i++) put(1'b0, 8'h55);
    put(1'b0, 8'hd5);
  endfunction
  function automatic void end_packet(); put(1'b1, 8'hfd); endfunction
  function automatic void fill_to(input int multiple); while (nch % multiple != 0) put(1'b1, 8'h07); endfunction
  function automatic int columns(); return (nch + lanes - 1) / lanes; endfunction
  function automatic int lane_of(input int i); return i % lanes; endfunction
  function automatic bit is_c(input int i); return ch[i][8]; endfunction
  function automatic bit is_code(input int i, input [7:0] v); return ch[i] == {1'b1, v}; endfunction
  function automatic bit is_plain(input int i);            // a control character with a 7-bit C code
    return is_code(i, 8'h07) || is_code(i, 8'h06) || is_code(i, 8'hfe);
  endfunction
  function automatic bit all_data(input int a, input int b);
    for (int i = a; i <= b; i++) if (is_c(i)) return 0;
    return 1;
  endfunction
  function automatic bit all_plain(input int a, input int b);
    for (int i = a; i <= b; i++) if (!is_plain(i)) return 0;
    return 1;
  endfunction
  function automatic [10:0] block_info(input int g);
    int b; reg [7:0] t; bit ok;
    b = 8 * g; ok = 0; t = 8'h00;
    if (all_data(b, b + 7)) return {1'b1, 2'b01, 8'h00};
    if (all_plain(b, b + 7)) begin ok = 1; t = 8'h1e; end
    else if (is_code(b, 8'hfb) && all_data(b + 1, b + 7)) begin ok = 1; t = 8'h78; end
    else if (all_plain(b, b + 3) && is_code(b + 4, 8'hfb) && all_data(b + 5, b + 7)) begin ok = 1; t = 8'h33; end
    else if (is_code(b, 8'h9c) && all_data(b + 1, b + 3) && is_code(b + 4, 8'hfb) && all_data(b + 5, b + 7)) begin ok = 1; t = 8'h66; end
    else if (is_code(b, 8'h9c) && all_data(b + 1, b + 3) && is_code(b + 4, 8'h9c) && all_data(b + 5, b + 7)) begin ok = 1; t = 8'h55; end
    else if (is_code(b, 8'h9c) && all_data(b + 1, b + 3) && all_plain(b + 4, b + 7)) begin ok = 1; t = 8'h4b; end
    else if (all_plain(b, b + 3) && is_code(b + 4, 8'h9c) && all_data(b + 5, b + 7)) begin ok = 1; t = 8'h2d; end
    else begin
      for (int k = 0; k < 8; k++)
        if (!ok && is_code(b + k, 8'hfd) && (k == 0 || all_data(b, b + k - 1)) && (k == 7 || all_plain(b + k + 1, b + 7))) begin
          ok = 1;
          case (k)
            0: t = 8'h87; 1: t = 8'h99; 2: t = 8'haa; 3: t = 8'hb4;
            4: t = 8'hcc; 5: t = 8'hd2; 6: t = 8'he1; default: t = 8'hff;
          endcase
        end
    end
    return {ok, 2'b10, t};
  endfunction
endmodule

// eth_xgmii_mon: reads XGMII columns as a receiving RS would (46.2, 46.3.3) and reports what it sees.
// A column is {c[3:0], d[31:0]}: lane k is control flag c[k] and octet d[8k+7:8k]; lane 0 comes first.
//   reset(), col(c, d)      one column; col() returns 1 if the column holds anything the monitor flags
//   frames                  Starts seen on lane 0; octets: data octets after the SFD up to the Terminate
//   start_lane, term_lane   where the last Start and Terminate were (-1: not in this column)
//   bad_start               Starts on lanes 1 to 3 (46.3.3.3: the RS must not pass them to the MAC)
//   errors                  Error characters (FEh) seen inside a frame; err_frames: frames that carried one
//   seq_cols                columns holding a Sequence ordered set (9Ch in lane 0, P11.19)
//   last_len                data octets of the last frame, preamble and SFD excluded
module eth_xgmii_mon;
  int frames = 0, octets = 0, bad_start = 0, errors = 0, err_frames = 0, seq_cols = 0, last_len = 0;
  int start_lane = -1, term_lane = -1, in_pkt = 0, pre_left = 0, len = 0;
  bit had_err = 0;
  function automatic void reset();
    frames = 0; octets = 0; bad_start = 0; errors = 0; err_frames = 0; seq_cols = 0; last_len = 0;
    in_pkt = 0; pre_left = 0; len = 0; had_err = 0; start_lane = -1; term_lane = -1;
  endfunction
  function automatic bit col(input [3:0] c, input [31:0] d);
    bit flag; reg [7:0] o;
    flag = 0; start_lane = -1; term_lane = -1;
    if (c[0] && d[7:0] == 8'h9c) seq_cols++;
    for (int k = 0; k < 4; k++) begin
      o = d[8*k +: 8];
      if (c[k] && o == 8'hfb) begin
        start_lane = k;
        if (k != 0) begin bad_start++; flag = 1; end
        else begin in_pkt = 1; pre_left = 7; len = 0; had_err = 0; frames++; end
      end
      else if (in_pkt && c[k] && o == 8'hfd) begin
        term_lane = k; in_pkt = 0; last_len = len;
        if (had_err) err_frames++;
      end
      else if (in_pkt && c[k] && o == 8'hfe) begin errors++; had_err = 1; flag = 1; len++; end
      else if (in_pkt && !c[k]) begin
        if (pre_left > 0) pre_left--;
        else begin len++; octets++; end
      end
    end
    return flag;
  endfunction
endmodule
Read included file: eth_pcs.sv
`timescale 1ns/1ns
// eth_pcs.sv: the 1000BASE-X PCS, transmit side and synchronization (read-only). It sits on hs_8b10b (hs_code.sv).

// eth_1000x: the transmit ordered-set layer (36.2.4). The stream is kept as {k, d} and as ten coded bits.
//   clear()            empty stream, running disparity negative
//   idle(k)            k idle ordered sets. Each tests the running disparity first (Figure 36-6):
//                      positive -> /I1/ (K28.5 D5.6), negative -> /I2/ (K28.5 D16.2)
//   cfg(word, k)       k configuration ordered sets, /C1/ and /C2/ in turn: K28.5, D21.5 or D2.2, word[7:0], word[15:8]
//   start_packet()     /S/ in place of the first preamble octet, then six 55h and D5h
//   data(d)            one data code-group
//   end_packet()       /T/ /R/, and one more /R/ when the first /R/ went out on an even position
//   err()              /V/
//   put(k, d)          any code-group
//   n                  code-groups so far; code-group i is even-numbered when i is even
//   sym[i] = {k, d};  code[i] = abcdei fghj, bit a (code[i][9]) is sent first;  rdb[i] = running disparity before i
//   is_k(i, d), comma_plus(), comma_minus()
// Fault: idle_wrong_disparity (every idle is /I2/, so a positive running disparity is never corrected).
module eth_1000x;
  bit idle_wrong_disparity = 0;
  hs_8b10b c8();
  bit [8:0] sym [0:8191]; bit [9:0] code [0:8191]; bit rdb [0:8191];
  int n = 0; bit c2 = 0;
  function automatic void clear(); n = 0; c2 = 0; c8.rd_tx = 0; endfunction
  function automatic void put(input bit k, input [7:0] d);
    sym[n] = {k, d}; rdb[n] = c8.rd_tx; code[n] = c8.enc(d, k); n++;
  endfunction
  function automatic void idle(input int k);
    bit positive;
    for (int i = 0; i < k; i++) begin
      positive = c8.rd_tx && !idle_wrong_disparity;
      put(1'b1, 8'hbc);                                // K28.5
      put(1'b0, positive ? 8'hc5 : 8'h50);             // D5.6 or D16.2
    end
  endfunction
  function automatic void cfg(input [15:0] word, input int k);
    for (int i = 0; i < k; i++) begin
      put(1'b1, 8'hbc);
      put(1'b0, c2 ? 8'h42 : 8'hb5);                   // D2.2 or D21.5
      put(1'b0, word[7:0]); put(1'b0, word[15:8]);
      c2 = !c2;
    end
  endfunction
  function automatic void data(input [7:0] d); put(1'b0, d); endfunction
  function automatic void start_packet();
    put(1'b1, 8'hfb);                                  // /S/ = K27.7
    for (int i = 0; i < 6; i++) put(1'b0, 8'h55);
    put(1'b0, 8'hd5);
  endfunction
  function automatic void end_packet();
    put(1'b1, 8'hfd);                                  // /T/ = K29.7
    put(1'b1, 8'hf7);                                  // /R/ = K23.7
    if (n % 2 != 0) put(1'b1, 8'hf7);                  // that /R/ was even-numbered: one more
  endfunction
  function automatic void err(); put(1'b1, 8'hfe); endfunction     // /V/ = K30.7
  function automatic bit is_k(input int i, input [7:0] d); return sym[i] == {1'b1, d}; endfunction
  function automatic int comma_plus();
    int c; c = 0;
    for (int i = 0; i < n; i++) if (code[i][9:3] == 7'b0011111) c++;
    return c;
  endfunction
  function automatic int comma_minus();
    int c; c = 0;
    for (int i = 0; i < n; i++) if (code[i][9:3] == 7'b1100000) c++;
    return c;
  endfunction
endmodule

// eth_1000x_sync: the synchronization process of Figure 36-9, one call of rx() per ten-bit code-group.
//   reset()            LOSS_OF_SYNC
//   rx(code)           takes one code-group; returns sync_status (1 = OK)
//   state              0 LOSS_OF_SYNC, 1 COMMA_DETECT_1, 2 ACQUIRE_SYNC_1, 3 COMMA_DETECT_2, 4 ACQUIRE_SYNC_2,
//                      5 COMMA_DETECT_3, 6 SYNC_ACQUIRED_1, 7 SYNC_ACQUIRED_2, 8 SYNC_ACQUIRED_2A,
//                      9 SYNC_ACQUIRED_3, 10 SYNC_ACQUIRED_3A, 11 SYNC_ACQUIRED_4, 12 SYNC_ACQUIRED_4A
//   even               the code-group just taken was even-numbered
//   good_cgs, bad_seen (every bad code-group since reset), k, d (the last decode)
// A code-group is bad when it is invalid, or when it holds a comma and is odd-numbered (36.2.5.1.3).
// Bench choices: in LOSS_OF_SYNC the decoder takes its running disparity from the comma it finds; an invalid
// code-group leaves the decoder's running disparity as the received bits set it.
module eth_1000x_sync;
  hs_8b10b c8();
  int state = 0, good_cgs = 0, bad_seen = 0;
  bit even = 0, sync = 0, rd = 0, k = 0; bit [7:0] d = 0;
  function automatic void reset(); state = 0; good_cgs = 0; bad_seen = 0; even = 0; sync = 0; rd = 0; endfunction
  function automatic bit rx(input [9:0] code);
    reg [11:0] r; bit invalid, comma, is_d, bad;
    comma = code[9:3] == 7'b0011111 || code[9:3] == 7'b1100000;
    if (state == 0 && comma) rd = (code[9:3] == 7'b1100000);
    r = c8.decode(code, rd);                           // {rd_out, disp_err, code_err, k, d}
    rd = r[11]; k = r[8]; d = r[7:0];
    invalid = r[10] || r[9];
    is_d = !invalid && !r[8];
    bad = invalid || (comma && even);                  // even: the one before was even, so this one is odd
    if (bad && state != 0) bad_seen++;
    case (state)
      0: begin if (comma) begin state = 1; even = 1; end else even = !even; end
      1, 3, 5: begin even = 0; state = is_d ? state + 1 : 0; end
      2, 4: begin
        if (bad) state = 0;
        else if (comma) begin state = state + 1; even = 1; end
        else even = !even;
      end
      6: begin even = !even; if (bad) begin state = 7; good_cgs = 0; end end
      7, 9, 11: begin
        even = !even;
        if (bad) begin state = (state == 11) ? 0 : state + 2; good_cgs = 0; end
        else begin state = state + 1; good_cgs = 1; end
      end
      default: begin                                   // 8, 10, 12: counting good code-groups
        even = !even;
        if (bad) begin state = (state == 12) ? 0 : state + 1; good_cgs = 0; end
        else if (good_cgs == 3) begin state = (state == 8) ? 6 : state - 3; good_cgs = 0; end
        else good_cgs++;
      end
    endcase
    sync = state >= 6;
    return sync;
  endfunction
endmodule

// ---- 10GBASE-R and 25GBASE-R: 64B/66B blocks (Clause 49; Clause 107 uses the same code) ----
// Eight XGMII characters are one vector raw[71:0] (49.2.13.2.2): raw[k] is the control flag of character k,
// raw[8 + 8*k +: 8] its octet. A block is blk[65:0]; bit 0 is sent first. blk[1:0] is the sync header,
// blk[9:2] the block type field of a control block, the rest the payload (Figure 49-7).

// eth_66: the control blocks that hold no Start, no Terminate and no frame data.
//   c_code(x)       Table 49-1: the 7-bit C code of XGMII control code x; 7Fh if x is not in the table
//   enc_ctrl(raw)   {ok, blk}: block type 1Eh (eight control characters), 2Dh (four, then an ordered set),
//                   4Bh (an ordered set, then four) or 55h (two ordered sets); ok = 0 if raw is none of these.
//                   It only lays out the fields. Whether the vector may be sent is the transmit process's
//                   decision (eth_66_tx).
//   on_wire(blk)    the 66 bits as text in the order they are sent: sync, block type, payload
//   ham(a, b)       how many bits differ between two block type values
// Fault: wrong_block_type (types 2Dh and 4Bh are swapped).
module eth_66;
  bit wrong_block_type = 0;
  function automatic [6:0] c_code(input [7:0] x);
    case (x)
      8'h07: return 7'h00;                             // idle
      8'h06: return 7'h06;                             // low power idle
      8'hfe: return 7'h1e;                             // error
      8'h1c: return 7'h2d;                             // the six reserved characters
      8'h3c: return 7'h33;
      8'h7c: return 7'h4b;
      8'hbc: return 7'h55;
      8'hdc: return 7'h66;
      8'hf7: return 7'h78;
      default: return 7'h7f;
    endcase
  endfunction
  function automatic [7:0] ch(input [71:0] raw, input int k); return raw[8 + 8*k +: 8]; endfunction
  // characters k to k+3 are a sequence ordered set: 9Ch with its flag, then three data octets
  function automatic bit is_q(input [71:0] raw, input int k);
    return raw[k] && ch(raw, k) == 8'h9c && !raw[k + 1] && !raw[k + 2] && !raw[k + 3];
  endfunction
  // characters k to k+3 are control characters with a C code
  function automatic bit is_c4(input [71:0] raw, input int k);
    for (int j = k; j < k + 4; j++) if (!raw[j] || c_code(ch(raw, j)) == 7'h7f) return 0;
    return 1;
  endfunction
  function automatic [66:0] enc_ctrl(input [71:0] raw);
    reg [65:0] b; bit q0, q4, c0, c4;
    b = 66'd0;
    b[1:0] = 2'b01;                                    // sync header "10": bit 0, sent first, is 1
    q0 = is_q(raw, 0); q4 = is_q(raw, 4); c0 = is_c4(raw, 0); c4 = is_c4(raw, 4);
    if (c0 && c4) b[9:2] = 8'h1e;
    else if (c0 && q4) b[9:2] = wrong_block_type ? 8'h4b : 8'h2d;
    else if (q0 && c4) b[9:2] = wrong_block_type ? 8'h2d : 8'h4b;
    else if (q0 && q4) b[9:2] = 8'h55;
    else return 67'd0;
    if (c0) for (int k = 0; k < 4; k++) b[10 + 7*k +: 7] = c_code(ch(raw, k));
    else begin b[33:10] = raw[39:16]; b[37:34] = 4'h0; end     // D1 to D3, then the O code of the sequence set
    if (c4) for (int k = 4; k < 8; k++) b[10 + 7*k +: 7] = c_code(ch(raw, k));
    else begin b[41:38] = 4'h0; b[65:42] = raw[71:48]; end     // the O code, then D5 to D7
    return {1'b1, b};
  endfunction
  function automatic string on_wire(input [65:0] blk);
    string s;
    s = "";
    for (int i = 0; i < 66; i++) begin
      if (i == 2 || i == 10) s = {s, " "};
      s = {s, blk[i] ? "1" : "0"};
    end
    return s;
  endfunction
  function automatic int ham(input [7:0] a, input [7:0] b);
    int n; reg [7:0] x;
    x = a ^ b; n = 0;
    for (int i = 0; i < 8; i++) if (x[i]) n++;
    return n;
  endfunction
endmodule

// eth_66_tx: the transmit state diagram (Figure 49-16) without the EEE state. One call per vector.
//   step(t)   t is the T_TYPE of the vector: 0 C (control), 1 S (start), 2 T (terminate), 3 D (data), 4 E (none of these).
//             Returns 1 if the vector is encoded and sent, 0 if the error block goes out in its place.
//   state     0 TX_INIT, 1 TX_C, 2 TX_D, 3 TX_T, 4 TX_E
module eth_66_tx;
  int state = 0;
  function automatic void reset(); state = 0; endfunction
  function automatic bit step(input int t);
    case (state)
      0, 1, 3: state = (t == 0) ? 1 : (t == 1) ? 2 : 4;                    // TX_INIT, TX_C, TX_T: only C or S may follow
      2: state = (t == 3) ? 2 : (t == 2) ? 3 : 4;                          // TX_D: only D or T may follow
      default: state = (t == 2) ? 3 : (t == 3) ? 2 : (t == 0) ? 1 : 4;     // TX_E: T, D or C leave it
    endcase
    return state != 4;
  endfunction
endmodule

// eth_66_comp: clock compensation on XGMII columns (49.2.4.7, 49.2.4.10). Call once per column, in order.
// A column is {c[3:0], d[31:0]}: lane k is flag c[k] and octet d[8k+7:8k].
//   can_delete(c, d)   1 if this column may be dropped: four idles that hold none of the first four characters
//                      after a Terminate, or the second of two consecutive sequence ordered sets
//   can_insert(c, d)   1 if an idle column may be added after this one: it is idle or an ordered set
module eth_66_comp;
  bit guard = 0, prev_seq = 0;
  function automatic void reset(); guard = 0; prev_seq = 0; endfunction
  function automatic bit is_seq(input [3:0] c, input [31:0] d); return c == 4'b0001 && d[7:0] == 8'h9c; endfunction
  function automatic bit is_idle(input [3:0] c, input [31:0] d); return c == 4'b1111 && d == 32'h07070707; endfunction
  function automatic bit can_delete(input [3:0] c, input [31:0] d);
    bit ok, has_t;
    has_t = 0;
    for (int k = 0; k < 4; k++) if (c[k] && d[8*k +: 8] == 8'hfd) has_t = 1;
    ok = (is_idle(c, d) && !guard) || (is_seq(c, d) && prev_seq);
    guard = has_t;                                     // the next column holds some of the four characters after /T/
    prev_seq = is_seq(c, d) && !ok;                    // only one of the two
    return ok;
  endfunction
  function automatic bit can_insert(input [3:0] c, input [31:0] d); return is_idle(c, d) || is_seq(c, d); endfunction
endmodule

// eth_66_scr: the scrambler and the descrambler of 10GBASE-R (49.2.6, 49.2.10; Figures 49-8 and 49-10).
// The register is s[57:0]: stage S0 is s[0] and holds the newest line bit. Use one instance to scramble and
// another to descramble.
//   scr_bit(b)       one payload bit in, one line bit out: b XOR S38 XOR S57. The line bit shifts into S0.
//   dscr_bit(b)      one line bit in, one payload bit out: the same XOR. The received bit shifts into S0.
//   scramble(blk)    a whole block: bits 1:0 (the sync header) pass, bits 2 to 65 are scrambled in that order
//   descramble(blk)  the reverse
//   load(v)          sets the register (the standard asks for no start value)
// Fault: scrambles_header (the two sync header bits go through the scrambler too).
module eth_66_scr;
  bit [57:0] s = 58'd0;
  bit scrambles_header = 0;
  function automatic void load(input [57:0] v); s = v; endfunction
  function automatic bit scr_bit(input bit b);
    bit o; o = b ^ s[38] ^ s[57]; s = {s[56:0], o}; return o;
  endfunction
  function automatic bit dscr_bit(input bit b);
    bit o; o = b ^ s[38] ^ s[57]; s = {s[56:0], b}; return o;
  endfunction
  function automatic [65:0] scramble(input [65:0] blk);
    reg [65:0] o; o = blk;
    for (int i = scrambles_header ? 0 : 2; i < 66; i++) o[i] = scr_bit(blk[i]);
    return o;
  endfunction
  function automatic [65:0] descramble(input [65:0] blk);
    reg [65:0] o; o = blk;
    for (int i = 2; i < 66; i++) o[i] = dscr_bit(blk[i]);
    return o;
  endfunction
endmodule

// eth_prbs31: the PRBS31 pattern generator (49.2.8, Figure 49-9). The register is s[30:0], stage S0 is s[0].
//   gen_bit()   the next pattern bit: S27 XOR S30 shifts into S0, and the output is that bit inverted
// The register must not be all zeros: it would stay there. The checker is not in this file.
module eth_prbs31;
  bit [30:0] s = 31'h7fffffff;
  function automatic bit gen_bit();
    bit f; f = s[27] ^ s[30]; s = {s[29:0], f}; return !f;
  endfunction
endmodule

// eth_66_test: the square wave of 49.2.8 and the two data patterns of the pseudo-random test pattern.
//   sq_bit()        square wave: sq_n ones, then sq_n zeros (sq_n may be 4 to 11)
//   pattern()       the 64-bit data pattern: zeros, or the payload of a block with two local fault sets (lf_pattern)
// The pseudo-random pattern generator and its checker (49.2.8, 49.2.12) are not in this file.
module eth_66_test;
  eth_66 code();
  bit lf_pattern = 0;
  int sq_n = 8, sq_k = 0;
  function automatic void restart(); sq_k = 0; endfunction
  function automatic bit sq_bit();
    bit b; b = (sq_k < sq_n); sq_k = (sq_k + 1) % (2 * sq_n); return b;
  endfunction
  function automatic [63:0] pattern();
    reg [66:0] r;
    if (!lf_pattern) return 64'd0;
    r = code.enc_ctrl({64'h0100009c_0100009c, 8'h11}); return r[65:2];
  endfunction
endmodule

// eth_66_loop: PCS loopback (49.2.14.4), switched by MDIO bit 3.0.14.
//   rx_block(from_tx, from_pma)   what the receive path decodes: its own transmit block when loopback is 1
//   pma_word(w)                   what goes to the PMA: the word 00FFh when loopback is 1, else w
module eth_66_loop;
  bit loopback = 0;
  function automatic [65:0] rx_block(input [65:0] from_tx, input [65:0] from_pma); return loopback ? from_tx : from_pma; endfunction
  function automatic [15:0] pma_word(input [15:0] w); return loopback ? 16'h00ff : w; endfunction
endmodule

Check Yourself

Predict the outputThe program lays one 67-octet frame with Start in character 0. It prints the type of the block that holds Terminate. What does it print?
`timescale 1ns/1ns
module tb;
  eth_frame f(); eth_rs rs(); eth_xgmii_mon mon();
  reg [3:0] c; reg [31:0] d; bit fl;
  // one frame of len data octets onto the lanes, then a Terminate and gap idles
  task automatic packet(input int len, input int gap);
    for (int i = 0; i < len; i++) f.pay[i] = i;
    f.build(48'h0a0000000002, 48'h0a0000000001, 16'h0800, len);
    rs.start_packet();
    for (int i = 0; i < f.n; i++) rs.put(1'b0, f.oct[i]);
    rs.end_packet(); rs.idle(gap);
  endtask
  function automatic string name(input int i);
    if (!rs.is_c(i)) return $sformatf("%h", rs.ch[i][7:0]);
    case (rs.ch[i][7:0]) 8'h07: return "I"; 8'hfb: return "S"; 8'hfd: return "T"; 8'hfe: return "E"; 8'h9c: return "Q"; default: return "?"; endcase
  endfunction
  // column k as {c, d}, lane 0 in the low bits
  task automatic column(input int k);
    for (int l = 0; l < 4; l++) begin c[l] = rs.ch[4*k + l][8]; d[8*l +: 8] = rs.ch[4*k + l][7:0]; end
  endtask
  task automatic show(input int k);
    column(k);
    $display("column %0d: %0s %0s %0s %0s  control flags, lane 0 first: %b", k, name(4*k), name(4*k + 1), name(4*k + 2), name(4*k + 3), {c[0], c[1], c[2], c[3]});
  endtask
  task automatic run_mon();
    mon.reset();
    for (int k = 0; k < rs.columns(); k++) begin column(k); fl = mon.col(c, d); end
  endtask
  eth_66 e(); reg [66:0] r; reg [10:0] info;
  // eight characters, from character 8g on, as one vector: the flags in v[7:0], the octets above them
  function automatic [71:0] vec(input int g);
    reg [71:0] v;
    for (int k = 0; k < 8; k++) begin v[k] = rs.ch[8*g + k][8]; v[8 + 8*k +: 8] = rs.ch[8*g + k][7:0]; end
    return v;
  endfunction
  function automatic string kinds(input int g);        // I, S, T, Q or E for a control character, D for data
    string s, one;
    s = "";
    for (int k = 0; k < 8; k++) begin
      one = "D";
      if (rs.is_c(8*g + k)) one = name(8*g + k);
      s = {s, one};
      if (k == 3) s = {s, " / "}; else if (k != 7) s = {s, " "};
    end
    return s;
  endfunction
  // a local fault ordered set: one column
  task automatic seq(); rs.put(1'b1, 8'h9c); rs.put(1'b0, 8'h00); rs.put(1'b0, 8'h00); rs.put(1'b0, 8'h01); endtask
  task automatic block(input int g);
    info = rs.block_info(g); r = e.enc_ctrl(vec(g));
    if (r[66]) $display("block %0d: %s  sync 10, type %h (laid out by eth_66)", g, kinds(g), r[9:2]);
    else if (info[9:8] == 2'b01) $display("block %0d: %s  sync 01, eight data octets", g, kinds(g));
    else $display("block %0d: %s  sync 10, type %h", g, kinds(g), info[7:0]);
  endtask
  initial begin
    rs.clear(); packet(49, 11); rs.fill_to(8);    // a 67-octet frame; Start is character 0
    for (int i = 0; i < rs.nch; i++) if (rs.is_code(i, 8'hfd)) begin
      info = rs.block_info(i / 8);
      $display("%h", info[7:0]);
    end
    $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_mac.sv
`timescale 1ns/1ns
// eth_frame: one MAC frame as octets, its packet as wire bits, and a bit-serial receiver.
//   pay[i]                         client data, set by the bench before build()
//   build(da, sa, lt, len)         destination, source, Length/Type, len data octets, then the FCS -> oct[0..n-1].
//                                  It adds no pad: give it 46 data octets or more. (Padding is P11.2.1's task; the
//                                  pages show the padding MAC's frames as measured tables.)
//   wire_bits(), wire_bit(i)       the packet in transmit order: preamble, SFD, frame
//   rx_start(), rx_bit(b), rx_end()  hunt for the SFD, collect octets, then parse()
//   parse()                        da, sa, lt, is_length, is_type, data_len, fcs_rx, fcs_calc, fcs_ok
// Faults: fcs_msb_first, fcs_no_invert, fcs_covers_preamble, sfd_wrong, msb_first_octets.
module eth_frame;
  localparam int MIN_FRAME = 64, MAX_BASIC = 1518, MAX_QTAG = 1522, MAX_ENVELOPE = 2000;
  bit fcs_msb_first = 0, fcs_no_invert = 0, fcs_covers_preamble = 0, sfd_wrong = 0, msb_first_octets = 0;
  hs_crc crc();
  bit [7:0] pay [0:2047];
  bit [7:0] oct [0:2047];
  int n = 0;
  bit [47:0] da = 0, sa = 0; bit [15:0] lt = 0;
  bit is_length = 0, is_type = 0, fcs_ok = 0;
  int data_len = 0;
  bit [31:0] fcs_rx = 0, fcs_calc = 0;
  // receiver state
  bit in_frame = 0; bit [7:0] hist = 0, cur = 0; int nb = 0, excess = 0, sfd_at = -1, bits_seen = 0;

  // The FCS of oct[0..len-1] as four octets: the first octet sent is in [7:0].
  function automatic [31:0] fcs_of(input int len);
    crc.use_crc32(); crc.msb_first = fcs_msb_first; crc.no_invert = fcs_no_invert; crc.reset();
    if (fcs_covers_preamble) begin
      for (int i = 0; i < 7; i++) crc.crc_byte(8'h55);
      crc.crc_byte(8'hd5);
    end
    for (int i = 0; i < len; i++) crc.crc_byte(oct[i]);
    return crc.check_value();
  endfunction

  function automatic void build(input [47:0] d, input [47:0] s, input [15:0] t, input int len);
    int k; reg [31:0] f;
    k = 0;
    for (int i = 0; i < 6; i++) begin oct[k] = d[47 - 8*i -: 8]; k++; end
    for (int i = 0; i < 6; i++) begin oct[k] = s[47 - 8*i -: 8]; k++; end
    oct[k] = t[15:8]; k++;
    oct[k] = t[7:0]; k++;
    for (int i = 0; i < len; i++) begin oct[k] = pay[i]; k++; end
    f = fcs_of(k);
    for (int i = 0; i < 4; i++) begin oct[k] = f[8*i +: 8]; k++; end
    n = k; excess = 0;
    parse();
  endfunction

  function automatic void parse();
    da = 0; sa = 0; lt = 0; is_length = 0; is_type = 0; fcs_ok = 0; data_len = 0; fcs_rx = 0; fcs_calc = 0;
    if (n >= 14) begin
      da = {oct[0], oct[1], oct[2], oct[3], oct[4], oct[5]};
      sa = {oct[6], oct[7], oct[8], oct[9], oct[10], oct[11]};
      lt = {oct[12], oct[13]};
      is_length = (lt <= 16'd1500);
      is_type = (lt >= 16'd1536);
    end
    if (n >= 18) begin
      fcs_rx = {oct[n-1], oct[n-2], oct[n-3], oct[n-4]};
      fcs_calc = fcs_of(n - 4);
      fcs_ok = (fcs_rx == fcs_calc);
      data_len = is_length ? int'(lt) : n - 18;
    end
  endfunction

  function automatic int wire_bits(); return 8 * (8 + n); endfunction
  function automatic bit wire_bit(input int i);
    int o, b; reg [7:0] v;
    o = i / 8; b = i % 8;
    if (o < 7) v = 8'h55;
    else if (o == 7) v = sfd_wrong ? 8'h55 : 8'hd5;
    else v = oct[o - 8];
    return msb_first_octets ? v[7 - b] : v[b];
  endfunction

  function automatic void rx_start();
    in_frame = 0; hist = 0; cur = 0; nb = 0; n = 0; excess = 0; sfd_at = -1; bits_seen = 0;
  endfunction
  function automatic void rx_bit(input bit b);
    bits_seen++;
    if (!in_frame) begin
      hist = {hist[6:0], b};                      // the oldest bit is hist[7]
      if (hist == 8'b10101011) begin in_frame = 1; sfd_at = bits_seen; end
    end else begin
      if (msb_first_octets) cur[7 - nb] = b; else cur[nb] = b;
      nb++;
      if (nb == 8) begin oct[n] = cur; n++; nb = 0; end
    end
  endfunction
  function automatic void rx_end(); excess = nb; parse(); endfunction
endmodule
// eth_axis: a MAC client bus in the style of AXI4-Stream (IHI 0051B 2.2 handshake, 2.5 TKEEP, 2.6 TLAST, 2.9 TUSER),
// 64 bits wide. Byte 0 of a beat is tdata[7:0] and is first in the frame (AXI4-Stream 2.4.1). Bench conventions,
// not AXI4-Stream's or 802.3's: tkeep is all ones except on the last beat, where it covers bytes 0 to k-1; one tuser
// bit (transfer-based, 2.9.1), read on the last beat only, marks a bad frame (receive) or asks the MAC to abort it
// (transmit).
//   load(n)                  beats for octets oct[0..n-1]: bd[], bk[], bl[], nbeats; bv[] = valid per cycle, ncyc
//   tx_cycles()              the transmit MAC: one beat per cycle once a frame has started. Returns 0 sent,
//                            1 underrun (tvalid fell inside the frame), 2 aborted by tuser. sent_octets, fail_cycle.
// Fault: tvalid_gap (load() leaves cycle 3 of the frame empty: the client was late with a beat).
module eth_axis;
  bit tvalid_gap = 0;
  bit [7:0] oct [0:2047];
  bit [63:0] bd [0:300]; bit [7:0] bk [0:300]; bit bl [0:300]; bit bu [0:300];
  int nbeats = 0;
  bit bv [0:301]; int bix [0:301]; int ncyc = 0;
  int sent_octets = 0, fail_cycle = -1;
  function automatic void load(input int n);
    int b, k;
    nbeats = (n + 7) / 8;
    for (b = 0; b < nbeats; b++) begin
      bd[b] = 64'd0; bk[b] = 8'd0; bl[b] = (b == nbeats - 1); bu[b] = 0;
      for (k = 0; k < 8; k++) if (8*b + k < n) begin bd[b][8*k +: 8] = oct[8*b + k]; bk[b][k] = 1'b1; end
    end
    ncyc = 0;
    for (b = 0; b < nbeats; b++) begin
      if (tvalid_gap && b == 3) begin bv[ncyc] = 0; bix[ncyc] = -1; ncyc++; end
      bv[ncyc] = 1; bix[ncyc] = b; ncyc++;
    end
  endfunction
  function automatic int tx_cycles();
    bit started; started = 0; sent_octets = 0; fail_cycle = -1;
    for (int c = 0; c < ncyc; c++) begin
      if (!bv[c]) begin
        if (started) begin fail_cycle = c; return 1; end
      end else begin
        started = 1;
        if (bl[bix[c]] && bu[bix[c]]) begin fail_cycle = c; return 2; end
        for (int k = 0; k < 8; k++) if (bk[bix[c]][k]) sent_octets++;
      end
    end
    return 0;
  endfunction
endmodule

// eth_pause: the PAUSE function of MAC Control (Annex 31B) at the station that receives PAUSE frames, in octet
// times (one octet time is 8 bit times; a pause quantum is 512 bit times = 64 octet times, 31B.2).
//   reset(), rx_pause(t, q)  a valid PAUSE frame with pause_time q ended at time t: the timer restarts (31B.3.3)
//   may_start(t)             1 when a new data frame may start at time t. A frame already started is never cut
//                            (31B.3.7). react is the bench's reaction time: frames may still start until t + react.
//   paused_until             the time the timer runs out
//   pause_octets(q, o[])     not here: build a PAUSE frame with eth_frame (DA 01-80-C2-00-00-01, 8808h, 0001h, q)
// Faults: pause_ignored, pause_adds_not_overrides (a new frame adds to the timer, and zero does not cancel),
//         slow_reaction (react = 70 quanta, over the 60 allowed at 10 Gb/s), timer_in_bits (q counts bit times).
module eth_pause;
  localparam int QUANTUM = 64;                     // octet times
  bit pause_ignored = 0, pause_adds_not_overrides = 0, slow_reaction = 0, timer_in_bits = 0;
  int react = 0, t_rx = -1, paused_until = 0;
  function automatic void reset(); t_rx = -1; paused_until = 0; endfunction
  function automatic void rx_pause(input int t, input int q);
    int len;
    if (pause_ignored) return;
    len = timer_in_bits ? (q + 7) / 8 : q * QUANTUM;
    if (pause_adds_not_overrides && paused_until > t) paused_until = paused_until + len;
    else paused_until = t + len;
    t_rx = t;
  endfunction
  function automatic bit may_start(input int t);
    int r;
    r = slow_reaction ? 70 * QUANTUM : react;
    if (t_rx < 0) return 1;
    if (t < t_rx + r) return 1;
    return t >= paused_until;
  endfunction
endmodule

// eth_pfc: priority-based flow control (Annex 31D). The frame is 802.3's; holding a priority's queue is the MAC
// Control client's job (IEEE 802.1Q, not held), so the eight timers here are a bench client, in octet times.
//   build(f_oct[], pev, times[])   not here: the bench writes opcode 01-01, the vector and eight times into eth_frame
//   reset(), rx(t, pev, tm[0..7])  for each e[n] = 1 (bit n of the vector's low octet), priority n stops until
//                                  t + 64 * time[n] (hold_end[n]); e[n] = 0 leaves priority n alone; time[n] = 0 releases it
//   blocked(n, t)                  1 while priority n is held
// Fault: pfc_wrong_priority (reads e[n] from bit 7 - n).
module eth_pfc;
  bit pfc_wrong_priority = 0;
  int hold_end [0:7];
  function automatic void reset(); for (int i = 0; i < 8; i++) hold_end[i] = 0; endfunction
  function automatic void rx(input int t, input [15:0] pev, input [127:0] tm);   // tm[16*n +: 16] = time[n]
    bit e;
    for (int n = 0; n < 8; n++) begin
      e = pfc_wrong_priority ? pev[7 - n] : pev[n];
      if (e) hold_end[n] = t + 64 * int'(tm[16*n +: 16]);
    end
  endfunction
  function automatic bit blocked(input int n, input int t); return t < hold_end[n]; endfunction
endmodule

// eth_csma_tx: one half-duplex transmitter (4.2.3.2), one call of tick() per octet time.
//   reset(), load(frame_octets)   a frame of frame_octets (DA to FCS) waits to be sent; it is padded to min_frame
//   tick(carrier)                 carrier: another station's signal is on the wire here now. Returns 1 when the
//                                 station puts an octet (packet or jam) on the wire.
//   plan[i]                       the wait, in slots, after collision i + 1. The bench sets it (default 0). This
//                                 readable station draws nothing and has no attempt limit.
//   state  0 idle, 1 defer, 2 send, 3 jam, 4 backoff, 5 sent (as far as the sender knows)
//   pkt, sent, quiet, left, attempts, late, last_start, last_r
// min_frame is 64 octets; a bench may lower it to show why it is 64. Fault: no_backoff (every wait is 0 slots).
// Deference is a bench simplification: the 12-octet quiet count restarts on any carrier, own or received, and the
// station never starts while carrier is present. 4.2.8 restarts only the first part of the gap, and then transmits
// whatever the carrier.
module eth_csma_tx;
  localparam int SLOT = 64, JAM = 4, GAP = 12, PRE = 8;   // octet times
  bit no_backoff = 0;
  int min_frame = 64;
  int plan [0:63];
  int state = 0, pkt = 0, sent = 0, quiet = GAP, left = 0, attempts = 0, late = 0, last_start = -1, last_r = 0, now = 0;
  function automatic void reset();
    state = 0; pkt = 0; sent = 0; quiet = GAP; left = 0; attempts = 0; late = 0; last_start = -1; last_r = 0; now = 0;
  endfunction
  function automatic void load(input int frame_octets);
    pkt = PRE + frame_octets;
    if (frame_octets < min_frame) pkt = PRE + min_frame;
    state = 1; attempts = 0; sent = 0; late = 0;
  endfunction
  function automatic bit tick(input bit carrier);
    bit on;
    on = 0;
    if (state == 1 && !carrier && quiet >= GAP) begin state = 2; sent = 0; last_start = now; end
    if (state == 2 && carrier) begin
      attempts++; if (sent > SLOT) late++;
      state = 3; left = JAM;
    end
    case (state)
      2: begin sent++; on = 1; if (sent == pkt) state = 5; end
      3: begin
           on = 1; left--;
           if (left == 0) begin
             last_r = no_backoff ? 0 : plan[(attempts - 1) % 64];
             left = SLOT * last_r;
             state = (left == 0) ? 1 : 4;
           end
         end
      4: begin left--; if (left == 0) state = 1; end
      default: ;
    endcase
    quiet = (carrier || on) ? 0 : ((quiet < GAP) ? quiet + 1 : GAP);
    now++;
    return on;
  endfunction
endmodule

// eth_csma: two eth_csma_tx stations, A and B, at the two ends of a wire with a one-way delay of d octet times.
//   run(fa, ready_a, fb, ready_b, tmax)   each station loads its frame (fa, fb octets) at its ready time
//   on_a[t], on_b[t]          what each station put on the wire at time t
//   ev_t[], ev_who[] (0 A, 1 B), ev_kind[], ev_v[], n_ev   the event log:
//     kind 0 starts attempt v; 1 sees a collision after v octets; 2 jam over, backs off v slots;
//     3 last octet sent (v = octets); 4 gives up after v attempts
//   delivered(i)              1 when station i's last attempt reached the far end with no overlap there
//   a.plan[], b.plan[], a.no_backoff, b.no_backoff, a.min_frame, b.min_frame: the stations' settings
module eth_csma;
  eth_csma_tx a(); eth_csma_tx b();
  int d = 10, n_ev = 0, tend = 0;
  bit on_a [0:16383]; bit on_b [0:16383];
  int ev_t [0:255]; int ev_who [0:255]; int ev_kind [0:255]; int ev_v [0:255];
  function automatic void log_ev(input int t, input int who, input int kind, input int v);
    if (n_ev < 256) begin ev_t[n_ev] = t; ev_who[n_ev] = who; ev_kind[n_ev] = kind; ev_v[n_ev] = v; n_ev++; end
  endfunction
  function automatic void note(input int t, input int who, input int s0, input int s1, input int sent0, input int att, input int r, input int sent1);
    if (s0 != 2 && s1 == 2) log_ev(t, who, 0, att + 1);
    if (s0 == 2 && (s1 == 3 || s1 == 4)) log_ev(t, who, 1, sent0);
    if (s0 == 3 && (s1 == 4 || s1 == 1)) log_ev(t, who, 2, r);
    if (s0 != 5 && s1 == 5) log_ev(t, who, 3, sent1);
    if (s0 != 6 && s1 == 6) log_ev(t, who, 4, att);
  endfunction
  function automatic void run(input int fa, input int ready_a, input int fb, input int ready_b, input int tmax);
    bit ca, cb; int sa, sb, xa, xb;
    a.reset(); b.reset(); n_ev = 0; tend = tmax;
    for (int t = 0; t < tmax; t++) begin
      if (t == ready_a) a.load(fa);
      if (t == ready_b) b.load(fb);
      ca = (t >= d) ? on_b[t - d] : 1'b0;
      cb = (t >= d) ? on_a[t - d] : 1'b0;
      sa = a.state; sb = b.state; xa = a.sent; xb = b.sent;
      on_a[t] = a.tick(ca);
      on_b[t] = b.tick(cb);
      note(t, 0, sa, a.state, xa, a.attempts, a.last_r, a.sent);
      note(t, 1, sb, b.state, xb, b.attempts, b.last_r, b.sent);
    end
  endfunction
  function automatic bit delivered(input int i);
    int s, p, u;
    if (i == 0 && a.state != 5) return 0;
    if (i == 1 && b.state != 5) return 0;
    s = (i == 0) ? a.last_start : b.last_start;
    p = (i == 0) ? a.pkt : b.pkt;
    for (int t = s; t < s + p; t++) begin
      u = t + d;
      if (u < tend && ((i == 0) ? on_b[u] : on_a[u])) return 0;
    end
    return 1;
  endfunction
endmodule

// eth_gap: how long the gap before the next Start is on a 4-lane XGMII, where Start must sit on lane 0
// (46.3.1.4). A gap counts every character from the Terminate to the last idle before Start. A packet is
// 8 + n characters (Start, six preamble octets, SFD, an n-octet frame) and starts on lane 0.
//   reset()                     DIC = 0 (the count is reset only at initialisation)
//   method                      0 deficit idle count, 1 always insert (both allowed by 46.3.1.4)
//   next_gap(n, mac_gap)        the gap after an n-octet frame when the MAC asks for mac_gap (12 or more)
//   deleted, inserted, dic      what the last call did, and the count after it
// Faults: ipg_min_only (always deletes, ignoring the bound), dic_max4 (bounds the count at 4, not 3),
//         start_any_lane (no alignment: the gap is always mac_gap).
module eth_gap;
  bit ipg_min_only = 0, dic_max4 = 0, start_any_lane = 0;
  int method = 0, dic = 0, deleted = 0, inserted = 0;
  function automatic void reset(); dic = 0; deleted = 0; inserted = 0; endfunction
  function automatic int next_gap(input int n, input int mac_gap);
    int m, top;
    deleted = 0; inserted = 0;
    m = (n + mac_gap) % 4;                       // lanes past lane 0 the next Start would land on
    if (start_any_lane || m == 0) return mac_gap;
    top = dic_max4 ? 4 : 3;
    if (method == 0 && (ipg_min_only || dic + m <= top)) begin deleted = m; dic = dic + m; end
    else begin inserted = 4 - m; if (method == 0) dic = dic - (4 - m); end
    return mac_gap - deleted + inserted;
  endfunction
endmodule
Read included file: eth_xgmii.sv
`timescale 1ns/1ns
// eth_rs: the packet as XGMII characters (9 bits: control flag and octet), four lanes per column, and the
// 66-bit block each pair of columns becomes.
//   clear(), put(c, d), idle(k)
//   lanes            4 for the XGMII and 25GMII (default), 8 for the 64-bit interfaces (XLGMII to 800GMII, P11.18)
//   start_packet()   adds idle until lane 0, then Start (FBh), six preamble octets and the SFD
//   end_packet()     Terminate (FDh)
//   columns(), lane_of(i)   columns of lanes characters; the lane of character i
//   block_info(g)    {valid, sync[1:0], type[7:0]} for characters 8g to 8g+7 (pad the tail with idle first)
// Fault: start_any_lane (Start is not aligned to lane 0).
module eth_rs;
  bit start_any_lane = 0;
  int lanes = 4;
  bit [8:0] ch [0:4095];
  int nch = 0;
  function automatic void clear(); nch = 0; endfunction
  function automatic void put(input bit c, input [7:0] d); ch[nch] = {c, d}; nch++; endfunction
  function automatic void idle(input int k); for (int i = 0; i < k; i++) put(1'b1, 8'h07); endfunction
  function automatic void start_packet();
    if (!start_any_lane) while (nch % lanes != 0) put(1'b1, 8'h07);
    put(1'b1, 8'hfb);
    for (int i = 0; i < 6; i++) put(1'b0, 8'h55);
    put(1'b0, 8'hd5);
  endfunction
  function automatic void end_packet(); put(1'b1, 8'hfd); endfunction
  function automatic void fill_to(input int multiple); while (nch % multiple != 0) put(1'b1, 8'h07); endfunction
  function automatic int columns(); return (nch + lanes - 1) / lanes; endfunction
  function automatic int lane_of(input int i); return i % lanes; endfunction
  function automatic bit is_c(input int i); return ch[i][8]; endfunction
  function automatic bit is_code(input int i, input [7:0] v); return ch[i] == {1'b1, v}; endfunction
  function automatic bit is_plain(input int i);            // a control character with a 7-bit C code
    return is_code(i, 8'h07) || is_code(i, 8'h06) || is_code(i, 8'hfe);
  endfunction
  function automatic bit all_data(input int a, input int b);
    for (int i = a; i <= b; i++) if (is_c(i)) return 0;
    return 1;
  endfunction
  function automatic bit all_plain(input int a, input int b);
    for (int i = a; i <= b; i++) if (!is_plain(i)) return 0;
    return 1;
  endfunction
  function automatic [10:0] block_info(input int g);
    int b; reg [7:0] t; bit ok;
    b = 8 * g; ok = 0; t = 8'h00;
    if (all_data(b, b + 7)) return {1'b1, 2'b01, 8'h00};
    if (all_plain(b, b + 7)) begin ok = 1; t = 8'h1e; end
    else if (is_code(b, 8'hfb) && all_data(b + 1, b + 7)) begin ok = 1; t = 8'h78; end
    else if (all_plain(b, b + 3) && is_code(b + 4, 8'hfb) && all_data(b + 5, b + 7)) begin ok = 1; t = 8'h33; end
    else if (is_code(b, 8'h9c) && all_data(b + 1, b + 3) && is_code(b + 4, 8'hfb) && all_data(b + 5, b + 7)) begin ok = 1; t = 8'h66; end
    else if (is_code(b, 8'h9c) && all_data(b + 1, b + 3) && is_code(b + 4, 8'h9c) && all_data(b + 5, b + 7)) begin ok = 1; t = 8'h55; end
    else if (is_code(b, 8'h9c) && all_data(b + 1, b + 3) && all_plain(b + 4, b + 7)) begin ok = 1; t = 8'h4b; end
    else if (all_plain(b, b + 3) && is_code(b + 4, 8'h9c) && all_data(b + 5, b + 7)) begin ok = 1; t = 8'h2d; end
    else begin
      for (int k = 0; k < 8; k++)
        if (!ok && is_code(b + k, 8'hfd) && (k == 0 || all_data(b, b + k - 1)) && (k == 7 || all_plain(b + k + 1, b + 7))) begin
          ok = 1;
          case (k)
            0: t = 8'h87; 1: t = 8'h99; 2: t = 8'haa; 3: t = 8'hb4;
            4: t = 8'hcc; 5: t = 8'hd2; 6: t = 8'he1; default: t = 8'hff;
          endcase
        end
    end
    return {ok, 2'b10, t};
  endfunction
endmodule

// eth_xgmii_mon: reads XGMII columns as a receiving RS would (46.2, 46.3.3) and reports what it sees.
// A column is {c[3:0], d[31:0]}: lane k is control flag c[k] and octet d[8k+7:8k]; lane 0 comes first.
//   reset(), col(c, d)      one column; col() returns 1 if the column holds anything the monitor flags
//   frames                  Starts seen on lane 0; octets: data octets after the SFD up to the Terminate
//   start_lane, term_lane   where the last Start and Terminate were (-1: not in this column)
//   bad_start               Starts on lanes 1 to 3 (46.3.3.3: the RS must not pass them to the MAC)
//   errors                  Error characters (FEh) seen inside a frame; err_frames: frames that carried one
//   seq_cols                columns holding a Sequence ordered set (9Ch in lane 0, P11.19)
//   last_len                data octets of the last frame, preamble and SFD excluded
module eth_xgmii_mon;
  int frames = 0, octets = 0, bad_start = 0, errors = 0, err_frames = 0, seq_cols = 0, last_len = 0;
  int start_lane = -1, term_lane = -1, in_pkt = 0, pre_left = 0, len = 0;
  bit had_err = 0;
  function automatic void reset();
    frames = 0; octets = 0; bad_start = 0; errors = 0; err_frames = 0; seq_cols = 0; last_len = 0;
    in_pkt = 0; pre_left = 0; len = 0; had_err = 0; start_lane = -1; term_lane = -1;
  endfunction
  function automatic bit col(input [3:0] c, input [31:0] d);
    bit flag; reg [7:0] o;
    flag = 0; start_lane = -1; term_lane = -1;
    if (c[0] && d[7:0] == 8'h9c) seq_cols++;
    for (int k = 0; k < 4; k++) begin
      o = d[8*k +: 8];
      if (c[k] && o == 8'hfb) begin
        start_lane = k;
        if (k != 0) begin bad_start++; flag = 1; end
        else begin in_pkt = 1; pre_left = 7; len = 0; had_err = 0; frames++; end
      end
      else if (in_pkt && c[k] && o == 8'hfd) begin
        term_lane = k; in_pkt = 0; last_len = len;
        if (had_err) err_frames++;
      end
      else if (in_pkt && c[k] && o == 8'hfe) begin errors++; had_err = 1; flag = 1; len++; end
      else if (in_pkt && !c[k]) begin
        if (pre_left > 0) pre_left--;
        else begin len++; octets++; end
      end
    end
    return flag;
  endfunction
endmodule
Read included file: eth_pcs.sv
`timescale 1ns/1ns
// eth_pcs.sv: the 1000BASE-X PCS, transmit side and synchronization (read-only). It sits on hs_8b10b (hs_code.sv).

// eth_1000x: the transmit ordered-set layer (36.2.4). The stream is kept as {k, d} and as ten coded bits.
//   clear()            empty stream, running disparity negative
//   idle(k)            k idle ordered sets. Each tests the running disparity first (Figure 36-6):
//                      positive -> /I1/ (K28.5 D5.6), negative -> /I2/ (K28.5 D16.2)
//   cfg(word, k)       k configuration ordered sets, /C1/ and /C2/ in turn: K28.5, D21.5 or D2.2, word[7:0], word[15:8]
//   start_packet()     /S/ in place of the first preamble octet, then six 55h and D5h
//   data(d)            one data code-group
//   end_packet()       /T/ /R/, and one more /R/ when the first /R/ went out on an even position
//   err()              /V/
//   put(k, d)          any code-group
//   n                  code-groups so far; code-group i is even-numbered when i is even
//   sym[i] = {k, d};  code[i] = abcdei fghj, bit a (code[i][9]) is sent first;  rdb[i] = running disparity before i
//   is_k(i, d), comma_plus(), comma_minus()
// Fault: idle_wrong_disparity (every idle is /I2/, so a positive running disparity is never corrected).
module eth_1000x;
  bit idle_wrong_disparity = 0;
  hs_8b10b c8();
  bit [8:0] sym [0:8191]; bit [9:0] code [0:8191]; bit rdb [0:8191];
  int n = 0; bit c2 = 0;
  function automatic void clear(); n = 0; c2 = 0; c8.rd_tx = 0; endfunction
  function automatic void put(input bit k, input [7:0] d);
    sym[n] = {k, d}; rdb[n] = c8.rd_tx; code[n] = c8.enc(d, k); n++;
  endfunction
  function automatic void idle(input int k);
    bit positive;
    for (int i = 0; i < k; i++) begin
      positive = c8.rd_tx && !idle_wrong_disparity;
      put(1'b1, 8'hbc);                                // K28.5
      put(1'b0, positive ? 8'hc5 : 8'h50);             // D5.6 or D16.2
    end
  endfunction
  function automatic void cfg(input [15:0] word, input int k);
    for (int i = 0; i < k; i++) begin
      put(1'b1, 8'hbc);
      put(1'b0, c2 ? 8'h42 : 8'hb5);                   // D2.2 or D21.5
      put(1'b0, word[7:0]); put(1'b0, word[15:8]);
      c2 = !c2;
    end
  endfunction
  function automatic void data(input [7:0] d); put(1'b0, d); endfunction
  function automatic void start_packet();
    put(1'b1, 8'hfb);                                  // /S/ = K27.7
    for (int i = 0; i < 6; i++) put(1'b0, 8'h55);
    put(1'b0, 8'hd5);
  endfunction
  function automatic void end_packet();
    put(1'b1, 8'hfd);                                  // /T/ = K29.7
    put(1'b1, 8'hf7);                                  // /R/ = K23.7
    if (n % 2 != 0) put(1'b1, 8'hf7);                  // that /R/ was even-numbered: one more
  endfunction
  function automatic void err(); put(1'b1, 8'hfe); endfunction     // /V/ = K30.7
  function automatic bit is_k(input int i, input [7:0] d); return sym[i] == {1'b1, d}; endfunction
  function automatic int comma_plus();
    int c; c = 0;
    for (int i = 0; i < n; i++) if (code[i][9:3] == 7'b0011111) c++;
    return c;
  endfunction
  function automatic int comma_minus();
    int c; c = 0;
    for (int i = 0; i < n; i++) if (code[i][9:3] == 7'b1100000) c++;
    return c;
  endfunction
endmodule

// eth_1000x_sync: the synchronization process of Figure 36-9, one call of rx() per ten-bit code-group.
//   reset()            LOSS_OF_SYNC
//   rx(code)           takes one code-group; returns sync_status (1 = OK)
//   state              0 LOSS_OF_SYNC, 1 COMMA_DETECT_1, 2 ACQUIRE_SYNC_1, 3 COMMA_DETECT_2, 4 ACQUIRE_SYNC_2,
//                      5 COMMA_DETECT_3, 6 SYNC_ACQUIRED_1, 7 SYNC_ACQUIRED_2, 8 SYNC_ACQUIRED_2A,
//                      9 SYNC_ACQUIRED_3, 10 SYNC_ACQUIRED_3A, 11 SYNC_ACQUIRED_4, 12 SYNC_ACQUIRED_4A
//   even               the code-group just taken was even-numbered
//   good_cgs, bad_seen (every bad code-group since reset), k, d (the last decode)
// A code-group is bad when it is invalid, or when it holds a comma and is odd-numbered (36.2.5.1.3).
// Bench choices: in LOSS_OF_SYNC the decoder takes its running disparity from the comma it finds; an invalid
// code-group leaves the decoder's running disparity as the received bits set it.
module eth_1000x_sync;
  hs_8b10b c8();
  int state = 0, good_cgs = 0, bad_seen = 0;
  bit even = 0, sync = 0, rd = 0, k = 0; bit [7:0] d = 0;
  function automatic void reset(); state = 0; good_cgs = 0; bad_seen = 0; even = 0; sync = 0; rd = 0; endfunction
  function automatic bit rx(input [9:0] code);
    reg [11:0] r; bit invalid, comma, is_d, bad;
    comma = code[9:3] == 7'b0011111 || code[9:3] == 7'b1100000;
    if (state == 0 && comma) rd = (code[9:3] == 7'b1100000);
    r = c8.decode(code, rd);                           // {rd_out, disp_err, code_err, k, d}
    rd = r[11]; k = r[8]; d = r[7:0];
    invalid = r[10] || r[9];
    is_d = !invalid && !r[8];
    bad = invalid || (comma && even);                  // even: the one before was even, so this one is odd
    if (bad && state != 0) bad_seen++;
    case (state)
      0: begin if (comma) begin state = 1; even = 1; end else even = !even; end
      1, 3, 5: begin even = 0; state = is_d ? state + 1 : 0; end
      2, 4: begin
        if (bad) state = 0;
        else if (comma) begin state = state + 1; even = 1; end
        else even = !even;
      end
      6: begin even = !even; if (bad) begin state = 7; good_cgs = 0; end end
      7, 9, 11: begin
        even = !even;
        if (bad) begin state = (state == 11) ? 0 : state + 2; good_cgs = 0; end
        else begin state = state + 1; good_cgs = 1; end
      end
      default: begin                                   // 8, 10, 12: counting good code-groups
        even = !even;
        if (bad) begin state = (state == 12) ? 0 : state + 1; good_cgs = 0; end
        else if (good_cgs == 3) begin state = (state == 8) ? 6 : state - 3; good_cgs = 0; end
        else good_cgs++;
      end
    endcase
    sync = state >= 6;
    return sync;
  endfunction
endmodule

// ---- 10GBASE-R and 25GBASE-R: 64B/66B blocks (Clause 49; Clause 107 uses the same code) ----
// Eight XGMII characters are one vector raw[71:0] (49.2.13.2.2): raw[k] is the control flag of character k,
// raw[8 + 8*k +: 8] its octet. A block is blk[65:0]; bit 0 is sent first. blk[1:0] is the sync header,
// blk[9:2] the block type field of a control block, the rest the payload (Figure 49-7).

// eth_66: the control blocks that hold no Start, no Terminate and no frame data.
//   c_code(x)       Table 49-1: the 7-bit C code of XGMII control code x; 7Fh if x is not in the table
//   enc_ctrl(raw)   {ok, blk}: block type 1Eh (eight control characters), 2Dh (four, then an ordered set),
//                   4Bh (an ordered set, then four) or 55h (two ordered sets); ok = 0 if raw is none of these.
//                   It only lays out the fields. Whether the vector may be sent is the transmit process's
//                   decision (eth_66_tx).
//   on_wire(blk)    the 66 bits as text in the order they are sent: sync, block type, payload
//   ham(a, b)       how many bits differ between two block type values
// Fault: wrong_block_type (types 2Dh and 4Bh are swapped).
module eth_66;
  bit wrong_block_type = 0;
  function automatic [6:0] c_code(input [7:0] x);
    case (x)
      8'h07: return 7'h00;                             // idle
      8'h06: return 7'h06;                             // low power idle
      8'hfe: return 7'h1e;                             // error
      8'h1c: return 7'h2d;                             // the six reserved characters
      8'h3c: return 7'h33;
      8'h7c: return 7'h4b;
      8'hbc: return 7'h55;
      8'hdc: return 7'h66;
      8'hf7: return 7'h78;
      default: return 7'h7f;
    endcase
  endfunction
  function automatic [7:0] ch(input [71:0] raw, input int k); return raw[8 + 8*k +: 8]; endfunction
  // characters k to k+3 are a sequence ordered set: 9Ch with its flag, then three data octets
  function automatic bit is_q(input [71:0] raw, input int k);
    return raw[k] && ch(raw, k) == 8'h9c && !raw[k + 1] && !raw[k + 2] && !raw[k + 3];
  endfunction
  // characters k to k+3 are control characters with a C code
  function automatic bit is_c4(input [71:0] raw, input int k);
    for (int j = k; j < k + 4; j++) if (!raw[j] || c_code(ch(raw, j)) == 7'h7f) return 0;
    return 1;
  endfunction
  function automatic [66:0] enc_ctrl(input [71:0] raw);
    reg [65:0] b; bit q0, q4, c0, c4;
    b = 66'd0;
    b[1:0] = 2'b01;                                    // sync header "10": bit 0, sent first, is 1
    q0 = is_q(raw, 0); q4 = is_q(raw, 4); c0 = is_c4(raw, 0); c4 = is_c4(raw, 4);
    if (c0 && c4) b[9:2] = 8'h1e;
    else if (c0 && q4) b[9:2] = wrong_block_type ? 8'h4b : 8'h2d;
    else if (q0 && c4) b[9:2] = wrong_block_type ? 8'h2d : 8'h4b;
    else if (q0 && q4) b[9:2] = 8'h55;
    else return 67'd0;
    if (c0) for (int k = 0; k < 4; k++) b[10 + 7*k +: 7] = c_code(ch(raw, k));
    else begin b[33:10] = raw[39:16]; b[37:34] = 4'h0; end     // D1 to D3, then the O code of the sequence set
    if (c4) for (int k = 4; k < 8; k++) b[10 + 7*k +: 7] = c_code(ch(raw, k));
    else begin b[41:38] = 4'h0; b[65:42] = raw[71:48]; end     // the O code, then D5 to D7
    return {1'b1, b};
  endfunction
  function automatic string on_wire(input [65:0] blk);
    string s;
    s = "";
    for (int i = 0; i < 66; i++) begin
      if (i == 2 || i == 10) s = {s, " "};
      s = {s, blk[i] ? "1" : "0"};
    end
    return s;
  endfunction
  function automatic int ham(input [7:0] a, input [7:0] b);
    int n; reg [7:0] x;
    x = a ^ b; n = 0;
    for (int i = 0; i < 8; i++) if (x[i]) n++;
    return n;
  endfunction
endmodule

// eth_66_tx: the transmit state diagram (Figure 49-16) without the EEE state. One call per vector.
//   step(t)   t is the T_TYPE of the vector: 0 C (control), 1 S (start), 2 T (terminate), 3 D (data), 4 E (none of these).
//             Returns 1 if the vector is encoded and sent, 0 if the error block goes out in its place.
//   state     0 TX_INIT, 1 TX_C, 2 TX_D, 3 TX_T, 4 TX_E
module eth_66_tx;
  int state = 0;
  function automatic void reset(); state = 0; endfunction
  function automatic bit step(input int t);
    case (state)
      0, 1, 3: state = (t == 0) ? 1 : (t == 1) ? 2 : 4;                    // TX_INIT, TX_C, TX_T: only C or S may follow
      2: state = (t == 3) ? 2 : (t == 2) ? 3 : 4;                          // TX_D: only D or T may follow
      default: state = (t == 2) ? 3 : (t == 3) ? 2 : (t == 0) ? 1 : 4;     // TX_E: T, D or C leave it
    endcase
    return state != 4;
  endfunction
endmodule

// eth_66_comp: clock compensation on XGMII columns (49.2.4.7, 49.2.4.10). Call once per column, in order.
// A column is {c[3:0], d[31:0]}: lane k is flag c[k] and octet d[8k+7:8k].
//   can_delete(c, d)   1 if this column may be dropped: four idles that hold none of the first four characters
//                      after a Terminate, or the second of two consecutive sequence ordered sets
//   can_insert(c, d)   1 if an idle column may be added after this one: it is idle or an ordered set
module eth_66_comp;
  bit guard = 0, prev_seq = 0;
  function automatic void reset(); guard = 0; prev_seq = 0; endfunction
  function automatic bit is_seq(input [3:0] c, input [31:0] d); return c == 4'b0001 && d[7:0] == 8'h9c; endfunction
  function automatic bit is_idle(input [3:0] c, input [31:0] d); return c == 4'b1111 && d == 32'h07070707; endfunction
  function automatic bit can_delete(input [3:0] c, input [31:0] d);
    bit ok, has_t;
    has_t = 0;
    for (int k = 0; k < 4; k++) if (c[k] && d[8*k +: 8] == 8'hfd) has_t = 1;
    ok = (is_idle(c, d) && !guard) || (is_seq(c, d) && prev_seq);
    guard = has_t;                                     // the next column holds some of the four characters after /T/
    prev_seq = is_seq(c, d) && !ok;                    // only one of the two
    return ok;
  endfunction
  function automatic bit can_insert(input [3:0] c, input [31:0] d); return is_idle(c, d) || is_seq(c, d); endfunction
endmodule

// eth_66_scr: the scrambler and the descrambler of 10GBASE-R (49.2.6, 49.2.10; Figures 49-8 and 49-10).
// The register is s[57:0]: stage S0 is s[0] and holds the newest line bit. Use one instance to scramble and
// another to descramble.
//   scr_bit(b)       one payload bit in, one line bit out: b XOR S38 XOR S57. The line bit shifts into S0.
//   dscr_bit(b)      one line bit in, one payload bit out: the same XOR. The received bit shifts into S0.
//   scramble(blk)    a whole block: bits 1:0 (the sync header) pass, bits 2 to 65 are scrambled in that order
//   descramble(blk)  the reverse
//   load(v)          sets the register (the standard asks for no start value)
// Fault: scrambles_header (the two sync header bits go through the scrambler too).
module eth_66_scr;
  bit [57:0] s = 58'd0;
  bit scrambles_header = 0;
  function automatic void load(input [57:0] v); s = v; endfunction
  function automatic bit scr_bit(input bit b);
    bit o; o = b ^ s[38] ^ s[57]; s = {s[56:0], o}; return o;
  endfunction
  function automatic bit dscr_bit(input bit b);
    bit o; o = b ^ s[38] ^ s[57]; s = {s[56:0], b}; return o;
  endfunction
  function automatic [65:0] scramble(input [65:0] blk);
    reg [65:0] o; o = blk;
    for (int i = scrambles_header ? 0 : 2; i < 66; i++) o[i] = scr_bit(blk[i]);
    return o;
  endfunction
  function automatic [65:0] descramble(input [65:0] blk);
    reg [65:0] o; o = blk;
    for (int i = 2; i < 66; i++) o[i] = dscr_bit(blk[i]);
    return o;
  endfunction
endmodule

// eth_prbs31: the PRBS31 pattern generator (49.2.8, Figure 49-9). The register is s[30:0], stage S0 is s[0].
//   gen_bit()   the next pattern bit: S27 XOR S30 shifts into S0, and the output is that bit inverted
// The register must not be all zeros: it would stay there. The checker is not in this file.
module eth_prbs31;
  bit [30:0] s = 31'h7fffffff;
  function automatic bit gen_bit();
    bit f; f = s[27] ^ s[30]; s = {s[29:0], f}; return !f;
  endfunction
endmodule

// eth_66_test: the square wave of 49.2.8 and the two data patterns of the pseudo-random test pattern.
//   sq_bit()        square wave: sq_n ones, then sq_n zeros (sq_n may be 4 to 11)
//   pattern()       the 64-bit data pattern: zeros, or the payload of a block with two local fault sets (lf_pattern)
// The pseudo-random pattern generator and its checker (49.2.8, 49.2.12) are not in this file.
module eth_66_test;
  eth_66 code();
  bit lf_pattern = 0;
  int sq_n = 8, sq_k = 0;
  function automatic void restart(); sq_k = 0; endfunction
  function automatic bit sq_bit();
    bit b; b = (sq_k < sq_n); sq_k = (sq_k + 1) % (2 * sq_n); return b;
  endfunction
  function automatic [63:0] pattern();
    reg [66:0] r;
    if (!lf_pattern) return 64'd0;
    r = code.enc_ctrl({64'h0100009c_0100009c, 8'h11}); return r[65:2];
  endfunction
endmodule

// eth_66_loop: PCS loopback (49.2.14.4), switched by MDIO bit 3.0.14.
//   rx_block(from_tx, from_pma)   what the receive path decodes: its own transmit block when loopback is 1
//   pma_word(w)                   what goes to the PMA: the word 00FFh when loopback is 1, else w
module eth_66_loop;
  bit loopback = 0;
  function automatic [65:0] rx_block(input [65:0] from_tx, input [65:0] from_pma); return loopback ? from_tx : from_pma; endfunction
  function automatic [15:0] pma_word(input [15:0] w); return loopback ? 16'h00ff : w; endfunction
endmodule
ConceptWhat does sync header 01 tell the receiver?
ConceptHow does a block carry the Start character?
ConceptA block arrives with sync header 10 and type field 00h. What reaches the XGMII?
ConceptWhat does the 25GBASE-R PCS change in the block formats of Clause 49?

Common Mistakes

Wrong Write the data sync header as 2'b01 in a vector whose bit 0 is sent first.

The standard writes 01 first bit first. Bit 0 must be 0 and bit 1 must be 1.

Fix Set bit 0 to 0 and bit 1 to 1 for data. Swap them for control.

Wrong Put the 8-bit XGMII code of an idle into the payload.

Eight octets do not fit in 56 bits. Control characters travel as 7-bit C codes.

Fix Send C code 00h for idle and 1Eh for error.

Wrong Use type 78h whenever a block holds a Start.

Start in character 4 needs the first four characters too. That is type 33h or 66h.

Fix Pick the type from where Start sits and what comes before it.

Wrong Reject a block whose spare bits are not zero.

The standard tells the receiver to ignore them.

Fix Check the sync header, the type and the codes. Leave the spare bits alone.

Remember

  • A block is a 2-bit sync header and 64 payload bits. Header 01 is data; 10 is control.
  • A control block starts with a type field. It says where Start, Terminate or an ordered set sits.
  • Other control characters travel as 7-bit C codes. Spare bits are zero and ignored.
  • An invalid block becomes eight Error characters. The same code runs at 25 Gb/s.

Practice

Report a problem with this page