Timestamps in Hardware
PTP is only as good as its four timestamps. A port takes them in hardware, at one fixed place in every frame. See where that place is, and what a clock crossing costs.
You Will Be Able To
- Place the stamp point of Clause 90 and the stamp point of PTP in a frame.
- Correct a stamp with the path data delay: which way on transmit, which way on receive.
- Measure the error of an event that crosses into another clock domain.
- Explain why a stamp must keep the clock reading of its own moment.
- Lesson
- P11.42
- Time
- 40 min
- Runs on
- Your browser
- Check
- 5 questions
A stamp taken by software is late by a random amount. A stamp taken at the wire is not.
An event that crosses two flops is late by two fixed clock periods and by a wait below 8,000 ps.
In the bench one event waits 7,999 ps.
- I/O
- Datapath
- Channel / handshake
- Data
- Send
The MAC hands a frame to the reconciliation sublayer, which puts it on the xMII.
- Detect
The sublayer sees the SFD go by and signals the client: TS_TX.indication.
- Delay
The frame still has to cross the PHY. It leaves the port a little later.
- Receive
The other way round, the frame has crossed the PHY before the sublayer sees its SFD.
Read the diagram as text
- TimeSync Client: reads the clock at each signal
- MAC: sends and receives frames
- Reconciliation sublayer: finds the SFD, both ways
- PHY: PCS, FEC, PMA, PMD
- MDI: the wire or the fibre
- MAC → Reconciliation sublayer: frames
- Reconciliation sublayer → TimeSync Client: TS_TX, TS_RX
- Reconciliation sublayer → PHY: xMII
- PHY → MDI: path data delay
Our own drawing after IEEE Std 802.3-2022 Figures 90-1, 90-2 and 90-3.
Why the Stamp Is Taken in Hardware
PTP works with four times: when a message left, and when it arrived, twice (P11.41).
An error in one of them goes straight into the offset.
Software sees a frame long after the wire did, and that delay changes from frame to frame.
So a port takes the stamp in hardware, next to the MAC, at the same place in every frame.
Two Signals: TS_TX and TS_RX
Clause 90 adds an optional service to the reconciliation sublayer, for full duplex only (90.1, 90.4).
It is called the Time Synchronization Service Interface, the TSSI.
It has two signals. TS_TX.indication says: a start frame delimiter just went out on the xMII.
TS_RX.indication says the same for a frame that came in.
Each carries one value, SFD = DETECTED. The sublayer may raise it only for an SFD (90.5.1, 90.5.2).
The signal carries no time. The TimeSync Client reads its own clock when the signal comes.
Every frame is signalled. Which frames matter is the client's business (90.4.1.2).
With frame preemption a second parameter, MM, says which kind of frame started: express or preemptable (90.4.3.1.1).
Where the Stamp Point Sits
- Cycle 0
Seven octets of preamble come first. Three are shown.
- Cycle 3
The SFD. Clause 90 measures from its beginning.
- Cycle 4
PTP defines its stamp one symbol later: where the frame itself begins.
IEEE Std 802.3-2022 90.7 and IEEE Std 1588-2019 7.3.4.1.
Clause 90 measures a frame at the beginning of its SFD (90.7).
PTP defines its stamp at the beginning of the first symbol after the SFD (IEEE Std 1588-2019 7.3.4.1).
The two are one octet apart. That is 8 ns at 1 Gb/s.
PTP allows another capture point, if the stamp is corrected by the time between the two (7.3.4.2).
| Rate | One octet | Rate | One octet |
|---|---|---|---|
| 10 Mb/s | 800 ns | 25 Gb/s | 0.32 ns |
| 100 Mb/s | 80 ns | 40 Gb/s | 0.2 ns |
| 1 Gb/s | 8 ns | 50 Gb/s | 0.16 ns |
| 2.5 Gb/s | 3.2 ns | 100 Gb/s | 0.08 ns |
| 5 Gb/s | 1.6 ns | 200 Gb/s | 0.04 ns |
| 10 Gb/s | 0.8 ns | 400 Gb/s | 0.02 ns |
IEEE Std 802.3df-2024 Table 90A-1, column "mismatched data delay measurement point". 800 Gb/s: 0.01 ns. Each value is the time of eight bits: this page's arithmetic.
The table does not name its two points. That they are the SFD start and the PTP point is this course's inference.
Two ports that pick different points and do not correct are off by this much.
A Clock That Counts in Fractions
The clock is a counter: seconds, nanoseconds, and a fraction of a nanosecond.
Every tick adds an increment. For a 125 MHz clock that is 8 ns.
At 1,000,000,000 the nanoseconds start again and the seconds go up by one.
| After tick | Seconds | Nanoseconds |
|---|---|---|
| 1 | 0 | 999,999,984 |
| 2 | 0 | 999,999,992 |
| 3 | 1 | 0 |
| 4 | 1 | 8 |
Bench run of a private model. The clock adds 8 ns a tick.
No oscillator runs at exactly 125 MHz. So a servo trims the increment a little.
| Increment | One tick adds | After 65,536 ticks | Against 8 ns |
|---|---|---|---|
| 080000h | 8 ns | 524,288 ns | exact |
| 080001h | 8 ns + 1/65,536 ns | 524,289 ns | 1.9 ppm fast |
| 07FFF0h | 8 ns - 16/65,536 ns | 524,272 ns | 31 ppm slow |
Bench run of a private model with 16 fraction bits, a course choice.
With 16 fraction bits, one unit of the increment is 1.9 ppm. Real units carry more bits for a finer step.
A servo can also step the clock: add or take off a whole amount at once.
Finding the SFD on the GMII
On the GMII a packet starts when TX_EN rises (35.2.3.2.1).
The MAC sends seven octets 55h, and then the SFD: D5h.
The detector waits for the first octet that is not 55h. If it is D5h, that is the SFD.
| Octets while TX_EN is 1 | Stamps | In tick |
|---|---|---|
| seven 55h, then D5h, then data | 1 | 8 |
| D5h as the first octet | 1 | 1 |
| two 55h, then D5h | 1 | 3 |
| 55h, 54h, then D5h | 0 | none |
| D5h again in the data | 1 | 3 |
| no D5h at all | 0 | none |
Bench run of a private model. Any number of 55h octets may come first: a course choice.
An octet D5h later in the frame is data. It must not make a second stamp.
Path Data Delay: Add on Transmit, Subtract on Receive
The sublayer sees the SFD at the xMII. The frame meets the wire at the MDI.
Between them lies the PHY. Its time is the path data delay (90.7).
A PHY reports four numbers in nanoseconds: least and greatest, for transmit and for receive.
Each sublayer has 32-bit registers for them: 1.1801 to 1.1808 in the PMA and PMD, and so on (45.2.1.176, 45.2.1.177).
Each number is the sum over all sublayers of the port (30.13.1.3, 30.13.1.4).
A transmitted frame leaves after its stamp was taken. So the delay is added.
A received frame arrived before its stamp was taken. So the delay is taken off (1588 7.3.4.2).
| Direction | Clock at the SFD | Path data delay | Correction | Stamp |
|---|---|---|---|---|
| Transmit | 216 ns | 40 to 61 ns | add 50.5 ns | 266.5 ns |
| Receive | 2 s and 6 ns | 100 to 120 ns | take off 110 ns | 1 s and 999,999,896 ns |
Bench run of a private model. The unit takes half the sum of the least and the greatest delay: a course choice.
The delay of the medium itself is not part of these numbers (90.7).
With FEC the delay depends on where the SFD falls in a block. The PHY should report it as for the start of a block.
Another Clock Domain Costs up to One Period
The receive side of a GMII runs on the clock of the PHY. The time counter runs on another clock.
So the receive SFD is an event from another clock domain.
It is sent as a level that changes once a frame, through two flops in a row.
The first flop samples the level at its next clock edge. That edge can be up to one period away.
In the bench the events come 4 to 7,991 ps before their edge, 3,954 ps on average.
The two flops add two whole periods. That part is fixed and can be taken off.
The rest, up to one period, cannot.
In this model a flop never goes metastable. A real first flop may, and the second one is there for that.
A Stamp Must Keep Its Own Moment
A receive stamp is ready two ticks after its event was sampled.
In those two ticks the servo may change the rate, or step the clock.
The stamp must still report the clock as it read when the event was sampled.
| While the stamp is on its way | Stamp | The twin's stamp | The twin is off by |
|---|---|---|---|
| nothing changes | 72 ns | 72 ns | 0 ns |
| a rate of 10 ns from the next tick | 72 ns | 70 ns | -2 ns |
| a step of 1 ms in the next tick | 72 ns | 1,000,072 ns | 1,000,000 ns |
| a step of 1 ms in the sampling tick | 72 ns | 1,000,072 ns | 1,000,000 ns |
Bench run of a private model and of its twin, which takes two increments off the clock when the stamp enters.
The twin reads the clock late and takes two increments off. That works only while nothing changes.
After a step it is wrong by the whole step.
Stamps Wait in a FIFO
Software reads the stamps later, one by one. Until then they wait in a FIFO.
Each stamp has a tag: the number of its frame, counted for each direction.
With the tag, software can match a stamp to the frame it sent or received.
| Step | Stamps that wait | Oldest tag | Lost |
|---|---|---|---|
| six frames, nobody reads | 4 | 0 | 2 |
| a pop | 3 | 1 | 2 |
| a pop | 2 | 2 | 2 |
| a pop | 1 | 3 | 2 |
| a pop and a seventh frame | 1 | 6 | 2 |
Bench run of a private model with a FIFO of four. Frames 4 and 5 were lost, and the tags show it.
When the FIFO is full, a new stamp is lost. Its tag is used up all the same.
So a gap in the tags tells the reader that stamps are missing.
What Else Moves a Stamp
Annex 90A lists more things that shift a frame inside a PHY.
A PCS may insert or remove an Idle. That moves the next frame.
Alignment markers and FEC codeword markers take the place of data, so frames after them shift.
A multi-lane receiver delays each lane by another amount to line them up (90.7).
The annex table sizes each effect at each rate. This lesson measures none.
The annex came with IEEE Std 802.3cx-2023, which also changed Clause 90.
This course has read only the table. The lesson follows IEEE Std 802.3-2022.
Try It
eth_sync2 is two flops and an edge detector. clk(level) is one edge of the receiving clock.
through(t) lets the level change t picoseconds into the run. The clock has an edge every 8,000 ps.
The first flop samples the new level at the next edge. seen is 1 two edges later.
late is the time from the event to that first edge. It is what stays after two periods are taken off.
An event just before an edge is late by 1 ps. One just after it waits 7,999 ps.
Over 1,000 random events the wait runs from 4 to 7,991 ps.
The timestamp unit is not in the readable library. It is the practice problem.
Change the clock to 4,000 ps. Predict the largest wait.
event at 3000 ps: sampled at edge 1, seen at edge 3, late by 5000 ps event at 15999 ps: sampled at edge 2, seen at edge 4, late by 1 ps event at 16001 ps: sampled at edge 3, seen at edge 5, late by 7999 ps 1000 events: late by 4 ps at least, 7991 ps at most, 3954 ps on averageRead 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_tsu.sv
`timescale 1ns/1ns
// eth_tsu.sv: an event that crosses into another clock domain (read-only). A bench model.
// eth_sync2: a level change carried through two flops, and an edge detector behind them.
// reset() all three flops at 0
// clk(level) one rising edge of the receiving clock. level is what the first flop samples at that edge
// seen 1 in the edge at which the change has passed both flops and can be used
// A model: a flop here never goes metastable. A real first flop may, which is why the second one is there.
module eth_sync2;
bit s1, s2, s3;
bit seen;
function automatic void reset();
s1 = 0; s2 = 0; s3 = 0; seen = 0;
endfunction
function automatic void clk(input bit level);
seen = (s2 != s3); // the values the flops held before this edge
s3 = s2; s2 = s1; s1 = level;
endfunction
endmodule
// eth_tsu_time: a time of day as text. t = {seconds[47:0], nanoseconds[29:0], fraction[15:0]}; the fraction
// counts 1/65,536 ns and is shown in thousandths.
module eth_tsu_time;
function automatic string show(input [93:0] t);
return $sformatf("%0d s %0d.%03d ns", t[93:46], t[45:16], (t[15:0] * 1000) / 65536);
endfunction
endmodule
Check Yourself
Common Mistakes
Wrong Stamp a frame when software sees it.
That delay changes from frame to frame, and PTP cannot remove it.
Fix Stamp in hardware at the SFD, and correct by a fixed delay.
Wrong Add the path data delay to a receive stamp.
A received frame crossed the PHY before it was stamped.
Fix Add on transmit. Take off on receive.
Wrong Read the clock when a crossed event is ready, then take two ticks off.
The rate or the time may have changed in those two ticks.
Fix Report the clock as it read at the sampling edge.
Wrong Stamp every octet D5h.
D5h is also a normal data octet.
Fix Stamp only the octet that ends the preamble, once a frame.
Remember
- Clause 90 gives the time client two signals, TS_TX and TS_RX. Each says only that an SFD passed the xMII.
- Clause 90 measures at the start of the SFD. PTP defines its point one octet later, so a port must correct.
- The PHY reports its path data delay. Add it to a transmit stamp and take it off a receive stamp.
- An event that crosses two flops is late by two fixed periods and by up to one period that nobody can remove.
- A stamp keeps the clock reading of its own moment, whatever the servo does afterwards.