1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

// NanoSoC teaching values: 2-master round-robin with a burst lock.
// The grant is held until the last beat of the granted burst, so bursts never
// interleave. The idle cycle of the link model is added by the fabric, not here.
module nano_rr_arb2 (
  input  logic       clk,
  input  logic       resetn,
  input  logic [1:0] req,
  input  logic       burst_done, // last beat (WLAST or RLAST) of the granted burst accepted
  output logic [1:0] grant
);
  logic       locked; // a burst is in progress: hold the grant
  logic [1:0] owner;  // who holds it
  logic       last;   // 0: M0 was granted last, 1: M1 was granted last

  always_comb begin
    grant = 2'b00;
    if (locked) grant = owner;
    else case (req)
      2'b01: grant = 2'b01;
      2'b10: grant = 2'b10;
      2'b11: grant = last ? 2'b01 : 2'b10;
      default: grant = 2'b00;
    endcase
  end

  always_ff @(posedge clk or negedge resetn) begin
    if (!resetn) begin
      locked <= 1'b0;
      owner <= 2'b00;
      last <= 1'b0;
    end else if (!locked) begin
      if (grant != 2'b00) begin
        locked <= 1'b1;
        owner <= grant;
        last <= grant[1]; // updated on EVERY grant, not only when both ask
      end
    end else if (burst_done) begin
      locked <= 1'b0;
    end
  end
endmodule

// ---- self-checking testbench: strict alternation, no interleaving ----
module tb;
  logic clk = 0, resetn = 0;
  always #5 clk = ~clk;
  logic [1:0] req = 2'b00;
  wire [1:0] grant;
  logic [1:0] beat = 2'd0; // beat counter of the granted burst (4-beat bursts)
  wire burst_done = (grant != 2'b00) && (beat == 2'd3);
  nano_rr_arb2 dut (.clk(clk), .resetn(resetn), .req(req), .burst_done(burst_done), .grant(grant));

  always @(posedge clk) begin
    if (!resetn) beat <= 2'd0;
    else if (grant != 2'b00) beat <= beat + 2'd1;
  end

  int errors = 0, n_m0 = 0, n_m1 = 0;
  logic [1:0] owner = 2'b00, prev = 2'b00;
  bit both_phase = 0, first = 1;
  always @(posedge clk) if (resetn && grant != 2'b00) begin
    if (beat == 2'd0) begin // a new burst starts
      owner = grant;
      if (both_phase) begin
        if (first && grant != 2'b01) begin errors++; $display("FAIL: M0 must win after M1 went last"); end
        if (!first && grant == prev) begin errors++; $display("FAIL: master %b granted twice in a row", grant); end
        first = 0;
        if (grant == 2'b01) n_m0++; else n_m1++;
      end
      prev = grant;
    end else if (grant != owner) begin errors++; $display("FAIL: grant changed inside a burst"); end
  end

  initial begin
    repeat (3) @(negedge clk); resetn = 1;
    req = 2'b10; repeat (20) @(negedge clk);     // M1 alone for several bursts
    both_phase = 1; req = 2'b11; repeat (80) @(negedge clk); // then both ask continuously
    req = 2'b00; repeat (6) @(negedge clk);
    if (n_m0 < 8 || n_m1 < 8 || n_m0 > n_m1 + 1 || n_m1 > n_m0 + 1) begin errors++; $display("FAIL: unfair share m0=%0d m1=%0d", n_m0, n_m1); end
    if (errors == 0) $display("PASS: strict alternation while both ask, no interleaving inside a burst (m0=%0d m1=%0d)", n_m0, n_m1);
    $finish;
  end
  initial #50000 begin $display("FAIL timeout"); $finish; end
endmodule