URL https://opencores.org/ocsvn/qaz_libs/qaz_libs/trunk

Subversion Repositories qaz_libs

[/] [qaz_libs/] [trunk/] [axi4_lib/] [sim/] [src/] [legacy/] [axi4_bfm_pkg.sv] - Blame information for rev 50

Go to most recent revision | Details | Compare with Previous | View Log


//////////////////////////////////////////////////////////////////////
////                                                              ////
//// Copyright (C) 2015 Authors and OPENCORES.ORG                 ////
////                                                              ////
//// This source file may be used and distributed without         ////
//// restriction provided that this copyright statement is not    ////
//// removed from the file and that any derivative work contains  ////
//// the original copyright notice and the associated disclaimer. ////
////                                                              ////
//// This source file is free software; you can redistribute it   ////
//// and/or modify it under the terms of the GNU Lesser General   ////
//// Public License as published by the Free Software Foundation; ////
//// either version 2.1 of the License, or (at your option) any   ////
//// later version.                                               ////
////                                                              ////
//// This source is distributed in the hope that it will be       ////
//// useful, but WITHOUT ANY WARRANTY; without even the implied   ////
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      ////
//// PURPOSE.  See the GNU Lesser General Public License for more ////
//// details.                                                     ////
////                                                              ////
//// You should have received a copy of the GNU Lesser General    ////
//// Public License along with this source; if not, download it   ////
//// from http://www.opencores.org/lgpl.shtml                     ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
 
 
// --------------------------------------------------------------------
//
package axi4_bfm_pkg;
 
  // --------------------------------------------------------------------
  //
  import tb_bfm_pkg::*;
  import axi4_transaction_pkg::*;
 
 
  // --------------------------------------------------------------------
  //
  class ar_master_transaction_class #(A = 32, N = 8, I = 1)
    extends tb_blocking_transaction_q_class #(axi4_transaction_class #(.A(A), .N(N), .I(I)));
 
    virtual axi4_if  #(.A(A), .N(N), .I(I)) axi4_m;
 
 
    //--------------------------------------------------------------------
    function new
      (
        virtual axi4_if  #(.A(A), .N(N), .I(I)) axi4_m
      );
 
      super.new();
      this.axi4_m = axi4_m;
 
    endfunction: new
 
 
    // --------------------------------------------------------------------
    //
    function void
      ar_default;
 
      axi4_m.cb_m.araddr   <= 'bx;
      axi4_m.cb_m.arburst  <= 'bx;
      axi4_m.cb_m.arcache  <= 'bx;
      axi4_m.cb_m.arid     <= 'bx;
      axi4_m.cb_m.arlen    <= 'bx;
      axi4_m.cb_m.arlock   <= 'bx;
      axi4_m.cb_m.arprot   <= 'bx;
      axi4_m.cb_m.arqos    <= 'bx;
      axi4_m.cb_m.arregion <= 'bx;
      axi4_m.cb_m.arsize   <= 'bx;
      axi4_m.cb_m.arvalid  <= 0;
 
    endfunction: ar_default
 
 
    // --------------------------------------------------------------------
    //
    task automatic
      transaction
      (
        ref T tr_h
      );
 
      ->this.start;
 
      repeat(tr_h.delay_h.next()) @(axi4_m.cb_m);
 
      axi4_m.cb_m.araddr   <= tr_h.addr;
      axi4_m.cb_m.arid     <= tr_h.id;
      axi4_m.cb_m.arlen    <= tr_h.len;
      axi4_m.cb_m.arsize   <= tr_h.size;
 
      axi4_m.cb_m.arburst  <= tr_h.burst;
      axi4_m.cb_m.arcache  <= tr_h.cache;
      axi4_m.cb_m.arlock   <= tr_h.lock;
      axi4_m.cb_m.arprot   <= tr_h.prot;
      axi4_m.cb_m.arqos    <= tr_h.qos;
      axi4_m.cb_m.arregion <= tr_h.region;
      axi4_m.cb_m.arvalid  <= 1;
 
      $display("^^^ %16.t | %m | master AR transaction @ 0x%08x |", $time, tr_h.addr);
 
      repeat(1) @(axi4_m.cb_m);
      wait(axi4_m.cb_m.arready);
 
      axi4_m.zero_cycle_delay();
      ar_default();
 
      ->this.done;
 
    endtask: transaction
 
 
  // --------------------------------------------------------------------
  //
  endclass: ar_master_transaction_class
 
 
  // --------------------------------------------------------------------
  //
  class r_master_transaction_class #(A = 32, N = 8, I = 1)
    extends tb_blocking_transaction_q_class #(axi4_transaction_class #(.A(A), .N(N), .I(I)));
 
    virtual axi4_if  #(.A(A), .N(N), .I(I)) axi4_m;
 
 
    //--------------------------------------------------------------------
    function new
      (
        virtual axi4_if  #(.A(A), .N(N), .I(I)) axi4_m
      );
 
      super.new();
      this.axi4_m = axi4_m;
 
    endfunction: new
 
 
    // --------------------------------------------------------------------
    //
    function void
      r_default;
 
      axi4_m.cb_m.rready <= 0;
 
    endfunction: r_default
 
 
    // --------------------------------------------------------------------
    //
    task automatic
      transaction
      (
        ref T tr_h
      );
 
      ->this.start;
 
      tr_h.data_h = new(tr_h.len);
 
      foreach(tr_h.payload_h.w[i])
      begin
        repeat(tr_h.delay_h.next()) @(axi4_m.cb_m);
        axi4_m.cb_m.rready <= 1;
        repeat(1) @(axi4_m.cb_m);
 
        wait(axi4_m.cb_m.rvalid);
        axi4_m.zero_cycle_delay();
 
        tr_h.data_h.w[i] = axi4_m.cb_m.rdata;
 
        $display("^^^ %16.t | %m | master R transaction | %d | 0x%016x |", $time, i, tr_h.data_h.w[i]);
        r_default();
      end
 
      ->this.done;
 
    endtask: transaction
 
 
  // --------------------------------------------------------------------
  //
  endclass: r_master_transaction_class
 
 
  // --------------------------------------------------------------------
  //
  class aw_master_transaction_class #(A = 32, N = 8, I = 1)
    extends tb_blocking_transaction_q_class #(axi4_transaction_class #(.A(A), .N(N), .I(I)));
 
    virtual axi4_if  #(.A(A), .N(N), .I(I)) axi4_m;
 
 
    //--------------------------------------------------------------------
    function new
      (
        virtual axi4_if  #(.A(A), .N(N), .I(I)) axi4_m
      );
 
      super.new();
      this.axi4_m = axi4_m;
 
    endfunction: new
 
 
    // --------------------------------------------------------------------
    //
    function void
      aw_default;
 
      axi4_m.cb_m.awaddr   <= 'bx;
      axi4_m.cb_m.awburst  <= 'bx;
      axi4_m.cb_m.awcache  <= 'bx;
      axi4_m.cb_m.awid     <= 'bx;
      axi4_m.cb_m.awlen    <= 'bx;
      axi4_m.cb_m.awlock   <= 'bx;
      axi4_m.cb_m.awprot   <= 'bx;
      axi4_m.cb_m.awqos    <= 'bx;
      axi4_m.cb_m.awregion <= 'bx;
      axi4_m.cb_m.awsize   <= 'bx;
      axi4_m.cb_m.awvalid  <= 0;
 
    endfunction: aw_default
 
    // --------------------------------------------------------------------
    //
    task automatic
      transaction
      (
        ref T tr_h
      );
 
      ->this.start;
 
      repeat(tr_h.delay_h.next()) @(axi4_m.cb_m);
 
      axi4_m.cb_m.awaddr   <= tr_h.addr;
      axi4_m.cb_m.awid     <= tr_h.id;
      axi4_m.cb_m.awlen    <= tr_h.len;
      axi4_m.cb_m.awsize   <= tr_h.size;
 
      axi4_m.cb_m.awburst  <= tr_h.burst;
      axi4_m.cb_m.awcache  <= tr_h.cache;
      axi4_m.cb_m.awlock   <= tr_h.lock;
      axi4_m.cb_m.awprot   <= tr_h.prot;
      axi4_m.cb_m.awqos    <= tr_h.qos;
      axi4_m.cb_m.awregion <= tr_h.region;
      axi4_m.cb_m.awvalid  <= 1;
 
      $display("^^^ %16.t | %m | master AW transaction @ 0x%08x |", $time, tr_h.addr);
 
      repeat(1) @(axi4_m.cb_m);
      wait(axi4_m.cb_m.awready);
 
      axi4_m.zero_cycle_delay();
      aw_default();
 
      ->this.done;
 
    endtask: transaction
 
 
  // --------------------------------------------------------------------
  //
  endclass: aw_master_transaction_class
 
 
  // --------------------------------------------------------------------
  //
  class w_master_transaction_class #(A = 32, N = 8, I = 1)
    extends tb_blocking_transaction_q_class #(axi4_transaction_class #(.A(A), .N(N), .I(I)));
 
    virtual axi4_if  #(.A(A), .N(N), .I(I)) axi4_m;
 
 
    //--------------------------------------------------------------------
    function new
      (
        virtual axi4_if  #(.A(A), .N(N), .I(I)) axi4_m
      );
 
      super.new();
      this.axi4_m = axi4_m;
 
    endfunction: new
 
 
    // --------------------------------------------------------------------
    //
    function void
      w_default;
 
      axi4_m.cb_m.wdata    <= 'bx;
      axi4_m.cb_m.wlast    <= 'bx;
      axi4_m.cb_m.wstrb    <= {N{1'b1}};
      axi4_m.cb_m.wvalid   <= 0;
 
    endfunction: w_default
 
 
    // --------------------------------------------------------------------
    //
    task automatic
      transaction
      (
        ref T tr_h
      );
 
      ->this.start;
 
      foreach(tr_h.payload_h.w[i])
      begin
        repeat(tr_h.delay_h.next()) @(axi4_m.cb_m);
 
        axi4_m.cb_m.wdata  <= tr_h.payload_h.w[i];
        // axi4_m.cb_m.wstrb  <= tr_h.strb;    // need to fix
 
        if(i < tr_h.payload_h.w.size - 1)
          axi4_m.cb_m.wlast   <= 0;
        else
          axi4_m.cb_m.wlast   <= 1;
 
        axi4_m.cb_m.wvalid <= 1;
 
        repeat(1) @(axi4_m.cb_m);
        wait(axi4_m.cb_m.wready);
 
        axi4_m.zero_cycle_delay();
        $display("^^^ %16.t | %m | master W transaction | %d | 0x%016x |", $time, i, tr_h.payload_h.w[i]);
        w_default();
      end
 
      ->this.done;
 
    endtask: transaction
 
 
  // --------------------------------------------------------------------
  //
  endclass: w_master_transaction_class
 
 
  // --------------------------------------------------------------------
  //
  class b_master_transaction_class #(A = 32, N = 8, I = 1)
    extends tb_blocking_transaction_q_class #(axi4_transaction_class #(.A(A), .N(N), .I(I)));
 
    virtual axi4_if  #(.A(A), .N(N), .I(I)) axi4_m;
 
 
    //--------------------------------------------------------------------
    function new
      (
        virtual axi4_if  #(.A(A), .N(N), .I(I)) axi4_m
      );
 
      super.new();
      this.axi4_m = axi4_m;
 
    endfunction: new
 
 
    // --------------------------------------------------------------------
    //
    function void
      b_default;
 
      axi4_m.cb_m.bready   <= 0;
 
    endfunction: b_default
 
 
    // --------------------------------------------------------------------
    //
    task automatic
      transaction
      (
        ref T tr_h
      );
 
      ->this.start;
 
      repeat(tr_h.delay_h.next()) @(axi4_m.cb_m);
      axi4_m.cb_m.bready <= 1;
      repeat(1) @(axi4_m.cb_m);
 
      wait(axi4_m.cb_m.bvalid);
      axi4_m.zero_cycle_delay();
 
      $display("^^^ %16.t | %m | master B transaction | 0x%x |", $time, axi4_m.cb_m.bresp);
      b_default();
 
      ->this.done;
 
    endtask: transaction
 
 
  // --------------------------------------------------------------------
  //
  endclass: b_master_transaction_class
 
 
  // --------------------------------------------------------------------
  //
  class axi4_master_bfm_class #(A = 32, N = 8, I = 1);
 
    ar_master_transaction_class #(.A(A), .N(N), .I(I))  ar_h;
    r_master_transaction_class  #(.A(A), .N(N), .I(I))  r_h;
    aw_master_transaction_class #(.A(A), .N(N), .I(I))  aw_h;
    w_master_transaction_class #(.A(A), .N(N), .I(I))   w_h;
    b_master_transaction_class  #(.A(A), .N(N), .I(I))  b_h;
 
    axi4_transaction_class tr_h;
    virtual axi4_if  #(.A(A), .N(N), .I(I)) axi4_m;
 
 
    //--------------------------------------------------------------------
    function new
      (
        virtual axi4_if  #(.A(A), .N(N), .I(I)) axi4_m
      );
 
      this.axi4_m = axi4_m;
 
      ar_h = new(axi4_m);
      r_h = new(axi4_m);
      aw_h = new(axi4_m);
      w_h = new(axi4_m);
      b_h = new(axi4_m);
 
      ar_h.init();
      ar_h.ar_default();
 
      r_h.init();
      r_h.r_default();
 
      aw_h.init();
      aw_h.aw_default();
 
      w_h.init();
      w_h.w_default();
 
      b_h.init();
      b_h.b_default();
 
    endfunction: new
 
 
    // --------------------------------------------------------------------
    //
    function void
      init;
 
    endfunction: init
 
 
    // --------------------------------------------------------------------
    //
    task
      basic_read
      (
        input   logic [(A-1):0]   araddr,
        input   logic [7:0]       arlen,
        output  logic [(8*N)-1:0] data[],
        output  logic [1:0]       rresp
      );
 
      this.tr_h = new;
      this.tr_h.basic_read(araddr, arlen);
 
      ar_h.put(tr_h);
      r_h.put(tr_h);
 
      @(r_h.done);
      data = tr_h.data_h.w;
      rresp = tr_h.resp;
 
    endtask: basic_read
 
 
    // --------------------------------------------------------------------
    //
    task
      basic_random_read_burst
      (
        output  logic [(8*N)-1:0] data[],
        output  logic [1:0]       rresp
      );
 
      this.tr_h = new;
      this.tr_h.basic_random_burst;
 
      ar_h.put(tr_h);
      r_h.put(tr_h);
 
      @(r_h.done);
      data = tr_h.data_h.w;
      rresp = tr_h.resp;
 
    endtask: basic_random_read_burst
 
 
    // --------------------------------------------------------------------
    //
    task
      basic_write
      (
        input   logic [(A-1):0]   awaddr,
        input   logic [7:0]       awlen,
        input   logic [(8*N)-1:0] data[],
        output  logic [1:0]       bresp
      );
 
      this.tr_h = new;
      this.tr_h.basic_write(awaddr, awlen);
 
      foreach(this.tr_h.payload_h.w[i])
        this.tr_h.payload_h.w[i] = data[i];
 
      aw_h.put(tr_h);
      w_h.put(tr_h);
      b_h.put(tr_h);
 
      @(b_h.done);
      bresp = tr_h.resp;
 
    endtask: basic_write
 
 
    // --------------------------------------------------------------------
    //
    task
      basic_random_write_burst
      (
        output  logic [1:0]       bresp
      );
 
      this.tr_h = new;
      this.tr_h.basic_random_burst;
 
      aw_h.put(tr_h);
      w_h.put(tr_h);
      b_h.put(tr_h);
 
      @(b_h.done);
      bresp = tr_h.resp;
 
    endtask: basic_random_write_burst
 
 
  // --------------------------------------------------------------------
  //
  endclass: axi4_master_bfm_class
 
 
// --------------------------------------------------------------------
//
endpackage: axi4_bfm_pkg
 
 

Browse

Tools

Subversion Repositories qaz_libs

[/] [qaz_libs/] [trunk/] [axi4_lib/] [sim/] [src/] [legacy/] [axi4_bfm_pkg.sv] - Blame information for rev 50

Line No.	Rev	Author	Line
1	45	qaztronic	`//////////////////////////////////////////////////////////////////////`
2			`//// ////`
3			`//// Copyright (C) 2015 Authors and OPENCORES.ORG ////`
4			`//// ////`
5			`//// This source file may be used and distributed without ////`
6			`//// restriction provided that this copyright statement is not ////`
7			`//// removed from the file and that any derivative work contains ////`
8			`//// the original copyright notice and the associated disclaimer. ////`
9			`//// ////`
10			`//// This source file is free software; you can redistribute it ////`
11			`//// and/or modify it under the terms of the GNU Lesser General ////`
12			`//// Public License as published by the Free Software Foundation; ////`
13			`//// either version 2.1 of the License, or (at your option) any ////`
14			`//// later version. ////`
15			`//// ////`
16			`//// This source is distributed in the hope that it will be ////`
17			`//// useful, but WITHOUT ANY WARRANTY; without even the implied ////`
18			`//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ////`
19			`//// PURPOSE. See the GNU Lesser General Public License for more ////`
20			`//// details. ////`
21			`//// ////`
22			`//// You should have received a copy of the GNU Lesser General ////`
23			`//// Public License along with this source; if not, download it ////`
24			`//// from http://www.opencores.org/lgpl.shtml ////`
25			`//// ////`
26			`//////////////////////////////////////////////////////////////////////`
27
28
29			`// --------------------------------------------------------------------`
30			`//`
31			`package axi4_bfm_pkg;`
32
33			`// --------------------------------------------------------------------`
34			`//`
35			`import tb_bfm_pkg::*;`
36			`import axi4_transaction_pkg::*;`
37
38
39			`// --------------------------------------------------------------------`
40			`//`
41			`class ar_master_transaction_class #(A = 32, N = 8, I = 1)`
42			`extends tb_blocking_transaction_q_class #(axi4_transaction_class #(.A(A), .N(N), .I(I)));`
43
44			`virtual axi4_if #(.A(A), .N(N), .I(I)) axi4_m;`
45
46
47			`//--------------------------------------------------------------------`
48			`function new`
49			`(`
50			`virtual axi4_if #(.A(A), .N(N), .I(I)) axi4_m`
51			`);`
52
53			`super.new();`
54			`this.axi4_m = axi4_m;`
55
56			`endfunction: new`
57
58
59			`// --------------------------------------------------------------------`
60			`//`
61			`function void`
62			`ar_default;`
63
64			`axi4_m.cb_m.araddr <= 'bx;`
65			`axi4_m.cb_m.arburst <= 'bx;`
66			`axi4_m.cb_m.arcache <= 'bx;`
67			`axi4_m.cb_m.arid <= 'bx;`
68			`axi4_m.cb_m.arlen <= 'bx;`
69			`axi4_m.cb_m.arlock <= 'bx;`
70			`axi4_m.cb_m.arprot <= 'bx;`
71			`axi4_m.cb_m.arqos <= 'bx;`
72			`axi4_m.cb_m.arregion <= 'bx;`
73			`axi4_m.cb_m.arsize <= 'bx;`
74			`axi4_m.cb_m.arvalid <= 0;`
75
76			`endfunction: ar_default`
77
78
79			`// --------------------------------------------------------------------`
80			`//`
81			`task automatic`
82			`transaction`
83			`(`
84			`ref T tr_h`
85			`);`
86
87			`->this.start;`
88
89			`repeat(tr_h.delay_h.next()) @(axi4_m.cb_m);`
90
91			`axi4_m.cb_m.araddr <= tr_h.addr;`
92			`axi4_m.cb_m.arid <= tr_h.id;`
93			`axi4_m.cb_m.arlen <= tr_h.len;`
94			`axi4_m.cb_m.arsize <= tr_h.size;`
95
96			`axi4_m.cb_m.arburst <= tr_h.burst;`
97			`axi4_m.cb_m.arcache <= tr_h.cache;`
98			`axi4_m.cb_m.arlock <= tr_h.lock;`
99			`axi4_m.cb_m.arprot <= tr_h.prot;`
100			`axi4_m.cb_m.arqos <= tr_h.qos;`
101			`axi4_m.cb_m.arregion <= tr_h.region;`
102			`axi4_m.cb_m.arvalid <= 1;`
103
104			`$display("^^^ %16.t \| %m \| master AR transaction @ 0x%08x \|", $time, tr_h.addr);`
105
106			`repeat(1) @(axi4_m.cb_m);`
107			`wait(axi4_m.cb_m.arready);`
108
109			`axi4_m.zero_cycle_delay();`
110			`ar_default();`
111
112			`->this.done;`
113
114			`endtask: transaction`
115
116
117			`// --------------------------------------------------------------------`
118			`//`
119			`endclass: ar_master_transaction_class`
120
121
122			`// --------------------------------------------------------------------`
123			`//`
124			`class r_master_transaction_class #(A = 32, N = 8, I = 1)`
125			`extends tb_blocking_transaction_q_class #(axi4_transaction_class #(.A(A), .N(N), .I(I)));`
126
127			`virtual axi4_if #(.A(A), .N(N), .I(I)) axi4_m;`
128
129
130			`//--------------------------------------------------------------------`
131			`function new`
132			`(`
133			`virtual axi4_if #(.A(A), .N(N), .I(I)) axi4_m`
134			`);`
135
136			`super.new();`
137			`this.axi4_m = axi4_m;`
138
139			`endfunction: new`
140
141
142			`// --------------------------------------------------------------------`
143			`//`
144			`function void`
145			`r_default;`
146
147			`axi4_m.cb_m.rready <= 0;`
148
149			`endfunction: r_default`
150
151
152			`// --------------------------------------------------------------------`
153			`//`
154			`task automatic`
155			`transaction`
156			`(`
157			`ref T tr_h`
158			`);`
159
160			`->this.start;`
161
162			`tr_h.data_h = new(tr_h.len);`
163
164			`foreach(tr_h.payload_h.w[i])`
165			`begin`
166			`repeat(tr_h.delay_h.next()) @(axi4_m.cb_m);`
167			`axi4_m.cb_m.rready <= 1;`
168			`repeat(1) @(axi4_m.cb_m);`
169
170			`wait(axi4_m.cb_m.rvalid);`
171			`axi4_m.zero_cycle_delay();`
172
173			`tr_h.data_h.w[i] = axi4_m.cb_m.rdata;`
174
175			`$display("^^^ %16.t \| %m \| master R transaction \| %d \| 0x%016x \|", $time, i, tr_h.data_h.w[i]);`
176			`r_default();`
177			`end`
178
179			`->this.done;`
180
181			`endtask: transaction`
182
183
184			`// --------------------------------------------------------------------`
185			`//`
186			`endclass: r_master_transaction_class`
187
188
189			`// --------------------------------------------------------------------`
190			`//`
191			`class aw_master_transaction_class #(A = 32, N = 8, I = 1)`
192			`extends tb_blocking_transaction_q_class #(axi4_transaction_class #(.A(A), .N(N), .I(I)));`
193
194			`virtual axi4_if #(.A(A), .N(N), .I(I)) axi4_m;`
195
196
197			`//--------------------------------------------------------------------`
198			`function new`
199			`(`
200			`virtual axi4_if #(.A(A), .N(N), .I(I)) axi4_m`
201			`);`
202
203			`super.new();`
204			`this.axi4_m = axi4_m;`
205
206			`endfunction: new`
207
208
209			`// --------------------------------------------------------------------`
210			`//`
211			`function void`
212			`aw_default;`
213
214			`axi4_m.cb_m.awaddr <= 'bx;`
215			`axi4_m.cb_m.awburst <= 'bx;`
216			`axi4_m.cb_m.awcache <= 'bx;`
217			`axi4_m.cb_m.awid <= 'bx;`
218			`axi4_m.cb_m.awlen <= 'bx;`
219			`axi4_m.cb_m.awlock <= 'bx;`
220			`axi4_m.cb_m.awprot <= 'bx;`
221			`axi4_m.cb_m.awqos <= 'bx;`
222			`axi4_m.cb_m.awregion <= 'bx;`
223			`axi4_m.cb_m.awsize <= 'bx;`
224			`axi4_m.cb_m.awvalid <= 0;`
225
226			`endfunction: aw_default`
227
228			`// --------------------------------------------------------------------`
229			`//`
230			`task automatic`
231			`transaction`
232			`(`
233			`ref T tr_h`
234			`);`
235
236			`->this.start;`
237
238			`repeat(tr_h.delay_h.next()) @(axi4_m.cb_m);`
239
240			`axi4_m.cb_m.awaddr <= tr_h.addr;`
241			`axi4_m.cb_m.awid <= tr_h.id;`
242			`axi4_m.cb_m.awlen <= tr_h.len;`
243			`axi4_m.cb_m.awsize <= tr_h.size;`
244
245			`axi4_m.cb_m.awburst <= tr_h.burst;`
246			`axi4_m.cb_m.awcache <= tr_h.cache;`
247			`axi4_m.cb_m.awlock <= tr_h.lock;`
248			`axi4_m.cb_m.awprot <= tr_h.prot;`
249			`axi4_m.cb_m.awqos <= tr_h.qos;`
250			`axi4_m.cb_m.awregion <= tr_h.region;`
251			`axi4_m.cb_m.awvalid <= 1;`
252
253			`$display("^^^ %16.t \| %m \| master AW transaction @ 0x%08x \|", $time, tr_h.addr);`
254
255			`repeat(1) @(axi4_m.cb_m);`
256			`wait(axi4_m.cb_m.awready);`
257
258			`axi4_m.zero_cycle_delay();`
259			`aw_default();`
260
261			`->this.done;`
262
263			`endtask: transaction`
264
265
266			`// --------------------------------------------------------------------`
267			`//`
268			`endclass: aw_master_transaction_class`
269
270
271			`// --------------------------------------------------------------------`
272			`//`
273			`class w_master_transaction_class #(A = 32, N = 8, I = 1)`
274			`extends tb_blocking_transaction_q_class #(axi4_transaction_class #(.A(A), .N(N), .I(I)));`
275
276			`virtual axi4_if #(.A(A), .N(N), .I(I)) axi4_m;`
277
278
279			`//--------------------------------------------------------------------`
280			`function new`
281			`(`
282			`virtual axi4_if #(.A(A), .N(N), .I(I)) axi4_m`
283			`);`
284
285			`super.new();`
286			`this.axi4_m = axi4_m;`
287
288			`endfunction: new`
289
290
291			`// --------------------------------------------------------------------`
292			`//`
293			`function void`
294			`w_default;`
295
296			`axi4_m.cb_m.wdata <= 'bx;`
297			`axi4_m.cb_m.wlast <= 'bx;`
298			`axi4_m.cb_m.wstrb <= {N{1'b1}};`
299			`axi4_m.cb_m.wvalid <= 0;`
300
301			`endfunction: w_default`
302
303
304			`// --------------------------------------------------------------------`
305			`//`
306			`task automatic`
307			`transaction`
308			`(`
309			`ref T tr_h`
310			`);`
311
312			`->this.start;`
313
314			`foreach(tr_h.payload_h.w[i])`
315			`begin`
316			`repeat(tr_h.delay_h.next()) @(axi4_m.cb_m);`
317
318			`axi4_m.cb_m.wdata <= tr_h.payload_h.w[i];`
319			`// axi4_m.cb_m.wstrb <= tr_h.strb; // need to fix`
320
321			`if(i < tr_h.payload_h.w.size - 1)`
322			`axi4_m.cb_m.wlast <= 0;`
323			`else`
324			`axi4_m.cb_m.wlast <= 1;`
325
326			`axi4_m.cb_m.wvalid <= 1;`
327
328			`repeat(1) @(axi4_m.cb_m);`
329			`wait(axi4_m.cb_m.wready);`
330
331			`axi4_m.zero_cycle_delay();`
332			`$display("^^^ %16.t \| %m \| master W transaction \| %d \| 0x%016x \|", $time, i, tr_h.payload_h.w[i]);`
333			`w_default();`
334			`end`
335
336			`->this.done;`
337
338			`endtask: transaction`
339
340
341			`// --------------------------------------------------------------------`
342			`//`
343			`endclass: w_master_transaction_class`
344
345
346			`// --------------------------------------------------------------------`
347			`//`
348			`class b_master_transaction_class #(A = 32, N = 8, I = 1)`
349			`extends tb_blocking_transaction_q_class #(axi4_transaction_class #(.A(A), .N(N), .I(I)));`
350
351			`virtual axi4_if #(.A(A), .N(N), .I(I)) axi4_m;`
352
353
354			`//--------------------------------------------------------------------`
355			`function new`
356			`(`
357			`virtual axi4_if #(.A(A), .N(N), .I(I)) axi4_m`
358			`);`
359
360			`super.new();`
361			`this.axi4_m = axi4_m;`
362
363			`endfunction: new`
364
365
366			`// --------------------------------------------------------------------`
367			`//`
368			`function void`
369			`b_default;`
370
371			`axi4_m.cb_m.bready <= 0;`
372
373			`endfunction: b_default`
374
375
376			`// --------------------------------------------------------------------`
377			`//`
378			`task automatic`
379			`transaction`
380			`(`
381			`ref T tr_h`
382			`);`
383
384			`->this.start;`
385
386			`repeat(tr_h.delay_h.next()) @(axi4_m.cb_m);`
387			`axi4_m.cb_m.bready <= 1;`
388			`repeat(1) @(axi4_m.cb_m);`
389
390			`wait(axi4_m.cb_m.bvalid);`
391			`axi4_m.zero_cycle_delay();`
392
393			`$display("^^^ %16.t \| %m \| master B transaction \| 0x%x \|", $time, axi4_m.cb_m.bresp);`
394			`b_default();`
395
396			`->this.done;`
397
398			`endtask: transaction`
399
400
401			`// --------------------------------------------------------------------`
402			`//`
403			`endclass: b_master_transaction_class`
404
405
406			`// --------------------------------------------------------------------`
407			`//`
408			`class axi4_master_bfm_class #(A = 32, N = 8, I = 1);`
409
410			`ar_master_transaction_class #(.A(A), .N(N), .I(I)) ar_h;`
411			`r_master_transaction_class #(.A(A), .N(N), .I(I)) r_h;`
412			`aw_master_transaction_class #(.A(A), .N(N), .I(I)) aw_h;`
413			`w_master_transaction_class #(.A(A), .N(N), .I(I)) w_h;`
414			`b_master_transaction_class #(.A(A), .N(N), .I(I)) b_h;`
415
416			`axi4_transaction_class tr_h;`
417			`virtual axi4_if #(.A(A), .N(N), .I(I)) axi4_m;`
418
419
420			`//--------------------------------------------------------------------`
421			`function new`
422			`(`
423			`virtual axi4_if #(.A(A), .N(N), .I(I)) axi4_m`
424			`);`
425
426			`this.axi4_m = axi4_m;`
427
428			`ar_h = new(axi4_m);`
429			`r_h = new(axi4_m);`
430			`aw_h = new(axi4_m);`
431			`w_h = new(axi4_m);`
432			`b_h = new(axi4_m);`
433
434			`ar_h.init();`
435			`ar_h.ar_default();`
436
437			`r_h.init();`
438			`r_h.r_default();`
439
440			`aw_h.init();`
441			`aw_h.aw_default();`
442
443			`w_h.init();`
444			`w_h.w_default();`
445
446			`b_h.init();`
447			`b_h.b_default();`
448
449			`endfunction: new`
450
451
452			`// --------------------------------------------------------------------`
453			`//`
454			`function void`
455			`init;`
456
457			`endfunction: init`
458
459
460			`// --------------------------------------------------------------------`
461			`//`
462			`task`
463			`basic_read`
464			`(`
465			`input logic [(A-1):0] araddr,`
466			`input logic [7:0] arlen,`
467			`output logic [(8*N)-1:0] data[],`
468			`output logic [1:0] rresp`
469			`);`
470
471			`this.tr_h = new;`
472			`this.tr_h.basic_read(araddr, arlen);`
473
474			`ar_h.put(tr_h);`
475			`r_h.put(tr_h);`
476
477			`@(r_h.done);`
478			`data = tr_h.data_h.w;`
479			`rresp = tr_h.resp;`
480
481			`endtask: basic_read`
482
483
484			`// --------------------------------------------------------------------`
485			`//`
486			`task`
487			`basic_random_read_burst`
488			`(`
489			`output logic [(8*N)-1:0] data[],`
490			`output logic [1:0] rresp`
491			`);`
492
493			`this.tr_h = new;`
494			`this.tr_h.basic_random_burst;`
495
496			`ar_h.put(tr_h);`
497			`r_h.put(tr_h);`
498
499			`@(r_h.done);`
500			`data = tr_h.data_h.w;`
501			`rresp = tr_h.resp;`
502
503			`endtask: basic_random_read_burst`
504
505
506			`// --------------------------------------------------------------------`
507			`//`
508			`task`
509			`basic_write`
510			`(`
511			`input logic [(A-1):0] awaddr,`
512			`input logic [7:0] awlen,`
513			`input logic [(8*N)-1:0] data[],`
514			`output logic [1:0] bresp`
515			`);`
516
517			`this.tr_h = new;`
518			`this.tr_h.basic_write(awaddr, awlen);`
519
520			`foreach(this.tr_h.payload_h.w[i])`
521			`this.tr_h.payload_h.w[i] = data[i];`
522
523			`aw_h.put(tr_h);`
524			`w_h.put(tr_h);`
525			`b_h.put(tr_h);`
526
527			`@(b_h.done);`
528			`bresp = tr_h.resp;`
529
530			`endtask: basic_write`
531
532
533			`// --------------------------------------------------------------------`
534			`//`
535			`task`
536			`basic_random_write_burst`
537			`(`
538			`output logic [1:0] bresp`
539			`);`
540
541			`this.tr_h = new;`
542			`this.tr_h.basic_random_burst;`
543
544			`aw_h.put(tr_h);`
545			`w_h.put(tr_h);`
546			`b_h.put(tr_h);`
547
548			`@(b_h.done);`
549			`bresp = tr_h.resp;`
550
551			`endtask: basic_random_write_burst`
552
553
554			`// --------------------------------------------------------------------`
555			`//`
556			`endclass: axi4_master_bfm_class`
557
558
559			`// --------------------------------------------------------------------`
560			`//`
561			`endpackage: axi4_bfm_pkg`
562
563