Auto-Negotiation on Twisted Pair

Two copper ports agree on speed and duplex before any frame moves. They talk in bursts of link pulses. See how a burst carries 16 bits.

You Will Be Able To

  • Tell clock pulses from data pulses by the time between them.
  • Read the fields of the 16-bit base page.
  • Say when ability match and acknowledge match become true.
  • Pick the mode two ports enable from their two pages.
Lesson
P11.36
Time
35 min
Runs on
Your browser
Check
5 questions

No clock, no frame, no code. Only pulses, and the gaps between them.

The Start of One BurstFourteen pulse positions, 62.5 µs apart. The odd ones always hold a pulse. An even one holds a pulse for a 1.
012345678910111213pulse position1234567891011121314link pulsemeaningclockD0 = 1clockD1 = 0clockD2 = 0clockD3 = 0clockD4 = 0clockD5 = 1clockD6 = 1
Scroll horizontally ↔
  1. Cycle 0

    Position 1 is a clock pulse. Every burst starts with one.

  2. Cycle 1

    A pulse at position 2, half way to the next clock pulse: D0 is 1.

  3. Cycle 3

    No pulse at position 4: D1 is 0.

  4. Cycle 10

    Position 11 is the clock pulse before D5.

  5. Cycle 11

    A pulse again: D5 is 1. D5 is ability bit A0, 10BASE-T.

Bench run of the readable example: the word 01E1h. A pulse is drawn as one column. A real pulse is 100 ns wide, far thinner.

From One Pulse to a Burst

An idle 10BASE-T port sends one short pulse about every 16 ms. It tells the far end that the link is alive.

That is the normal link pulse. It carries no data.

Auto-negotiation puts a burst of pulses in its place: the Fast Link Pulse (FLP) burst (28.2.1.1).

An old 10BASE-T port sees a burst as one link pulse. So it is not disturbed.

Once the link is up, the bursts stop. They are for start-up only.

Clock Pulses and Data Pulses

A burst has 33 pulse positions. The 17 odd ones always hold a pulse: the clock pulses (28.2.1.1.1).

The 16 even ones are the data. A pulse there is a 1. No pulse is a 0.

LeastTypicalMost
Clock pulse to clock pulse111 µs125 µs139 µs
Clock pulse to the data pulse of a 155.5 µs62.5 µs69.5 µs
Pulses in a burst of 16 bits1733
Burst to burst8 ms16 ms24 ms

IEEE Std 802.3-2022 Table 28-1, with the non-optimized burst spacing. A burst of 16 bits is about 2 ms wide. A pulse is about 100 ns wide.

So a burst has 17 pulses for a word of all zeros and 33 for all ones.

All pulses look the same. Only the spacing says which is which.

The bench sender puts its last clock pulse 2.0 ms after the first.

The Receiver: Two Timers

The receiver starts two timers at each clock pulse (28.2.2.1).

data_detect_min_timer runs 15 to 47 µs. data_detect_max_timer runs 78 to 100 µs (Table 28-9).

A pulse between the two is a data pulse: the bit is 1.

A pulse after both is the next clock pulse. Then the bit before it is 0.

PulseTime since the pulse beforeThe receiver says
0first clock pulse of a burst
162.5 µsdata pulse: the bit is 1
262.5 µsclock pulse
3125.0 µsclock pulse, and the bit before it is 0
4125.0 µsclock pulse, and the bit before it is 0
5125.0 µsclock pulse, and the bit before it is 0
6125.0 µsclock pulse, and the bit before it is 0
762.5 µsdata pulse: the bit is 1
862.5 µsclock pulse
962.5 µsdata pulse: the bit is 1

Bench run of a private model on the burst of the example. It hands the word 01E1h on at pulse 21, the 17th clock pulse.

The bench receiver is a model. Time moves in ticks of 0.1 µs, and a pulse is one instant.

A pulse arrivesThe receiver says
10.0 µs after a clock pulseignored
29.9 µs after a clock pulseignored
30.0 µs after a clock pulsedata pulse: the bit is 1
62.5 µs after a clock pulsedata pulse: the bit is 1
89.9 µs after a clock pulsedata pulse: the bit is 1
90.0 µs after a clock pulseclock pulse, and the bit before it is 0
125.0 µs after a clock pulseclock pulse, and the bit before it is 0
29.9 µs after a data pulseignored
30.0 µs after a data pulseclock pulse
5.9999 ms after the first pulse of a burstclock pulse, and the bit before it is 0
6.0000 ms after the first pulse of a burstfirst clock pulse of a burst

Bench run of a private model. Its timers are bench choices inside Table 28-9: 30 µs, 90 µs and 6 ms.

After a data pulse, the short timer starts again. The next pulse counted is a clock pulse.

A third timer ends the burst. nlp_test_min_timer starts at the first pulse and runs 5 to 7 ms.

A pulse after that opens a new burst.

What happens on the wireResult
a clean burstthe word 01E1h
one more pulse, 10 µs after the first clock pulsethe word 01E1h
one more pulse, 40 µs after the first clock pulsethe word 01E1h
the data pulse of D0 lostthe word 01E0h
the third clock pulse lostno word
the last clock pulse lostno word
the data pulse of D0 late, 95 µs after its clock pulsethe word 01E2h

Bench run of a private model on the word 01E1h. One wrong word is harmless: the receiver waits for three equal words.

The two "no word" rows are the bench's rule: it hands a word on only at the 17th clock pulse.

The standard also counts 16 clock pulses as enough (28.3.3). Then a lost clock pulse could give a shifted word.

The receiver keeps the first 16 bits. It counts no more than 17 clock pulses in a burst (28.3.3).

The 16 data bits are the link code word. The first one sent is the base page (28.2.1.2).

D0D1D2D3D4D5D6D7D8D9D10D11D12D13D14D15
FieldS0S1S2S3S4A0A1A2A3A4A5A6XNPRFAckNP
The example1000011110000000

The base page, IEEE Std 802.3-2022 Figure 28-7. D0 is sent first. The second row is the word 01E1h of the example.

BitMeaning
S4 to S0Selector. 00001 is IEEE 802.3 (Annex 28A)
A010BASE-T
A110BASE-T full duplex
A2100BASE-TX
A3100BASE-TX full duplex
A4100BASE-T4
A5PAUSE
A6ASM_DIR, asymmetric pause
XNPExtended Next Pages, of 48 bits, are supported
RFRemote fault
AckAcknowledge: I have your word
NPNext Page: I have more pages to send

IEEE Std 802.3-2022 28.2.1.2 and Table 28B-1.

Each ability bit is one technology. A port sets every bit it is willing to use.

It may hide an ability. It must never offer one it does not have (28.2.1).

Ability Match and Acknowledge Match

One burst may be damaged. So the receiver trusts a word only when it has come three times in a row.

ability_match: three words in a row are equal. The Ack bit is left out of the comparison (28.3.1).

acknowledge_match: three words in a row are equal, and all have Ack set.

WordValueAck bitability_matchacknowledge_match
101E1h000
201E1h000
301E1h010
441E1h110
541E1h110
641E1h111
741E1h111
84061h100
941E1h100
1041E1h100

Bench run of a private model. It works the two flags out again at each word, from the last three.

Any three in a row count. Word 4 sets Ack, and ability_match stays 1.

From First Burst to LinkThe main path of the arbitration. Each state changes what the port sends.
  • Control / FSM
  • Control
From first burst to linkThe main path of the arbitration. Each state changes what the port sends. control Ability Detect send my page, Ack = 0 control AcknowledgeDetect send my page, Ack = 1 control CompleteAcknowledge 6 to 8 more words control FLP Link GoodCheck pick the best commonmode control FLP Link Good bursts stop, datastarts control Transmit Disable silence, then startagain ability_matchacknowledge_matchacks sentPHY reports linkwords disagreetimer
  1. control Ability Detectsend my page, Ack = 0
    • ability_match → Acknowledge Detect
  2. control Acknowledge Detectsend my page, Ack = 1
    • acknowledge_match → Complete Acknowledge
    • words disagree → Transmit Disable
  3. control Complete Acknowledge6 to 8 more words
    • acks sent → FLP Link Good Check
  4. control FLP Link Good Checkpick the best common mode
    • PHY reports link → FLP Link Good
  5. control FLP Link Goodbursts stop, data starts
  6. control Transmit Disablesilence, then start again
    • timer → Ability Detect
  1. Advertise

    The port sends its base page with Ack = 0, burst after burst.

  2. Three equal words

    It has the partner's page. Now it sends its own page with Ack = 1.

  3. Three equal words with Ack

    The partner has this port's page too. The port sends six to eight more.

  4. Resolve

    Both ends pick the same mode from the two pages and switch that PHY on.

  5. Or start again

    If the acknowledged word is not the word matched before, the port goes silent and restarts.

Read the diagram as text
  • Ability Detect: send my page, Ack = 0
  • Acknowledge Detect: send my page, Ack = 1
  • Complete Acknowledge: 6 to 8 more words
  • FLP Link Good Check: pick the best common mode
  • FLP Link Good: bursts stop, data starts
  • Transmit Disable: silence, then start again
  • Ability Detect → Acknowledge Detect: ability_match
  • Acknowledge Detect → Complete Acknowledge: acknowledge_match
  • Complete Acknowledge → FLP Link Good Check: acks sent
  • FLP Link Good Check → FLP Link Good: PHY reports link
  • Acknowledge Detect → Transmit Disable: words disagree
  • Transmit Disable → Ability Detect: timer

Our own drawing of the main path of IEEE Std 802.3-2022 Figure 28-18. Parallel detection and Next Pages are left out.

After acknowledge_match a port sends six to eight more words with Ack (28.2.1.2.5). Then the bursts stop.

Priority Resolution

Both ports now hold both pages. Each one looks for the technologies that are on both.

If there are several, a fixed list decides (28B.3). Both ends use the same list, so they agree.

RankTechnologyWhere it is offered
1 to 540GBASE-T, 25GBASE-T, 10GBASE-T, 5GBASE-T and 2.5GBASE-T, each full duplexExtended Next Page, message code 9
6, 71000BASE-T full duplex, 1000BASE-TNext Pages
8100BASE-T2 full duplexNext Pages
9100BASE-TX full duplexA3
10100BASE-T2Next Pages
11100BASE-T4A4
12100BASE-TXA2
1310BASE-T full duplexA1
1410BASE-TA0

IEEE Std 802.3-2022 28B.3, the best first. The last column is from Table 28B-1, 28C.11, 28D.4 and 28D.5.

The list is not the bit order. 100BASE-T4 is bit A4, yet it ranks below 100BASE-TX full duplex, bit A3.

Port A offersPort B offersBoth enable
10BASE-T, 10BASE-T full duplex, 100BASE-TX, 100BASE-TX full duplex, 100BASE-T410BASE-T, 10BASE-T full duplex, 100BASE-TX, 100BASE-TX full duplex, 100BASE-T4100BASE-TX full duplex
10BASE-T, 10BASE-T full duplex, 100BASE-TX, 100BASE-TX full duplex, 100BASE-T410BASE-T, 100BASE-TX, 100BASE-T4100BASE-T4
10BASE-T, 10BASE-T full duplex, 100BASE-TX, 100BASE-TX full duplex10BASE-T, 10BASE-T full duplex, 100BASE-TX, 100BASE-T4100BASE-TX
10BASE-T, 10BASE-T full duplex10BASE-T, 10BASE-T full duplex, 100BASE-TX, 100BASE-TX full duplex, 100BASE-T410BASE-T full duplex
10BASE-T10BASE-T, 10BASE-T full duplex, 100BASE-TX, 100BASE-TX full duplex, 100BASE-T410BASE-T
10BASE-T10BASE-T full duplex, 100BASE-TX, 100BASE-TX full duplex, 100BASE-T4nothing in common
100BASE-TX full duplex, 100BASE-T410BASE-T, 10BASE-T full duplex, 100BASE-TXnothing in common
100BASE-TX full duplex100BASE-T4nothing in common

Bench run of a private model on pairs of base pages.

With nothing in common, no PHY is enabled.

The pause bits A5 and A6 are no technology. They are resolved by Table 28B-3, and only for a full-duplex mode.

P11.21 worked through that table for fibre ports. The rows are the same.

Partners Without Auto-Negotiation, and More Pages

Some partners send no bursts. Parallel detection handles them (28.2.3.1).

The port also listens for plain link pulses and for a 100BASE-TX or 100BASE-T4 signal.

If exactly one of them is seen, that PHY is enabled. Only half duplex can be found this way.

A port may have more to say than 16 bits. It sets NP and sends Next Pages after the base page (28.2.3.4).

1000BASE-T needs them: its abilities and its master or slave role travel in Next Pages (28D.5).

A port that sets XNP can send pages of 48 bits in one longer burst.

Try It

eth_flp_page builds a base page from its fields. Here: both 10BASE-T modes and both 100BASE-TX modes.

eth_flp_tx turns the word into pulse times. It is a bench model: a pulse is a time in ticks of 0.1 µs.

Pulse 1 comes 62.5 µs after pulse 0. That is a data pulse: D0 is 1.

Pulses 3 to 6 are 125 µs apart. Nothing sits between them: D1 to D4 are 0.

Pulse 7 is 62.5 µs after pulse 6: D5 is 1.

The receiver is not in the readable library. It is the practice problem.

Change the word to 16'h0001. Predict the number of pulses.

RUNIcarus Verilog · in your browser
Edit the code, then run it
Expected: word 01e1, D0 first: 1000011110000000 22 pulses, the last one at 2000.0 us pulse 1 at 62.5 us, 62.5 us after pulse 0 pulse 2 at 125.0 us, 62.5 us after pulse 1 pulse 3 at 250.0 us, 125.0 us after pulse 2 pulse 4 at 375.0 us, 125.0 us after pulse 3 pulse 5 at 500.0 us, 125.0 us after pulse 4 pulse 6 at 625.0 us, 125.0 us after pulse 5 pulse 7 at 687.5 us, 62.5 us after pulse 6 pulse 8 at 750.0 us, 62.5 us after pulse 7 pulse 9 at 812.5 us, 62.5 us after pulse 8
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_flp.sv
`timescale 1ns/1ns
// eth_flp.sv: the link pulses of Clause 28 auto-negotiation, sender side (read-only). A bench model: a link pulse
// is a time in ticks of 0.1 us, the width of one pulse (100 ns, Table 28-1). The receiver is not in this file.

// eth_flp_tx: one Fast Link Pulse burst as a list of pulse times (28.2.1.1.1, 28.2.1.1.2, Table 28-1).
//   clock_gap        ticks from a clock pulse to the next one. Typical 1250 (125 us); 1110 to 1390 is allowed.
//   data_gap         ticks from a clock pulse to the data pulse of a 1. Typical 625 (62.5 us); 555 to 695.
//   burst(t0, word)  the burst of a 16-bit word, with the first clock pulse at t0. D0 is sent first.
//   n, at[k]         the number of pulses in the burst, and the time of pulse k
module eth_flp_tx;
  int clock_gap = 1250, data_gap = 625;
  int n = 0;
  int at [0:32];
  function automatic void burst(input int t0, input [15:0] word);
    int t;
    n = 0; t = t0;
    for (int i = 0; i < 17; i++) begin
      at[n] = t; n++;                                  // a clock pulse: always there
      if (i < 16 && word[i]) begin                     // a 1: one more pulse, between two clock pulses
        at[n] = t + data_gap; n++;
      end
      t += clock_gap;
    end
  endfunction
endmodule

// eth_flp_page: the base page of the IEEE 802.3 selector as fields (Figure 28-7, Annex 28B).
//   page(abil, rf, ack, np)   abil[k] is ability bit Ak, k = 0 to 6. The selector is 00001 and XNP is 0.
//   tech(k)                   the name of ability bit Ak
module eth_flp_page;
  function automatic [15:0] page(input [6:0] abil, input bit rf, input bit ack, input bit np);
    return {np, ack, rf, 1'b0, abil, 5'b00001};
  endfunction
  function automatic string tech(input int k);
    case (k)
      0: return "10BASE-T";
      1: return "10BASE-T full duplex";
      2: return "100BASE-TX";
      3: return "100BASE-TX full duplex";
      4: return "100BASE-T4";
      5: return "PAUSE";
      6: return "ASM_DIR";
      default: return "none";
    endcase
  endfunction
endmodule

Check Yourself

Predict the outputThe bench sender builds the burst of the word 4081h. How many pulses does it print?
`timescale 1ns/1ns
module tb;
  eth_flp_tx tx();
  initial begin
    tx.burst(0, 16'h4081);
    $display("%0d", tx.n);
    $finish;
  end
endmodule
Read included file: hs_pkg.sv
`timescale 1ns/1ns
// hs_pkg.sv: shared pure functions, and the bench random generator (read-only).
package hs_pkg;
  // xorshift32 (Marsaglia 2003): a linear generator over GF(2), period 2^32 - 1. A zero state is
  // replaced by 1, because zero maps to itself.
  function automatic [31:0] xs32(input [31:0] s);
    reg [31:0] x;
    x = (s == 32'd0) ? 32'd1 : s;
    x = x ^ (x << 13); x = x ^ (x >> 17); x = x ^ (x << 5);
    return x;
  endfunction
  // A Fibonacci PRBS generator x^n + x^m + 1 (PRBS7: 7,6; PRBS9: 9,5; PRBS15: 15,14; PRBS23: 23,18;
  // PRBS31: 31,28). The output bit is s[n-1]; the next state shifts the feedback into bit 0.
  function automatic [31:0] prbs_next(input [31:0] s, input int n, input int m);
    reg fb;
    fb = s[n-1] ^ s[m-1];
    return ((s << 1) | {31'd0, fb}) & ((n == 32) ? 32'hffffffff : ((32'd1 << n) - 32'd1));
  endfunction
  function automatic int ones(input [63:0] v);
    int n; n = 0;
    for (int i = 0; i < 64; i++) n += v[i];
    return n;
  endfunction
  // GF(16) with x^4 + x + 1, and GF(1024) with x^10 + x^3 + 1: shift-and-add multiply, no tables.
  function automatic [3:0] gf16_mul(input [3:0] a, input [3:0] b);
    reg [3:0] p, x; p = 4'd0; x = a;
    for (int i = 0; i < 4; i++) begin
      if (b[i]) p = p ^ x;
      x = x[3] ? ({x[2:0], 1'b0} ^ 4'b0011) : {x[2:0], 1'b0};
    end
    return p;
  endfunction
  function automatic [3:0] gf16_pow(input int e);   // alpha^e, alpha = x
    reg [3:0] p; int k; p = 4'd1; k = e % 15; if (k < 0) k += 15;
    for (int i = 0; i < k; i++) p = gf16_mul(p, 4'd2);
    return p;
  endfunction
  function automatic int gf16_log(input [3:0] a);   // -1 for 0
    reg [3:0] p; p = 4'd1;
    if (a == 4'd0) return -1;
    for (int i = 0; i < 15; i++) begin if (p == a) return i; p = gf16_mul(p, 4'd2); end
    return -1;
  endfunction
  function automatic [9:0] gf1024_mul(input [9:0] a, input [9:0] b);
    reg [9:0] p, x; p = 10'd0; x = a;
    for (int i = 0; i < 10; i++) begin
      if (b[i]) p = p ^ x;
      x = x[9] ? ({x[8:0], 1'b0} ^ 10'b0000001001) : {x[8:0], 1'b0};
    end
    return p;
  endfunction
  function automatic [9:0] gf1024_pow(input int e);
    reg [9:0] p; int k; p = 10'd1; k = e % 1023; if (k < 0) k += 1023;
    for (int i = 0; i < k; i++) p = gf1024_mul(p, 10'd2);
    return p;
  endfunction
endpackage

// hs_rng: the bench's random numbers. Same seed, same numbers, on every engine.
module hs_rng;
  int unsigned s = 32'h2545f491;
  function automatic void seed(input int unsigned v); s = (v == 0) ? 32'd1 : v; endfunction
  function automatic int unsigned next(); s = hs_pkg::xs32(s); return s; endfunction
  function automatic int below(input int n); s = hs_pkg::xs32(s); return (n <= 0) ? 0 : int'(s % n); endfunction
  function automatic bit bit1(); s = hs_pkg::xs32(s); return s[16]; endfunction
  function automatic bit chance_ppm(input int ppm); s = hs_pkg::xs32(s); return (s % 1000000) < ppm; endfunction
  function automatic [7:0] byte8(); s = hs_pkg::xs32(s); return s[23:16]; endfunction
endmodule
Read included file: hs_code.sv
`timescale 1ns/1ns
// hs_code.sv: line codes, CRCs and scramblers (read-only).

// ---------------------------------------------------------------------------------------------
// hs_8b10b: 8b/10b encoder and decoder with running disparity and the 12 K codes.
// code[9:0] = {a,b,c,d,e,i,f,g,h,j}; bit a (code[9]) goes on the wire first. rd: 0 = RD-, 1 = RD+.
//   encode(d, k, rd_in) -> {rd_out, code[9:0]}            (11 bits)
//   decode(code, rd_in) -> {rd_out, disp_err, code_err, k, d[7:0]}   (12 bits)
//   enc(d, k) / dec(code): the same, with the running disparity kept in rd_tx / rd_rx
// A K request for a byte that is not one of the 12 K codes is encoded as data and counted in bad_k.
// Decoder: code_err = the code is in neither column of the table; disp_err = it is a valid code
// only in the other column. rd_out follows the sub-block rule on the received bits.
// Faults: no_rd (always the RD- column), a7_never (never the alternate D.x.A7),
//         keep_rd_on_unbalanced (the 4b sub-block is chosen with the disparity from before the 6b one),
//         no_balanced_flip (D.07 and D.x.3 keep their RD- form at RD+), dec_no_disp_check.
module hs_8b10b;
  bit no_rd = 0, a7_never = 0, keep_rd_on_unbalanced = 0, no_balanced_flip = 0, dec_no_disp_check = 0;
  bit trace = 0;
  bit rd_tx = 0, rd_rx = 0;
  int bad_k = 0, symbols = 0, code_errs = 0, disp_errs = 0;
  bit last_k = 0, last_code_err = 0, last_disp_err = 0;
  bit valid_m [0:1023]; bit valid_p [0:1023]; bit [8:0] kd [0:1023]; bit built = 0;
  function automatic [5:0] t6(input [4:0] x);   // 5b/6b, RD- column, abcdei
    case (x)
      5'd0: return 6'b100111;  5'd1: return 6'b011101;  5'd2: return 6'b101101;  5'd3: return 6'b110001;
      5'd4: return 6'b110101;  5'd5: return 6'b101001;  5'd6: return 6'b011001;  5'd7: return 6'b111000;
      5'd8: return 6'b111001;  5'd9: return 6'b100101;  5'd10: return 6'b010101; 5'd11: return 6'b110100;
      5'd12: return 6'b001101; 5'd13: return 6'b101100; 5'd14: return 6'b011100; 5'd15: return 6'b010111;
      5'd16: return 6'b011011; 5'd17: return 6'b100011; 5'd18: return 6'b010011; 5'd19: return 6'b110010;
      5'd20: return 6'b001011; 5'd21: return 6'b101010; 5'd22: return 6'b011010; 5'd23: return 6'b111010;
      5'd24: return 6'b110011; 5'd25: return 6'b100110; 5'd26: return 6'b010110; 5'd27: return 6'b110110;
      5'd28: return 6'b001110; 5'd29: return 6'b101110; 5'd30: return 6'b011110; default: return 6'b101011;
    endcase
  endfunction
  function automatic [3:0] t4d(input [2:0] y);  // 3b/4b data, RD- column, fghj (y = 7 is P7)
    case (y)
      3'd0: return 4'b1011; 3'd1: return 4'b1001; 3'd2: return 4'b0101; 3'd3: return 4'b1100;
      3'd4: return 4'b1101; 3'd5: return 4'b1010; 3'd6: return 4'b0110; default: return 4'b1110;
    endcase
  endfunction
  function automatic [3:0] t4k(input [2:0] y);  // 3b/4b for K codes, RD- form before the flip
    case (y)
      3'd0: return 4'b1011; 3'd1: return 4'b0110; 3'd2: return 4'b1010; 3'd3: return 4'b1100;
      3'd4: return 4'b1101; 3'd5: return 4'b0101; 3'd6: return 4'b1001; default: return 4'b0111;
    endcase
  endfunction
  function automatic bit k_ok(input [7:0] d);
    return d[4:0] == 5'd28 || d == 8'hf7 || d == 8'hfb || d == 8'hfd || d == 8'hfe;
  endfunction
  function automatic int n6(input [5:0] v); return v[0] + v[1] + v[2] + v[3] + v[4] + v[5]; endfunction
  function automatic int n4(input [3:0] v); return v[0] + v[1] + v[2] + v[3]; endfunction
  // running disparity at the end of a sub-block (more ones: +; more zeros: -; 000111 and 0011: +; 111000 and 1100: -)
  function automatic bit rd6(input [5:0] v, input bit rd);
    return (n6(v) > 3) ? 1'b1 : (n6(v) < 3) ? 1'b0 : (v == 6'b000111) ? 1'b1 : (v == 6'b111000) ? 1'b0 : rd;
  endfunction
  function automatic bit rd4(input [3:0] v, input bit rd);
    return (n4(v) > 2) ? 1'b1 : (n4(v) < 2) ? 1'b0 : (v == 4'b0011) ? 1'b1 : (v == 4'b1100) ? 1'b0 : rd;
  endfunction
  // faults: [0] no_rd [1] a7_never [2] keep_rd_on_unbalanced [3] no_balanced_flip
  function automatic [10:0] core(input [7:0] d, input bit k, input bit rd_in, input [3:0] f);
    reg [5:0] six; reg [3:0] four; reg rd0, r6, rd1, a7, kk; reg [4:0] x; reg [2:0] y; int o6, o4;
    x = d[4:0]; y = d[7:5]; kk = k && k_ok(d); rd0 = f[0] ? 1'b0 : rd_in;
    six = (kk && x == 5'd28) ? 6'b001111 : t6(x); o6 = n6(six);
    if (rd0 && (o6 != 3 || (six == 6'b111000 && !f[3]))) begin six = ~six; o6 = 6 - o6; end
    r6 = (o6 > 3) ? 1'b1 : (o6 < 3) ? 1'b0 : (six == 6'b000111) ? 1'b1 : (six == 6'b111000) ? 1'b0 : rd0;
    rd1 = f[2] ? rd0 : r6;
    if (kk) begin
      four = t4k(y); if (rd1) four = ~four;
    end else begin
      a7 = (y == 3'd7) && !f[1] && ((!rd1 && (x == 5'd17 || x == 5'd18 || x == 5'd20)) || (rd1 && (x == 5'd11 || x == 5'd13 || x == 5'd14)));
      four = a7 ? 4'b0111 : t4d(y);
      if (rd1 && (n4(four) != 2 || (four == 4'b1100 && !f[3]))) four = ~four;
    end
    o4 = n4(four);
    return {(o4 > 2) ? 1'b1 : (o4 < 2) ? 1'b0 : (four == 4'b0011) ? 1'b1 : (four == 4'b1100) ? 1'b0 : r6, six, four};
  endfunction
  function automatic [10:0] encode(input [7:0] d, input bit k, input bit rd_in);
    if (k && !k_ok(d)) bad_k++;
    return core(d, k, rd_in, {no_balanced_flip, keep_rd_on_unbalanced, a7_never, no_rd});
  endfunction
  function automatic void build();
    reg [10:0] c;
    for (int i = 0; i < 1024; i++) begin valid_m[i] = 0; valid_p[i] = 0; kd[i] = 9'd0; end
    for (int i = 0; i < 268; i++) begin
      reg [7:0] d; reg k;
      if (i < 256) begin d = i[7:0]; k = 0; end
      else begin k = 1; d = (i < 264) ? {3'(i - 256), 5'd28} : (i == 264) ? 8'hf7 : (i == 265) ? 8'hfb : (i == 266) ? 8'hfd : 8'hfe; end
      c = core(d, k, 1'b0, 4'd0); valid_m[c[9:0]] = 1; kd[c[9:0]] = {k, d};
      c = core(d, k, 1'b1, 4'd0); valid_p[c[9:0]] = 1; kd[c[9:0]] = {k, d};
    end
    built = 1;
  endfunction
  function automatic [11:0] decode(input [9:0] code, input bit rd_in);
    reg here, there, ce, de, r;
    if (!built) build();
    here = rd_in ? valid_p[code] : valid_m[code];
    there = rd_in ? valid_m[code] : valid_p[code];
    ce = !(here || there); de = !ce && !here && !dec_no_disp_check;
    r = rd4(code[3:0], rd6(code[9:4], rd_in));
    return {r, de, ce, ce ? 9'd0 : kd[code]};
  endfunction
  function automatic [9:0] enc(input [7:0] d, input bit k);
    reg [10:0] r; r = encode(d, k, rd_tx); rd_tx = r[10];
    if (trace) $display("s%0d TX %s%0d.%0d code=%b rd=%s", symbols, (k && k_ok(d)) ? "K" : "D", d[4:0], d[7:5], r[9:0], r[10] ? "+" : "-");
    symbols++;
    return r[9:0];
  endfunction
  function automatic [8:0] dec(input [9:0] code);
    reg [11:0] r; r = decode(code, rd_rx); rd_rx = r[11];
    last_disp_err = r[10]; last_code_err = r[9]; last_k = r[8];
    if (r[9]) code_errs++; if (r[10]) disp_errs++;
    if (trace && (r[9] || r[10])) $display("RX %b %s", code, r[9] ? "code error" : "disparity error");
    return r[8:0];
  endfunction
  function automatic bit comma7(input [6:0] w); return w == 7'b0011111 || w == 7'b1100000; endfunction
endmodule

// ---------------------------------------------------------------------------------------------
// hs_crc: a CRC of 1 to 32 bits with any polynomial, seed, bit order and final inversion.
// The register shifts left; the polynomial omits the x^width term. The field is sent register bit
// width-1 first (USB 2.0, USB 3.2 and Ethernet all send it this way).
//   use_crc32(), use_crc16_usb2(), use_crc5_usb2(), use_crc16_usb3(): parameter sets
//   reset(), crc_bit(b), crc_byte(v), crc_bits(v, n), field(), field_bit(i), check_value(), crc_residue_ok()
// Faults: msb_first (bytes enter MSB first), no_invert (the field is not complemented), seed_zero.
module hs_crc;
  int width = 32;
  bit [31:0] poly = 32'h04c11db7, seed = 32'hffffffff, residue = 32'hc704dd7b;
  bit lsb_first = 1, invert = 1;
  bit msb_first = 0, no_invert = 0, seed_zero = 0;
  bit [31:0] r = 32'hffffffff;
  function automatic [31:0] mask(); return (width >= 32) ? 32'hffffffff : ((32'd1 << width) - 32'd1); endfunction
  function automatic void reset(); r = seed_zero ? 32'd0 : (seed & mask()); endfunction
  function automatic void set(input int w, input [31:0] p, input [31:0] s, input [31:0] res, input bit lsb, input bit inv);
    width = w; poly = p; seed = s; residue = res; lsb_first = lsb; invert = inv; reset();
  endfunction
  function automatic void use_crc32();      set(32, 32'h04c11db7, 32'hffffffff, 32'hc704dd7b, 1, 1); endfunction
  function automatic void use_crc16_usb2(); set(16, 32'h8005, 32'hffff, 32'h800d, 1, 1); endfunction
  function automatic void use_crc5_usb2();  set(5, 32'h05, 32'h1f, 32'h0c, 1, 1); endfunction
  function automatic void use_crc16_usb3(); set(16, 32'h100b, 32'hffff, 32'hf6aa, 1, 1); endfunction
  function automatic void crc_bit(input bit b);
    reg fb; fb = b ^ r[width - 1];
    r = ((r << 1) ^ (fb ? poly : 32'd0)) & mask();
  endfunction
  function automatic void crc_byte(input [7:0] v);
    for (int i = 0; i < 8; i++) crc_bit(v[(lsb_first ^ msb_first) ? i : 7 - i]);
  endfunction
  function automatic void crc_bits(input [31:0] v, input int n);   // n bits of v, bit 0 first
    for (int i = 0; i < n; i++) crc_bit(v[i]);
  endfunction
  function automatic [31:0] field(); return (invert && !no_invert) ? (~r & mask()) : r; endfunction
  function automatic bit field_bit(input int i); reg [31:0] f; f = field(); return f[width - 1 - i]; endfunction
  // the usual published "check" number: the field with its first-sent bit read as bit 0
  function automatic [31:0] check_value();
    reg [31:0] f, o; f = field(); o = 32'd0;
    for (int i = 0; i < width; i++) o[i] = f[width - 1 - i];
    return lsb_first ? o : f;
  endfunction
  function automatic bit crc_residue_ok(); return r == (residue & mask()); endfunction
endmodule

// ---------------------------------------------------------------------------------------------
// hs_scr: additive (frame-synchronous) and multiplicative (self-synchronising) scramblers.
// poly holds the coefficients: bit k is x^k; the +1 term is always used (taps() sets bit 0); len is the degree.
// Additive: a Galois LFSR. The key bit is s[len-1]; each step shifts left and adds the low terms of
//   the polynomial when the key bit is 1. The data never enters the register.
// Multiplicative: the line bit is the data bit XOR the register bits at the polynomial's terms;
//   the scrambler shifts its own output in, the descrambler shifts the received line bit in.
//   scr_add(len, poly, seed), scr_mul(len, poly), use_usb3_gen1(), use_x58(), use_x23_usb3() (see its note)
//   scr_bit(b), dscr_bit(b), scr_byte(v), dscr_byte(v) (bit 0 first), scr_reset(), scr_hold() (a skip
//   symbol: no step), scr_unscrambled() (a symbol sent in the clear: 8 steps, data untouched)
// Faults: advance_on_skip (scr_hold steps the LFSR 8 times), no_reset (scr_reset does nothing),
//         wrong_tap (the lowest term x^k becomes x^(k+1)), seed_zero (scr_reset loads 0).
module hs_scr;
  bit mult = 0; int len = 16;
  bit [63:0] poly = 64'h10039, seed = 64'hffff;
  bit advance_on_skip = 0, no_reset = 0, wrong_tap = 0, seed_zero = 0;
  bit [63:0] s = 64'hffff;
  int steps = 0;
  function automatic [63:0] lmask(); return (len >= 64) ? 64'hffffffffffffffff : ((64'd1 << len) - 64'd1); endfunction
  function automatic [63:0] taps();
    reg [63:0] p; int k; p = poly | 64'd1; k = 1;
    if (wrong_tap) begin
      while (k < len && !p[k]) k++;
      if (k < len) begin p[k] = 1'b0; p[k + 1] = 1'b1; end
    end
    return p;
  endfunction
  function automatic void load(); s = (seed_zero ? 64'd0 : seed) & lmask(); endfunction
  function automatic void scr_add(input int n, input [63:0] p, input [63:0] sd); mult = 0; len = n; poly = p; seed = sd; s = sd & lmask(); endfunction
  function automatic void scr_mul(input int n, input [63:0] p); mult = 1; len = n; poly = p; seed = 64'd0; s = 64'd0; endfunction
  function automatic void use_usb3_gen1(); scr_add(16, 64'h10039, 64'hffff); endfunction   // x^16 + x^5 + x^4 + x^3 + 1, seed FFFFh
  function automatic void use_x58(); scr_mul(58, (64'd1 << 58) | (64'd1 << 39) | 64'd1); endfunction   // x^58 + x^39 + 1
  // USB 3.2 Gen 2 (§6.3.2.3) polynomial x^23 + x^21 + x^16 + x^8 + x^5 + x^2 + 1 with seed 1DBFBCh. Only the
  // polynomial and seed are the specification's: the register form here is this library's Galois form, and
  // the reset and bypass rules of §6.3.2.3 are not modelled, so do not quote its key stream as USB's.
  function automatic void use_x23_usb3(); scr_add(23, (64'd1 << 23) | (64'd1 << 21) | (64'd1 << 16) | (64'd1 << 8) | (64'd1 << 5) | (64'd1 << 2) | 64'd1, 64'h1dbfbc); endfunction
  function automatic void scr_reset(); if (!no_reset) load(); endfunction
  function automatic bit key(); return s[len - 1]; endfunction
  function automatic void step();
    reg kb; kb = s[len - 1];
    s = ((s << 1) & lmask()) ^ (kb ? (taps() & lmask()) : 64'd0);
    steps++;
  endfunction
  // the XOR of the register bits at the polynomial's terms x^1..x^len (bit k-1 of the register for x^k)
  function automatic bit fbx(input [63:0] st); return ^(st & (taps() >> 1) & lmask()); endfunction
  function automatic bit scr_bit(input bit b);
    reg o;
    if (!mult) begin o = b ^ s[len - 1]; step(); end
    else begin o = b ^ fbx(s); s = ((s << 1) | {63'd0, o}) & lmask(); steps++; end
    return o;
  endfunction
  function automatic bit dscr_bit(input bit b);
    reg o;
    if (!mult) begin o = b ^ s[len - 1]; step(); end
    else begin o = b ^ fbx(s); s = ((s << 1) | {63'd0, b}) & lmask(); steps++; end
    return o;
  endfunction
  function automatic [7:0] scr_byte(input [7:0] v);
    reg [7:0] o; for (int i = 0; i < 8; i++) o[i] = scr_bit(v[i]); return o;
  endfunction
  function automatic [7:0] dscr_byte(input [7:0] v);
    reg [7:0] o; for (int i = 0; i < 8; i++) o[i] = dscr_bit(v[i]); return o;
  endfunction
  // a skip symbol passes unscrambled and the LFSR holds
  function automatic void scr_hold(); if (advance_on_skip && !mult) for (int i = 0; i < 8; i++) step(); endfunction
  // another symbol that is sent unscrambled (a K code other than COM and SKP): the LFSR still steps 8 times
  function automatic void scr_unscrambled(); if (!mult) for (int i = 0; i < 8; i++) step(); endfunction
endmodule
Read included file: eth_flp.sv
`timescale 1ns/1ns
// eth_flp.sv: the link pulses of Clause 28 auto-negotiation, sender side (read-only). A bench model: a link pulse
// is a time in ticks of 0.1 us, the width of one pulse (100 ns, Table 28-1). The receiver is not in this file.

// eth_flp_tx: one Fast Link Pulse burst as a list of pulse times (28.2.1.1.1, 28.2.1.1.2, Table 28-1).
//   clock_gap        ticks from a clock pulse to the next one. Typical 1250 (125 us); 1110 to 1390 is allowed.
//   data_gap         ticks from a clock pulse to the data pulse of a 1. Typical 625 (62.5 us); 555 to 695.
//   burst(t0, word)  the burst of a 16-bit word, with the first clock pulse at t0. D0 is sent first.
//   n, at[k]         the number of pulses in the burst, and the time of pulse k
module eth_flp_tx;
  int clock_gap = 1250, data_gap = 625;
  int n = 0;
  int at [0:32];
  function automatic void burst(input int t0, input [15:0] word);
    int t;
    n = 0; t = t0;
    for (int i = 0; i < 17; i++) begin
      at[n] = t; n++;                                  // a clock pulse: always there
      if (i < 16 && word[i]) begin                     // a 1: one more pulse, between two clock pulses
        at[n] = t + data_gap; n++;
      end
      t += clock_gap;
    end
  endfunction
endmodule

// eth_flp_page: the base page of the IEEE 802.3 selector as fields (Figure 28-7, Annex 28B).
//   page(abil, rf, ack, np)   abil[k] is ability bit Ak, k = 0 to 6. The selector is 00001 and XNP is 0.
//   tech(k)                   the name of ability bit Ak
module eth_flp_page;
  function automatic [15:0] page(input [6:0] abil, input bit rf, input bit ack, input bit np);
    return {np, ack, rf, 1'b0, abil, 5'b00001};
  endfunction
  function automatic string tech(input int k);
    case (k)
      0: return "10BASE-T";
      1: return "10BASE-T full duplex";
      2: return "100BASE-TX";
      3: return "100BASE-TX full duplex";
      4: return "100BASE-T4";
      5: return "PAUSE";
      6: return "ASM_DIR";
      default: return "none";
    endcase
  endfunction
endmodule
ConceptWhich bit of the base page is sent first in a burst?
ConceptTwo clock pulses are 125 µs apart with no pulse between them. What did the sender mean?
ConceptA port has seen three equal words with Ack set. What does it do next?
ConceptPort A offers all five base-page technologies. Port B offers 10BASE-T and 100BASE-TX, half duplex only. What is enabled?

Common Mistakes

Wrong Tell a clock pulse by its shape.

All link pulses look the same.

Fix Use the time since the last clock pulse: the window between the two timers means data.

Wrong Trust a word after one burst.

One lost or extra pulse changes the word.

Fix Wait for three equal words in a row.

Wrong Compare the Ack bit for ability_match.

The partner sets Ack in the middle of the exchange.

Fix Leave D14 out for ability_match. Ask for it in all three words for acknowledge_match.

Wrong Pick the highest ability bit that both pages set.

100BASE-T4 is bit A4 but ranks below 100BASE-TX full duplex.

Fix Use the list of 28B.3.

Remember

  • An FLP burst has 17 clock pulses. A pulse half way between two of them is a 1; none is a 0.
  • The receiver sorts pulses with two timers that start at each clock pulse.
  • The 16 bits are the base page: selector, ability bits, XNP, RF, Ack and NP. D0 goes first.
  • Three equal words in a row give ability_match. Three with Ack give acknowledge_match.
  • Both ends pick the best common technology from one fixed list, so they pick the same one.

Practice

Report a problem with this page