Time-Sensitive Networking: Gates
Some frames must leave at an exact time, every cycle. A gate behind each queue keeps the line free for them. See a schedule run, and the guard band it needs.
You Will Be Able To
- Say what a transmission gate and a gate control list are.
- Follow a list through its cycle, also when list and cycle do not match.
- Apply the rule that a frame must end before its gate closes.
- Explain the guard band, its cost, and how frame preemption shrinks it.
- Lesson
- P11.45
- Time
- 40 min
- Runs on
- Your browser
- Check
- 5 questions
A robot arm gets a command every millisecond. If one command is late, the arm jerks.
A higher priority is not enough. A gate schedule gives the command a window of its own.
- Cycle 0
The cycle starts. Only queue 1 may send: its scheduled frame has the line to itself.
- Cycle 1
After 100 ticks the gates swap. Queue 0, the rest of the traffic, may send for 400 ticks.
- Cycle 2
The cycle is over after 500 ticks, and the list starts again.
- Cycle 4
It repeats exactly. A frame of queue 1 can rely on its window.
Bench run of the readable example (eth_gcl): a list of two entries with a cycle of 500 ticks.
Why Priority Falls Short
A switch sends the frame of the highest class first. But it cannot stop a frame that is on the line.
So an urgent frame may wait for one whole frame of any class. That can happen at every hop.
A frame of 1,518 octets with its overhead holds a 100 Mb/s link for 123.04 µs.
For control loops that is too much, and worse, it changes from cycle to cycle.
The answer of IEEE 802.1Q is a time schedule: at fixed times, only chosen classes may send (8.6.8.4).
This is one part of Time-Sensitive Networking (TSN). All ports need a common time, usually from PTP (Annex Q.3).
A Gate for Each Queue
- Storage
- Control / FSM
- Datapath
- Data
- Control
- Queues
Frames wait in a queue for each traffic class.
- Gates
Each queue has a transmission gate. A closed gate hides the queue from selection.
- The list
One gate control list for the port sets all its gates, entry by entry.
- Selection
Among the queues with an open gate, selection works as before. With strict priority, the highest class goes first.
- The line
The MAC sends the chosen frame to its end.
Read the diagram as text
- Queue 1: scheduled traffic
- Queue 0: everything else
- Gate 1: open or closed
- Gate 0: open or closed
- Gate control list: one for the port
- Transmission selection: picks the next frame
- MAC: one frame at a time
- Queue 1 → Gate 1
- Queue 0 → Gate 0
- Gate control list → Gate 0: sets both gates
- Gate control list → Gate 1
- Gate 1 → Transmission selection: if open
- Gate 0 → Transmission selection: if open
- Transmission selection → MAC: a frame
Our own drawing after IEEE Std 802.1Q-2022 Figure 8-16.
Each queue of a port gets a transmission gate (8.6.8.4).
Open: the queue takes part in transmission selection as usual.
Closed: its frames are not selected, however urgent they are.
A port without this feature behaves as if all gates were always open.
The Gate Control List
A port has one gate control list. Each entry is a gate operation (Table 8-7).
| Entry | Operation | Gate of queue 1 | Gate of queue 0 | TimeInterval |
|---|---|---|---|---|
| 0 | SetGateStates | open | closed | 100 ticks |
| 1 | SetGateStates | closed | open | 400 ticks |
The list of the example. The standard gives a TimeInterval in nanoseconds; this bench counts ticks.
SetGateStates sets every gate of the port at once. Then it waits for its TimeInterval.
The list runs once in each gating cycle. Then it starts again.
In the example the cycle is as long as the list: 500 ticks.
One central planner can work out the list of every port on the path (46.1.3.2).
It may, for instance, shift each list by the travel time. Then the window moves with the frame.
Three State Machines
Three small state machines run the list (8.6.9).
| State machine | Its job | Clause |
|---|---|---|
| Cycle Timer | starts a new cycle each time the cycle time has passed | 8.6.9.1 |
| List Execute | runs the entries in order and waits out each TimeInterval | 8.6.9.2 |
| List Config | swaps in a new list at a chosen time | 8.6.9.3 |
IEEE Std 802.1Q-2022 8.6.9. One set for each port.
The Cycle Timer counts from a base time. Every cycle starts a whole number of cycle times after it.
List Execute counts a timer down, one tick at a time. At zero it executes the next entry (Figure 8-20).
The readable eth_gcl is a model of these two. It has no List Config: its list never changes.
A real tick is one nanosecond, or as fine as the port's clock is.
A List Longer or Shorter Than Its Cycle
The intervals of a list need not add up to the cycle time.
| The list | Cycle | The gates change at tick (queue 1, queue 0) |
|---|---|---|
| 100 and 200 ticks | 500 | 0: oC, 100: Co, 500: oC |
| 60, 90, 40 and 110 ticks | 170 | 0: Co, 60: oC, 150: oo, 170: Co, 230: oC, 320: oo, 340: Co |
| 50, 0, 0 and 120 ticks | 172 | 0: oC, 50: Co, 51: oC, 52: Co, 172: oC |
Bench run of eth_gcl. o is open, C is closed.
First row: the list is over after 300 ticks. The gates stay as the last entry left them.
Second row: the cycle ends at tick 170, inside the third entry. The fourth is never executed.
Third row: an interval of 0 counts as 1 tick (8.6.9.2.1). So ticks 50 and 51 each have their own entry.
A Frame Must End Before the Gate Closes
An open gate is not enough. A frame that starts late would run on after the gate has closed.
So the standard adds a rule to transmission selection (8.6.8.4).
A frame is available only if all of it can be sent before the next gate-close event of its queue.
And not the frame alone. The media-dependent overhead counts too (12.4.2.2).
On Ethernet that is 20 octets: 7 of preamble, the SFD, and a gap of 12.
| At tick | Frame | Gate closes in | Frame and overhead | May it start? | It starts at tick | Started anyway: overrun? |
|---|---|---|---|---|---|---|
| 300 | 64 octets | 200 ticks | 84 ticks | yes | 300 | no |
| 300 | 180 octets | 200 ticks | 200 ticks | yes | 300 | no |
| 300 | 181 octets | 200 ticks | 201 ticks | no | 600 | no |
| 300 | 192 octets | 200 ticks | 212 ticks | no | 600 | no |
| 300 | 193 octets | 200 ticks | 213 ticks | no | 600 | yes |
| 460 | 64 octets | 40 ticks | 84 ticks | no | 600 | yes |
Bench run of a private model, for queue 0 of the example list. One tick is one octet time.
A frame of 180 octets needs 200 ticks and just fits. One octet more, and it must wait for the next window.
The last column asks what would happen without the rule. A frame of 192 octets would still end in time.
The gap is not transmission. So the rule is a little stricter than the overrun it prevents.
Without the Rule: Overrun
| Queue 0 is sent | Cycles with an overrun | Longest wait of a scheduled frame | Longest idle time before a window | Octets of queue 0 sent |
|---|---|---|---|---|
| whenever its gate is open | 20 of 20 | 786 ticks | 0 ticks | 245,382 |
| by the rule of 8.6.8.4 | 0 of 20 | 0 ticks | 1,368 ticks | 205,518 |
| with preemption and hold | 0 of 20 | 0 ticks | 139 ticks | 227,212 |
Bench run of a private line model: 20 cycles of 12,500 ticks. Queue 1 has a window of 1,250 ticks. Queue 0 holds frames of 64 to 1,518 octets.
The first row is a port that looks only at the gate. Its queue 0 always has a frame ready.
In all 20 cycles a frame of queue 0 was still on the line when the window opened.
The scheduled frame waited up to 786 ticks. At 100 Mb/s that is 62.88 µs of jitter.
The standard has a counter for this: TransmissionOverrun, one for each queue (12.29.1.1.2).
In a correct port it stays at 0.
The Guard Band and Its Price
With the rule, queue 0 goes silent some time before each window. That silence is the guard band.
The standard needs no entry for it in the list. It follows from the rule (Annex Q).
In the second row no cycle has an overrun, and the scheduled frame never waits.
But the line was idle for up to 1,368 ticks before a window: 109.44 µs.
The waiting frame was a long one. A shorter frame behind it may not overtake: a queue keeps its order.
Queue 0 carried 16% fewer octets than without the rule.
The worst case is a frame of 1,518 octets that just misses: 1,537 idle ticks.
That is the frame and its 20 octets of overhead, less one tick.
Preemption Makes It Smaller
Frame preemption of the last lesson cuts the price (Annex S).
Queue 0 becomes preemptable, and its gate stays open all the time.
The list asks the MAC to hold shortly before the window, and to release after it.
| Operation | What it does |
|---|---|
| SetGateStates | sets every gate, then waits for its TimeInterval |
| Set-And-Hold-MAC | the same, and by this point the MAC has stopped sending preemptable frames |
| Set-And-Release-MAC | the same, and from this point the MAC may send them again |
IEEE Std 802.1Q-2022 Table 8-7.
A held MAC cuts the frame on the line and starts no new one. The rest of the frame follows after the window.
Third row of the table: no overrun, no wait, and at most 139 idle ticks. Queue 0 loses 7%.
How early must the hold come? IEEE 802.1Q calls that time holdAdvance (12.30.1.2).
It is a property of the MAC. For an Ethernet MAC the hold response time bounds it (IEEE 802.3 99.4.8).
This bench uses that bound: 155 ticks. The example of Annex S.4 uses 124 octet times.
This row is a model of ours. The annex is informative and gives no numbers of this kind.
Changing the Schedule
A running schedule can be replaced without stopping it. That is the job of List Config (8.6.9.3).
Management writes the new list into the Admin variables and sets ConfigChange.
The new list becomes the Oper list at AdminBaseTime.
If that time has passed, it takes over a whole number of new cycles after it.
Until then ConfigPending is true.
| Managed object | Meaning |
|---|---|
| GateEnabled | the state machines run |
| AdminControlList, AdminCycleTime, AdminBaseTime | the next schedule, as written by management |
| OperControlList, OperCycleTime, OperBaseTime | the schedule that is running |
| ConfigChange | set by management: take the next schedule |
| ConfigPending | a new schedule waits for its start time |
| queueMaxSDU | the largest frame a queue accepts |
| TransmissionOverrun | a counter for each queue: frames still sent when the gate closed |
| TickGranularity | how fine the port's clock is, in tenths of a nanosecond |
IEEE Std 802.1Q-2022 Table 12-32 and 12.29.1.1, a selection.
The last old cycle may be stretched a little, so that no tiny cycle is left over (Annex Q.5).
Try It
eth_gcl is a model of the Cycle Timer and List Execute machines.
set writes one entry: the gates as a vector, bit q for queue q, and the TimeInterval in ticks.
start(2, 500) gives the list two entries and a cycle of 500 ticks.
step moves time on by one tick. watch prints a line whenever a gate has changed.
At tick 0 entry 0 opens queue 1 alone. At tick 100 entry 1 swaps the gates.
At tick 500 the cycle timer starts the list again.
The rule about the end of a frame is not in the readable library. It is the practice problem.
Change the cycle to 450 ticks. Predict the tick of the third line.
tick 0: queue 1 open, queue 0 closed tick 100: queue 1 closed, queue 0 open tick 500: queue 1 open, queue 0 closed tick 600: queue 1 closed, queue 0 open tick 1000: queue 1 open, queue 0 closedRead 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_tsn.sv
`timescale 1ns/1ns
// eth_tsn.sv: transmission gates (read-only). A bench model: time in ticks, at most eight gates.
// eth_gcl: one port's gate control list at work (IEEE Std 802.1Q-2022 8.6.8.4, 8.6.9.1, 8.6.9.2).
// set(k, gates, interval) entry k of the list: SetGateStates with a gate state for each queue and a TimeInterval
// start(len, cycle) the list has len entries, the cycle lasts cycle ticks; time starts at a cycle start
// step() one tick on. After it, oper is the gate state during the tick that has just begun
// oper[q] 1: the gate of queue q is open
// Figure 8-20 in words: at a cycle start the list pointer goes to 0. An entry is executed, and the next one follows
// when its TimeInterval has run out. An interval of 0 counts as 1. After the last entry nothing changes until the
// Cycle Timer starts the next cycle. If that comes first, the rest of the list is not executed.
module eth_gcl;
reg [7:0] gate [0:15];
int interval [0:15];
int len = 0, cycle_time = 1;
reg [7:0] admin = 8'hff; // AdminGateStates: the state before the first cycle (default: all open)
reg [7:0] oper = 8'hff; // OperGateStates
int now = -1, cycle_start = 0; // CurrentTime and CycleStartTime, in ticks
int list_pointer = 0, exit_timer = 0;
bit ended = 1; // END_OF_CYCLE
function automatic void set(input int k, input [7:0] g, input int ticks);
gate[k] = g; interval[k] = ticks;
endfunction
function automatic void start(input int n, input int cycle);
len = n; cycle_time = cycle; oper = admin; now = -1; cycle_start = 0; list_pointer = 0; exit_timer = 0; ended = 1;
endfunction
function automatic void step();
now++;
if (now == 0 || now >= cycle_start + cycle_time) begin // Cycle Timer: START_CYCLE, then NEW_CYCLE
cycle_start = now; list_pointer = 0; exit_timer = 0; ended = (len == 0);
end
if (!ended) begin
if (exit_timer == 0) begin // EXECUTE_CYCLE
oper = gate[list_pointer];
exit_timer = (interval[list_pointer] == 0) ? 1 : interval[list_pointer];
list_pointer++;
if (list_pointer >= len) ended = 1;
end
exit_timer--; // DELAY
end
endfunction
endmodule
Check Yourself
Common Mistakes
Wrong Start a frame because its gate is open.
The frame may still be on the line when the gate closes.
Fix Start it only if frame and overhead end before the gate-close event.
Wrong Count only the frame when you check the room.
Preamble, SFD and the gap take 20 octet times on Ethernet.
Fix Add the media-dependent overhead of 12.4.2.2.
Wrong Expect the gates to open when the list has ended.
After the last entry nothing changes until the next cycle.
Fix Let the last entry set the state that should last.
Wrong Treat every cycle start as a gate-close event.
An entry that leaves a gate open is no event for that queue.
Fix Look for the next entry that changes the gate from open to closed.
Remember
- Every queue of a port has a transmission gate. A closed gate keeps its frames out of selection.
- A gate control list sets all gates, entry by entry, and repeats in a fixed cycle.
- After the last entry the gates stay. A cycle that ends early cuts the list. An interval of 0 counts as 1.
- A frame starts only if it and 20 octets of overhead end before its gate closes. That creates the guard band.
- Frame preemption with hold and release shrinks the guard band to about one small piece of a frame.