Scrambling: Additive and Multiplicative LFSRs
Build both kinds of scrambler and predict what each does with one bit error and with a lost position.
You Will Be Able To
- Explain what a key stream is and why both ends must agree on its position.
- Predict how many data bits one wire error corrupts in each kind of scrambler.
- Find a receiver that steps, holds or resets its register at the wrong symbol.
- Choose between an additive and a multiplicative scrambler for a link.
- Lesson
- P10.5
- Time
- 35 min
- Runs on
- Your browser
- Check
- 5 questions
A receiver decodes its training patterns without one error. Then the first skip symbol arrives, and every data byte after it is wrong. The sender held its scrambler on the skip symbol, and the receiver stepped.
| Receiver | Data bytes wrong | First wrong symbol |
|---|---|---|
| Clean | 0 of 1686 | none |
rx.advance_on_skip = 1: steps on a skip symbol | 892 of 1686 | 30 |
rx.no_reset = 1: ignores the reset event | 1678 of 1686 | 3 |
rx.wrong_tap = 1: one feedback tap moved | 1591 of 1686 | 1 |
Bench run: 2,000 symbols in the style of USB 3.2 Gen 1, with random data, reset symbols and skip symbols. The sender is clean in every row.
Why Links Scramble
Real data repeats. An idle link sends the same byte for a long time. A repeating pattern gives the receiver a poor mix of edges. It also radiates, as the next section shows.
A scrambler XORs the data with a noise-like bit sequence. The receiver XORs with the same sequence and gets the data back.
The sequence comes from a linear feedback shift register (LFSR). It is a shift register whose input is the XOR of a few of its own bits. A polynomial names those bits.
The bench scrambled zero bytes with the USB 3.2 Gen 1 register. The line carried FF 17 C0 14 B2 E7 02 82. Idle zeros now look like noise.
Spreading the Spectrum
A repeating pattern puts its energy into a few sharp frequencies. A cable carrying those frequencies acts as an antenna, and the link fails its emission tests.
Scrambling spreads that energy across many frequencies, so no single one stands out. USB 3.2 Gen 1 scrambles its data before the 8b/10b code for exactly this reason: to reduce EMI (§3.2.1.1).
The 8b/10b code already guarantees the edges. At Gen 1 the scrambler is there for the spectrum, not for the clock recovery.
| Idle line of D0.0 bytes, 600 bits | Strongest frequency | Frequencies with over 1% of the power |
|---|---|---|
| Not scrambled | 38.4% of the power | 4 |
| Scrambled with the Gen 1 register | 2.6% of the power | 13 |
Bench run: the line bits through the 8b/10b encoder, then a discrete Fourier transform over 600 bits. DC is excluded.
USB 3.2 also uses spread spectrum clocking to lower the emissions further (§3.2.1.1). P10.6 covers it.
Additive: XOR with a Key Stream
- Neutral
- Datapath
- Storage
- Control / FSM
- Data
- Control
- Make a key bit
Each step, the register shifts and feeds back the XOR of a few of its bits. Its top bit is the key bit.
- XOR it with the data
The line bit is the data bit XOR the key bit. The receiver runs the same register and XORs again.
- Follow one error
A flipped line bit flips one data bit. The register never saw it, so nothing else changes.
- Stay in step
Both registers must be at the same position. A reset event reloads the seed at both ends. A skip symbol holds both.
Read the diagram as text
- Data bit
- XOR
- Line bit
- 16-bit LFSR: free running
- COM and SKP: reset, or hold
- Data bit → XOR
- 16-bit LFSR → XOR: key bit
- XOR → Line bit
- COM and SKP → 16-bit LFSR: keeps both ends in step
Bench run: one flipped wire bit in 20,000 gave 1 wrong data bit.
The register output is the key stream. USB 3.2 Gen 1 defines one this way (§6.3.1.3):
| Rule | USB 3.2 Gen 1 |
|---|---|
| Polynomial | x^16 + x^5 + x^4 + x^3 + 1 |
| Seed | FFFFh |
| Reset event | Each COM symbol reloads the seed, at both ends |
| Steps per symbol | Eight, for every symbol except SKP |
| What is scrambled | Data symbols. K codes are sent as they are |
USB 3.2 §6.3.1.3. Gen 2 uses a 23-bit register with the seed 1D BFBCh (§6.3.2.3). USB4 also uses an additive 23-bit register (§4.3.1.5).
The specification prints the first 16 bytes of this key stream (§6.8.4.1). The bench register produces the same 16 bytes. Its sequence repeats after 65,535 steps.
The key stream only helps when both ends are at the same position. The bench moved the receiver one bit ahead. 24,950 of 50,000 bits came out wrong: half, which is no better than guessing.
That is why skip symbols need a rule. A link may add or remove them on the way, so the two ends see different numbers of them. Both registers must stand still on a skip.
The twin in the first table breaks this rule. In a second bench run 100 of 100 bytes between a skip and the next COM were wrong. After the COM, 0 were.
Multiplicative: The Line Is the State
- Neutral
- Datapath
- Storage
- Data
- Scramble
The line bit is the data bit XOR two older line bits: the ones sent 39 and 58 steps ago.
- Remember the line
The line bit shifts into the register. The descrambler shifts in the bit it received.
- Synchronise by listening
After 58 received bits the descrambler holds the same 58 bits as the scrambler. No seed is exchanged.
- Follow one error
A flipped line bit is wrong once as it arrives. It is used again 39 and 58 steps later, so it corrupts three data bits.
Read the diagram as text
- Data bit
- XOR
- Line bit
- 58-bit shift register: the last 58 line bits
- Data bit → XOR
- 58-bit shift register → XOR: bits 39 and 58 back
- XOR → Line bit
- Line bit → 58-bit shift register: shifts in
Bench run with x^58 + x^39 + 1: one flipped wire bit gave 3 wrong data bits, at offsets 0, 39, 58.
The bench started the descrambler in a different state from the scrambler. 49 of the first 58 bits were wrong. Not one of the next 19,942 was.
The price is error multiplication. Each wrong line bit is used three times, so the error count of the data triples.
There is a second price. Feed zeros into a zero register: the line never toggles. The bench saw a run of 1,000 equal bits in 1,000.
Worse, the register is the last 58 line bits, and anyone can see those. Data chosen to equal the XOR of the two tapped bits cancels the scrambler. The bench held the line still for 500 bits this way. Such data is called a killer pattern.
Many Bits per Clock: The Parallel LFSR
A 10 Gb/s link cannot step its scrambler once per bit: the logic would need a 10 GHz clock. Real RTL steps it 8, 32 or 64 times in one clock.
The register is linear: every bit after W steps is an XOR of the starting bits. Step each one-hot start state W times, note which bits come out, and you have the equations.
| Key bit | Is the XOR of start bits |
|---|---|
| 0 | 15 |
| 1 | 14 |
| 2 | 13 |
| 3 | 12 |
| 4 | 11 |
| 5 | 10 |
| 6 | 9 |
| 7 | 8 |
Bench run: the USB 3.2 Gen 1 register, 8 steps per clock. The feedback enters at the bottom, so the first eight key bits are simply the top eight register bits.
At 8 bits per clock the widest next-state XOR has 4 inputs. At 32 bits per clock a key bit needs up to 7 and a next-state bit up to 8. The bench checked both against serial stepping on 5,000 start states: 0 mismatches.
A synthesis tool would unroll a loop of W steps into the same XOR network. The equations matter when you check that network, or write it for a fixed bus width.
Two Register Forms, and a Seed per Lane
One polynomial can be built two ways. A Fibonacci register XORs several taps into its input; a Galois register XORs its output into several taps. Both run through the same sequence.
The bench ran the USB 3.2 Gen 1 polynomial both ways from FFFFh. The two outputs were the same sequence, shifted by 37,504 bits: 65,535 of 65,535 bits agree.
So two designs that both claim the polynomial may still disagree on the bits. The seed and the form must both match; USB 3.2 prints the first key bytes to check them (§6.8.4.1).
A wide link gives each lane its own seed. USB4 starts lane 0 at 1D BFBCh and lane 1 at 06 07BBh (§4.3.1.5). The lanes then do not carry the same pattern side by side.
With one seed on both lanes, 20,000 of 20,000 key bits matched. With USB4's two seeds, 10,014 did: half, as chance gives.
At Gen 2, a SYNC ordered set every 16,384 TSEQ sets resets the USB 3.2 scrambler at both ends (§6.3.2.3).
The Limits of a Scrambler
| Additive (frame-synchronous) | Multiplicative (self-synchronising) | |
|---|---|---|
| What the register holds | Its own free-running sequence | The last line bits |
| Needs a seed and a reset event | Yes, at both ends | No |
| One flipped wire bit | 1 wrong data bit | 3 wrong data bits |
| Receiver at the wrong position | 24,950 of 50,000 bits wrong, until the next reset | 49 wrong bits in the first 58, then 0 |
| Data that defeats it | Data equal to the key stream | Data equal to the XOR of the two older line bits |
Bench values. The additive runs use x^16 + x^5 + x^4 + x^3 + 1. The multiplicative runs use x^58 + x^39 + 1.
A scrambler gives no run-length limit. It only makes long runs unlikely. In 20,000 scrambled random bits the bench saw a run of 16. 8b/10b never exceeds five.
A scrambler is also not encryption. The polynomial and the seed are public, so anyone can descramble.
Try It
The first line is the key stream: zero data XOR the key is the key itself.
The message has a skip in the middle. Both ends call scr_hold(), so they stay in step and all 16 bytes come back.
Add rx.advance_on_skip = 1; before the message. The receiver now steps eight times on the skip, and the last eight bytes are wrong.
key stream: ff 17 c0 14 b2 e7 02 82 16 bytes with a skip in the middle: 0 wrongRead 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 Step the receive register on every received symbol, skip symbols included.
Skip symbols are added and removed on the way, so the two ends count different numbers of them.
Fix Hold the register on a skip symbol and reload it on the reset symbol, at both ends.
always_ff @(posedge clk)
if (sym_valid) lfsr <= next8(lfsr);always_ff @(posedge clk)
if (sym_valid && is_com) lfsr <= 16'hffff;
else if (sym_valid && !is_skp) lfsr <= next8(lfsr);Wrong Rely on the scrambler to limit the run length.
Scrambled data is only noise-like, and the bench saw a run of 16 in 20,000 random bits.
Fix Size the clock recovery for rare long runs, or use a line code that has a hard limit.
Wrong Budget one data error for each line error on a self-synchronising link with a two-tap polynomial.
Each wrong line bit is used 3 times by the descrambler.
Fix Multiply the line error count by 3 before it reaches the CRC or the error-correcting code.
Wrong Call scrambling a form of encryption.
The polynomial and seed are in the public specification, so the key stream is known to everyone.
Fix Use scrambling for the signal on the wire, and a cipher when the data must stay secret.
Remember
- A scrambler XORs data with a noise-like sequence from an LFSR. It adds no bits.
- Additive: the register runs freely. One wire error is one data error, but both ends need the same seed and position.
- Multiplicative: the register holds past line bits. It synchronises by itself, and one wire error becomes three.
- Skip symbols hold the additive register and a reset symbol reloads it. Getting either wrong corrupts all data until the next reset.
- Scrambling spreads the energy of repeating data over many frequencies, which lowers EMI. It does not limit the run length or hide the data.