PAM4 Lanes: Gray Mapping and Precoding
Fast lanes send two bits on one of four levels. See why the map is a Gray code, how one wrong decision becomes a burst, and how the precoder ends it.
You Will Be Able To
- Map pairs of bits to the four PAM4 levels and back.
- Explain why a decision error costs one bit with Gray mapping.
- Show how a DFE turns one wrong decision into a burst.
- Precode and decode a stream of symbols with 1/(1+D) mod 4.
- Lesson
- P11.35
- Time
- 35 min
- Runs on
- Your browser
- Check
- 5 questions
One wrong decision, five wrong symbols. The equaliser passed the error on.
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Level sent | 1 | 2 | 1 | 2 | 1 | 2 | 2 | 0 | 3 | 1 | 0 | 2 |
| Level decided | 1 | 2 | 2 (wrong) | 1 (wrong) | 2 (wrong) | 1 (wrong) | 3 (wrong) | 0 | 3 | 1 | 0 | 2 |
Bench run: a channel with a one-tap DFE. Noise pushes symbol 2 up one level. Four more symbols go wrong after it.
Two Bits on Four Levels
A PAM4 lane sends one of four amplitudes in every symbol. Each symbol carries two bits.
- Neutral
- Datapath
- Channel / handshake
- Data
- Map
Each pair of bits picks one of four levels.
- Precode
If it is switched on, each level sent depends on the level sent before.
- Decide
The receiver picks the nearest level. Noise can push it one level off.
- Undo
The decoder and the Gray map give the bits back.
Read the diagram as text
- Bits: pairs {A, B}
- Gray map: two bits, one of four levels
- Precoder: optional, mod 4
- Channel: four amplitudes
- Slicer and DFE: decides a level
- Decoder: optional, mod 4
- Gray map back: a level, two bits
- Bits: to the FEC
- Bits → Gray map: 2 bits
- Gray map → Precoder: G(j)
- Precoder → Channel: P(j)
- Channel → Slicer and DFE: noise
- Slicer and DFE → Decoder: P(j) decided
- Decoder → Gray map back: G(j)
- Gray map back → Bits: 2 bits
Our own drawing of 120.5.7 and 135.5.7 of IEEE Std 802.3-2022. The channel and the DFE are a bench model.
So 53.125 GBd carries 106.25 Gb/s. That is one lane of the 800G port of P11.34.
The PMA does the mapping, not the PCS. It takes pairs of bits from the lane (120.5.7.1).
| First bit A | Second bit B | Level | Amplitude |
|---|---|---|---|
| 0 | 0 | 0 | −1 |
| 0 | 1 | 1 | −1/3 |
| 1 | 1 | 2 | +1/3 |
| 1 | 0 | 3 | +1 |
IEEE Std 802.3-2022 120.5.7.1. The amplitudes are those of 94.2.2.7, the lowest first.
A is the bit that arrives first. Note the third row: the pair 1, 1 is level 2, not level 3.
The price is the spacing. Four levels in the same swing sit three times closer: 9.5 dB, by the bench's arithmetic.
One Decision Error, One Bit
Noise most often moves a symbol to the level next door.
In a Gray code, neighbours differ in one bit. So such an error costs one bit, never two.
| Levels taken for each other | Bits they carry | Wrong bits |
|---|---|---|
| 0 and 1 | 00 and 01 | 1 |
| 1 and 2 | 01 and 11 | 1 |
| 2 and 3 | 11 and 10 | 1 |
| 0 and 2, two levels apart | 00 and 11 | 2 |
| 1 and 3, two levels apart | 01 and 10 | 2 |
Bench run of a private model. In a second run, 6,000 decisions one level off gave 6,000 wrong bits.
A plain binary map would put 01 beside 10. One decision error there would cost two bits.
An error of two levels still costs two bits. It needs much more noise, so it is rare.
A DFE Turns One Error into a Burst
On a long channel, each symbol leaks into the next one. A decision-feedback equaliser (DFE) removes the leak.
It takes its last decision, scaled, away from the next sample. That works while the decision is right.
A wrong decision is taken away too. So the next sample is off by the same amount, the other way.
The bench model is the worst case: the leak is as large as the symbol itself.
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Level sent | 1 | 2 | 1 | 2 | 1 | 2 | 2 | 0 | 3 | 1 | 0 | 2 |
| Level decided | 1 | 2 | 2 (wrong) | 1 (wrong) | 2 (wrong) | 1 (wrong) | 3 (wrong) | 0 | 3 | 1 | 0 | 2 |
| Decided, with no DFE | 1 | 2 | 2 (wrong) | 2 | 1 | 2 | 2 | 0 | 3 | 1 | 0 | 2 |
Bench run of the readable example. The same noise hits symbol 2 in both runs.
The errors alternate: one level up, one level down. The burst ends when the slicer hits an outer level.
In a long run, 100 pushed decisions grew into 412. The longest burst was 20 symbols.
The Precoder: 1/(1+D) Mod 4
The precoder sits after the Gray map (135.5.7.2). It works on levels, as numbers 0 to 3.
It sends P(j) = (G(j) − P(j − 1)) mod 4. Each level sent depends on the level sent before.
The receiver adds two decided levels: G(j) = (P(j) + P(j − 1)) mod 4.
Inside a burst the errors are +1, −1, +1. Added in pairs they cancel.
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Level sent | 1 | 0 | 3 | 2 | 1 | 2 | 3 | 2 | 3 | 0 | 2 | 1 | 3 | 1 | 2 | 0 |
| Level decided | 1 | 0 | 3 | 3 (wrong) | 0 (wrong) | 3 (wrong) | 2 (wrong) | 3 (wrong) | 2 (wrong) | 1 (wrong) | 1 (wrong) | 2 (wrong) | 2 (wrong) | 2 (wrong) | 1 (wrong) | 1 (wrong) |
Bench run, precoder off. Noise pushes symbol 3 up. 13 decisions are wrong, and so are 13 bits.
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Symbol wanted, G | 1 | 0 | 3 | 2 | 1 | 2 | 3 | 2 | 3 | 0 | 2 | 1 | 3 | 1 | 2 | 0 |
| Level sent, P | 1 | 3 | 0 | 2 | 3 | 3 | 0 | 2 | 1 | 3 | 3 | 2 | 1 | 0 | 2 | 2 |
| Level decided | 1 | 3 | 0 | 3 (wrong) | 2 (wrong) | 3 | 0 | 2 | 1 | 3 | 3 | 2 | 1 | 0 | 2 | 2 |
| Symbol handed on | 1 | 0 | 3 | 3 (wrong) | 1 | 1 (wrong) | 3 | 2 | 3 | 0 | 2 | 1 | 3 | 1 | 2 | 0 |
Bench run of a private model, precoder on, the same bits and the same push. 2 symbols handed on are wrong: 2 bits. Here the burst is only 2 decisions long, as other levels are sent. The long run below has longer ones.
Only the two ends of the burst remain: the sum with the first wrong level, and the sum after the last.
| Channel | Precoder | Wrong decisions | Longest burst | Wrong bits | Most FEC symbols hit by one event |
|---|---|---|---|---|---|
| With a DFE | off | 412 | 20 | 412 | 4 |
| With a DFE | on | 438 | 21 | 200 | 2 |
| Flat, no DFE | off | 100 | 1 | 100 | 1 |
| Flat, no DFE | on | 100 | 1 | 200 | 1 |
Bench run of a private model: 20,000 random symbols, 100 decisions pushed one level off. An FEC symbol is ten bits of this lane, a bench cut. In the flat runs every push falls at the same place of such a symbol.
The precoder has a price. A lone error also touches two sums, so it costs two wrong symbols.
So the precoder pays on channels that need a strong DFE. That is why it can be switched off.
It also helps the FEC of P11.32. A long burst fills several 10-bit symbols. Two wrong bits fill two at most.
In the bench an FEC symbol is ten bits of this one lane. A real 800G lane interleaves four PCS lanes.
Checked Against the Standard
The standard prints test data: the first 13 symbols of four training patterns (Table 136-8).
Each comes from a PRBS13 generator, as plain PAM4 and as PAM4 with precoding.
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | |
|---|---|---|---|---|---|---|---|---|---|---|
| Pair of bits {A, B} | 01 | 00 | 10 | 01 | 10 | 11 | 00 | 11 | 11 | 00 |
| Gray-coded symbol | 1 | 0 | 3 | 1 | 3 | 2 | 0 | 2 | 2 | 0 |
| Precoded symbol | 1 | 3 | 0 | 1 | 2 | 0 | 0 | 2 | 0 | 0 |
Bench run of a private model on the PRBS13 of polynomial 0. Both symbol rows equal the first ten symbols of Table 136-8.
The private model gives all four rows: 4 of 4 as PAM4 and with precoding.
It also gives the 46 symbols of the PRBS13Q test pattern that 120.5.11.2.1 prints.
In a training pattern the precoder starts from 0: the level before the first symbol counts as 0 (136.8.11.1.3).
Switching It On
Precoding is a capability, and only some lanes need it.
The rule covers a lane toward a backplane or copper-cable PMD with link training, and a chip-to-chip link.
There the PMA must be able to precode what it sends. Decoding is optional (135.5.7.2, 120.5.7.2, 173.5.7.2).
An optical PHY, such as 800GBASE-SR8 or DR8, has no such rule.
Each lane has its own switches, one for each direction: precoder_tx_out_enable_i and precoder_rx_in_enable_i.
A PMA with a PAM4 lane on both sides has two more. Registers 1.600 to 1.603 hold them all.
On a backplane or a copper cable, link training decides. A receiver asks its partner for precoding (136.8.11.2.2).
Both ends must agree.
| Precoder at the sender | Decoder at the receiver | Wrong bits |
|---|---|---|
| off | off | 0 |
| on | on | 0 |
| on | off | 6,434 of 12,800 |
| off | on | 6,464 of 12,800 |
Bench run of a private model on a clean channel with random bits.
With one end on and the other off, half of the bits are wrong. No FEC repairs that.
The older 100GBASE-KP4 PMA frames its lanes and restarts the precoder every 46 symbols (94.2.2.6). Later PMAs dropped that.
Try It
eth_pam4_ch is a bench channel with a slicer and a one-tap DFE. It works in whole levels, 0 to 3.
Run 1 has no noise. Every decision is right.
Run 2 pushes symbol 2 one level up. The wrong decision is fed back, and four more symbols go wrong.
The burst ends at symbol 7. The slicer cannot answer below level 0, so the decision is right again.
Run 3 sets flat: no leak and no DFE. The same push costs one symbol.
The Gray map and the precoder are not in the readable library. They are the practice problem.
Move the push to symbol 8, a level 3. Predict the number of wrong decisions.
levels sent: 1 2 1 2 1 2 2 0 3 1 0 2 levels decided: 1 2 1 2 1 2 2 0 3 1 0 2 wrong by: . . . . . . . . . . . . 0 wrong decisions, longest burst 0 levels sent: 1 2 1 2 1 2 2 0 3 1 0 2 levels decided: 1 2 2 1 2 1 3 0 3 1 0 2 wrong by: . . +1 -1 +1 -1 +1 . . . . . 5 wrong decisions, longest burst 5 levels sent: 1 2 1 2 1 2 2 0 3 1 0 2 levels decided: 1 2 2 2 1 2 2 0 3 1 0 2 wrong by: . . +1 . . . . . . . . . 1 wrong decisions, longest burst 1Read 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_pam4.sv
`timescale 1ns/1ns
// eth_pam4.sv: a PAM4 lane below the transmitter's mapping (read-only). A level is a number 0 to 3: the four
// amplitudes from the lowest to the highest. The Gray map and the precoder are not in this file.
// eth_pam4_ch: a bench channel, a slicer and a one-tap decision-feedback equaliser (DFE), in whole levels.
// A bench model, not a clause: the channel adds the level before to every level (a full first post-cursor), and the
// DFE takes its last decision away again. So a wrong decision is also taken away from the next symbol.
// reset() the line has idled at level 0: the level before and the last decision are 0
// rx(p, push) one symbol. p is the level sent. push moves the slicer input by that many levels: +1 or -1
// is noise at a threshold, 0 is a clean symbol. Returns the decided level, 0 to 3.
// errs decisions that differ from the level sent, since reset
// burst, longest the length of the run of wrong decisions that is open now, and of the longest so far
// flat 1: a channel with no interference and no DFE. The slicer sees p + push.
module eth_pam4_ch;
bit flat = 0;
int last_p = 0, last_d = 0, errs = 0, burst = 0, longest = 0;
function automatic void reset(); last_p = 0; last_d = 0; errs = 0; burst = 0; longest = 0; endfunction
function automatic [1:0] rx(input [1:0] p, input int push);
int z, d;
z = flat ? p + push : p + last_p - last_d + push; // the channel, the DFE's correction, the noise
d = (z < 0) ? 0 : (z > 3) ? 3 : z; // the slicer can only answer 0 to 3
if (d != p) begin errs++; burst++; if (burst > longest) longest = burst; end
else burst = 0;
last_p = p; last_d = d;
return d[1:0];
endfunction
endmodule
// eth_prbs13: the PRBS13 generator of the training pattern and of PRBS13Q (136.8.11.1.3, Table 136-8, 120.5.11.2.1).
// taps bit k - 1 is set for every term x^k of the polynomial (the 1 is left out)
// s the 13 bits of state: s[0] is S0
// load(text) the state from a string of 13 characters, S0 first, as the table prints the seed
// next() one bit: the XOR of the tapped stages. It is the output and it enters S0.
module eth_prbs13;
reg [12:0] taps = 13'h1803, s = 13'h1;
function automatic void load(input string text);
for (int i = 0; i < 13; i++) s[i] = (text[i] == "1");
endfunction
function automatic bit next();
bit fb;
fb = ^(s & taps);
s = {s[11:0], fb};
return fb;
endfunction
endmodule
Check Yourself
Common Mistakes
Wrong Map the pair 1, 1 to level 3, as a binary number.
Levels 1 and 2 would then differ in both bits.
Fix Use the Gray order: 00, 01, 11, 10 from the lowest level up.
Wrong Take the second bit of a pair as A.
A is the bit that arrives first.
Fix {A, B} = {1, 0} is level 3, and {0, 1} is level 1.
Wrong Let the decoder add its own last result.
An error would then live on in every later symbol.
Fix Add the two levels the slicer decided: P(j) + P(j − 1), mod 4.
Wrong Switch the precoder on at one end only.
The other end hands on precoded levels as if they were data.
Fix Set the sender's precoder and the receiver's decoder together, as training asks.
Remember
- A PAM4 symbol carries two bits. The Gray map is 00, 01, 11, 10 from the lowest level up, with the first bit as A.
- Neighbouring levels differ in one bit, so a one-level decision error costs one bit.
- A DFE feeds a wrong decision back. The errors alternate up and down, and one error becomes a burst.
- The precoder sends (G − P before) mod 4. The decoder adds two decided levels, mod 4. A burst leaves two wrong symbols.
- Precoding doubles lone errors, so it is a switch. Training sets it for each lane and direction, the same at both ends.