Energy-Efficient Ethernet
An idle Ethernet link burns almost as much power as a busy one. Energy-Efficient Ethernet lets it sleep between frames and wake in microseconds. See the timeline of one sleep.
You Will Be Able To
- Name the phases of Low Power Idle: sleep, quiet, refresh and wake.
- Say how the RS signals LPI on the XGMII.
- Follow the LPI transmit state diagram of the 10GBASE-R PCS.
- Explain why a frame waits for the wake time, and who sets that time.
- Lesson
- P11.39
- Time
- 40 min
- Runs on
- Your browser
- Check
- 5 questions
A link with nothing to send can switch its transmitter off. It only has to check in now and then.
In the bench, a long sleep keeps the transmitter off for 99.03% of the time.
- Cycle 1
Nothing to send. For 5 µs the transmitter tells the partner that it will go quiet.
- Cycle 2
The transmitter is off. This lasts 1.75 ms.
- Cycle 3
A refresh: the transmitter comes back for a moment, so the partner stays in tune.
- Cycle 6
Quiet again.
- Cycle 7
A frame is waiting. The transmitter wakes the partner.
- Cycle 9
Back to normal. The frame itself must wait a little longer still.
Bench run of a private model of Figure 49-12, with the timer values of 10GBASE-KR in ticks of 0.1 µs.
An Idle Link Still Costs Power
A normal link never rests. Between frames it sends idle, at full rate and full power.
The optional Energy-Efficient Ethernet (EEE) lets a link rest in those gaps (78.1).
The mode is called Low Power Idle (LPI). The link stays up, and no frame is lost or damaged.
Each direction sleeps on its own. One may sleep while the other carries frames (78.3).
Both ends must want it. Most PHYs say so in auto-negotiation, with a Next Page of message code 10 (78.3, 73A.4).
Sleep, Quiet, Refresh, Wake
A sleeping transmitter goes through four kinds of time (78.1.3.3, 78.2).
Sleep, for Ts: it tells the partner that it will go quiet.
Quiet, for Tq: it sends nothing.
Refresh, for Tr: it sends for a moment. The partner uses that to keep its clock and its equalizer in tune.
Quiet and refresh repeat. A wake signal ends them when a frame is waiting.
| PHY | Ts: sleep signal | Tq: quiet | Tr: refresh |
|---|---|---|---|
| 100BASE-TX | 200 µs to 220 µs | 20 ms to 22 ms | 200 µs to 220 µs |
| 1000BASE-KX | 19.9 µs to 20.1 µs | 2.5 ms to 2.6 ms | 19.9 µs to 20.1 µs |
| 10GBASE-KX4 | 19.9 µs to 20.1 µs | 2.5 ms to 2.6 ms | 19.9 µs to 20.1 µs |
| 10GBASE-KR | 4.9 µs to 5.1 µs | 1.7 ms to 1.8 ms | 16.9 µs to 17.5 µs |
| 10GBASE-T | 2.88 µs to 3.2 µs | 39.68 µs | 1.28 µs |
| 40GBASE-KR4 | 0.9 µs to 1.1 µs | 1.7 ms to 1.8 ms | 5.9 µs to 6.5 µs |
IEEE Std 802.3-2022 Table 78-2, six of its rows. 40GBASE-CR4 and the four-lane 100G backplane and cable PHYs have the values of 40GBASE-KR4.
In the bench, 10GBASE-KR is quiet for 1750.0 µs and refreshes for 17.2 µs. That makes 99.03% of quiet time.
Who Does What
- I/O
- Datapath
- Control
- Data
- Ask
The LPI client sees an empty queue and asks for Low Power Idle.
- Signal
The RS puts the LPI code on the xMII and stops the MAC from sending.
- Sleep
The PCS sends LPI blocks for a moment. Then it tells the PMD to switch the transmitter off.
- Follow
The partner sees the LPI blocks and then silence. Its receiver may power down too.
- Tell
The partner's RS reports LPI to its own client. No frame is lost on the way.
Read the diagram as text
- LPI client: decides when to sleep
- RS: sends LPI, holds the MAC
- PCS: sleep, quiet, refresh, wake
- PMD: transmitter on or off
- Partner PCS: follows, and checks the times
- Partner RS: tells its LPI client
- LPI client → RS: LP_IDLE.request
- RS → PCS: LPI on the xMII
- PCS → PMD: tx_mode
- PMD → Partner PCS: the line
- Partner PCS → Partner RS: LPI on the xMII
Our own drawing after IEEE Std 802.3-2022 78.1.1 and Figures 78-1 and 78-2.
When to sleep is the LPI client's choice. The standard does not say how it decides (78.1.1.2).
The client asks the RS with LP_IDLE.request. The partner's client hears of it by LP_IDLE.indication.
LPI on the XGMII
The RS says "LPI" with a code of its own on the MII. Each interface has one.
| Interface | How the RS says "LPI" | Clause |
|---|---|---|
| MII, 100 Mb/s | TX_EN 0, TX_ER 1, TXD 0001 | 22.7 |
| GMII, 1 Gb/s | TX_EN 0, TX_ER 1, TXD 01h | 35.4 |
| XGMII, 10 Gb/s | control character 06h in all four lanes | 46.4 |
| XLGMII and CGMII | control character 06h in all eight lanes | 81.4 |
IEEE Std 802.3-2022 Tables 22-1 and 35-1, 46.3.1.5 and 81.3.1.5.
On the XGMII the RS sends the control character 06h in all four lanes (46.3.1.5).
To wake the link, it sends Idle again: 07h.
Then it must wait before the first Start. For 10GBASE-KR that is 15.38 µs: 4,807 columns of Idle.
The receive side mirrors this. The PHY shows LPI on the receive XGMII while its partner sleeps (78.1.3.3.2).
The RS Holds the MAC Back
A frame that goes out while the partner still wakes is lost. So the RS runs a small state diagram (46.4.2).
| State of the RS | The MAC | It leaves when |
|---|---|---|
| LPI_DEASSERTED | may send | the client asks for LPI |
| LPI_ASSERTED | must wait | the client stops asking |
| LPI_WAIT | must wait | the wake timer ends, and only then |
IEEE Std 802.3-2022 Figure 46-13. The wake timer is the resolved Tw_sys_tx.
While it says "must wait", the RS shows the MAC a busy carrier, and the MAC defers.
The wake timer starts when the request ends. Nothing shortens it.
A new request inside LPI_WAIT changes nothing here. The timer still runs from the first end.
So a client that asks again and stops again can free the MAC too early. A careful client waits out the wake time.
Its length is Tw_sys_tx: the time this system waits after it stops sending LPI.
The PCS Runs the Timeline
The 10GBASE-R PCS turns LPI characters into LPI blocks. Its LPI transmit diagram does the rest (49.2.13.3.1).
| State of the PCS | Transmitter | Lasts | It leaves |
|---|---|---|---|
| TX_ACTIVE | data | to TX_SLEEP on an LPI block | |
| TX_SLEEP | data: the sleep signal | 4.9 µs to 5.1 µs | to TX_QUIET at the end. To TX_ACTIVE at once if the LPI blocks stop |
| TX_QUIET | off | 1.7 ms to 1.8 ms | to TX_ALERT at the end, or when the LPI blocks stop |
| TX_ALERT | the alert signal: FF00h again and again (72.6.2) | 1.1 µs to 1.3 µs | to TX_WAKE at the end, never before |
| TX_WAKE | data: the wake signal | 10.9 µs to 11.1 µs | at the end, never before: to TX_SLEEP if LPI blocks still come, else to TX_ACTIVE |
| TX_SCR_BYPASS | data, not scrambled | 1.1 µs to 1.3 µs | the same. Entered after TX_WAKE, and only when the FEC of Clause 74 is in use |
IEEE Std 802.3-2022 Figure 49-12 and Table 49-2.
There is no "refresh" state. A refresh is TX_ALERT, TX_WAKE and TX_SLEEP in a row, while the RS keeps sending LPI.
Add their timers: 1.1 + 10.9 + 4.9 µs is 16.9 µs. That is the least Tr of 10GBASE-KR in Table 78-2.
With the scrambler bypass, TX_SCR_BYPASS comes after TX_WAKE, and a refresh is one T1U longer.
The alert signal helps a sleeping receiver notice that the quiet time is over (78.1.1).
Look at the "never before" rows. A wake that has begun always runs to its end.
Wake Before You Send
| A frame arrives | This PCS is back in TX_ACTIVE after | The MAC may start after | The twin lets the MAC start after |
|---|---|---|---|
| in the quiet time | 12.2 µs | 15.4 µs | 1.3 µs |
| in a refresh, 5 us into the wake | 6.0 µs | 15.4 µs | 0.1 µs |
| in the first sleep signal | 0.0 µs | 15.4 µs | 0.1 µs |
Bench run of a private model and of the twin sends_in_refresh. Times are from the end of the LPI request. The wake time is 15.4 µs: 15.38 µs in whole ticks.
In the bench, this PCS is ready after 12.2 µs at most. Table 49-2 allows up to 12.4 µs.
The MAC still waits 15.4 µs.
The wait is not for this port. It is for the partner, whose receiver must lock on to the signal again.
The twin frees the MAC as soon as its own transmitter is on.
In a refresh the transmitter is on. So the twin sends at once, into a partner that expects silence next.
How Long Is the Wake Time?
Table 78-4 gives five numbers for each PHY (78.2, 78.5).
Tw_phy: the time from Idle on the xMII until the PHY can take data.
Tw_sys_rx: the time the system behind the receiver needs.
Two shrink times: how much of the wait the two PHYs may eat up on the way.
Tw_sys_tx: what the sender must wait in the end.
| PHY | Tw_phy | Tw_sys_rx | Shrink, transmit | Shrink, receive | Tw_sys_tx | Sum of the three |
|---|---|---|---|---|---|---|
| 100BASE-TX | 20.5 | 10 | 5 | 15 | 30 | 30 |
| 1000BASE-KX | 11.25 | 1.76 | 5 | 6.5 | 13.26 | 13.26 |
| 10GBASE-KX4 | 9.25 | 2.88 | 5 | 4.5 | 12.38 | 12.38 |
| 10GBASE-KR, case 1 | 12.25 | 2.88 | 5 | 7.5 | 15.38 | 15.38 |
| 10GBASE-KR, case 2 | 14.25 | 2.88 | 5 | 9.5 | 17.38 | 17.38 |
IEEE Std 802.3-2022 Table 78-4, in microseconds. The last column is this page's arithmetic: Tw_sys_rx plus the two shrink times (Figure 78-5). Case 2 of 10GBASE-KR is with FEC.
For these PHYs the sender's wait is the receiver's need plus the two shrink times.
In other rows, such as 1000BASE-T and 40GBASE-KR4, the entry is Tw_phy and the sum is not.
A system waits for the greater of Tw_sys_tx and Tw_phy (Figure 78-5).
The table gives the least wait. A receiver that sleeps deeper can ask for more.
It asks in an LLDP frame, with the EEE TLV of Clause 79 (79.3.5).
The TLV carries a transmit Tw, a receive Tw, a fallback and two echoes. Both Tw values start at Tw_phy.
Devices at 10 Gb/s and above must support that exchange (78.4).
The Receiver Keeps Watch
The receiving PCS follows the sleep and checks the clock (Figure 49-13).
| The partner | States of the receiver, in order | Last change at | Wake errors | Link failures |
|---|---|---|---|---|
| refreshes, then wakes | SLEEP → QUIET → WAKE → SLEEP → QUIET → WAKE → ACTIVE | 3,524 µs | 0 | 0 |
| wakes, but lock comes 20 µs later | SLEEP → QUIET → WAKE → WTF → ACTIVE | 1,777 µs | 1 | 0 |
| never refreshes | SLEEP → QUIET → ACTIVE | 2,506.9 µs | 0 | 1 |
Bench run of a private model of Figure 49-13. Its three timers are 2.5 ms, 11.5 µs and 10 ms, inside Table 49-3.
It expects energy again within 2 to 3 ms of the last LPI block. If none comes, it reports a link failure.
After energy it must lock within 11.5 µs, or 13.7 µs with the scrambler bypass.
If not, it counts a wake error and gets up to 10 ms more.
Faster Links: Fast Wake
What this lesson showed is called deep sleep: the transmitter really goes off.
PHYs at 25 Gb/s and above also have fast wake (78.1.3.3.1).
There the transmitter keeps running and only sends LPI blocks. The saving is above the PHY, and the wake is short.
Most optical PHYs have fast wake only. Table 78-1 marks them.
An EEE Fast Wake TLV tells the partner which mode is in use (79.3.6).
In deep sleep, a 40G or 100G PCS sends rapid alignment markers, so its lanes line up again quickly (82.2.9).
Its PMA has quiet and alert signals of its own (83.5.11).
Try It
eth_lpi_col builds XGMII columns. A column is four control bits and four octets.
Idle is 07h in every lane. LPI is 06h in every lane.
The bench sends LPI for 2 ms. That is 625,000 columns of 3.2 ns.
Then it sends Idle for the wake time. cols rounds 15.38 µs up to 4,807 whole columns.
Only after them comes Start, FBh in lane 0.
With FEC the wait is 17.38 µs: 5,432 columns.
The state diagrams are not in the readable library. They are the practice problem.
Change the sleep to 500 µs. Predict the number of LPI columns.
2 x Idle: TXC f, TXD 07070707 625000 x LPI: TXC f, TXD 06060606 4807 x Idle: TXC f, TXD 07070707 1 x Start: TXC 1, TXD 555555fb one column: 3.2 ns; 15.38 us is 4807 columns; 17.38 us is 5432Read 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_lpi.sv
`timescale 1ns/1ns
// eth_lpi.sv: Low Power Idle on the XGMII (read-only). A bench model.
// eth_lpi_col: the columns an RS sends around a sleep (46.3.1.5). A column is {TXC[3:0], TXD[31:0]}.
// lpi() LPI in all four lanes: control, octet 06h
// idle() Idle in all four lanes: control, octet 07h
// start() Start (FBh) in lane 0, then three preamble octets
// name(col) "LPI", "Idle", "Start" or "other"
// cols(ns) the number of whole columns that cover ns nanoseconds at 10 Gb/s: a column is 3.2 ns
module eth_lpi_col;
function automatic [35:0] lpi(); return {4'b1111, 32'h06060606}; endfunction
function automatic [35:0] idle(); return {4'b1111, 32'h07070707}; endfunction
function automatic [35:0] start(); return {4'b0001, 32'h555555fb}; endfunction
function automatic string name(input [35:0] col);
if (col == lpi()) return "LPI";
if (col == idle()) return "Idle";
if (col == start()) return "Start";
return "other";
endfunction
function automatic int cols(input int ns);
return (ns * 10 + 31) / 32;
endfunction
endmodule
Check Yourself
Common Mistakes
Wrong Start a frame as soon as your own transmitter is on.
The wake time is for the partner's receiver, not for your transmitter.
Fix Wait Tw_sys_tx from the moment the LPI request ends.
Wrong Send LPI once and then go silent on the XGMII.
The PCS takes any other column as the end of the sleep.
Fix Keep 06h in all lanes for the whole sleep.
Wrong Cut a wake short because a new LPI request came.
The partner has seen the alert and expects the full wake signal.
Fix Let TX_ALERT and TX_WAKE run to the end, then sleep again.
Wrong Treat Tw_sys_tx of Table 78-4 as fixed.
A receiver may ask for more through the EEE TLV.
Fix Use the resolved value: the table gives only the least one.
Remember
- EEE lets each direction of a link sleep on its own: sleep signal, quiet, refresh, and a wake when a frame waits.
- On the XGMII, LPI is the control character 06h in all four lanes for the whole sleep.
- The RS holds the MAC from the request until Tw_sys_tx after its end. Only that timer frees the MAC.
- The PCS runs TX_SLEEP, TX_QUIET, TX_ALERT and TX_WAKE. An alert or a wake that has begun runs to its end.
- Table 78-4 gives the least wake time. The EEE TLV of LLDP can make it longer.