8b/10b: Running Disparity and K-Codes
Encode a byte by hand, track the running disparity, and say what a comma is for.
You Will Be Able To
- Encode a byte by hand from the 5b/6b and 3b/4b tables.
- Predict the running disparity after each symbol of a stream.
- Explain how a receiver finds symbol boundaries from a comma.
- Find an encoder that breaks the disparity rule from the decoder flags alone.
- Lesson
- P10.3
- Time
- 35 min
- Runs on
- Your browser
- Check
- 5 questions
A new encoder passes every data check: each byte decodes to the right value. On the board the link drops after a few thousand symbols. The encoder always read the same column of the code table, so it sent more ones than zeros.
- with running disparity
- always the RD- column
Read the plot as a table
| Symbols sent | with running disparity | always the RD- column |
|---|---|---|
| 20 | 0 | 28 |
| 40 | 0 | 44 |
| 60 | 2 | 66 |
| 80 | 0 | 88 |
| 100 | 2 | 110 |
| 120 | 0 | 124 |
Bench run. With the rule the sum stays between 0 and 2 at symbol ends. Without it the sum reaches 124 after 120 symbols and keeps climbing.
Why the Line Must Balance
A fast link has a capacitor in series with each wire. USB 3.2 requires this AC coupling (§6.2.2). A capacitor blocks the average level, so the average must not move.
The line therefore needs as many ones as zeros. This is called DC balance. The count of ones minus zeros sent so far is the running sum.
The receiver also has no clock wire. It recovers its clock from the edges in the data. A long run of equal bits has no edges, so the run length must stay short.
Raw bytes give neither promise. A file of zeros is one endless run. 8b/10b fixes both by sending ten bits for every eight.
Two Small Tables Make One Code
- Neutral
- Storage
- Datapath
- Data
- Control
- Split the byte
The low five bits are x and the high three bits are y. The byte is named D.x.y, so 4Ah is D10.2.
- Encode six bits
The 5b/6b table has two columns. The running disparity picks one. The six bits abcdei go out first.
- Encode four bits
The 3b/4b table uses the disparity as it stands after those six bits. Then fghj goes out.
- Carry the disparity
The disparity after ten bits is the starting point for the next byte. It runs across symbols.
Read the diagram as text
- Byte HGF EDCBA: named D.x.y
- Running disparity: RD- or RD+
- 5b/6b table: EDCBA to abcdei
- 3b/4b table: HGF to fghj
- abcdei: sent first
- fghj: sent second
- Byte HGF EDCBA → 5b/6b table: x = low 5 bits
- Byte HGF EDCBA → 3b/4b table: y = high 3 bits
- Running disparity → 5b/6b table: picks the column
- 5b/6b table → 3b/4b table: disparity after 6 bits
- 5b/6b table → abcdei
- 3b/4b table → fghj
- 3b/4b table → Running disparity: disparity after 10 bits
USB 3.2 §6.3.1 and Figure 6-7 give this mapping: ABCDE to abcdei and FGH to fghj. Bit a goes on the wire first (§6.3.1.1).
| Name | Byte | At RD- (abcdei fghj) | At RD+ (abcdei fghj) | Forms |
|---|---|---|---|---|
| D0.0 | 00h | 100111 0100 | 011000 1011 | two codes |
| D3.0 | 03h | 110001 1011 | 110001 0100 | two codes |
| D10.2 | 4Ah | 010101 0101 | 010101 0101 | one code |
| D7.0 | 07h | 111000 1011 | 000111 0100 | two codes |
| D3.3 | 63h | 110001 1100 | 110001 0011 | two codes |
| D11.7 | EBh | 110100 1110 | 110100 1000 | two codes |
| K28.5 | BCh | 001111 1010 | 110000 0101 | two codes |
| K28.1 | 3Ch | 001111 1001 | 110000 0110 | two codes |
| K28.7 | FCh | 001111 1000 | 110000 0111 | two codes |
Printed by the bench encoder. Each row equals USB 3.2 Appendix A, Tables A-1 and A-2.
Look at the last column. The bench counted all 256 data bytes: 184 have two codes and 72 have one. A byte has one code when its ten bits are already balanced.
The bench also counted the ones in every code, in both columns. 282 codes have five ones. 127 have four and 127 have six. No code has any other count.
Running Disparity Picks the Column
The running disparity (RD) is one bit of memory. RD- means the line is behind on ones. RD+ means it is ahead.
A code with six ones
It may only be sent at RD-. Afterwards the disparity is RD+.
A code with four ones
It may only be sent at RD+. Afterwards the disparity is RD-.
A code with five ones
It leaves the disparity where it was.
So an unbalanced code is always followed, sooner or later, by one that leans the other way. The running sum cannot drift.
The rule is applied twice inside each symbol: after the six bits, and again after the four. D0.0 at RD- is 100111 0100. Its first part leans to ones and its second part leans back.
Where the Disparity Starts
Running disparity needs a starting value. Neither end has one after the line has been idle.
USB 3.2 lets a transmitter start at either disparity after electrical idle (§6.3.1.2, rule 1). The receiver does not assume one: it takes the disparity of the first symbol it uses for symbol lock (rule 2).
That symbol is a comma, K28.5, and K28.5 is unbalanced. Its form tells the receiver which column the transmitter was in.
| Receiver | Links with false disparity errors |
|---|---|
| Assumes RD- at the start | 9 of 20 |
| Takes the disparity of the K28.5 it locks on | 0 of 20 |
Bench run: 20 links, each starting at a random disparity with a K28.5 and 49 random data bytes. The data on every link is clean.
The receiver that assumes RD- is wrong whenever the link starts at RD+. It reports errors on a clean link, and the link layer counts them.
USB 3.2 also lets the receiver take its disparity again when symbol lock is lost and regained (rule 3). The library's lane receiver does the same after each realignment.
K Codes and the Comma
Data uses 440 of the 1,024 ten-bit patterns. Twelve K codes use 24 more. A K code is a control symbol: it can never be mistaken for data.
Three K codes hold a special seven-bit pattern: 0011111 or its inverse 1100000. This pattern is the comma. K28.1, K28.5 and K28.7 contain it.
The comma never appears inside data, and never across two data symbols. The bench searched 8,000 symbols bit by bit. It found the pattern only at the K28.5 symbols.
A receiver gets a stream of bits with no marks. It slides a seven-bit window along the stream. When it sees a comma, it knows where a symbol starts. USB 3.2 names K28.5 COM and uses it for symbol alignment (Table 6-2).
What Each K Code Is For
The twelve K codes are a link's punctuation. USB 3.2 gives most of them a job (§6.3.3, Table 6-2).
| Gen 1 symbol | Name | Job |
|---|---|---|
| K28.5 | COM | Symbol alignment, and the scrambler reset |
| K28.1 | SKP | Clock compensation: added or removed on the way |
| K27.7 | SHP | Start of a header packet |
| K28.2 | SDP | Start of a data packet payload |
| K29.7 | END | End of a packet |
| K28.3 | EDB | End of a nullified (bad) packet |
| K30.7 | SLC | Start of a link command |
| K23.7 | EPF | End of packet framing |
| K28.4 | SUB | Put in place of a symbol the decoder could not decode |
| K28.6 | Reserved |
USB 3.2 Rev 1.1 Table 6-2 (Gen 1 column). Gen 2 sends these as scrambled bytes inside data blocks instead.
The code table also guarantees edges. Over all 536 codes, every code has at least 2 transitions inside its ten bits, and 5.51 on average.
What the Decoder Flags
One flipped line bit usually spoils one byte. In three bench runs it spoiled 1, 1, 1 byte, flagged as a disparity error, a code error, a code error.
A decoder can report two kinds of error. A code error means the ten bits are in neither column. A disparity error means the code is valid but belongs to the other column.
USB 3.2 requires each received symbol to be in the column for the current disparity (§6.3.1.2, rule 4). The bench flipped one wire bit in each of 800 short streams.
| What the decoder reported | Flips | What it means |
|---|---|---|
| Code error in the hit symbol | 276 | The ten bits are in neither column. |
| Disparity error in the hit symbol | 251 | A valid code, but from the wrong column. |
| Nothing in the hit symbol, a flag up to 5 symbols later | 273 | The hit symbol decoded to a wrong byte, silently. |
| No flag within ten symbols | 0 |
Bench run: 800 trials, one wire bit flipped in each, random bytes. A flag tells you an error happened nearby. It does not name the symbol.
About one flip in three is not caught where it lands. The disparity then stays wrong until the next unbalanced code exposes it. A flag says that an error happened nearby. It does not say which symbol was hit.
What the Rule Buys
| Encoder | Longest run | Ones minus zeros | Comma patterns outside K28.5 | Disparity errors at the decoder | Wrong bytes |
|---|---|---|---|---|---|
| Follows the running disparity | 5 | -2 to 4 | 0 | 0 | 0 |
tx.no_rd = 1: always the RD- column | 6 | -2 to 7,745 | 35 | 3,871 | 0 |
Bench run: 8,000 symbols, random bytes with a K28.5 every 100 symbols. The twin's bytes still decode, so a data check alone would pass it.
The clean stream never has more than 5 equal bits in a row. The twin sends the right bytes, yet its sum climbs without limit and false commas appear in data.
Try It
Each line shows the name, the six bits, the four bits, the count of ones and the disparity after the symbol.
K28.5 has six ones, so the link moves to RD+. D0.0 and D10.2 are sent with five ones and leave it there. The first D7.0 has four ones and the second has six.
Add tx.no_rd = 1; before the first send. Every symbol now comes from the RD- column, and both D7.0 lines print 111000 1011.
K28.5 001111 1010 ones 6 RD+ D0.0 011000 1011 ones 5 RD+ D0.0 011000 1011 ones 5 RD+ D10.2 010101 0101 ones 5 RD+ D7.0 000111 0100 ones 4 RD- D7.0 111000 1011 ones 6 RD+ D11.7 110100 1000 ones 4 RD-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
Check Yourself
Common Mistakes
Wrong Treat 8b/10b as eight data bits plus two parity bits.
The ten bits are a table look-up, and no two of them are a checksum of the other eight.
Fix Decode by table. Use the code and disparity flags as a weak error alarm, and keep a CRC for real detection.
Wrong Assume every byte has two codes and flip the disparity after every symbol.
72 data bytes are sent with five ones and must leave the disparity unchanged.
Fix Update the disparity from the bits that were sent: more ones gives RD+, more zeros gives RD-, equal keeps it.
code = lookup(d, rd);
rd = !rd; // wrong for a balanced codecode = lookup(d, rd);
if (ones(code) > 5) rd = 1;
else if (ones(code) < 5) rd = 0;Wrong Choose the four-bit part with the disparity from before the symbol.
The six-bit part may already have moved the disparity, so the four-bit part comes from the wrong column.
Fix Compute the disparity after abcdei and use that to pick fghj.
Wrong Blame the symbol that raised a disparity error.
In the bench run 273 of 800 flipped bits raised their first flag in a later symbol.
Fix Treat the flag as "an error near here". Find the bad packet with its CRC.
Remember
- A fast line needs DC balance and short runs. 8b/10b gives both by sending ten bits for eight.
- Every code has four, five or six ones. The running disparity picks the column so that the sum cannot drift.
- The disparity is updated after the six-bit part and again after the four-bit part, and it carries across symbols.
- The comma is a seven-bit pattern found only in K28.1, K28.5 and K28.7. It gives the receiver its symbol boundaries.
- Code and disparity errors show that something went wrong nearby. They are not a parity check and do not name the symbol.