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

Subversion Repositories axi_master

[/] [axi_master/] [trunk/] [src/] [base/] [axi_master.v] - Blame information for rev 14

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


/////////////////////////////////////////////////////////////////////
////                                                             ////
////  Author: Eyal Hochberg                                      ////
////          eyal@provartec.com                                 ////
////                                                             ////
////  Downloaded from: http://www.opencores.org                  ////
/////////////////////////////////////////////////////////////////////
////                                                             ////
//// Copyright (C) 2010 Provartec LTD                            ////
//// www.provartec.com                                           ////
//// info@provartec.com                                          ////
////                                                             ////
//// 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.////
////                                                             ////
//// 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. http://www.gnu.org/licenses/lgpl.html              ////
////                                                             ////
/////////////////////////////////////////////////////////////////////
 
//////////////////////////////////////
//
// General:
//   The AXI master has an internal master per ID. 
//   These internal masters work simultaniously and an interconnect matrix connets them. 
// 
//
// I/F :
//   idle - all internal masters emptied their command FIFOs
//   scrbrd_empty - all scoreboard checks have been completed (for random testing)
//
//
// Tasks:
//
// enable(input master_num)
//   Description: Enables master
//   Parameters: master_num - number of internal master
//
// enable_all()  
//   Description: Enables all masters
//
// write_single(input master_num, input addr, input wdata)
//   Description: write a single AXI burst (1 data cycle)
//   Parameters: master_num - number of internal master
//           addr  - address
//           wdata - write data
// 
// read_single(input master_num, input addr, output rdata)
//   Description: read a single AXI burst (1 data cycle)
//   Parameters: master_num - number of internal master
//               addr  - address
//               rdata - return read data
//
// check_single(input master_num, input addr, input expected)
//   Description: read a single AXI burst and gives an error if the data read does not match expected
//   Parameters: master_num - number of internal master
//               addr  - address
//               expected - expected read data
//
// write_and_check_single(input master_num, input addr, input data)
//   Description: write a single AXI burst read it back and compare the write and read data
//   Parameters: master_num - number of internal master
//               addr  - address
//               data - data to write and expect on read
//
// insert_wr_cmd(input master_num, input addr, input len, input size)
//   Description: add an AXI write burst to command FIFO
//   Parameters: master_num - number of internal master
//               addr - address
//               len - AXI LEN (data strobe number)
//               size - AXI SIZE (data width)
//  
// insert_rd_cmd(input master_num, input addr, input len, input size)
//   Description: add an AXI read burst to command FIFO
//   Parameters: master_num - number of internal master
//               addr - address
//               len - AXI LEN (data strobe number)
//               size - AXI SIZE (data width)
//  
// insert_wr_data(input master_num, input wdata)
//   Description: add a single data to data FIFO (to be used in write bursts)
//   Parameters: master_num - number of internal master
//               wdata - write data
//  
// insert_wr_incr_data(input master_num, input addr, input len, input size)
//   Description: add an AXI write burst to command FIFO will use incremental data (no need to use insert_wr_data)
//   Parameters: master_num - number of internal master
//               addr - address
//               len - AXI LEN (data strobe number)
//               size - AXI SIZE (data width)
//  
// insert_rand_chk(input master_num, input burst_num)
//   Description: add multiple commands to command FIFO. Each command writes incremental data to a random address, reads the data back and checks the data. Useful for random testing.
//   Parameters: master_num - number of internal master
//               burst_num - total number of bursts to check
//  
// insert_rand(input burst_num)
//   Description: disperces burst_num between internal masters and calls insert_rand_chk for each master
//   Parameters:  burst_num - total number of bursts to check (combined)
//
//  
//  Parameters:
//  
//    For random testing: (changing these values automatically update interanl masters)
//      ahb_bursts - if set, bursts will only be of length 1, 4, 8 or 16.
//      len_min  - minimum burst AXI LEN (length)
//      len_max  - maximum burst AXI LEN (length)
//      size_min - minimum burst AXI SIZE (width)
//      size_max - maximum burst AXI SIZE (width)
//      addr_min - minimum address (in bytes)
//      addr_max - maximum address (in bytes)
//  
//////////////////////////////////////
 
OUTFILE PREFIX.v
 
INCLUDE def_axi_master.txt
 
ITER IDX ID_NUM
module PREFIX(PORTS);
 
`include "prgen_rand.v"
 
   input                               clk;
   input                               reset;
 
   port                                GROUP_STUB_AXI;
 
   output                              idle;
   output                              scrbrd_empty;
 
 
   //random parameters
   integer                             GROUP_AXI_MASTER_RAND = GROUP_AXI_MASTER_RAND.DEFAULT;
 
   wire                                GROUP_STUB_AXI_IDX;
   wire                                idle_IDX;
   wire                                scrbrd_empty_IDX;
 
 
   always @(*)
     begin
        #FFD;
        PREFIX_singleIDX.GROUP_AXI_MASTER_RAND = GROUP_AXI_MASTER_RAND;
     end
 
   assign                              idle = CONCAT(idle_IDX &);
   assign                              scrbrd_empty = CONCAT(scrbrd_empty_IDX &);
 
 
   CREATE axi_master_single.v
 
     LOOP IDX ID_NUM
   PREFIX_single #(IDX, ID_BITS'GROUP_AXI_ID[IDX], CMD_DEPTH)
   PREFIX_singleIDX(
                   .clk(clk),
                   .reset(reset),
                   .GROUP_STUB_AXI(GROUP_STUB_AXI_IDX),
                   .idle(idle_IDX),
                   .scrbrd_empty(scrbrd_empty_IDX)
                   );
 
   ENDLOOP IDX
 
     IFDEF TRUE(ID_NUM==1)
 
   assign GROUP_STUB_AXI.OUT = GROUP_STUB_AXI_0.OUT;
   assign GROUP_STUB_AXI_0.IN = GROUP_STUB_AXI.IN;
 
     ELSE TRUE(ID_NUM==1)
 
CREATE ic.v \\
DEFCMD(SWAP.GLOBAL CONST(PREFIX) PREFIX) \\
DEFCMD(SWAP.GLOBAL MASTER_NUM ID_NUM) \\
DEFCMD(SWAP.GLOBAL SLAVE_NUM 1) \\
DEFCMD(SWAP.GLOBAL CONST(ID_BITS) ID_BITS) \\
DEFCMD(SWAP.GLOBAL CONST(CMD_DEPTH) CMD_DEPTH) \\
DEFCMD(SWAP.GLOBAL CONST(DATA_BITS) DATA_BITS) \\
DEFCMD(SWAP.GLOBAL CONST(ADDR_BITS) ADDR_BITS) \\
DEFCMD(SWAP.GLOBAL CONST(USER_BITS) 0)
LOOP IDX ID_NUM
  STOMP NEWLINE
  DEFCMD(GROUP.GLOBAL MIDX_ID overrides { ) \\
  DEFCMD(GROUP_AXI_ID[IDX]) \\
  DEFCMD(})
ENDLOOP IDX
 
 
    PREFIX_ic PREFIX_ic(
                       .clk(clk),
                       .reset(reset),
                       .MIDX_GROUP_STUB_AXI(GROUP_STUB_AXI_IDX),
                       .S0_GROUP_STUB_AXI(GROUP_STUB_AXI),
                       STOMP ,
 
      );
 
     ENDIF TRUE(ID_NUM==1)
 
 
 
   task check_master_num;
      input [24*8-1:0] task_name;
      input [31:0] master_num;
      begin
         if (master_num >= ID_NUM)
           begin
              $display("FATAL ERROR: task %0s called for master %0d that does not exist.\tTime: %0d ns.", task_name, master_num, $time);
           end
      end
   endtask
 
   task enable;
      input [31:0] master_num;
      begin
         check_master_num("enable", master_num);
         case (master_num)
           IDX : PREFIX_singleIDX.enable = 1;
         endcase
      end
   endtask
 
   task enable_all;
      begin
         PREFIX_singleIDX.enable = 1;
      end
   endtask
 
   task write_single;
      input [31:0] master_num;
      input [ADDR_BITS-1:0]  addr;
      input [DATA_BITS-1:0]  wdata;
      begin
         check_master_num("write_single", master_num);
         case (master_num)
           IDX : PREFIX_singleIDX.write_single(addr, wdata);
         endcase
      end
   endtask
 
   task read_single;
      input [31:0] master_num;
      input [ADDR_BITS-1:0]  addr;
      output [DATA_BITS-1:0]  rdata;
      begin
         check_master_num("read_single", master_num);
         case (master_num)
           IDX : PREFIX_singleIDX.read_single(addr, rdata);
         endcase
      end
   endtask
 
   task check_single;
      input [31:0] master_num;
      input [ADDR_BITS-1:0]  addr;
      input [DATA_BITS-1:0]  expected;
      begin
         check_master_num("check_single", master_num);
         case (master_num)
           IDX : PREFIX_singleIDX.check_single(addr, expected);
         endcase
      end
   endtask
 
   task write_and_check_single;
      input [31:0] master_num;
      input [ADDR_BITS-1:0]  addr;
      input [DATA_BITS-1:0]  data;
      begin
         check_master_num("write_and_check_single", master_num);
         case (master_num)
           IDX : PREFIX_singleIDX.write_and_check_single(addr, data);
         endcase
      end
   endtask
 
   task insert_wr_cmd;
      input [31:0] master_num;
      input [ADDR_BITS-1:0]  addr;
      input [LEN_BITS-1:0]   len;
      input [SIZE_BITS-1:0]  size;
      begin
         check_master_num("insert_wr_cmd", master_num);
         case (master_num)
           IDX : PREFIX_singleIDX.insert_wr_cmd(addr, len, size);
         endcase
      end
   endtask
 
   task insert_rd_cmd;
      input [31:0] master_num;
      input [ADDR_BITS-1:0]  addr;
      input [LEN_BITS-1:0]   len;
      input [SIZE_BITS-1:0]  size;
      begin
         check_master_num("insert_rd_cmd", master_num);
         case (master_num)
           IDX : PREFIX_singleIDX.insert_rd_cmd(addr, len, size);
         endcase
      end
   endtask
 
   task insert_wr_data;
      input [31:0] master_num;
      input [DATA_BITS-1:0]  wdata;
      begin
         check_master_num("insert_wr_data", master_num);
         case (master_num)
           IDX : PREFIX_singleIDX.insert_wr_data(wdata);
         endcase
      end
   endtask
 
   task insert_wr_incr_data;
      input [31:0] master_num;
      input [ADDR_BITS-1:0]  addr;
      input [LEN_BITS-1:0]   len;
      input [SIZE_BITS-1:0]  size;
      begin
         check_master_num("insert_wr_incr_data", master_num);
         case (master_num)
           IDX : PREFIX_singleIDX.insert_wr_incr_data(addr, len, size);
         endcase
      end
   endtask
 
   task insert_rand_chk;
      input [31:0] master_num;
      input [31:0] burst_num;
      begin
         check_master_num("insert_rand_chk", master_num);
         case (master_num)
           IDX : PREFIX_singleIDX.insert_rand_chk(burst_num);
         endcase
      end
   endtask
 
   task insert_rand;
      input [31:0] burst_num;
 
      reg [31:0] burst_numIDX;
      integer remain;
      begin
         remain = burst_num;
         LOOP IDX ID_NUM
         if (remain > 0)
           begin
              burst_numIDX = rand(1, remain);
              remain = remain - burst_numIDX;
              insert_rand_chk(IDX, burst_numIDX);
           end
         ENDLOOP IDX
      end
   endtask
 
 
endmodule
 
 

Line No.	Rev	Author	Line
1	2	eyalhoc	`/////////////////////////////////////////////////////////////////////`
2			`//// ////`
3			`//// Author: Eyal Hochberg ////`
4			`//// eyal@provartec.com ////`
5			`//// ////`
6			`//// Downloaded from: http://www.opencores.org ////`
7			`/////////////////////////////////////////////////////////////////////`
8			`//// ////`
9			`//// Copyright (C) 2010 Provartec LTD ////`
10			`//// www.provartec.com ////`
11			`//// info@provartec.com ////`
12			`//// ////`
13			`//// This source file may be used and distributed without ////`
14			`//// restriction provided that this copyright statement is not ////`
15			`//// removed from the file and that any derivative work contains ////`
16			`//// the original copyright notice and the associated disclaimer.////`
17			`//// ////`
18			`//// This source file is free software; you can redistribute it ////`
19			`//// and/or modify it under the terms of the GNU Lesser General ////`
20			`//// Public License as published by the Free Software Foundation.////`
21			`//// ////`
22			`//// This source is distributed in the hope that it will be ////`
23			`//// useful, but WITHOUT ANY WARRANTY; without even the implied ////`
24			`//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ////`
25			`//// PURPOSE. See the GNU Lesser General Public License for more////`
26			`//// details. http://www.gnu.org/licenses/lgpl.html ////`
27			`//// ////`
28			`/////////////////////////////////////////////////////////////////////`
29	6	eyalhoc
30			`//////////////////////////////////////`
31			`//`
32			`// General:`
33			`// The AXI master has an internal master per ID.`
34			`// These internal masters work simultaniously and an interconnect matrix connets them.`
35			`//`
36			`//`
37			`// I/F :`
38			`// idle - all internal masters emptied their command FIFOs`
39			`// scrbrd_empty - all scoreboard checks have been completed (for random testing)`
40			`//`
41			`//`
42			`// Tasks:`
43			`//`
44			`// enable(input master_num)`
45			`// Description: Enables master`
46			`// Parameters: master_num - number of internal master`
47			`//`
48			`// enable_all()`
49			`// Description: Enables all masters`
50			`//`
51			`// write_single(input master_num, input addr, input wdata)`
52			`// Description: write a single AXI burst (1 data cycle)`
53			`// Parameters: master_num - number of internal master`
54			`// addr - address`
55			`// wdata - write data`
56			`//`
57			`// read_single(input master_num, input addr, output rdata)`
58			`// Description: read a single AXI burst (1 data cycle)`
59			`// Parameters: master_num - number of internal master`
60			`// addr - address`
61			`// rdata - return read data`
62			`//`
63			`// check_single(input master_num, input addr, input expected)`
64			`// Description: read a single AXI burst and gives an error if the data read does not match expected`
65			`// Parameters: master_num - number of internal master`
66			`// addr - address`
67			`// expected - expected read data`
68			`//`
69			`// write_and_check_single(input master_num, input addr, input data)`
70			`// Description: write a single AXI burst read it back and compare the write and read data`
71			`// Parameters: master_num - number of internal master`
72			`// addr - address`
73			`// data - data to write and expect on read`
74			`//`
75			`// insert_wr_cmd(input master_num, input addr, input len, input size)`
76			`// Description: add an AXI write burst to command FIFO`
77			`// Parameters: master_num - number of internal master`
78			`// addr - address`
79			`// len - AXI LEN (data strobe number)`
80			`// size - AXI SIZE (data width)`
81			`//`
82			`// insert_rd_cmd(input master_num, input addr, input len, input size)`
83			`// Description: add an AXI read burst to command FIFO`
84			`// Parameters: master_num - number of internal master`
85			`// addr - address`
86			`// len - AXI LEN (data strobe number)`
87			`// size - AXI SIZE (data width)`
88			`//`
89			`// insert_wr_data(input master_num, input wdata)`
90			`// Description: add a single data to data FIFO (to be used in write bursts)`
91			`// Parameters: master_num - number of internal master`
92			`// wdata - write data`
93			`//`
94			`// insert_wr_incr_data(input master_num, input addr, input len, input size)`
95			`// Description: add an AXI write burst to command FIFO will use incremental data (no need to use insert_wr_data)`
96			`// Parameters: master_num - number of internal master`
97			`// addr - address`
98			`// len - AXI LEN (data strobe number)`
99			`// size - AXI SIZE (data width)`
100			`//`
101			`// insert_rand_chk(input master_num, input burst_num)`
102			`// Description: add multiple commands to command FIFO. Each command writes incremental data to a random address, reads the data back and checks the data. Useful for random testing.`
103			`// Parameters: master_num - number of internal master`
104			`// burst_num - total number of bursts to check`
105			`//`
106	9	eyalhoc	`// insert_rand(input burst_num)`
107			`// Description: disperces burst_num between internal masters and calls insert_rand_chk for each master`
108			`// Parameters: burst_num - total number of bursts to check (combined)`
109			`//`
110	6	eyalhoc	`//`
111			`// Parameters:`
112			`//`
113			`// For random testing: (changing these values automatically update interanl masters)`
114	10	eyalhoc	`// ahb_bursts - if set, bursts will only be of length 1, 4, 8 or 16.`
115	6	eyalhoc	`// len_min - minimum burst AXI LEN (length)`
116			`// len_max - maximum burst AXI LEN (length)`
117			`// size_min - minimum burst AXI SIZE (width)`
118			`// size_max - maximum burst AXI SIZE (width)`
119			`// addr_min - minimum address (in bytes)`
120			`// addr_max - maximum address (in bytes)`
121			`//`
122			`//////////////////////////////////////`
123
124			`OUTFILE PREFIX.v`
125
126			`INCLUDE def_axi_master.txt`
127
128	14	eyalhoc	`ITER IDX ID_NUM`
129	6	eyalhoc	`module PREFIX(PORTS);`
130
131	9	eyalhoc	`include "prgen_rand.v"
132
133	6	eyalhoc	`input clk;`
134			`input reset;`
135
136			`port GROUP_STUB_AXI;`
137
138			`output idle;`
139			`output scrbrd_empty;`
140
141
142			`//random parameters`
143			`integer GROUP_AXI_MASTER_RAND = GROUP_AXI_MASTER_RAND.DEFAULT;`
144
145	14	eyalhoc	`wire GROUP_STUB_AXI_IDX;`
146			`wire idle_IDX;`
147			`wire scrbrd_empty_IDX;`
148	6	eyalhoc
149
150			`always @(*)`
151			`begin`
152			`#FFD;`
153	14	eyalhoc	`PREFIX_singleIDX.GROUP_AXI_MASTER_RAND = GROUP_AXI_MASTER_RAND;`
154	6	eyalhoc	`end`
155
156	14	eyalhoc	`assign idle = CONCAT(idle_IDX &);`
157			`assign scrbrd_empty = CONCAT(scrbrd_empty_IDX &);`
158	6	eyalhoc
159
160			`CREATE axi_master_single.v`
161
162	14	eyalhoc	`LOOP IDX ID_NUM`
163			`PREFIX_single #(IDX, ID_BITS'GROUP_AXI_ID[IDX], CMD_DEPTH)`
164			`PREFIX_singleIDX(`
165	6	eyalhoc	`.clk(clk),`
166			`.reset(reset),`
167	14	eyalhoc	`.GROUP_STUB_AXI(GROUP_STUB_AXI_IDX),`
168			`.idle(idle_IDX),`
169			`.scrbrd_empty(scrbrd_empty_IDX)`
170	6	eyalhoc	`);`
171	9	eyalhoc
172	14	eyalhoc	`ENDLOOP IDX`
173	6	eyalhoc
174			`IFDEF TRUE(ID_NUM==1)`
175
176			`assign GROUP_STUB_AXI.OUT = GROUP_STUB_AXI_0.OUT;`
177			`assign GROUP_STUB_AXI_0.IN = GROUP_STUB_AXI.IN;`
178
179			`ELSE TRUE(ID_NUM==1)`
180
181	14	eyalhoc	`CREATE ic.v \\`
182			`DEFCMD(SWAP.GLOBAL CONST(PREFIX) PREFIX) \\`
183	9	eyalhoc	`DEFCMD(SWAP.GLOBAL MASTER_NUM ID_NUM) \\`
184			`DEFCMD(SWAP.GLOBAL SLAVE_NUM 1) \\`
185			`DEFCMD(SWAP.GLOBAL CONST(ID_BITS) ID_BITS) \\`
186			`DEFCMD(SWAP.GLOBAL CONST(CMD_DEPTH) CMD_DEPTH) \\`
187			`DEFCMD(SWAP.GLOBAL CONST(DATA_BITS) DATA_BITS) \\`
188	14	eyalhoc	`DEFCMD(SWAP.GLOBAL CONST(ADDR_BITS) ADDR_BITS) \\`
189			`DEFCMD(SWAP.GLOBAL CONST(USER_BITS) 0)`
190			`LOOP IDX ID_NUM`
191			`STOMP NEWLINE`
192			`DEFCMD(GROUP.GLOBAL MIDX_ID overrides { ) \\`
193			`DEFCMD(GROUP_AXI_ID[IDX]) \\`
194			`DEFCMD(})`
195			`ENDLOOP IDX`
196	6	eyalhoc
197	14	eyalhoc
198	6	eyalhoc	`PREFIX_ic PREFIX_ic(`
199			`.clk(clk),`
200			`.reset(reset),`
201	14	eyalhoc	`.MIDX_GROUP_STUB_AXI(GROUP_STUB_AXI_IDX),`
202	6	eyalhoc	`.S0_GROUP_STUB_AXI(GROUP_STUB_AXI),`
203			`STOMP ,`
204
205			`);`
206
207			`ENDIF TRUE(ID_NUM==1)`
208
209
210
211			`task check_master_num;`
212			`input [24*8-1:0] task_name;`
213			`input [31:0] master_num;`
214			`begin`
215			`if (master_num >= ID_NUM)`
216			`begin`
217			`$display("FATAL ERROR: task %0s called for master %0d that does not exist.\tTime: %0d ns.", task_name, master_num, $time);`
218			`end`
219			`end`
220			`endtask`
221
222			`task enable;`
223			`input [31:0] master_num;`
224			`begin`
225			`check_master_num("enable", master_num);`
226			`case (master_num)`
227	14	eyalhoc	`IDX : PREFIX_singleIDX.enable = 1;`
228	6	eyalhoc	`endcase`
229			`end`
230			`endtask`
231
232			`task enable_all;`
233			`begin`
234	14	eyalhoc	`PREFIX_singleIDX.enable = 1;`
235	6	eyalhoc	`end`
236			`endtask`
237
238			`task write_single;`
239			`input [31:0] master_num;`
240			`input [ADDR_BITS-1:0] addr;`
241			`input [DATA_BITS-1:0] wdata;`
242			`begin`
243			`check_master_num("write_single", master_num);`
244			`case (master_num)`
245	14	eyalhoc	`IDX : PREFIX_singleIDX.write_single(addr, wdata);`
246	6	eyalhoc	`endcase`
247			`end`
248			`endtask`
249
250			`task read_single;`
251			`input [31:0] master_num;`
252			`input [ADDR_BITS-1:0] addr;`
253			`output [DATA_BITS-1:0] rdata;`
254			`begin`
255			`check_master_num("read_single", master_num);`
256			`case (master_num)`
257	14	eyalhoc	`IDX : PREFIX_singleIDX.read_single(addr, rdata);`
258	6	eyalhoc	`endcase`
259			`end`
260			`endtask`
261
262			`task check_single;`
263			`input [31:0] master_num;`
264			`input [ADDR_BITS-1:0] addr;`
265			`input [DATA_BITS-1:0] expected;`
266			`begin`
267			`check_master_num("check_single", master_num);`
268			`case (master_num)`
269	14	eyalhoc	`IDX : PREFIX_singleIDX.check_single(addr, expected);`
270	6	eyalhoc	`endcase`
271			`end`
272			`endtask`
273
274			`task write_and_check_single;`
275			`input [31:0] master_num;`
276			`input [ADDR_BITS-1:0] addr;`
277			`input [DATA_BITS-1:0] data;`
278			`begin`
279			`check_master_num("write_and_check_single", master_num);`
280			`case (master_num)`
281	14	eyalhoc	`IDX : PREFIX_singleIDX.write_and_check_single(addr, data);`
282	6	eyalhoc	`endcase`
283			`end`
284			`endtask`
285
286			`task insert_wr_cmd;`
287			`input [31:0] master_num;`
288			`input [ADDR_BITS-1:0] addr;`
289			`input [LEN_BITS-1:0] len;`
290			`input [SIZE_BITS-1:0] size;`
291			`begin`
292			`check_master_num("insert_wr_cmd", master_num);`
293			`case (master_num)`
294	14	eyalhoc	`IDX : PREFIX_singleIDX.insert_wr_cmd(addr, len, size);`
295	6	eyalhoc	`endcase`
296			`end`
297			`endtask`
298
299			`task insert_rd_cmd;`
300			`input [31:0] master_num;`
301			`input [ADDR_BITS-1:0] addr;`
302			`input [LEN_BITS-1:0] len;`
303			`input [SIZE_BITS-1:0] size;`
304			`begin`
305			`check_master_num("insert_rd_cmd", master_num);`
306			`case (master_num)`
307	14	eyalhoc	`IDX : PREFIX_singleIDX.insert_rd_cmd(addr, len, size);`
308	6	eyalhoc	`endcase`
309			`end`
310			`endtask`
311
312			`task insert_wr_data;`
313			`input [31:0] master_num;`
314			`input [DATA_BITS-1:0] wdata;`
315			`begin`
316			`check_master_num("insert_wr_data", master_num);`
317			`case (master_num)`
318	14	eyalhoc	`IDX : PREFIX_singleIDX.insert_wr_data(wdata);`
319	6	eyalhoc	`endcase`
320			`end`
321			`endtask`
322
323			`task insert_wr_incr_data;`
324			`input [31:0] master_num;`
325			`input [ADDR_BITS-1:0] addr;`
326			`input [LEN_BITS-1:0] len;`
327			`input [SIZE_BITS-1:0] size;`
328			`begin`
329			`check_master_num("insert_wr_incr_data", master_num);`
330			`case (master_num)`
331	14	eyalhoc	`IDX : PREFIX_singleIDX.insert_wr_incr_data(addr, len, size);`
332	6	eyalhoc	`endcase`
333			`end`
334			`endtask`
335
336			`task insert_rand_chk;`
337			`input [31:0] master_num;`
338			`input [31:0] burst_num;`
339			`begin`
340			`check_master_num("insert_rand_chk", master_num);`
341			`case (master_num)`
342	14	eyalhoc	`IDX : PREFIX_singleIDX.insert_rand_chk(burst_num);`
343	6	eyalhoc	`endcase`
344			`end`
345			`endtask`
346
347	9	eyalhoc	`task insert_rand;`
348			`input [31:0] burst_num;`
349
350			`reg [31:0] burst_numIDX;`
351			`integer remain;`
352			`begin`
353			`remain = burst_num;`
354			`LOOP IDX ID_NUM`
355			`if (remain > 0)`
356			`begin`
357			`burst_numIDX = rand(1, remain);`
358			`remain = remain - burst_numIDX;`
359			`insert_rand_chk(IDX, burst_numIDX);`
360			`end`
361			`ENDLOOP IDX`
362			`end`
363			`endtask`
364	6	eyalhoc
365
366			`endmodule`
367
368

Browse

Tools

Subversion Repositories axi_master

[/] [axi_master/] [trunk/] [src/] [base/] [axi_master.v] - Blame information for rev 14